From 55680db160c3c486ccbbb40e10f6338e4d98e84d Mon Sep 17 00:00:00 2001 From: Emad William Farag Date: Sun, 4 Feb 2018 23:36:54 -0500 Subject: [PATCH 01/39] Support for custom EOL per formatter --- include/spdlog/details/logger_impl.h | 2 +- include/spdlog/details/os.h | 3 +-- include/spdlog/details/pattern_formatter_impl.h | 6 +++--- include/spdlog/formatter.h | 3 ++- tests/format.cpp | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index 88044747..df69102d 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -350,7 +350,7 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg) char date_buf[100]; std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); details::log_msg err_msg; - err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol); + err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::default_eol); sinks::stderr_sink_mt::instance()->log(err_msg); _last_err_time = now; } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index b881cae4..2b8f3e95 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -140,8 +140,7 @@ inline bool operator!=(const std::tm& tm1, const std::tm& tm2) #endif #endif -SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL; -SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1; +SPDLOG_CONSTEXPR static const char* default_eol = SPDLOG_EOL; diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index a73f5dea..ceea930a 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -487,8 +487,8 @@ class full_formatter SPDLOG_FINAL:public flag_formatter /////////////////////////////////////////////////////////////////////////////// // pattern_formatter inline impl /////////////////////////////////////////////////////////////////////////////// -inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time) - : _pattern_time(pattern_time) +inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time, std::string eol) + : _eol(move(eol)), _pattern_time(pattern_time) { compile_pattern(pattern); } @@ -682,5 +682,5 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg) f->format(msg, tm_time); } //write eol - msg.formatted.write(details::os::eol, details::os::eol_size); + msg.formatted.write(_eol.data(), _eol.size()); } diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index 8bf0f43f..39315764 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -29,11 +29,12 @@ class pattern_formatter SPDLOG_FINAL : public formatter { public: - explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local); + explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter&) = delete; pattern_formatter& operator=(const pattern_formatter&) = delete; void format(details::log_msg& msg) override; private: + const std::string _eol; const std::string _pattern; const pattern_time_type _pattern_time; std::vector> _formatters; diff --git a/tests/format.cpp b/tests/format.cpp index adb8ba8b..0b2e1d6d 100644 --- a/tests/format.cpp +++ b/tests/format.cpp @@ -13,7 +13,7 @@ std::string log_info(const T& what, spdlog::level::level_enum logger_level = spd oss_logger.set_pattern("%v"); oss_logger.info(what); - return oss.str().substr(0, oss.str().length() - spdlog::details::os::eol_size); + return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol)); } From 05b2aabe0eaba7e3722a990eac9f592b6e2909bd Mon Sep 17 00:00:00 2001 From: Benjamin Schindler Date: Thu, 8 Feb 2018 09:14:45 +0100 Subject: [PATCH 02/39] Make set_color public in wincolor_sink to retain configurability --- include/spdlog/sinks/wincolor_sink.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index f9e86c7a..d8211fb1 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -50,6 +50,13 @@ public: wincolor_sink(const wincolor_sink& other) = delete; wincolor_sink& operator=(const wincolor_sink& other) = delete; + // change the color for the given level + void set_color(level::level_enum level, WORD color) + { + std::lock_guard lock(base_sink::_mutex); + colors_[level] = color; + } + protected: virtual void _sink_it(const details::log_msg& msg) override { @@ -64,13 +71,6 @@ protected: // windows console always flushed? } - // change the color for the given level - void set_color(level::level_enum level, WORD color) - { - std::lock_guard lock(base_sink::_mutex); - colors_[level] = color; - } - private: HANDLE out_handle_; std::unordered_map colors_; From 11ee6834f6fbb0dd7bf6a5d1ba7ba30decdc8f84 Mon Sep 17 00:00:00 2001 From: Colin Duquesnoy Date: Sat, 10 Feb 2018 15:15:46 +0100 Subject: [PATCH 03/39] Fix compilation error with GCC 8 error: need 'typename' before 'std::conditional::value, fmt::BasicMemoryWriter, fmt::BasicMemoryWriter >::type' because 'std::conditional::value, fmt::BasicMemoryWriter, fmt::BasicMemoryWriter >' is a dependent scope std::conditional::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; --- include/spdlog/sinks/file_sinks.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index e7856172..e13c81a6 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -81,7 +81,7 @@ public: // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". static filename_t calc_filename(const filename_t& filename, std::size_t index) { - std::conditional::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; + typename std::conditional::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; if (index) { filename_t basename, ext; From 646a140ed4ecb38302ae4d65c08ce8f1d0e18a7a Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 11 Feb 2018 20:45:56 +0100 Subject: [PATCH 04/39] Specify CXX language explicitly in CMake Marking project as CXX will disable detecting C compiler and other checks. Removed 'INCLUDES DESTINATION' as it made the include path appear doubled. --- CMakeLists.txt | 3 +- example/CMakeLists.txt | 98 +++++++++++++++++++++--------------------- tests/CMakeLists.txt | 46 ++++++++++---------- 3 files changed, 73 insertions(+), 74 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5164609b..b4fe429d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ # cmake_minimum_required(VERSION 3.1) -project(spdlog VERSION 0.16.3) +project(spdlog VERSION 0.16.3 LANGUAGES CXX) include(CTest) include(CMakeDependentOption) include(GNUInstallDirs) @@ -73,7 +73,6 @@ configure_file("cmake/spdlog.pc.in" "${pkg_config}" @ONLY) install( TARGETS spdlog EXPORT "${targets_export_name}" - INCLUDES DESTINATION "${include_install_dir}" ) # install headers diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt index 7859e4d5..ae5add05 100644 --- a/example/CMakeLists.txt +++ b/example/CMakeLists.txt @@ -1,49 +1,49 @@ -# *************************************************************************/ -# * Copyright (c) 2015 Ruslan Baratov. */ -# * */ -# * 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. */ -# *************************************************************************/ - -cmake_minimum_required(VERSION 3.0) -project(SpdlogExamples) - -if(TARGET spdlog) - # Part of the main project - add_library(spdlog::spdlog ALIAS spdlog) -else() - # Stand-alone build - find_package(spdlog CONFIG REQUIRED) -endif() - -find_package(Threads) - -add_executable(example example.cpp) -target_link_libraries(example spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) - -add_executable(benchmark bench.cpp) -target_link_libraries(benchmark spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) - -add_executable(multisink multisink.cpp) -target_link_libraries(multisink spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) - -enable_testing() -file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs") -add_test(NAME RunExample COMMAND example) -add_test(NAME RunBenchmark COMMAND benchmark) +# *************************************************************************/ +# * Copyright (c) 2015 Ruslan Baratov. */ +# * */ +# * 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. */ +# *************************************************************************/ + +cmake_minimum_required(VERSION 3.0) +project(SpdlogExamples CXX) + +if(TARGET spdlog) + # Part of the main project + add_library(spdlog::spdlog ALIAS spdlog) +else() + # Stand-alone build + find_package(spdlog CONFIG REQUIRED) +endif() + +find_package(Threads) + +add_executable(example example.cpp) +target_link_libraries(example spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) + +add_executable(benchmark bench.cpp) +target_link_libraries(benchmark spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) + +add_executable(multisink multisink.cpp) +target_link_libraries(multisink spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) + +enable_testing() +file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs") +add_test(NAME RunExample COMMAND example) +add_test(NAME RunBenchmark COMMAND benchmark) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 94bf8e76..ef41e993 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,23 +1,23 @@ -project(spdlog-utests) - -enable_testing() -find_package(Threads REQUIRED) - -set(SPDLOG_UTESTS_SOURCES - errors.cpp - file_helper.cpp - file_log.cpp - format.cpp - includes.h - registry.cpp - test_macros.cpp - utils.cpp - utils.h - main.cpp) - -add_executable(${PROJECT_NAME} ${SPDLOG_UTESTS_SOURCES}) -target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads) -target_link_libraries(${PROJECT_NAME} PRIVATE spdlog) - -add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME}) -file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs") +project(spdlog-utests CXX) + +enable_testing() +find_package(Threads REQUIRED) + +set(SPDLOG_UTESTS_SOURCES + errors.cpp + file_helper.cpp + file_log.cpp + format.cpp + includes.h + registry.cpp + test_macros.cpp + utils.cpp + utils.h + main.cpp) + +add_executable(${PROJECT_NAME} ${SPDLOG_UTESTS_SOURCES}) +target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads) +target_link_libraries(${PROJECT_NAME} PRIVATE spdlog) + +add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME}) +file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs") From 5d08bd17093e2da4d19ad806eeaf1bb3ab6012b6 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 11 Feb 2018 21:16:15 +0100 Subject: [PATCH 05/39] Bump example's cmake version to 3.1 CMake 3.1 is used in main CMakeLists file, no reason not to use it in example. Threads::Threads is introduced in cmake 3.1. --- example/CMakeLists.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt index ae5add05..cc699729 100644 --- a/example/CMakeLists.txt +++ b/example/CMakeLists.txt @@ -21,7 +21,7 @@ # * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ # *************************************************************************/ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.1) project(SpdlogExamples CXX) if(TARGET spdlog) @@ -32,16 +32,16 @@ else() find_package(spdlog CONFIG REQUIRED) endif() -find_package(Threads) +find_package(Threads REQUIRED) add_executable(example example.cpp) -target_link_libraries(example spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries(example spdlog::spdlog Threads::Threads) add_executable(benchmark bench.cpp) -target_link_libraries(benchmark spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries(benchmark spdlog::spdlog Threads::Threads) add_executable(multisink multisink.cpp) -target_link_libraries(multisink spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries(multisink spdlog::spdlog Threads::Threads) enable_testing() file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs") From 8e861728a0512c08ef9907ab708d02309736a796 Mon Sep 17 00:00:00 2001 From: grzadr Date: Thu, 22 Feb 2018 09:46:54 +0100 Subject: [PATCH 06/39] Fix indentation in line 2916 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Compiling with -Wmisleading-indentation triggers warning: /data/Git/spdlog/tests/catch.hpp: In member function ‘bool Catch::TestSpec::Filter::matches(const Catch::TestCaseInfo&) const’: /data/Git/spdlog/tests/catch.hpp:2913:17: warning: this ‘for’ clause does not guard... [-Wmisleading-indentation] for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) ^~~ /data/Git/spdlog/tests/catch.hpp:2916:21: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘for’ return true; ^~~~~~ --- tests/catch.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/catch.hpp b/tests/catch.hpp index 925c6bff..5585d1e3 100644 --- a/tests/catch.hpp +++ b/tests/catch.hpp @@ -2913,7 +2913,7 @@ namespace Catch { for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) if( !(*it)->matches( testCase ) ) return false; - return true; + return true; } }; From 851b49e147eef768680d53e358bb0661b6b363f0 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 22 Feb 2018 13:37:50 +0200 Subject: [PATCH 07/39] Update CMakeLists.txt --- tests/CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index ef41e993..9ec232c8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,5 +1,4 @@ project(spdlog-utests CXX) - enable_testing() find_package(Threads REQUIRED) From bdca50e6a78d8c15d744da483d969216a6e3564b Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 13:26:53 +0200 Subject: [PATCH 08/39] Fixed issue #637 --- include/spdlog/details/async_log_helper.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index bba9bc0e..4ff51391 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -216,9 +216,10 @@ inline spdlog::details::async_log_helper::async_log_helper( _overflow_policy(overflow_policy), _worker_warmup_cb(worker_warmup_cb), _flush_interval_ms(flush_interval_ms), - _worker_teardown_cb(worker_teardown_cb), - _worker_thread(&async_log_helper::worker_loop, this) -{} + _worker_teardown_cb(worker_teardown_cb) +{ + _worker_thread = std::thread(&async_log_helper::worker_loop, this); +} // Send to the worker thread termination message(level=off) // and wait for it to finish gracefully From 6df52df5b4d7e4796d267b4edf989788b67b11ed Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 14:05:48 +0200 Subject: [PATCH 09/39] Use emplace_back in pattern_formatter --- .../spdlog/details/pattern_formatter_impl.h | 71 +++++++++---------- 1 file changed, 35 insertions(+), 36 deletions(-) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index a73f5dea..65339a3b 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -502,8 +502,7 @@ inline void spdlog::pattern_formatter::compile_pattern(const std::string& patter if (*it == '%') { if (user_chars) //append user chars found so far - _formatters.push_back(std::move(user_chars)); - + _formatters.push_back(std::move(user_chars)); if (++it != end) handle_flag(*it); else @@ -527,136 +526,136 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) switch (flag) { // logger name - case 'n': - _formatters.push_back(std::unique_ptr(new details::name_formatter())); + case 'n': + _formatters.emplace_back(new details::name_formatter()); break; case 'l': - _formatters.push_back(std::unique_ptr(new details::level_formatter())); + _formatters.emplace_back(new details::level_formatter()); break; case 'L': - _formatters.push_back(std::unique_ptr(new details::short_level_formatter())); + _formatters.emplace_back(new details::short_level_formatter()); break; case('t'): - _formatters.push_back(std::unique_ptr(new details::t_formatter())); + _formatters.emplace_back(new details::t_formatter()); break; case('v'): - _formatters.push_back(std::unique_ptr(new details::v_formatter())); + _formatters.emplace_back(new details::v_formatter()); break; case('a'): - _formatters.push_back(std::unique_ptr(new details::a_formatter())); + _formatters.emplace_back(new details::a_formatter()); break; case('A'): - _formatters.push_back(std::unique_ptr(new details::A_formatter())); + _formatters.emplace_back(new details::A_formatter()); break; case('b'): case('h'): - _formatters.push_back(std::unique_ptr(new details::b_formatter())); + _formatters.emplace_back(new details::b_formatter()); break; case('B'): - _formatters.push_back(std::unique_ptr(new details::B_formatter())); + _formatters.emplace_back(new details::B_formatter()); break; case('c'): - _formatters.push_back(std::unique_ptr(new details::c_formatter())); + _formatters.emplace_back(new details::c_formatter()); break; case('C'): - _formatters.push_back(std::unique_ptr(new details::C_formatter())); + _formatters.emplace_back(new details::C_formatter()); break; case('Y'): - _formatters.push_back(std::unique_ptr(new details::Y_formatter())); + _formatters.emplace_back(new details::Y_formatter()); break; case('D'): case('x'): - _formatters.push_back(std::unique_ptr(new details::D_formatter())); + _formatters.emplace_back(new details::D_formatter()); break; case('m'): - _formatters.push_back(std::unique_ptr(new details::m_formatter())); + _formatters.emplace_back(new details::m_formatter()); break; case('d'): - _formatters.push_back(std::unique_ptr(new details::d_formatter())); + _formatters.emplace_back(new details::d_formatter()); break; case('H'): - _formatters.push_back(std::unique_ptr(new details::H_formatter())); + _formatters.emplace_back(new details::H_formatter()); break; case('I'): - _formatters.push_back(std::unique_ptr(new details::I_formatter())); + _formatters.emplace_back(new details::I_formatter()); break; case('M'): - _formatters.push_back(std::unique_ptr(new details::M_formatter())); + _formatters.emplace_back(new details::M_formatter()); break; case('S'): - _formatters.push_back(std::unique_ptr(new details::S_formatter())); + _formatters.emplace_back(new details::S_formatter()); break; case('e'): - _formatters.push_back(std::unique_ptr(new details::e_formatter())); + _formatters.emplace_back(new details::e_formatter()); break; case('f'): - _formatters.push_back(std::unique_ptr(new details::f_formatter())); + _formatters.emplace_back(new details::f_formatter()); break; case('F'): - _formatters.push_back(std::unique_ptr(new details::F_formatter())); + _formatters.emplace_back(new details::F_formatter()); break; case('E'): - _formatters.push_back(std::unique_ptr(new details::E_formatter())); + _formatters.emplace_back(new details::E_formatter()); break; case('p'): - _formatters.push_back(std::unique_ptr(new details::p_formatter())); + _formatters.emplace_back(new details::p_formatter()); break; case('r'): - _formatters.push_back(std::unique_ptr(new details::r_formatter())); + _formatters.emplace_back(new details::r_formatter()); break; case('R'): - _formatters.push_back(std::unique_ptr(new details::R_formatter())); + _formatters.emplace_back(new details::R_formatter()); break; case('T'): case('X'): - _formatters.push_back(std::unique_ptr(new details::T_formatter())); + _formatters.emplace_back(new details::T_formatter()); break; case('z'): - _formatters.push_back(std::unique_ptr(new details::z_formatter())); + _formatters.emplace_back(new details::z_formatter()); break; case ('+'): - _formatters.push_back(std::unique_ptr(new details::full_formatter())); + _formatters.emplace_back(new details::full_formatter()); break; case ('P'): - _formatters.push_back(std::unique_ptr(new details::pid_formatter())); + _formatters.emplace_back(new details::pid_formatter()); break; case ('i'): - _formatters.push_back(std::unique_ptr(new details::i_formatter())); + _formatters.emplace_back(new details::i_formatter()); break; default: //Unknown flag appears as is - _formatters.push_back(std::unique_ptr(new details::ch_formatter('%'))); - _formatters.push_back(std::unique_ptr(new details::ch_formatter(flag))); + _formatters.emplace_back(new details::ch_formatter('%')); + _formatters.emplace_back(new details::ch_formatter(flag)); break; } } From 7eb41ccf0f21b7a86115cbd81ae6c66dfb2d446c Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 14:29:14 +0200 Subject: [PATCH 10/39] Use -O3 flag in tests --- tests/Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/Makefile b/tests/Makefile index b1935e75..e8333186 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -1,10 +1,10 @@ CXX ?= g++ ifeq ($(STYLE),printf) $(info *** PRINTF STYLE ***) - CXXFLAGS = -DSPDLOG_FMT_PRINTF -Wall -pedantic -std=c++11 -pthread -O2 -I../include + CXXFLAGS = -DSPDLOG_FMT_PRINTF -Wall -pedantic -std=c++11 -pthread -O3 -I../include else $(info *** FORMAT STYLE ***) - CXXFLAGS = -Wall -pedantic -std=c++11 -pthread -O2 -I../include + CXXFLAGS = -Wall -pedantic -std=c++11 -pthread -O3 -I../include endif LDPFALGS = -pthread From 7fe3912f12efe15639f740ecf76579c5f75d6512 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 14:29:31 +0200 Subject: [PATCH 11/39] astyle --- include/spdlog/details/async_log_helper.h | 4 +- .../spdlog/details/pattern_formatter_impl.h | 70 +++++++++---------- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 4ff51391..82282db9 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -216,9 +216,9 @@ inline spdlog::details::async_log_helper::async_log_helper( _overflow_policy(overflow_policy), _worker_warmup_cb(worker_warmup_cb), _flush_interval_ms(flush_interval_ms), - _worker_teardown_cb(worker_teardown_cb) + _worker_teardown_cb(worker_teardown_cb) { - _worker_thread = std::thread(&async_log_helper::worker_loop, this); + _worker_thread = std::thread(&async_log_helper::worker_loop, this); } // Send to the worker thread termination message(level=off) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 65339a3b..b93d8fb5 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -502,7 +502,7 @@ inline void spdlog::pattern_formatter::compile_pattern(const std::string& patter if (*it == '%') { if (user_chars) //append user chars found so far - _formatters.push_back(std::move(user_chars)); + _formatters.push_back(std::move(user_chars)); if (++it != end) handle_flag(*it); else @@ -526,136 +526,136 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) switch (flag) { // logger name - case 'n': - _formatters.emplace_back(new details::name_formatter()); + case 'n': + _formatters.emplace_back(new details::name_formatter()); break; case 'l': - _formatters.emplace_back(new details::level_formatter()); + _formatters.emplace_back(new details::level_formatter()); break; case 'L': - _formatters.emplace_back(new details::short_level_formatter()); + _formatters.emplace_back(new details::short_level_formatter()); break; case('t'): - _formatters.emplace_back(new details::t_formatter()); + _formatters.emplace_back(new details::t_formatter()); break; case('v'): - _formatters.emplace_back(new details::v_formatter()); + _formatters.emplace_back(new details::v_formatter()); break; case('a'): - _formatters.emplace_back(new details::a_formatter()); + _formatters.emplace_back(new details::a_formatter()); break; case('A'): - _formatters.emplace_back(new details::A_formatter()); + _formatters.emplace_back(new details::A_formatter()); break; case('b'): case('h'): - _formatters.emplace_back(new details::b_formatter()); + _formatters.emplace_back(new details::b_formatter()); break; case('B'): - _formatters.emplace_back(new details::B_formatter()); + _formatters.emplace_back(new details::B_formatter()); break; case('c'): - _formatters.emplace_back(new details::c_formatter()); + _formatters.emplace_back(new details::c_formatter()); break; case('C'): - _formatters.emplace_back(new details::C_formatter()); + _formatters.emplace_back(new details::C_formatter()); break; case('Y'): - _formatters.emplace_back(new details::Y_formatter()); + _formatters.emplace_back(new details::Y_formatter()); break; case('D'): case('x'): - _formatters.emplace_back(new details::D_formatter()); + _formatters.emplace_back(new details::D_formatter()); break; case('m'): - _formatters.emplace_back(new details::m_formatter()); + _formatters.emplace_back(new details::m_formatter()); break; case('d'): - _formatters.emplace_back(new details::d_formatter()); + _formatters.emplace_back(new details::d_formatter()); break; case('H'): - _formatters.emplace_back(new details::H_formatter()); + _formatters.emplace_back(new details::H_formatter()); break; case('I'): - _formatters.emplace_back(new details::I_formatter()); + _formatters.emplace_back(new details::I_formatter()); break; case('M'): - _formatters.emplace_back(new details::M_formatter()); + _formatters.emplace_back(new details::M_formatter()); break; case('S'): - _formatters.emplace_back(new details::S_formatter()); + _formatters.emplace_back(new details::S_formatter()); break; case('e'): - _formatters.emplace_back(new details::e_formatter()); + _formatters.emplace_back(new details::e_formatter()); break; case('f'): - _formatters.emplace_back(new details::f_formatter()); + _formatters.emplace_back(new details::f_formatter()); break; case('F'): - _formatters.emplace_back(new details::F_formatter()); + _formatters.emplace_back(new details::F_formatter()); break; case('E'): - _formatters.emplace_back(new details::E_formatter()); + _formatters.emplace_back(new details::E_formatter()); break; case('p'): - _formatters.emplace_back(new details::p_formatter()); + _formatters.emplace_back(new details::p_formatter()); break; case('r'): - _formatters.emplace_back(new details::r_formatter()); + _formatters.emplace_back(new details::r_formatter()); break; case('R'): - _formatters.emplace_back(new details::R_formatter()); + _formatters.emplace_back(new details::R_formatter()); break; case('T'): case('X'): - _formatters.emplace_back(new details::T_formatter()); + _formatters.emplace_back(new details::T_formatter()); break; case('z'): - _formatters.emplace_back(new details::z_formatter()); + _formatters.emplace_back(new details::z_formatter()); break; case ('+'): - _formatters.emplace_back(new details::full_formatter()); + _formatters.emplace_back(new details::full_formatter()); break; case ('P'): - _formatters.emplace_back(new details::pid_formatter()); + _formatters.emplace_back(new details::pid_formatter()); break; case ('i'): - _formatters.emplace_back(new details::i_formatter()); + _formatters.emplace_back(new details::i_formatter()); break; default: //Unknown flag appears as is - _formatters.emplace_back(new details::ch_formatter('%')); - _formatters.emplace_back(new details::ch_formatter(flag)); + _formatters.emplace_back(new details::ch_formatter('%')); + _formatters.emplace_back(new details::ch_formatter(flag)); break; } } From 051048ebd728fe8623b2970232969bd30606855c Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 14:34:25 +0200 Subject: [PATCH 12/39] Fixed issue #645 (include tweakme.h from common.h) --- include/spdlog/common.h | 2 ++ include/spdlog/spdlog.h | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 0dde700c..9fbfc669 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -5,6 +5,8 @@ #pragma once +#include "tweakme.h" + #include #include #include diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index ff79ef6e..f84697d8 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -9,7 +9,6 @@ #define SPDLOG_VERSION "0.16.3" -#include "tweakme.h" #include "common.h" #include "logger.h" From 04d0dd5987742785f4b6c057d9a63dfa7058666b Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 14:39:41 +0200 Subject: [PATCH 13/39] moved SPDLOG_VERSION macro to common.h --- include/spdlog/common.h | 2 ++ include/spdlog/spdlog.h | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 9fbfc669..6c7ab149 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -5,6 +5,8 @@ #pragma once +#define SPDLOG_VERSION "0.16.3" + #include "tweakme.h" #include diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index f84697d8..8bfffd01 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -7,7 +7,6 @@ #pragma once -#define SPDLOG_VERSION "0.16.3" #include "common.h" #include "logger.h" From 7709fc70eb69f2cf21a7d8d95527a235b2d5545f Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 15:10:21 +0200 Subject: [PATCH 14/39] small fix to pattern_formatter ctor --- include/spdlog/details/pattern_formatter_impl.h | 4 ++-- include/spdlog/formatter.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 3946574e..72f29270 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -487,8 +487,8 @@ class full_formatter SPDLOG_FINAL:public flag_formatter /////////////////////////////////////////////////////////////////////////////// // pattern_formatter inline impl /////////////////////////////////////////////////////////////////////////////// -inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time, std::string eol) - : _eol(move(eol)), _pattern_time(pattern_time) +inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time, const std::string& eol) + : _eol(eol), _pattern_time(pattern_time) { compile_pattern(pattern); } diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index 39315764..b69d7eb1 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -29,7 +29,7 @@ class pattern_formatter SPDLOG_FINAL : public formatter { public: - explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string eol = spdlog::details::os::default_eol); + explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string& eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter&) = delete; pattern_formatter& operator=(const pattern_formatter&) = delete; void format(details::log_msg& msg) override; From 3620b31ef2de4165872a71a616f86bab91c53aa2 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 16:40:45 +0200 Subject: [PATCH 15/39] added pattern formatter tests --- tests/{format.cpp => test_misc.cpp} | 4 +- tests/test_pattern_formatter.cpp | 68 +++++++++++++++++++++++++++++ tests/tests.vcxproj | 4 +- tests/tests.vcxproj.filters | 9 ++-- 4 files changed, 80 insertions(+), 5 deletions(-) rename tests/{format.cpp => test_misc.cpp} (99%) create mode 100644 tests/test_pattern_formatter.cpp diff --git a/tests/format.cpp b/tests/test_misc.cpp similarity index 99% rename from tests/format.cpp rename to tests/test_misc.cpp index 0b2e1d6d..4f6ee72c 100644 --- a/tests/format.cpp +++ b/tests/test_misc.cpp @@ -39,7 +39,6 @@ TEST_CASE("basic_logging ", "[basic_logging]") //REQUIRE(log_info(some_logged_class("some_val")) == "some_val"); } - TEST_CASE("log_levels", "[log_levels]") { REQUIRE(log_info("Hello", spdlog::level::err) == ""); @@ -54,3 +53,6 @@ TEST_CASE("log_levels", "[log_levels]") + + + diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp new file mode 100644 index 00000000..473870e7 --- /dev/null +++ b/tests/test_pattern_formatter.cpp @@ -0,0 +1,68 @@ +#include "includes.h" + +// log to str and return it +static std::string log_to_str(const std::string& msg, std::shared_ptr formatter = nullptr) +{ + std::ostringstream oss; + auto oss_sink = std::make_shared(oss); + spdlog::logger oss_logger("pattern_tester", oss_sink); + oss_logger.set_level(spdlog::level::info); + if (formatter) oss_logger.set_formatter(formatter); + oss_logger.info(msg); + return oss.str(); +} +TEST_CASE("custom eol", "[pattern_formatter]") +{ + std::string msg = "Hello custom eol test"; + std::string eol = ";)"; + auto formatter = std::make_shared("%v", spdlog::pattern_time_type::local, ";)"); + + REQUIRE(log_to_str(msg, formatter) == msg + eol); +} + +TEST_CASE("empty format", "[pattern_formatter]") +{ + auto formatter = std::make_shared("", spdlog::pattern_time_type::local, ""); + REQUIRE(log_to_str("Some message", formatter) == ""); +} + +TEST_CASE("empty format2", "[pattern_formatter]") +{ + auto formatter = std::make_shared("", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "\n"); +} + +TEST_CASE("level", "[pattern_formatter]") +{ + auto formatter = std::make_shared("[%l] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[info] Some message\n"); +} + + +TEST_CASE("short level", "[pattern_formatter]") +{ + auto formatter = std::make_shared("[%L] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[I] Some message\n"); +} + +TEST_CASE("name", "[pattern_formatter]") +{ + auto formatter = std::make_shared("[%n] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n"); +} + +TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") +{ + using namespace::std::chrono; + auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); + auto now_tm = spdlog::details::os::localtime(); + std::stringstream oss; + oss << std::put_time(&now_tm, "%D") << " Some message\n"; + REQUIRE(log_to_str("Some message", formatter) == oss.str()); +} + + + + + + diff --git a/tests/tests.vcxproj b/tests/tests.vcxproj index ef9d78f9..286c6979 100644 --- a/tests/tests.vcxproj +++ b/tests/tests.vcxproj @@ -21,6 +21,7 @@ {59A07559-5F38-4DD6-A7FA-DB4153690B42} tests + 10.0.16299.0 @@ -128,10 +129,11 @@ - + + diff --git a/tests/tests.vcxproj.filters b/tests/tests.vcxproj.filters index adc86e7b..d1fdf73d 100644 --- a/tests/tests.vcxproj.filters +++ b/tests/tests.vcxproj.filters @@ -18,9 +18,6 @@ Source Files - - Source Files - Source Files @@ -39,6 +36,12 @@ Source Files + + Source Files + + + Source Files + From a8b5bb894eeb680b873203b43adf31c860c52c69 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 16:49:26 +0200 Subject: [PATCH 16/39] fixed cmake for tests --- tests/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 9ec232c8..119fab55 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -6,7 +6,8 @@ set(SPDLOG_UTESTS_SOURCES errors.cpp file_helper.cpp file_log.cpp - format.cpp + test_misc.cpp + test_pattern_formatter includes.h registry.cpp test_macros.cpp From 80163dc6c1d3e31fa26c8b9515ecfbf76767442f Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 18:16:43 +0200 Subject: [PATCH 17/39] Better support for WinRT --- include/spdlog/details/os.h | 9 ++++++--- include/spdlog/details/spdlog_impl.h | 5 +++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 2b8f3e95..26d1fd16 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -154,10 +154,13 @@ SPDLOG_CONSTEXPR static const char folder_sep = '/'; inline void prevent_child_fd(FILE *f) { + #ifdef _WIN32 +#if !defined(__cplusplus_winrt) auto file_handle = (HANDLE)_get_osfhandle(_fileno(f)); if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) throw spdlog_ex("SetHandleInformation failed", errno); +#endif #else auto fd = fileno(f); if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) @@ -351,7 +354,7 @@ inline size_t _thread_id() //Return current thread id as size_t (from thread local storage) inline size_t thread_id() { -#if defined(SPDLOG_DISABLE_TID_CACHING) || (defined(_MSC_VER) && (_MSC_VER < 1900)) || (defined(__clang__) && !__has_feature(cxx_thread_local)) +#if defined(SPDLOG_DISABLE_TID_CACHING) || (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt ) || (defined(__clang__) && !__has_feature(cxx_thread_local)) return _thread_id(); #else // cache thread id in tls static thread_local const size_t tid = _thread_id(); @@ -367,7 +370,7 @@ inline size_t thread_id() inline void sleep_for_millis(int milliseconds) { #if defined(_WIN32) - Sleep(milliseconds); + ::Sleep(milliseconds); #else std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); #endif @@ -436,7 +439,7 @@ inline int pid() { #ifdef _WIN32 - return ::_getpid(); + return static_cast(::GetCurrentProcessId()); #else return static_cast(::getpid()); #endif diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 25c7b7e9..9733a733 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -16,7 +16,7 @@ #include "../sinks/syslog_sink.h" #endif -#ifdef _WIN32 +#if defined _WIN32 && !defined(__cplusplus_winrt) #include "../sinks/wincolor_sink.h" #else #include "../sinks/ansicolor_sink.h" @@ -107,7 +107,8 @@ inline std::shared_ptr spdlog::stderr_logger_st(const std::strin // // stdout/stderr color loggers // -#ifdef _WIN32 +#if defined _WIN32 && !defined(__cplusplus_winrt) + inline std::shared_ptr spdlog::stdout_color_mt(const std::string& logger_name) { auto sink = std::make_shared(); From d650fa24561bd710b1c9adaa9d945d9c66f4afc0 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 18:25:39 +0200 Subject: [PATCH 18/39] Fixed tests for older gcc compilers --- tests/test_pattern_formatter.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp index 473870e7..38fad954 100644 --- a/tests/test_pattern_formatter.cpp +++ b/tests/test_pattern_formatter.cpp @@ -51,13 +51,14 @@ TEST_CASE("name", "[pattern_formatter]") REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n"); } + TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") { using namespace::std::chrono; auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); auto now_tm = spdlog::details::os::localtime(); std::stringstream oss; - oss << std::put_time(&now_tm, "%D") << " Some message\n"; + oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; REQUIRE(log_to_str("Some message", formatter) == oss.str()); } From 3826ac14336b7b862b48ef9182672fe572f1a47c Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 18:32:06 +0200 Subject: [PATCH 19/39] bumped bundled fmt version to 4.1.0 --- include/spdlog/fmt/bundled/format.cc | 64 +- include/spdlog/fmt/bundled/format.h | 5206 ++++++++++++-------------- include/spdlog/fmt/bundled/ostream.h | 98 +- include/spdlog/fmt/bundled/posix.h | 459 +-- include/spdlog/fmt/bundled/printf.h | 927 ++--- include/spdlog/fmt/bundled/time.h | 222 +- 6 files changed, 3119 insertions(+), 3857 deletions(-) diff --git a/include/spdlog/fmt/bundled/format.cc b/include/spdlog/fmt/bundled/format.cc index 09d2ea9f..2d236bc6 100644 --- a/include/spdlog/fmt/bundled/format.cc +++ b/include/spdlog/fmt/bundled/format.cc @@ -72,9 +72,11 @@ // Dummy implementations of strerror_r and strerror_s called if corresponding // system functions are not available. +FMT_MAYBE_UNUSED static inline fmt::internal::Null<> strerror_r(int, char *, ...) { return fmt::internal::Null<>(); } +FMT_MAYBE_UNUSED static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) { return fmt::internal::Null<>(); } @@ -121,7 +123,7 @@ typedef void (*FormatFunc)(Writer &, int, StringRef); // Buffer should be at least of size 1. int safe_strerror( int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT { - FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer"); + FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer"); class StrError { private: @@ -159,6 +161,11 @@ int safe_strerror( ERANGE : result; } +#ifdef __c2__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif + // Fallback to strerror if strerror_r and strerror_s are not available. int fallback(internal::Null<>) { errno = 0; @@ -166,13 +173,15 @@ int safe_strerror( return errno; } +#ifdef __c2__ +# pragma clang diagnostic pop +#endif + public: StrError(int err_code, char *&buf, std::size_t buf_size) : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} int run() { - // Suppress a warning about unused strerror_r. - strerror_r(0, FMT_NULL, ""); return handle(strerror_r(error_code_, buffer_, buffer_size_)); } }; @@ -396,51 +405,6 @@ FMT_FUNC void format_system_error( fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. } -template -void internal::ArgMap::init(const ArgList &args) { - if (!map_.empty()) - return; - typedef internal::NamedArg NamedArg; - const NamedArg *named_arg = FMT_NULL; - bool use_values = - args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; - if (use_values) { - for (unsigned i = 0;/*nothing*/; ++i) { - internal::Arg::Type arg_type = args.type(i); - switch (arg_type) { - case internal::Arg::NONE: - return; - case internal::Arg::NAMED_ARG: - named_arg = static_cast(args.values_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); - break; - default: - /*nothing*/; - } - } - return; - } - for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { - internal::Arg::Type arg_type = args.type(i); - if (arg_type == internal::Arg::NAMED_ARG) { - named_arg = static_cast(args.args_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); - } - } - for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { - switch (args.args_[i].type) { - case internal::Arg::NONE: - return; - case internal::Arg::NAMED_ARG: - named_arg = static_cast(args.args_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); - break; - default: - /*nothing*/; - } - } -} - template void internal::FixedBuffer::grow(std::size_t) { FMT_THROW(std::runtime_error("buffer overflow")); @@ -502,8 +466,6 @@ template struct internal::BasicData; template void internal::FixedBuffer::grow(std::size_t); -template void internal::ArgMap::init(const ArgList &args); - template FMT_API int internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, double value); @@ -516,8 +478,6 @@ template FMT_API int internal::CharTraits::format_float( template void internal::FixedBuffer::grow(std::size_t); -template void internal::ArgMap::init(const ArgList &args); - template FMT_API int internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, double value); diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h index 91f43481..561a9e07 100644 --- a/include/spdlog/fmt/bundled/format.h +++ b/include/spdlog/fmt/bundled/format.h @@ -28,6 +28,7 @@ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ +#define FMT_INCLUDE #include #include #include @@ -39,11 +40,26 @@ #include #include #include // for std::pair +#undef FMT_INCLUDE // The fmt library version in the form major * 10000 + minor * 100 + patch. -#define FMT_VERSION 40000 +#define FMT_VERSION 40100 -#ifdef _SECURE_SCL +#if defined(__has_include) +# define FMT_HAS_INCLUDE(x) __has_include(x) +#else +# define FMT_HAS_INCLUDE(x) 0 +#endif + +#if (FMT_HAS_INCLUDE() && __cplusplus > 201402L) || \ + (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) +# include +# define FMT_HAS_STRING_VIEW 1 +#else +# define FMT_HAS_STRING_VIEW 0 +#endif + +#if defined _SECURE_SCL && _SECURE_SCL # define FMT_SECURE_SCL _SECURE_SCL #else # define FMT_SECURE_SCL 0 @@ -97,7 +113,9 @@ typedef __int64 intmax_t; # define FMT_HAS_GXX_CXX11 1 # endif #else +# define FMT_GCC_VERSION 0 # define FMT_GCC_EXTENSION +# define FMT_HAS_GXX_CXX11 0 #endif #if defined(__INTEL_COMPILER) @@ -135,6 +153,32 @@ typedef __int64 intmax_t; # define FMT_HAS_CPP_ATTRIBUTE(x) 0 #endif +#if FMT_HAS_CPP_ATTRIBUTE(maybe_unused) +# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED +// VC++ 1910 support /std: option and that will set _MSVC_LANG macro +// Clang with Microsoft CodeGen doesn't define _MSVC_LANG macro +#elif defined(_MSVC_LANG) && _MSVC_LANG > 201402 && _MSC_VER >= 1910 +# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED +#endif + +#ifdef FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED +# define FMT_MAYBE_UNUSED [[maybe_unused]] +// g++/clang++ also support [[gnu::unused]]. However, we don't use it. +#elif defined(__GNUC__) +# define FMT_MAYBE_UNUSED __attribute__((unused)) +#else +# define FMT_MAYBE_UNUSED +#endif + +// Use the compiler's attribute noreturn +#if defined(__MINGW32__) || defined(__MINGW64__) +# define FMT_NORETURN __attribute__((noreturn)) +#elif FMT_HAS_CPP_ATTRIBUTE(noreturn) && __cplusplus >= 201103L +# define FMT_NORETURN [[noreturn]] +#else +# define FMT_NORETURN +#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++ @@ -156,6 +200,12 @@ typedef __int64 intmax_t; # endif #endif +#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700 +# define FMT_USE_ALLOCATOR_TRAITS 1 +#else +# define FMT_USE_ALLOCATOR_TRAITS 0 +#endif + // Check if exceptions are disabled. #if defined(__GNUC__) && !defined(__EXCEPTIONS) # define FMT_EXCEPTIONS 0 @@ -262,11 +312,14 @@ typedef __int64 intmax_t; // makes the fmt::literals implementation easier. However, an explicit check // for variadic templates is added here just in case. // For Intel's compiler both it and the system gcc/msc must support UDLs. -# define FMT_USE_USER_DEFINED_LITERALS \ - FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ +# if FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ (FMT_HAS_FEATURE(cxx_user_literals) || \ (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \ (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500) +# define FMT_USE_USER_DEFINED_LITERALS 1 +# else +# define FMT_USE_USER_DEFINED_LITERALS 0 +# endif #endif #ifndef FMT_USE_EXTERN_TEMPLATES @@ -303,166 +356,130 @@ typedef __int64 intmax_t; #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) # include // _BitScanReverse, _BitScanReverse64 -namespace fmt -{ -namespace internal -{ -# pragma intrinsic(_BitScanReverse) -inline uint32_t clz(uint32_t x) -{ - unsigned long r = 0; - _BitScanReverse(&r, x); +namespace fmt { +namespace internal { +// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning +# ifndef __clang__ +# pragma intrinsic(_BitScanReverse) +# endif +inline uint32_t clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); - assert(x != 0); - // Static analysis complains about using uninitialized data - // "r", but the only way that can happen is if "x" is 0, - // which the callers guarantee to not happen. + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. # pragma warning(suppress: 6102) - return 31 - r; + return 31 - r; } # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) -# ifdef _WIN64 +// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning +# if defined(_WIN64) && !defined(__clang__) # pragma intrinsic(_BitScanReverse64) # endif -inline uint32_t clzll(uint64_t x) -{ - unsigned long r = 0; +inline uint32_t clzll(uint64_t x) { + unsigned long r = 0; # ifdef _WIN64 - _BitScanReverse64(&r, x); + _BitScanReverse64(&r, x); # else - // Scan the high 32 bits. - if (_BitScanReverse(&r, static_cast(x >> 32))) - return 63 - (r + 32); + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); - // Scan the low 32 bits. - _BitScanReverse(&r, static_cast(x)); + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); # endif - assert(x != 0); - // Static analysis complains about using uninitialized data - // "r", but the only way that can happen is if "x" is 0, - // which the callers guarantee to not happen. + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. # pragma warning(suppress: 6102) - return 63 - r; + return 63 - r; } # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) } } #endif -namespace fmt -{ -namespace internal -{ -struct DummyInt -{ - int data[2]; - operator int() const - { - return 0; - } +namespace fmt { +namespace internal { +struct DummyInt { + int data[2]; + operator int() const { return 0; } }; typedef std::numeric_limits FPUtil; // Dummy implementations of system functions such as signbit and ecvt called // if the latter are not available. -inline DummyInt signbit(...) -{ - return DummyInt(); -} -inline DummyInt _ecvt_s(...) -{ - return DummyInt(); -} -inline DummyInt isinf(...) -{ - return DummyInt(); -} -inline DummyInt _finite(...) -{ - return DummyInt(); -} -inline DummyInt isnan(...) -{ - return DummyInt(); -} -inline DummyInt _isnan(...) -{ - return DummyInt(); -} +inline DummyInt signbit(...) { return DummyInt(); } +inline DummyInt _ecvt_s(...) { return DummyInt(); } +inline DummyInt isinf(...) { return DummyInt(); } +inline DummyInt _finite(...) { return DummyInt(); } +inline DummyInt isnan(...) { return DummyInt(); } +inline DummyInt _isnan(...) { return DummyInt(); } // A helper function to suppress bogus "conditional expression is constant" // warnings. template -inline T const_check(T value) -{ - return value; -} +inline T const_check(T value) { return value; } } } // namespace fmt -namespace std -{ +namespace std { // Standard permits specialization of std::numeric_limits. This specialization // is used to resolve ambiguity between isinf and std::isinf in glibc: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 // and the same for isnan and signbit. template <> class numeric_limits : - public std::numeric_limits -{ -public: - // Portable version of isinf. - template - static bool isinfinity(T x) - { - using namespace fmt::internal; - // The resolution "priority" is: - // isinf macro > std::isinf > ::isinf > fmt::internal::isinf - if (const_check(sizeof(isinf(x)) == sizeof(bool) || - sizeof(isinf(x)) == sizeof(int))) - { - return isinf(x) != 0; - } - return !_finite(static_cast(x)); + public std::numeric_limits { + public: + // Portable version of isinf. + template + static bool isinfinity(T x) { + using namespace fmt::internal; + // The resolution "priority" is: + // isinf macro > std::isinf > ::isinf > fmt::internal::isinf + if (const_check(sizeof(isinf(x)) == sizeof(bool) || + sizeof(isinf(x)) == sizeof(int))) { + return isinf(x) != 0; } + return !_finite(static_cast(x)); + } - // Portable version of isnan. - template - static bool isnotanumber(T x) - { - using namespace fmt::internal; - if (const_check(sizeof(isnan(x)) == sizeof(bool) || - sizeof(isnan(x)) == sizeof(int))) - { - return isnan(x) != 0; - } - return _isnan(static_cast(x)) != 0; + // Portable version of isnan. + template + static bool isnotanumber(T x) { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) == sizeof(bool) || + sizeof(isnan(x)) == sizeof(int))) { + return isnan(x) != 0; } + return _isnan(static_cast(x)) != 0; + } - // Portable version of signbit. - static bool isnegative(double x) - { - using namespace fmt::internal; - if (const_check(sizeof(signbit(x)) == sizeof(bool) || - sizeof(signbit(x)) == sizeof(int))) - { - return signbit(x) != 0; - } - if (x < 0) return true; - if (!isnotanumber(x)) return false; - int dec = 0, sign = 0; - char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. - _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); - return sign != 0; + // Portable version of signbit. + static bool isnegative(double x) { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) == sizeof(bool) || + sizeof(signbit(x)) == sizeof(int))) { + return signbit(x) != 0; } + if (x < 0) return true; + if (!isnotanumber(x)) return false; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); + return sign != 0; + } }; } // namespace std -namespace fmt -{ +namespace fmt { // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -517,91 +534,96 @@ class BasicFormatter; \endrst */ template -class BasicStringRef -{ -private: - const Char *data_; - std::size_t size_; +class BasicStringRef { + private: + const Char *data_; + std::size_t size_; -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) {} + 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) {} - /** - \rst - Constructs a string reference object from a C string computing - the size with ``std::char_traits::length``. - \endrst - */ - BasicStringRef(const Char *s) - : data_(s), size_(std::char_traits::length(s)) {} + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + BasicStringRef(const Char *s) + : data_(s), size_(std::char_traits::length(s)) {} - /** - \rst - Constructs a string reference from a ``std::basic_string`` object. - \endrst - */ - template - BasicStringRef( - const std::basic_string, Allocator> &s) - : data_(s.c_str()), size_(s.size()) {} + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()), size_(s.size()) {} - /** - \rst - Converts a string reference to an ``std::string`` object. - \endrst - */ - std::basic_string to_string() const - { - return std::basic_string(data_, size_); - } +#if FMT_HAS_STRING_VIEW + /** + \rst + Constructs a string reference from a ``std::basic_string_view`` object. + \endrst + */ + BasicStringRef( + const std::basic_string_view> &s) + : data_(s.data()), size_(s.size()) {} - /** Returns a pointer to the string data. */ - const Char *data() const - { - return data_; - } + /** + \rst + Converts a string reference to an ``std::string_view`` object. + \endrst + */ + explicit operator std::basic_string_view() const FMT_NOEXCEPT { + return std::basic_string_view(data_, size_); + } +#endif - /** Returns the string size. */ - std::size_t size() const - { - return size_; - } + /** + \rst + Converts a string reference to an ``std::string`` object. + \endrst + */ + std::basic_string to_string() const { + return std::basic_string(data_, size_); + } - // Lexicographically compare this string reference to other. - int compare(BasicStringRef other) const - { - std::size_t size = size_ < other.size_ ? size_ : other.size_; - int result = std::char_traits::compare(data_, other.data_, size); - if (result == 0) - result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - return result; - } + /** Returns a pointer to the string data. */ + const Char *data() const { return data_; } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) == 0; - } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) != 0; - } - friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) < 0; - } - friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) <= 0; - } - friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) > 0; - } - friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.compare(rhs) >= 0; - } + /** Returns the string size. */ + std::size_t size() const { return size_; } + + // Lexicographically compare this string reference to other. + int compare(BasicStringRef other) const { + std::size_t size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) != 0; + } + friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) >= 0; + } }; typedef BasicStringRef StringRef; @@ -633,54 +655,45 @@ typedef BasicStringRef WStringRef; \endrst */ template -class BasicCStringRef -{ -private: - const Char *data_; +class BasicCStringRef { + private: + const Char *data_; -public: - /** Constructs a string reference object from a C string. */ - BasicCStringRef(const Char *s) : data_(s) {} + public: + /** Constructs a string reference object from a C string. */ + BasicCStringRef(const Char *s) : data_(s) {} - /** - \rst - Constructs a string reference from a ``std::basic_string`` object. - \endrst - */ - template - BasicCStringRef( - const std::basic_string, Allocator> &s) - : data_(s.c_str()) {} + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicCStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()) {} - /** Returns the pointer to a C string. */ - const Char *c_str() const - { - return data_; - } + /** Returns the pointer to a C string. */ + const Char *c_str() const { return data_; } }; typedef BasicCStringRef CStringRef; typedef BasicCStringRef WCStringRef; /** A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error -{ -public: - explicit FormatError(CStringRef message) - : std::runtime_error(message.c_str()) {} - FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} - FMT_API ~FormatError() FMT_DTOR_NOEXCEPT; +class FormatError : public std::runtime_error { + public: + explicit FormatError(CStringRef message) + : std::runtime_error(message.c_str()) {} + FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} + FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; }; -namespace internal -{ +namespace internal { // 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 <> \ @@ -695,10 +708,9 @@ FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong); // Casts nonnegative integer to unsigned. template -inline typename MakeUnsigned::Type to_unsigned(Int value) -{ - FMT_ASSERT(value >= 0, "negative value"); - return static_cast::Type>(value); +inline typename MakeUnsigned::Type to_unsigned(Int value) { + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::Type>(value); } // The number of characters to store in the MemoryBuffer object itself @@ -708,16 +720,12 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if FMT_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 @@ -727,339 +735,278 @@ inline T *make_ptr(T *ptr, std::size_t) \endrst */ 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 = FMT_NULL, std::size_t capacity = 0) - : ptr_(ptr), size_(0), capacity_(capacity) {} + Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0) + : ptr_(ptr), size_(0), capacity_(capacity) {} - /** - \rst - Increases the buffer capacity to hold at least *size* elements updating - ``ptr_`` and ``capacity_``. - \endrst - */ - virtual void grow(std::size_t size) = 0; + /** + \rst + Increases the buffer capacity to hold at least *size* elements updating + ``ptr_`` and ``capacity_``. + \endrst + */ + 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 may not be 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; + } - /** - \rst - Reserves space to store at least *capacity* elements. - \endrst - */ - void reserve(std::size_t capacity) - { - if (capacity > capacity_) - grow(capacity); - } + /** + \rst + Reserves space to store at least *capacity* elements. + \endrst + */ + void reserve(std::size_t capacity) { + if (capacity > capacity_) + grow(capacity); + } - void clear() FMT_NOEXCEPT { size_ = 0; } + void clear() FMT_NOEXCEPT { size_ = 0; } - void push_back(const T &value) - { - if (size_ == capacity_) - grow(size_ + 1); - ptr_[size_++] = value; - } + void push_back(const T &value) { + if (size_ == capacity_) + grow(size_ + 1); + ptr_[size_++] = value; + } - /** Appends data to the end of the buffer. */ - template - void append(const U *begin, const U *end); + /** Appends data to the end of the buffer. */ + template + void append(const U *begin, const U *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 template -void Buffer::append(const U *begin, const U *end) -{ - FMT_ASSERT(end >= begin, "negative value"); - std::size_t new_size = size_ + (end - begin); - if (new_size > capacity_) - grow(new_size); - std::uninitialized_copy(begin, end, - internal::make_ptr(ptr_, capacity_) + size_); - size_ = new_size; +void Buffer::append(const U *begin, const U *end) { + FMT_ASSERT(end >= begin, "negative value"); + std::size_t new_size = size_ + static_cast(end - begin); + if (new_size > capacity_) + grow(new_size); + std::uninitialized_copy(begin, end, + internal::make_ptr(ptr_, capacity_) + size_); + size_ = new_size; } -namespace internal -{ +namespace internal { // A memory buffer for trivially copyable/constructible 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]; - // Deallocate memory allocated by the buffer. - void deallocate() - { - if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); - } + // Deallocate memory allocated by the buffer. + void deallocate() { + if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); + } -protected: - void grow(std::size_t size) FMT_OVERRIDE; + protected: + void grow(std::size_t size) FMT_OVERRIDE; -public: - explicit MemoryBuffer(const Allocator &alloc = Allocator()) - : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() - { - deallocate(); - } + public: + explicit MemoryBuffer(const Allocator &alloc = Allocator()) + : Allocator(alloc), Buffer(data_, SIZE) {} + ~MemoryBuffer() FMT_OVERRIDE { deallocate(); } #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::uninitialized_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 deallocating. - 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::uninitialized_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 deallocating. + other.ptr_ = other.data_; } + } -public: - MemoryBuffer(MemoryBuffer &&other) - { - move(other); - } + public: + MemoryBuffer(MemoryBuffer &&other) { + move(other); + } - MemoryBuffer &operator=(MemoryBuffer &&other) - { - assert(this != &other); - deallocate(); - move(other); - return *this; - } + MemoryBuffer &operator=(MemoryBuffer &&other) { + assert(this != &other); + deallocate(); + 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 = this->capacity_ + this->capacity_ / 2; - if (size > new_capacity) - new_capacity = size; - T *new_ptr = this->allocate(new_capacity, FMT_NULL); - // The following code doesn't throw, so the raw pointer above doesn't leak. - std::uninitialized_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_) - Allocator::deallocate(old_ptr, old_capacity); +void MemoryBuffer::grow(std::size_t size) { + std::size_t new_capacity = this->capacity_ + this->capacity_ / 2; + if (size > new_capacity) + new_capacity = size; +#if FMT_USE_ALLOCATOR_TRAITS + T *new_ptr = + std::allocator_traits::allocate(*this, new_capacity, FMT_NULL); +#else + T *new_ptr = this->allocate(new_capacity, FMT_NULL); +#endif + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_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_) + Allocator::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) {} +class FixedBuffer : public fmt::Buffer { + public: + FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} -protected: - FMT_API void grow(std::size_t size) FMT_OVERRIDE; + protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; }; template -class BasicCharTraits -{ -public: +class BasicCharTraits { + public: #if FMT_SECURE_SCL - typedef stdext::checked_array_iterator CharPtr; + typedef stdext::checked_array_iterator CharPtr; #else - typedef Char *CharPtr; + typedef Char *CharPtr; #endif - static Char cast(int value) - { - return static_cast(value); - } + static Char cast(int value) { return static_cast(value); } }; template class CharTraits; template <> -class CharTraits : public BasicCharTraits -{ -private: - // Conversion from wchar_t to char is not allowed. - static char convert(wchar_t); +class CharTraits : public BasicCharTraits { + private: + // Conversion from wchar_t to char is not allowed. + static char convert(wchar_t); -public: - static char convert(char value) - { - return value; - } + public: + static char convert(char value) { return value; } - // Formats a floating-point number. - template - FMT_API 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 + FMT_API static int format_float(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); }; #if FMT_USE_EXTERN_TEMPLATES extern template int CharTraits::format_float -(char *buffer, std::size_t size, - const char* format, unsigned width, int precision, double value); + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, double value); extern template int CharTraits::format_float -(char *buffer, std::size_t size, - const char* format, unsigned width, int precision, long double value); + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, long double value); #endif template <> -class CharTraits : public BasicCharTraits -{ -public: - static wchar_t convert(char value) - { - return value; - } - static wchar_t convert(wchar_t value) - { - return value; - } +class CharTraits : public BasicCharTraits { + public: + static wchar_t convert(char value) { return value; } + static wchar_t convert(wchar_t value) { return value; } - template - FMT_API static int format_float(wchar_t *buffer, std::size_t size, - const wchar_t *format, unsigned width, int precision, T value); + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); }; #if FMT_USE_EXTERN_TEMPLATES extern template int CharTraits::format_float -(wchar_t *buffer, std::size_t size, - const wchar_t* format, unsigned width, int precision, double value); + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, double value); extern template int CharTraits::format_float -(wchar_t *buffer, std::size_t size, - const wchar_t* format, unsigned width, int precision, long double value); + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, long double value); #endif // 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; }; -FMT_API void report_unknown_type(char code, const char *type); +FMT_API FMT_NORETURN void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct FMT_API BasicData -{ - static const uint32_t POWERS_OF_10_32[]; - static const uint64_t POWERS_OF_10_64[]; - static const char DIGITS[]; +struct FMT_API BasicData { + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const char DIGITS[]; }; #if FMT_USE_EXTERN_TEMPLATES @@ -1071,70 +1018,63 @@ typedef BasicData<> Data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) -{ - // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. - int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; - return to_unsigned(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. + int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1; } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) -{ - unsigned count = 1; - for (;;) - { - // Integer division is slow so do it for a group of four digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - if (n < 10) return count; - if (n < 100) return count + 1; - if (n < 1000) return count + 2; - if (n < 10000) return count + 3; - n /= 10000u; - count += 4; - } +inline unsigned count_digits(uint64_t n) { + unsigned count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } } #endif #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) -{ - int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; - return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; +inline unsigned count_digits(uint32_t n) { + int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; } #endif // A functor that doesn't add a thousands separator. -struct NoThousandsSep -{ - template - void operator()(Char *) {} +struct NoThousandsSep { + template + void operator()(Char *) {} }; // A functor that adds a thousands separator. -class ThousandsSep -{ -private: - fmt::StringRef sep_; +class ThousandsSep { + private: + fmt::StringRef sep_; - // Index of a decimal digit with the least significant digit having index 0. - unsigned digit_index_; + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; -public: - explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} + public: + explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} - template - void operator()(Char *&buffer) - { - if (++digit_index_ % 3 != 0) - return; - buffer -= sep_.size(); - std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), - internal::make_ptr(buffer, sep_.size())); - } + template + void operator()(Char *&buffer) { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), + internal::make_ptr(buffer, sep_.size())); + } }; // Formats a decimal unsigned integer value writing into buffer. @@ -1142,37 +1082,33 @@ public: // add a thousands separator if necessary. template inline void format_decimal(Char *buffer, UInt value, unsigned num_digits, - ThousandsSep thousands_sep) -{ - buffer += 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 = static_cast((value % 100) * 2); - value /= 100; - *--buffer = Data::DIGITS[index + 1]; - thousands_sep(buffer); - *--buffer = Data::DIGITS[index]; - thousands_sep(buffer); - } - if (value < 10) - { - *--buffer = static_cast('0' + value); - return; - } - unsigned index = static_cast(value * 2); + ThousandsSep thousands_sep) { + buffer += 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 = static_cast((value % 100) * 2); + value /= 100; *--buffer = Data::DIGITS[index + 1]; thousands_sep(buffer); *--buffer = Data::DIGITS[index]; + thousands_sep(buffer); + } + if (value < 10) { + *--buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; } template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) -{ - format_decimal(buffer, value, num_digits, NoThousandsSep()); - return; +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { + format_decimal(buffer, value, num_digits, NoThousandsSep()); + return; } #ifndef _WIN32 @@ -1186,62 +1122,36 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) #if FMT_USE_WINDOWS_H // 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: - FMT_API 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: + FMT_API 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() {} - FMT_API 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() {} + FMT_API 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. - FMT_API 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. + FMT_API int convert(WStringRef s); }; FMT_API void format_windows_error(fmt::Writer &out, int error_code, @@ -1249,56 +1159,50 @@ FMT_API void format_windows_error(fmt::Writer &out, int error_code, #endif // A formatting argument value. -struct Value -{ - template - struct StringValue - { - const Char *value; - std::size_t size; - }; +struct Value { + template + struct StringValue { + const Char *value; + std::size_t size; + }; - typedef void (*FormatFunc)( - void *formatter, const void *arg, void *format_str_ptr); + typedef void (*FormatFunc)( + void *formatter, const void *arg, void *format_str_ptr); - struct CustomValue - { - const void *value; - FormatFunc format; - }; + 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; - }; + 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, NAMED_ARG, - // Integer types should go first, - INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, - // followed by floating-point types. - DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, - CSTRING, STRING, WSTRING, POINTER, CUSTOM - }; + enum Type { + NONE, NAMED_ARG, + // Integer types should go first, + INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, + // followed by floating-point types. + DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, + CSTRING, STRING, WSTRING, POINTER, CUSTOM + }; }; // A formatting argument. It is a trivially copyable/constructible type to // allow storage in internal::MemoryBuffer. -struct Arg : Value -{ - Type type; +struct Arg : Value { + Type type; }; template @@ -1312,17 +1216,15 @@ struct Null {}; // A helper class template to enable or disable overloads taking wide // characters and strings in MakeValue. template -struct WCharHelper -{ - typedef Null Supported; - typedef T Unsupported; +struct WCharHelper { + typedef Null Supported; + typedef T Unsupported; }; template -struct WCharHelper -{ - typedef T Supported; - typedef Null Unsupported; +struct WCharHelper { + typedef T Supported; + typedef Null Unsupported; }; typedef char Yes[1]; @@ -1335,36 +1237,30 @@ T &get(); Yes &convert(fmt::ULongLong); No &convert(...); -template -struct ConvertToIntImpl -{ - enum { value = ENABLE_CONVERSION }; +template +struct ConvertToIntImpl { + enum { value = ENABLE_CONVERSION }; }; -template -struct ConvertToIntImpl2 -{ - enum { value = false }; +template +struct ConvertToIntImpl2 { + enum { value = false }; }; -template -struct ConvertToIntImpl2 -{ - enum - { - // Don't convert numeric types. - value = ConvertToIntImpl::is_specialized>::value - }; +template +struct ConvertToIntImpl2 { + enum { + // Don't convert numeric types. + value = ConvertToIntImpl::is_specialized>::value + }; }; -template -struct ConvertToInt -{ - enum - { - enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) - }; - enum { value = ConvertToIntImpl2::value }; +template +struct ConvertToInt { + enum { + enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) + }; + enum { value = ConvertToIntImpl2::value }; }; #define FMT_DISABLE_CONVERSION_TO_INT(Type) \ @@ -1376,49 +1272,30 @@ FMT_DISABLE_CONVERSION_TO_INT(float); FMT_DISABLE_CONVERSION_TO_INT(double); FMT_DISABLE_CONVERSION_TO_INT(long double); -template +template struct EnableIf {}; -template -struct EnableIf -{ - typedef T type; -}; +template +struct EnableIf { typedef T type; }; -template -struct Conditional -{ - typedef T type; -}; +template +struct Conditional { typedef T type; }; -template -struct Conditional -{ - typedef F type; -}; +template +struct Conditional { typedef F type; }; // For bcc32 which doesn't understand ! in template arguments. template -struct Not -{ - enum { value = 0 }; -}; +struct Not { enum { value = 0 }; }; template <> -struct Not -{ - enum { value = 1 }; -}; +struct Not { enum { value = 1 }; }; template -struct FalseType -{ - enum { value = 0 }; -}; +struct FalseType { enum { value = 0 }; }; -template struct LConvCheck -{ - LConvCheck(int) {} +template struct LConvCheck { + LConvCheck(int) {} }; // Returns the thousands separator for the current locale. @@ -1426,15 +1303,11 @@ template struct LConvCheck // ``lconv`` is stubbed as an empty struct. template inline StringRef thousands_sep( - LConv *lc, LConvCheck = 0) -{ - return lc->thousands_sep; + LConv *lc, LConvCheck = 0) { + return lc->thousands_sep; } -inline fmt::StringRef thousands_sep(...) -{ - return ""; -} +inline fmt::StringRef thousands_sep(...) { return ""; } #define FMT_CONCAT(a, b) a##b @@ -1457,69 +1330,67 @@ inline fmt::StringRef thousands_sep(...) typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED #endif -template -void format_arg(Formatter &, const Char *, const T &) -{ - FMT_STATIC_ASSERT(FalseType::value, - "Cannot format argument. To enable the use of ostream " - "operator<< include fmt/ostream.h. Otherwise provide " - "an overload of format_arg."); +template +void format_arg(Formatter&, ...) { + FMT_STATIC_ASSERT(FalseType::value, + "Cannot format argument. To enable the use of ostream " + "operator<< include fmt/ostream.h. Otherwise provide " + "an overload of format_arg."); } // Makes an Arg object from any type. template -class MakeValue : public Arg -{ -public: - typedef typename Formatter::Char Char; +class MakeValue : public Arg { + public: + typedef typename Formatter::Char Char; -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); + private: + // The following two methods are private to disallow formatting of + // arbitrary pointers. If you want to output a pointer cast it to + // "void *" or "const void *". In particular, this forbids formatting + // of "[const] volatile char *" which is printed as bool by iostreams. + // Do not implement! + template + MakeValue(const T *value); + template + MakeValue(T *value); - // The following methods are private to disallow formatting of wide - // characters and strings into narrow strings as in - // fmt::format("{}", L"test"); - // To fix this, use a wide format string: fmt::format(L"{}", L"test"). + // 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"). #if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); #endif - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); +#if FMT_HAS_STRING_VIEW + MakeValue(typename WCharHelper::Unsupported); +#endif + MakeValue(typename WCharHelper::Unsupported); - void set_string(StringRef str) - { - string.value = str.data(); - string.size = str.size(); - } + void set_string(StringRef str) { + string.value = str.data(); + string.size = str.size(); + } - void set_string(WStringRef str) - { - wstring.value = str.data(); - wstring.size = str.size(); - } + void set_string(WStringRef str) { + wstring.value = str.data(); + wstring.size = str.size(); + } - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) - { - format_arg(*static_cast(formatter), - *static_cast(format_str_ptr), - *static_cast(arg)); - } + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg( + void *formatter, const void *arg, void *format_str_ptr) { + format_arg(*static_cast(formatter), + *static_cast(format_str_ptr), + *static_cast(arg)); + } -public: - MakeValue() {} + public: + MakeValue() {} #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ MakeValue(Type value) { field = rhs; } \ @@ -1528,72 +1399,81 @@ public: #define FMT_MAKE_VALUE(Type, field, TYPE) \ FMT_MAKE_VALUE_(Type, field, TYPE, value) - FMT_MAKE_VALUE(bool, int_value, BOOL) - 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, BOOL) + 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 (const_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(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 (const_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 (const_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; - } + MakeValue(unsigned long value) { + if (const_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, INT) - FMT_MAKE_VALUE(unsigned char, uint_value, UINT) - 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, INT) + FMT_MAKE_VALUE(unsigned char, uint_value, UINT) + FMT_MAKE_VALUE(char, int_value, CHAR) + +#if __cplusplus >= 201103L + template < + typename T, + typename = typename std::enable_if< + std::is_enum::value && ConvertToInt::value>::type> + MakeValue(T value) { int_value = value; } + + template < + typename T, + typename = typename std::enable_if< + std::is_enum::value && ConvertToInt::value>::type> + static uint64_t type(T) { return Arg::INT; } +#endif #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) - MakeValue(typename WCharHelper::Supported value) - { - int_value = value; - } - static uint64_t type(wchar_t) - { - return Arg::CHAR; - } + MakeValue(typename WCharHelper::Supported value) { + int_value = value; + } + static uint64_t type(wchar_t) { return Arg::CHAR; } #endif #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(signed char *, sstring.value, CSTRING) - FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) - FMT_MAKE_VALUE(unsigned char *, ustring.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_(CStringRef, string.value, CSTRING, value.c_str()) + FMT_MAKE_VALUE(char *, string.value, CSTRING) + FMT_MAKE_VALUE(const char *, string.value, CSTRING) + FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING) + FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) + FMT_MAKE_STR_VALUE(const std::string &, STRING) +#if FMT_HAS_STRING_VIEW + FMT_MAKE_STR_VALUE(const std::string_view &, STRING) +#endif + FMT_MAKE_STR_VALUE(StringRef, STRING) + FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str()) #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ MakeValue(typename WCharHelper::Supported value) { \ @@ -1601,95 +1481,78 @@ public: } \ static uint64_t type(Type) { return Arg::TYPE; } - FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) - FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) +#if FMT_HAS_STRING_VIEW + FMT_MAKE_WSTR_VALUE(const std::wstring_view &, WSTRING) +#endif + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) - FMT_MAKE_VALUE(void *, pointer, POINTER) - FMT_MAKE_VALUE(const void *, pointer, POINTER) + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) - template - MakeValue(const T &value, - typename EnableIf::value>::value, int>::type = 0) - { - custom.value = &value; - custom.format = &format_custom_arg; - } + template + MakeValue(const T &value, + typename EnableIf::value>::value, int>::type = 0) { + custom.value = &value; + custom.format = &format_custom_arg; + } - template - static typename EnableIf::value>::value, uint64_t>::type - type(const T &) - { - return Arg::CUSTOM; - } + template + static typename EnableIf::value>::value, uint64_t>::type + type(const T &) { + return Arg::CUSTOM; + } - // Additional template param `Char_` is needed here because make_type always - // uses char. - template - MakeValue(const NamedArg &value) - { - pointer = &value; - } - template - MakeValue(const NamedArgWithType &value) - { - pointer = &value; - } + // Additional template param `Char_` is needed here because make_type always + // uses char. + template + MakeValue(const NamedArg &value) { pointer = &value; } + template + MakeValue(const NamedArgWithType &value) { pointer = &value; } - template - static uint64_t type(const NamedArg &) - { - return Arg::NAMED_ARG; - } - template - static uint64_t type(const NamedArgWithType &) - { - return Arg::NAMED_ARG; - } + template + static uint64_t type(const NamedArg &) { return Arg::NAMED_ARG; } + template + static uint64_t type(const NamedArgWithType &) { return Arg::NAMED_ARG; } }; template -class MakeArg : public Arg -{ +class MakeArg : public Arg { public: - MakeArg() - { - type = Arg::NONE; - } + MakeArg() { + type = Arg::NONE; + } - template - MakeArg(const T &value) - : Arg(MakeValue(value)) - { - type = static_cast(MakeValue::type(value)); - } + template + MakeArg(const T &value) + : Arg(MakeValue(value)) { + type = static_cast(MakeValue::type(value)); + } }; template -struct NamedArg : Arg -{ - BasicStringRef name; +struct NamedArg : Arg { + BasicStringRef name; - template - NamedArg(BasicStringRef argname, const T &value) - : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} + template + NamedArg(BasicStringRef argname, const T &value) + : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} }; template -struct NamedArgWithType : NamedArg -{ - NamedArgWithType(BasicStringRef argname, const T &value) - : NamedArg(argname, value) {} +struct NamedArgWithType : NamedArg { + NamedArgWithType(BasicStringRef argname, const T &value) + : NamedArg(argname, value) {} }; -class RuntimeError : public std::runtime_error -{ -protected: - RuntimeError() : std::runtime_error("") {} - RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} - FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT; +class RuntimeError : public std::runtime_error { + protected: + RuntimeError() : std::runtime_error("") {} + RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} + FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; }; template @@ -1697,84 +1560,73 @@ class ArgMap; } // namespace internal /** 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_; - }; +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_; + }; - internal::Arg::Type type(unsigned index) const - { - return type(types_, index); + internal::Arg::Type type(unsigned index) const { + return type(types_, index); + } + + template + friend class internal::ArgMap; + + public: + // Maximum number of arguments with packed types. + enum { MAX_PACKED_ARGS = 16 }; + + ArgList() : types_(0) {} + + ArgList(ULongLong types, const internal::Value *values) + : types_(types), values_(values) {} + ArgList(ULongLong types, const internal::Arg *args) + : types_(types), args_(args) {} + + uint64_t types() const { return types_; } + + /** 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; } - - template - friend class internal::ArgMap; - -public: - // Maximum number of arguments with packed types. - enum { MAX_PACKED_ARGS = 16 }; - - ArgList() : types_(0) {} - - ArgList(ULongLong types, const internal::Value *values) - : types_(types), values_(values) {} - ArgList(ULongLong types, const internal::Arg *args) - : types_(types), args_(args) {} - - uint64_t types() const - { - return types_; + 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; } - - /** 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]; + for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) { + if (args_[i].type == Arg::NONE) + return args_[i]; } + return args_[index]; + } - static internal::Arg::Type type(uint64_t types, unsigned index) - { - unsigned shift = index * 4; - uint64_t mask = 0xf; - return static_cast( - (types & (mask << shift)) >> shift); - } + static internal::Arg::Type type(uint64_t types, unsigned index) { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast( + (types & (mask << shift)) >> shift); + } }; #define FMT_DISPATCH(call) static_cast(this)->call @@ -1804,169 +1656,148 @@ public: \endrst */ template -class ArgVisitor -{ -private: - typedef internal::Arg Arg; +class ArgVisitor { + private: + typedef internal::Arg Arg; -public: - void report_unhandled_arg() {} + public: + void report_unhandled_arg() {} - Result visit_unhandled_arg() - { - FMT_DISPATCH(report_unhandled_arg()); - return Result(); - } - - /** Visits an ``int`` argument. **/ - Result visit_int(int value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``long long`` argument. **/ - Result visit_long_long(LongLong value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an ``unsigned`` argument. **/ - Result visit_uint(unsigned value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an ``unsigned long long`` argument. **/ - Result visit_ulong_long(ULongLong value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``bool`` argument. **/ - Result visit_bool(bool value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``char`` or ``wchar_t`` argument. **/ - Result visit_char(int value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an argument of any integral type. **/ - template - Result visit_any_int(T) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a ``double`` argument. **/ - Result visit_double(double value) - { - return FMT_DISPATCH(visit_any_double(value)); - } - - /** Visits a ``long double`` argument. **/ - Result visit_long_double(long double value) - { - return FMT_DISPATCH(visit_any_double(value)); - } - - /** Visits a ``double`` or ``long double`` argument. **/ - template - Result visit_any_double(T) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a null-terminated C string (``const char *``) argument. **/ - Result visit_cstring(const char *) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a string argument. **/ - Result visit_string(Arg::StringValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a wide string argument. **/ - Result visit_wstring(Arg::StringValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a pointer argument. **/ - Result visit_pointer(const void *) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits an argument of a custom (user-defined) type. **/ - Result visit_custom(Arg::CustomValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** - \rst - Visits an argument dispatching to the appropriate visit method based on - the argument type. For example, if the argument type is ``double`` then - the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be - called. - \endrst - */ - Result visit(const Arg &arg) - { - switch (arg.type) - { - case Arg::NONE: - case Arg::NAMED_ARG: - FMT_ASSERT(false, "invalid argument type"); - break; - 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::BOOL: - return FMT_DISPATCH(visit_bool(arg.int_value != 0)); - case Arg::CHAR: - return FMT_DISPATCH(visit_char(arg.int_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::CSTRING: - return FMT_DISPATCH(visit_cstring(arg.string.value)); - 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)); - } - return Result(); + Result visit_unhandled_arg() { + FMT_DISPATCH(report_unhandled_arg()); + return Result(); + } + + /** Visits an ``int`` argument. **/ + Result visit_int(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``long long`` argument. **/ + Result visit_long_long(LongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned`` argument. **/ + Result visit_uint(unsigned value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned long long`` argument. **/ + Result visit_ulong_long(ULongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``bool`` argument. **/ + Result visit_bool(bool value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``char`` or ``wchar_t`` argument. **/ + Result visit_char(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an argument of any integral type. **/ + template + Result visit_any_int(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a ``double`` argument. **/ + Result visit_double(double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``long double`` argument. **/ + Result visit_long_double(long double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``double`` or ``long double`` argument. **/ + template + Result visit_any_double(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a null-terminated C string (``const char *``) argument. **/ + Result visit_cstring(const char *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a string argument. **/ + Result visit_string(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a wide string argument. **/ + Result visit_wstring(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a pointer argument. **/ + Result visit_pointer(const void *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits an argument of a custom (user-defined) type. **/ + Result visit_custom(Arg::CustomValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be + called. + \endrst + */ + Result visit(const Arg &arg) { + switch (arg.type) { + case Arg::NONE: + case Arg::NAMED_ARG: + FMT_ASSERT(false, "invalid argument type"); + break; + 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::BOOL: + return FMT_DISPATCH(visit_bool(arg.int_value != 0)); + case Arg::CHAR: + return FMT_DISPATCH(visit_char(arg.int_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::CSTRING: + return FMT_DISPATCH(visit_cstring(arg.string.value)); + 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)); } + return Result(); + } }; -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. @@ -1974,162 +1805,94 @@ 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 type_prefix() 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 type_prefix() 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; - } - char type_prefix() const - { - return TYPE; - } + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char type_prefix() 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_; - } - char type_prefix() const - { - return type_; - } + bool flag(unsigned f) const { return (flags_ & f) != 0; } + int precision() const { return precision_; } + char type() const { return type_; } + char type_prefix() const { return type_; } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT -{ -private: - T value_; +class IntFormatSpec : public SpecT { + private: + T value_; -public: - IntFormatSpec(T val, const SpecT &spec = SpecT()) - : SpecT(spec), value_(val) {} + public: + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} - T value() const - { - return value_; - } + T value() const { return value_; } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec -{ -private: - const Char *str_; +class StrFormatSpec : public AlignSpec { + private: + const Char *str_; -public: - template - StrFormatSpec(const Char *str, unsigned width, FillChar fill) - : AlignSpec(width, fill), str_(str) - { - internal::CharTraits::convert(FillChar()); - } + public: + template + StrFormatSpec(const Char *str, unsigned width, FillChar fill) + : AlignSpec(width, fill), str_(str) { + internal::CharTraits::convert(FillChar()); + } - const Char *str() const - { - return str_; - } + const Char *str() const { return str_; } }; /** @@ -2242,238 +2005,235 @@ FMT_DEFINE_INT_FORMATTERS(ULongLong) */ 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); } -namespace internal -{ +namespace internal { template -class ArgMap -{ -private: - typedef std::vector< +class ArgMap { + private: + typedef std::vector< std::pair, internal::Arg> > MapType; - typedef typename MapType::value_type Pair; + typedef typename MapType::value_type Pair; - MapType map_; + MapType map_; -public: - FMT_API void init(const ArgList &args); + public: + void init(const ArgList &args); - const internal::Arg *find(const fmt::BasicStringRef &name) const - { - // The list is unsorted, so just return the first matching name. - for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); - it != end; ++it) - { - if (it->first == name) - return &it->second; - } - return FMT_NULL; + const internal::Arg *find(const fmt::BasicStringRef &name) const { + // The list is unsorted, so just return the first matching name. + for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); + it != end; ++it) { + if (it->first == name) + return &it->second; } + return FMT_NULL; + } }; +template +void ArgMap::init(const ArgList &args) { + if (!map_.empty()) + return; + typedef internal::NamedArg NamedArg; + const NamedArg *named_arg = FMT_NULL; + bool use_values = + args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; + if (use_values) { + for (unsigned i = 0;/*nothing*/; ++i) { + internal::Arg::Type arg_type = args.type(i); + switch (arg_type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.values_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } + return; + } + for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { + internal::Arg::Type arg_type = args.type(i); + if (arg_type == internal::Arg::NAMED_ARG) { + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + } + } + for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { + switch (args.args_[i].type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } +} + template -class ArgFormatterBase : public ArgVisitor -{ -private: - BasicWriter &writer_; - Spec &spec_; +class ArgFormatterBase : public ArgVisitor { + private: + BasicWriter &writer_; + Spec &spec_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); - void write_pointer(const void *p) - { - spec_.flags_ = HASH_FLAG; - spec_.type_ = 'x'; - writer_.write_int(reinterpret_cast(p), spec_); + void write_pointer(const void *p) { + spec_.flags_ = HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), spec_); + } + + // workaround MSVC two-phase lookup issue + typedef internal::Arg Arg; + + protected: + BasicWriter &writer() { return writer_; } + Spec &spec() { return spec_; } + + void write(bool value) { + const char *str_value = value ? "true" : "false"; + Arg::StringValue str = { str_value, std::strlen(str_value) }; + writer_.write_str(str, spec_); + } + + void write(const char *value) { + Arg::StringValue str = {value, value ? std::strlen(value) : 0}; + writer_.write_str(str, spec_); + } + + public: + typedef Spec SpecType; + + ArgFormatterBase(BasicWriter &w, Spec &s) + : writer_(w), spec_(s) {} + + template + void visit_any_int(T value) { writer_.write_int(value, spec_); } + + template + void visit_any_double(T value) { writer_.write_double(value, spec_); } + + void visit_bool(bool value) { + if (spec_.type_) { + visit_any_int(value); + return; } + write(value); + } - // workaround MSVC two-phase lookup issue - typedef internal::Arg Arg; - -protected: - BasicWriter &writer() - { - return writer_; + void visit_char(int value) { + if (spec_.type_ && spec_.type_ != 'c') { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; } - Spec &spec() - { - return spec_; + if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) + FMT_THROW(FormatError("invalid format specifier for char")); + typedef typename BasicWriter::CharPtr CharPtr; + Char fill = internal::CharTraits::cast(spec_.fill()); + CharPtr out = CharPtr(); + const unsigned CHAR_SIZE = 1; + if (spec_.width_ > CHAR_SIZE) { + out = writer_.grow_buffer(spec_.width_); + if (spec_.align_ == ALIGN_RIGHT) { + std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); + out += spec_.width_ - CHAR_SIZE; + } else if (spec_.align_ == ALIGN_CENTER) { + out = writer_.fill_padding(out, spec_.width_, + internal::const_check(CHAR_SIZE), fill); + } else { + std::uninitialized_fill_n(out + CHAR_SIZE, + spec_.width_ - CHAR_SIZE, fill); + } + } else { + out = writer_.grow_buffer(CHAR_SIZE); } + *out = internal::CharTraits::cast(value); + } - void write(bool value) - { - const char *str_value = value ? "true" : "false"; - Arg::StringValue str = { str_value, std::strlen(str_value) }; - writer_.write_str(str, spec_); - } + void visit_cstring(const char *value) { + if (spec_.type_ == 'p') + return write_pointer(value); + write(value); + } - void write(const char *value) - { - Arg::StringValue str = {value, value ? std::strlen(value) : 0}; - writer_.write_str(str, spec_); - } + // Qualification with "internal" here and below is a workaround for nvcc. + void visit_string(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } -public: - typedef Spec SpecType; + using ArgVisitor::visit_wstring; - ArgFormatterBase(BasicWriter &w, Spec &s) - : writer_(w), spec_(s) {} + void visit_wstring(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } - template - void visit_any_int(T value) - { - writer_.write_int(value, spec_); - } - - template - void visit_any_double(T value) - { - writer_.write_double(value, spec_); - } - - void visit_bool(bool value) - { - if (spec_.type_) - { - visit_any_int(value); - return; - } - write(value); - } - - void visit_char(int value) - { - if (spec_.type_ && spec_.type_ != 'c') - { - spec_.flags_ |= CHAR_FLAG; - writer_.write_int(value, spec_); - return; - } - if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) - FMT_THROW(FormatError("invalid format specifier for char")); - typedef typename BasicWriter::CharPtr CharPtr; - Char fill = internal::CharTraits::cast(spec_.fill()); - CharPtr out = CharPtr(); - const unsigned CHAR_SIZE = 1; - if (spec_.width_ > CHAR_SIZE) - { - out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == ALIGN_RIGHT) - { - std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); - out += spec_.width_ - CHAR_SIZE; - } - else if (spec_.align_ == ALIGN_CENTER) - { - out = writer_.fill_padding(out, spec_.width_, - internal::const_check(CHAR_SIZE), fill); - } - else - { - std::uninitialized_fill_n(out + CHAR_SIZE, - spec_.width_ - CHAR_SIZE, fill); - } - } - else - { - out = writer_.grow_buffer(CHAR_SIZE); - } - *out = internal::CharTraits::cast(value); - } - - void visit_cstring(const char *value) - { - if (spec_.type_ == 'p') - return write_pointer(value); - write(value); - } - - // Qualification with "internal" here and below is a workaround for nvcc. - void visit_string(internal::Arg::StringValue value) - { - writer_.write_str(value, spec_); - } - - using ArgVisitor::visit_wstring; - - void visit_wstring(internal::Arg::StringValue value) - { - writer_.write_str(value, spec_); - } - - void visit_pointer(const void *value) - { - if (spec_.type_ && spec_.type_ != 'p') - report_unknown_type(spec_.type_, "pointer"); - write_pointer(value); - } + void visit_pointer(const void *value) { + if (spec_.type_ && spec_.type_ != 'p') + report_unknown_type(spec_.type_, "pointer"); + write_pointer(value); + } }; -class FormatterBase -{ -private: - ArgList args_; - int next_arg_index_; +class FormatterBase { + private: + ArgList args_; + int next_arg_index_; - // Returns the argument with specified index. - FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); + // Returns the argument with specified index. + FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); -protected: - const ArgList &args() const - { - return args_; + protected: + const ArgList &args() const { return args_; } + + explicit FormatterBase(const ArgList &args) { + args_ = args; + next_arg_index_ = 0; + } + + // Returns the next argument. + Arg next_arg(const char *&error) { + if (next_arg_index_ >= 0) + return do_get_arg(internal::to_unsigned(next_arg_index_++), error); + error = "cannot switch from manual to automatic argument indexing"; + return Arg(); + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + Arg get_arg(unsigned arg_index, const char *&error) { + return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); + } + + bool check_no_auto_index(const char *&error) { + if (next_arg_index_ > 0) { + error = "cannot switch from automatic to manual argument indexing"; + return false; } + next_arg_index_ = -1; + return true; + } - explicit FormatterBase(const ArgList &args) - { - args_ = args; - next_arg_index_ = 0; - } - - // Returns the next argument. - Arg next_arg(const char *&error) - { - if (next_arg_index_ >= 0) - return do_get_arg(internal::to_unsigned(next_arg_index_++), error); - error = "cannot switch from manual to automatic argument indexing"; - return Arg(); - } - - // Checks if manual indexing is used and returns the argument with - // specified index. - Arg get_arg(unsigned arg_index, const char *&error) - { - return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); - } - - bool check_no_auto_index(const char *&error) - { - if (next_arg_index_ > 0) - { - error = "cannot switch from automatic to manual argument indexing"; - return false; - } - next_arg_index_ = -1; - return true; - } - - template - void write(BasicWriter &w, const Char *start, const Char *end) - { - if (start != end) - w << BasicStringRef(start, internal::to_unsigned(end - start)); - } + template + void write(BasicWriter &w, const Char *start, const Char *end) { + if (start != end) + w << BasicStringRef(start, internal::to_unsigned(end - start)); + } }; } // namespace internal @@ -2495,94 +2255,87 @@ protected: \endrst */ template -class BasicArgFormatter : public internal::ArgFormatterBase -{ -private: - BasicFormatter &formatter_; - const Char *format_; +class BasicArgFormatter : public internal::ArgFormatterBase { + private: + BasicFormatter &formatter_; + const Char *format_; -public: - /** - \rst - Constructs an argument formatter object. - *formatter* is a reference to the main formatter object, *spec* contains - format specifier information for standard argument types, and *fmt* points - to the part of the format string being parsed for custom argument types. - \endrst - */ - BasicArgFormatter(BasicFormatter &formatter, - Spec &spec, const Char *fmt) - : internal::ArgFormatterBase(formatter.writer(), spec), - formatter_(formatter), format_(fmt) {} + public: + /** + \rst + Constructs an argument formatter object. + *formatter* is a reference to the main formatter object, *spec* contains + format specifier information for standard argument types, and *fmt* points + to the part of the format string being parsed for custom argument types. + \endrst + */ + BasicArgFormatter(BasicFormatter &formatter, + Spec &spec, const Char *fmt) + : internal::ArgFormatterBase(formatter.writer(), spec), + formatter_(formatter), format_(fmt) {} - /** Formats an argument of a custom (user-defined) type. */ - void visit_custom(internal::Arg::CustomValue c) - { - c.format(&formatter_, c.value, &format_); - } + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) { + c.format(&formatter_, c.value, &format_); + } }; /** The default argument formatter. */ template class ArgFormatter : - public BasicArgFormatter, Char, FormatSpec> -{ -public: - /** Constructs an argument formatter object. */ - ArgFormatter(BasicFormatter &formatter, - FormatSpec &spec, const Char *fmt) - : BasicArgFormatter, - Char, FormatSpec>(formatter, spec, fmt) {} + public BasicArgFormatter, Char, FormatSpec> { + public: + /** Constructs an argument formatter object. */ + ArgFormatter(BasicFormatter &formatter, + FormatSpec &spec, const Char *fmt) + : BasicArgFormatter, + Char, FormatSpec>(formatter, spec, fmt) {} }; /** This template formats data and writes the output to a writer. */ template -class BasicFormatter : private internal::FormatterBase -{ -public: - /** The character type for the output. */ - typedef CharType Char; +class BasicFormatter : private internal::FormatterBase { + public: + /** The character type for the output. */ + typedef CharType Char; -private: - BasicWriter &writer_; - internal::ArgMap map_; + private: + BasicWriter &writer_; + internal::ArgMap map_; - FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); - using internal::FormatterBase::get_arg; + using internal::FormatterBase::get_arg; - // Checks if manual indexing is used and returns the argument with - // specified name. - internal::Arg get_arg(BasicStringRef arg_name, const char *&error); + // Checks if manual indexing is used and returns the argument with + // specified name. + internal::Arg get_arg(BasicStringRef arg_name, const char *&error); - // 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); - // Parses argument name and returns corresponding argument. - internal::Arg parse_arg_name(const Char *&s); + // Parses argument name and returns corresponding argument. + internal::Arg parse_arg_name(const Char *&s); -public: - /** - \rst - Constructs a ``BasicFormatter`` object. References to the arguments and - the writer are stored in the formatter object so make sure they have - appropriate lifetimes. - \endrst - */ - BasicFormatter(const ArgList &args, BasicWriter &w) - : internal::FormatterBase(args), writer_(w) {} + public: + /** + \rst + Constructs a ``BasicFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + BasicFormatter(const ArgList &args, BasicWriter &w) + : internal::FormatterBase(args), writer_(w) {} - /** Returns a reference to the writer associated with this formatter. */ - BasicWriter &writer() - { - return writer_; - } + /** Returns a reference to the writer associated with this formatter. */ + BasicWriter &writer() { return writer_; } - /** Formats stored arguments and writes the output to the writer. */ - void format(BasicCStringRef format_str); + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); - // Formats a single argument and advances format_str, a format string pointer. - const Char *format(const Char *&format_str, const internal::Arg &arg); + // Formats a single argument and advances format_str, a format string pointer. + const Char *format(const Char *&format_str, const internal::Arg &arg); }; // Generates a comma-separated list with results of applying f to @@ -2604,30 +2357,24 @@ public: # 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< BasicFormatter >::type(arg); +inline uint64_t make_type(const T &arg) { + return MakeValue< BasicFormatter >::type(arg); } template - struct ArgArray; +struct ArgArray; template -struct ArgArray -{ - typedef Value Type[N > 0 ? N : 1]; +struct ArgArray { + // '+' is used to silence GCC -Wduplicated-branches warning. + typedef Value Type[N > 0 ? N : +1]; -template -static Value make(const T &value) -{ + template + static Value make(const T &value) { #ifdef __clang__ Value result = MakeValue(value); // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang: @@ -2637,48 +2384,41 @@ static Value make(const T &value) #else return MakeValue(value); #endif -} - }; + } +}; template -struct ArgArray -{ - typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE +struct ArgArray { + typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE - template - static Arg make(const T &value) - { - return MakeArg(value); - } + template + static Arg make(const T &value) { return MakeArg(value); } }; #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 @@ -2785,50 +2525,45 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) An error returned by an operating system or a language runtime, for example a file opening error. */ -class SystemError : public internal::RuntimeError -{ -private: - FMT_API void init(int err_code, CStringRef format_str, ArgList args); +class SystemError : public internal::RuntimeError { + private: + FMT_API void init(int err_code, CStringRef format_str, ArgList args); -protected: - int error_code_; + protected: + int error_code_; - typedef char Char; // For FMT_VARIADIC_CTOR. + typedef char Char; // For FMT_VARIADIC_CTOR. - SystemError() {} + SystemError() {} -public: - /** - \rst - Constructs a :class:`fmt::SystemError` object with a description - formatted with `fmt::format_system_error`. *message* and additional - arguments passed into the constructor are formatted similarly to - `fmt::format`. + public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with a description + formatted with `fmt::format_system_error`. *message* and additional + arguments passed into the constructor are formatted similarly to + `fmt::format`. - **Example**:: + **Example**:: - // This throws a SystemError with the description - // cannot open file 'madeup': No such file or directory - // or similar (system message may vary). - const char *filename = "madeup"; - std::FILE *file = std::fopen(filename, "r"); - if (!file) - throw fmt::SystemError(errno, "cannot open file '{}'", filename); - \endrst - */ - SystemError(int error_code, CStringRef message) - { - init(error_code, message, ArgList()); - } - FMT_DEFAULTED_COPY_CTOR(SystemError) - FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) + // 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, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_DEFAULTED_COPY_CTOR(SystemError) + FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) - FMT_API ~SystemError() FMT_DTOR_NOEXCEPT; + FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; - int error_code() const - { - return error_code_; - } + int error_code() const { return error_code_; } }; /** @@ -2869,771 +2604,649 @@ FMT_API void format_system_error(fmt::Writer &out, int error_code, \endrst */ template -class BasicWriter -{ -private: - // Output buffer. - 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 FMT_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); + } + + // Writes an unsigned decimal integer. + template + Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) { + unsigned num_digits = internal::count_digits(value); + Char *ptr = get(grow_buffer(prefix_size + num_digits)); + internal::format_decimal(ptr + prefix_size, value, num_digits); + return ptr; + } + + // Writes a decimal integer. + template + void write_decimal(Int value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) { + abs_value = 0 - abs_value; + *write_unsigned_decimal(abs_value, 1) = '-'; + } else { + write_unsigned_decimal(abs_value, 0); } + } - // Writes an unsigned decimal integer. - template - Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) - { - unsigned num_digits = internal::count_digits(value); - Char *ptr = get(grow_buffer(prefix_size + num_digits)); - internal::format_decimal(ptr + prefix_size, value, num_digits); - return ptr; - } + // 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::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } - // Writes a decimal integer. - template - void write_decimal(Int value) - { - typedef typename internal::IntTraits::MainType MainType; - MainType abs_value = static_cast(value); - if (internal::is_negative(value)) - { - abs_value = 0 - abs_value; - *write_unsigned_decimal(abs_value, 1) = '-'; - } - else - { - write_unsigned_decimal(abs_value, 0); - } - } + template + CharPtr prepare_int_buffer(unsigned num_digits, + const Spec &spec, const char *prefix, unsigned prefix_size); - // 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::uninitialized_copy(prefix, prefix + prefix_size, p); - return p + size - 1; - } + // Formats an integer. + template + void write_int(T value, Spec spec); - template - CharPtr prepare_int_buffer(unsigned num_digits, - const Spec &spec, const char *prefix, unsigned prefix_size); + // Formats a floating-point number (double or long double). + template + void write_double(T value, const Spec &spec); - // Formats an integer. - template - void write_int(T value, Spec spec); + // Writes a formatted string. + template + CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); - // Formats a floating-point number (double or long double). - template - void write_double(T value, const Spec &spec); + template + void write_str(const internal::Arg::StringValue &str, + const Spec &spec); - // Writes a formatted string. - template - CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); + // This following methods are private to disallow writing wide characters + // and strings to a char stream. If you want to print a wide string as a + // pointer as std::ostream does, cast it to const void*. + // Do not implement! + void operator<<(typename internal::WCharHelper::Unsupported); + void operator<<( + typename internal::WCharHelper::Unsupported); - template - void write_str(const internal::Arg::StringValue &str, - const Spec &spec); + // 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'; + } - // 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); + template + void append_float_length(Char *&, T) {} - // Appends floating-point length specifier to the format string. - // The second argument is only used for overload resolution. - void append_float_length(Char *&format_ptr, long double) - { - *format_ptr++ = 'L'; - } + template + friend class internal::ArgFormatterBase; - template - void append_float_length(Char *&, T) {} + template + friend class BasicPrintfArgFormatter; - template - friend class internal::ArgFormatterBase; + protected: + /** + Constructs a ``BasicWriter`` object. + */ + explicit BasicWriter(Buffer &b) : buffer_(b) {} - template - friend class BasicPrintfArgFormatter; + public: + /** + \rst + Destroys a ``BasicWriter`` object. + \endrst + */ + virtual ~BasicWriter() {} -protected: - /** - Constructs a ``BasicWriter`` object. - */ - explicit BasicWriter(Buffer &b) : buffer_(b) {} + /** + Returns the total number of characters written. + */ + std::size_t size() const { return buffer_.size(); } -public: - /** - \rst - Destroys a ``BasicWriter`` object. - \endrst - */ - virtual ~BasicWriter() {} + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } - /** - Returns the total number of characters written. - */ - std::size_t size() const - { - return buffer_.size(); - } + /** + 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]; + } - /** - Returns a pointer to the output buffer content. No terminating null - character is appended. - */ - const Char *data() const FMT_NOEXCEPT - { - return &buffer_[0]; - } + /** + \rst + Returns the content of the output buffer as an `std::string`. + \endrst + */ + std::basic_string str() const { + return std::basic_string(&buffer_[0], buffer_.size()); + } - /** - 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]; - } + /** + \rst + Writes formatted data. - /** - \rst - Returns the content of the output buffer as an `std::string`. - \endrst - */ - std::basic_string str() const - { - return std::basic_string(&buffer_[0], buffer_.size()); - } + *args* is an argument list representing arbitrary arguments. - /** - \rst - Writes formatted data. + **Example**:: - *args* is an argument list representing arbitrary arguments. + MemoryWriter out; + out.write("Current point:\n"); + out.write("({:+f}, {:+f})", -3.14, 3.14); - **Example**:: + This will write the following output to the ``out`` object: - MemoryWriter out; - out.write("Current point:\n"); - out.write("({:+f}, {:+f})", -3.14, 3.14); + .. code-block:: none - This will write the following output to the ``out`` object: + Current point: + (-3.140000, +3.140000) - .. code-block:: none + The output can be accessed using :func:`data()`, :func:`c_str` or + :func:`str` methods. - Current point: - (-3.140000, +3.140000) + See also :ref:`syntax`. + \endrst + */ + void write(BasicCStringRef format, ArgList args) { + BasicFormatter(args, *this).format(format); + } + FMT_VARIADIC_VOID(write, BasicCStringRef) - The output can be accessed using :func:`data()`, :func:`c_str` or - :func:`str` methods. + BasicWriter &operator<<(int value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) { + write_decimal(value); + return *this; + } - See also :ref:`syntax`. - \endrst - */ - void write(BasicCStringRef format, ArgList args) - { - BasicFormatter(args, *this).format(format); - } - FMT_VARIADIC_VOID(write, BasicCStringRef) + /** + \rst + Formats *value* and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(ULongLong value) { + return *this << IntFormatSpec(value); + } - BasicWriter &operator<<(int value) - { - write_decimal(value); - return *this; - } - BasicWriter &operator<<(unsigned value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(long value) - { - write_decimal(value); - return *this; - } - BasicWriter &operator<<(unsigned long value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(LongLong value) - { - write_decimal(value); - return *this; - } + BasicWriter &operator<<(double value) { + write_double(value, FormatSpec()); + return *this; + } - /** - \rst - Formats *value* and writes it to the stream. - \endrst - */ - BasicWriter &operator<<(ULongLong value) - { - return *this << IntFormatSpec(value); - } + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(long double value) { + write_double(value, FormatSpec()); + return *this; + } - BasicWriter &operator<<(double value) - { - write_double(value, FormatSpec()); - return *this; - } + /** + Writes a character to the stream. + */ + BasicWriter &operator<<(char value) { + buffer_.push_back(value); + return *this; + } - /** - \rst - Formats *value* using the general format for floating-point numbers - (``'g'``) and writes it to the stream. - \endrst - */ - BasicWriter &operator<<(long double value) - { - write_double(value, FormatSpec()); - return *this; - } + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + buffer_.push_back(value); + return *this; + } - /** - Writes a character to the stream. - */ - BasicWriter &operator<<(char value) - { - buffer_.push_back(value); - return *this; - } + /** + \rst + Writes *value* to the stream. + \endrst + */ + BasicWriter &operator<<(fmt::BasicStringRef value) { + const Char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } - BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) - { - buffer_.push_back(value); - return *this; - } + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + const char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } - /** - \rst - Writes *value* to the stream. - \endrst - */ - BasicWriter &operator<<(fmt::BasicStringRef value) - { - const Char *str = value.data(); - buffer_.append(str, str + value.size()); - return *this; - } + template + BasicWriter &operator<<(IntFormatSpec spec) { + internal::CharTraits::convert(FillChar()); + write_int(spec.value(), spec); + return *this; + } - BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) - { - const char *str = value.data(); - buffer_.append(str, str + value.size()); - return *this; - } + template + BasicWriter &operator<<(const StrFormatSpec &spec) { + const StrChar *s = spec.str(); + write_str(s, std::char_traits::length(s), spec); + return *this; + } - template - BasicWriter &operator<<(IntFormatSpec spec) - { - internal::CharTraits::convert(FillChar()); - write_int(spec.value(), spec); - return *this; - } + void clear() FMT_NOEXCEPT { buffer_.clear(); } - template - BasicWriter &operator<<(const StrFormatSpec &spec) - { - const StrChar *s = spec.str(); - write_str(s, std::char_traits::length(s), spec); - return *this; - } - - void clear() FMT_NOEXCEPT { buffer_.clear(); } - - Buffer &buffer() FMT_NOEXCEPT { return buffer_; } + Buffer &buffer() FMT_NOEXCEPT { return buffer_; } }; 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 = internal::CharTraits::cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) - { - std::uninitialized_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::uninitialized_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 = internal::CharTraits::cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) { + std::uninitialized_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::uninitialized_fill_n(out + size, spec.width() - size, fill); } - else - { - out = grow_buffer(size); - } - std::uninitialized_copy(s, s + size, out); - return out; + } else { + out = grow_buffer(size); + } + std::uninitialized_copy(s, s + size, out); + return out; } template template void BasicWriter::write_str( - const internal::Arg::StringValue &s, const Spec &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")); - } + const internal::Arg::StringValue &s, const Spec &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")); } - std::size_t precision = static_cast(spec.precision_); - if (spec.precision_ >= 0 && precision < str_size) - str_size = precision; - write_str(str_value, str_size, spec); + } + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < str_size) + str_size = precision; + write_str(str_value, str_size, spec); } 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 = internal::CharTraits::cast(fill); - std::uninitialized_fill_n(buffer, left_padding, fill_char); - buffer += left_padding; - CharPtr content = buffer; - std::uninitialized_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 = internal::CharTraits::cast(fill); + std::uninitialized_fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::uninitialized_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 = internal::CharTraits::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 + internal::to_unsigned(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::uninitialized_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::uninitialized_fill(p, p + fill_size, fill); - } - return result; + const char *prefix, unsigned prefix_size) { + unsigned width = spec.width(); + Alignment align = spec.align(); + Char fill = internal::CharTraits::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 + internal::to_unsigned(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::uninitialized_fill(p, p + fill_size, fill); } - unsigned size = prefix_size + num_digits; - if (width <= size) - { - CharPtr p = grow_buffer(size); - std::uninitialized_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::uninitialized_fill(p, p + fill_size, fill); } - CharPtr p = grow_buffer(width); - CharPtr end = p + width; - if (align == ALIGN_LEFT) - { - std::uninitialized_copy(prefix, prefix + prefix_size, p); - p += size; - std::uninitialized_fill(p, end, fill); + return result; + } + unsigned size = prefix_size + num_digits; + if (width <= size) { + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + CharPtr p = grow_buffer(width); + CharPtr end = p + width; + if (align == ALIGN_LEFT) { + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + std::uninitialized_fill(p, end, fill); + } else if (align == ALIGN_CENTER) { + p = fill_padding(p, width, size, fill); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + } else { + if (align == ALIGN_NUMERIC) { + if (prefix_size != 0) { + p = std::uninitialized_copy(prefix, prefix + prefix_size, p); + size -= prefix_size; + } + } else { + std::uninitialized_copy(prefix, prefix + prefix_size, end - size); } - else if (align == ALIGN_CENTER) - { - p = fill_padding(p, width, size, fill); - std::uninitialized_copy(prefix, prefix + prefix_size, p); - p += size; - } - else - { - if (align == ALIGN_NUMERIC) - { - if (prefix_size != 0) - { - p = std::uninitialized_copy(prefix, prefix + prefix_size, p); - size -= prefix_size; - } - } - else - { - std::uninitialized_copy(prefix, prefix + prefix_size, end - size); - } - std::uninitialized_fill(p, end - size, fill); - p = end; - } - return p - 1; + std::uninitialized_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 = static_cast(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 = static_cast(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; + internal::format_decimal(get(p), abs_value, 0); + break; + } + case 'x': case 'X': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); } - else if (spec.flag(SIGN_FLAG)) - { - prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; - ++prefix_size; + 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_prefix(); } - 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; - internal::format_decimal(get(p), abs_value, 0); - break; - } - case 'x': - case 'X': - { - UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = spec.type_prefix(); - } - 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_prefix(); - } - 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-- = static_cast('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-- = static_cast('0' + (n & 7)); - } - while ((n >>= 3) != 0); - break; - } - case 'n': - { - unsigned num_digits = internal::count_digits(abs_value); - fmt::StringRef sep = ""; + 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-- = static_cast('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-- = static_cast('0' + (n & 7)); + } while ((n >>= 3) != 0); + break; + } + case 'n': { + unsigned num_digits = internal::count_digits(abs_value); + fmt::StringRef sep = ""; #if !(defined(ANDROID) || defined(__ANDROID__)) - sep = internal::thousands_sep(std::localeconv()); + sep = internal::thousands_sep(std::localeconv()); #endif - unsigned size = static_cast( - num_digits + sep.size() * ((num_digits - 1) / 3)); - CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; - internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); - break; - } - default: - internal::report_unknown_type( - spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); - break; - } + unsigned size = static_cast( + num_digits + sep.size() * ((num_digits - 1) / 3)); + CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); + break; + } + default: + internal::report_unknown_type( + spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); + break; + } } template template -void BasicWriter::write_double(T value, const Spec &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': +void BasicWriter::write_double(T value, const Spec &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': #if FMT_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; - } + case 'E': case 'G': case 'A': + upper = true; + break; + default: + internal::report_unknown_type(type, "double"); + break; + } - char sign = 0; - // Use isnegative instead of value < 0 because the latter is always - // false for NaN. - if (internal::FPUtil::isnegative(static_cast(value))) - { - sign = '-'; - value = -value; - } - else if (spec.flag(SIGN_FLAG)) - { - sign = spec.flag(PLUS_FLAG) ? '+' : ' '; - } + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::FPUtil::isnegative(static_cast(value))) { + sign = '-'; + value = -value; + } else if (spec.flag(SIGN_FLAG)) { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } - if (internal::FPUtil::isnotanumber(value)) - { - // Format NaN ourselves because sprintf's output is not consistent - // across platforms. - std::size_t nan_size = 4; - const char *nan = upper ? " NAN" : " nan"; - if (!sign) - { - --nan_size; - ++nan; - } - CharPtr out = write_str(nan, nan_size, spec); - if (sign) - *out = sign; - return; + if (internal::FPUtil::isnotanumber(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::FPUtil::isinfinity(value)) - { - // Format infinity ourselves because sprintf's output is not consistent - // across platforms. - std::size_t inf_size = 4; - const char *inf = upper ? " INF" : " inf"; - if (!sign) - { - --inf_size; - ++inf; - } - CharPtr out = write_str(inf, inf_size, spec); - if (sign) - *out = sign; - return; - } - - std::size_t offset = buffer_.size(); - unsigned width = spec.width(); + CharPtr out = write_str(nan, nan_size, spec); if (sign) - { - buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u)); - if (width > 0) - --width; - ++offset; - } + *out = sign; + return; + } - // Build format string. - enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg - Char format[MAX_FORMAT_SIZE]; - Char *format_ptr = format; - *format_ptr++ = '%'; - unsigned width_for_sprintf = width; - if (spec.flag(HASH_FLAG)) - *format_ptr++ = '#'; - if (spec.align() == ALIGN_CENTER) - { - width_for_sprintf = 0; - } - else - { - if (spec.align() == ALIGN_LEFT) - *format_ptr++ = '-'; - if (width != 0) - *format_ptr++ = '*'; - } - if (spec.precision() >= 0) - { - *format_ptr++ = '.'; - *format_ptr++ = '*'; + if (internal::FPUtil::isinfinity(value)) { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t inf_size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) { + --inf_size; + ++inf; } + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } - append_float_length(format_ptr, value); - *format_ptr++ = type; - *format_ptr = '\0'; + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); + if (sign) { + buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u)); + if (width > 0) + --width; + ++offset; + } - // Format using snprintf. - Char fill = internal::CharTraits::cast(spec.fill()); - unsigned n = 0; - Char *start = FMT_NULL; - for (;;) - { - std::size_t buffer_size = buffer_.capacity() - offset; + // Build format string. + enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg + Char format[MAX_FORMAT_SIZE]; + Char *format_ptr = format; + *format_ptr++ = '%'; + unsigned width_for_sprintf = width; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.align() == ALIGN_CENTER) { + width_for_sprintf = 0; + } else { + if (spec.align() == ALIGN_LEFT) + *format_ptr++ = '-'; + if (width != 0) + *format_ptr++ = '*'; + } + if (spec.precision() >= 0) { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = type; + *format_ptr = '\0'; + + // Format using snprintf. + Char fill = internal::CharTraits::cast(spec.fill()); + unsigned n = 0; + Char *start = FMT_NULL; + for (;;) { + std::size_t buffer_size = buffer_.capacity() - offset; #if FMT_MSC_VER - // MSVC's vsnprintf_s doesn't work with zero size, so reserve - // space for at least one extra character to make the size non-zero. - // Note that the buffer's capacity will increase by more than 1. - if (buffer_size == 0) - { - buffer_.reserve(offset + 1); - buffer_size = buffer_.capacity() - offset; - } + // 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 - start = &buffer_[offset]; - int result = internal::CharTraits::format_float( - start, buffer_size, format, width_for_sprintf, spec.precision(), value); - if (result >= 0) - { - n = internal::to_unsigned(result); - if (offset + n < buffer_.capacity()) - break; // The buffer is large enough - continue with formatting. - buffer_.reserve(offset + n + 1); - } - else - { - // If result is negative we ask to increase the capacity by at least 1, - // but as std::vector, the buffer grows exponentially. - buffer_.reserve(buffer_.capacity() + 1); - } + start = &buffer_[offset]; + int result = internal::CharTraits::format_float( + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (result >= 0) { + n = internal::to_unsigned(result); + if (offset + n < buffer_.capacity()) + break; // The buffer is large enough - continue with formatting. + buffer_.reserve(offset + n + 1); + } else { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer_.reserve(buffer_.capacity() + 1); } + } + 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() > n) { + width = spec.width(); + CharPtr p = grow_buffer(width); + std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); + fill_padding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) { + while (*start == ' ') + *start++ = fill; 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() > n) - { - width = spec.width(); - CharPtr p = grow_buffer(width); - std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); - fill_padding(p, spec.width(), n, fill); - return; - } - if (spec.fill() != ' ' || sign) - { - while (*start == ' ') - *start++ = fill; - if (sign) - *(start - 1) = sign; - } - grow_buffer(n); + *(start - 1) = sign; + } + grow_buffer(n); } /** @@ -3671,37 +3284,34 @@ void BasicWriter::write_double(T value, const Spec &spec) \endrst */ template > -class BasicMemoryWriter : public BasicWriter -{ -private: - internal::MemoryBuffer buffer_; +class BasicMemoryWriter : public BasicWriter { + private: + internal::MemoryBuffer buffer_; -public: - explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) - : BasicWriter(buffer_), buffer_(alloc) {} + public: + explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) + : BasicWriter(buffer_), buffer_(alloc) {} #if FMT_USE_RVALUE_REFERENCES - /** - \rst - Constructs a :class:`fmt::BasicMemoryWriter` object moving the content - of the other object to it. - \endrst - */ - 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. - \endrst - */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) - { - buffer_ = std::move(other.buffer_); - return *this; - } + /** + \rst + Moves the content of the other ``BasicMemoryWriter`` object to this one. + \endrst + */ + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + buffer_ = std::move(other.buffer_); + return *this; + } #endif }; @@ -3729,30 +3339,29 @@ typedef BasicMemoryWriter WMemoryWriter; \endrst */ template -class BasicArrayWriter : public BasicWriter -{ -private: - internal::FixedBuffer buffer_; +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) {} + 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) {} - /** - \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) {} + /** + \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; @@ -3766,45 +3375,43 @@ FMT_API void report_system_error(int error_code, #if FMT_USE_WINDOWS_H /** A Windows error. */ -class WindowsError : public SystemError -{ -private: - FMT_API void init(int error_code, CStringRef format_str, ArgList args); +class WindowsError : public SystemError { + private: + FMT_API void init(int error_code, CStringRef format_str, ArgList args); -public: - /** - \rst - Constructs a :class:`fmt::WindowsError` object with the description - of the form + public: + /** + \rst + Constructs a :class:`fmt::WindowsError` object with the description + of the form - .. parsed-literal:: - **: ** + .. parsed-literal:: + **: ** - where ** is the formatted message and ** is the - system message corresponding to the error code. - *error_code* is a Windows error code as given by ``GetLastError``. - If *error_code* is not a valid error code such as -1, the system message - will look like "error -1". + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". - **Example**:: + **Example**:: - // This throws a WindowsError with the description - // cannot open file 'madeup': The system cannot find the file specified. - // or similar (system message may vary). - const char *filename = "madeup"; - LPOFSTRUCT of = LPOFSTRUCT(); - HFILE file = OpenFile(filename, &of, OF_READ); - if (file == HFILE_ERROR) { - throw fmt::WindowsError(GetLastError(), - "cannot open file '{}'", filename); - } - \endrst - */ - WindowsError(int error_code, CStringRef message) - { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) + // 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, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) }; // Reports a Windows error without throwing an exception. @@ -3833,18 +3440,16 @@ FMT_API void print_colored(Color c, CStringRef format, ArgList args); std::string message = format("The answer is {}", 42); \endrst */ -inline std::string format(CStringRef format_str, ArgList args) -{ - MemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::string format(CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + return w.str(); } -inline std::wstring format(WCStringRef format_str, ArgList args) -{ - WMemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::wstring format(WCStringRef format_str, ArgList args) { + WMemoryWriter w; + w.write(format_str, args); + return w.str(); } /** @@ -3872,132 +3477,106 @@ FMT_API void print(CStringRef format_str, ArgList 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_; +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 = static_cast((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 = static_cast((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 internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1); - } + /** Returns the number of characters written to the output buffer. */ + std::size_t size() const { + return internal::to_unsigned(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_; - } + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + 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_; - } + /** + 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_; + } - /** - \rst - Returns the content of the output buffer as an ``std::string``. - \endrst - */ - std::string str() const - { - return std::string(str_, size()); - } + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + 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) -{ - typedef typename internal::IntTraits::MainType MainType; - MainType abs_value = static_cast(value); - if (internal::is_negative(value)) - { - *buffer++ = '-'; - abs_value = 0 - abs_value; +inline void format_decimal(char *&buffer, T value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(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; } /** @@ -4011,15 +3590,13 @@ inline void format_decimal(char *&buffer, T value) \endrst */ template -inline internal::NamedArgWithType arg(StringRef name, const T &arg) -{ - return internal::NamedArgWithType(name, arg); +inline internal::NamedArgWithType arg(StringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); } template -inline internal::NamedArgWithType arg(WStringRef name, const T &arg) -{ - return internal::NamedArgWithType(name, arg); +inline internal::NamedArgWithType arg(WStringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); } // The following two functions are deleted intentionally to disable @@ -4057,10 +3634,10 @@ void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; #define FMT_GET_ARG_NAME(type, index) arg##index #if FMT_USE_VARIADIC_TEMPLATES -# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ +# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \ template \ ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ - const Args & ... args) { \ + const Args & ... args) Const { \ typedef fmt::internal::ArgArray ArgArray; \ typename ArgArray::Type array{ \ ArgArray::template make >(args)...}; \ @@ -4070,35 +3647,35 @@ void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; #else // Defines a wrapper for a function taking __VA_ARGS__ arguments // and n additional arguments of arbitrary types. -# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \ +# define FMT_WRAP(Const, Char, ReturnType, func, call, n, ...) \ template \ inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ - FMT_GEN(n, FMT_MAKE_ARG)) { \ + FMT_GEN(n, FMT_MAKE_ARG)) Const { \ fmt::internal::ArgArray::Type arr; \ FMT_GEN(n, FMT_ASSIGN_##Char); \ call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \ } -# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ - inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \ +# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \ + inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) Const { \ call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \ } \ - FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \ - FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__) + FMT_WRAP(Const, Char, ReturnType, func, call, 1, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 2, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 3, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 4, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 5, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 6, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 7, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 8, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 9, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 10, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 11, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 12, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 13, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 14, __VA_ARGS__) \ + FMT_WRAP(Const, Char, ReturnType, func, call, 15, __VA_ARGS__) #endif // FMT_USE_VARIADIC_TEMPLATES /** @@ -4129,10 +3706,16 @@ void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; \endrst */ #define FMT_VARIADIC(ReturnType, func, ...) \ - FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__) + FMT_VARIADIC_(, char, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_VARIADIC_CONST(ReturnType, func, ...) \ + FMT_VARIADIC_(const, char, ReturnType, func, return func, __VA_ARGS__) #define FMT_VARIADIC_W(ReturnType, func, ...) \ - FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) + FMT_VARIADIC_(, wchar_t, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_VARIADIC_CONST_W(ReturnType, func, ...) \ + FMT_VARIADIC_(const, wchar_t, ReturnType, func, return func, __VA_ARGS__) #define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id) @@ -4156,443 +3739,386 @@ void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) -namespace fmt -{ +namespace fmt { FMT_VARIADIC(std::string, format, CStringRef) FMT_VARIADIC_W(std::wstring, format, WCStringRef) FMT_VARIADIC(void, print, CStringRef) FMT_VARIADIC(void, print, std::FILE *, CStringRef) FMT_VARIADIC(void, print_colored, Color, CStringRef) -namespace internal -{ +namespace internal { template -inline bool is_name_start(Char c) -{ - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +inline bool is_name_start(Char c) { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; } // 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 -unsigned 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 = (std::numeric_limits::max)(); - break; - } - value = new_value; +unsigned parse_nonnegative_int(const Char *&s) { + assert('0' <= *s && *s <= '9'); + unsigned value = 0; + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + unsigned big = max_int / 10; + do { + // Check for overflow. + if (value > big) { + value = max_int + 1; + break; } - while ('0' <= *s && *s <= '9'); - // Convert to unsigned to prevent a warning. - unsigned max_int = (std::numeric_limits::max)(); - if (value > max_int) - FMT_THROW(FormatError("number is too big")); - return value; + value = value * 10 + (*s - '0'); + ++s; + } while ('0' <= *s && *s <= '9'); + // Convert to unsigned to prevent a warning. + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + return value; } -inline void require_numeric_argument(const Arg &arg, char spec) -{ - if (arg.type > Arg::LAST_NUMERIC_TYPE) - { - std::string message = - fmt::format("format specifier '{}' requires numeric argument", spec); - FMT_THROW(fmt::FormatError(message)); - } +inline void require_numeric_argument(const Arg &arg, char spec) { + if (arg.type > Arg::LAST_NUMERIC_TYPE) { + std::string message = + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); + } } template -void check_sign(const Char *&s, const Arg &arg) -{ - char sign = static_cast(*s); - require_numeric_argument(arg, sign); - if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) - { - FMT_THROW(FormatError(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(FormatError(fmt::format( + "format specifier '{}' requires signed argument", sign))); + } + ++s; } } // namespace internal template inline internal::Arg BasicFormatter::get_arg( - BasicStringRef arg_name, const char *&error) -{ - if (check_no_auto_index(error)) - { - map_.init(args()); - const internal::Arg *arg = map_.find(arg_name); - if (arg) - return *arg; - error = "argument not found"; - } - return internal::Arg(); + BasicStringRef arg_name, const char *&error) { + if (check_no_auto_index(error)) { + map_.init(args()); + const internal::Arg *arg = map_.find(arg_name); + if (arg) + return *arg; + error = "argument not found"; + } + return internal::Arg(); } template -inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) -{ - const char *error = FMT_NULL; - internal::Arg arg = *s < '0' || *s > '9' ? - next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); - if (error) - { - FMT_THROW(FormatError( - *s != '}' && *s != ':' ? "invalid format string" : error)); - } - return arg; +inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) { + const char *error = FMT_NULL; + internal::Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); + if (error) { + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); + } + return arg; } template -inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) -{ - assert(internal::is_name_start(*s)); - const Char *start = s; - Char c; - do - { - c = *++s; - } - while (internal::is_name_start(c) || ('0' <= c && c <= '9')); - const char *error = FMT_NULL; - internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); - if (error) - FMT_THROW(FormatError(error)); - return arg; +inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) { + assert(internal::is_name_start(*s)); + const Char *start = s; + Char c; + do { + c = *++s; + } while (internal::is_name_start(c) || ('0' <= c && c <= '9')); + const char *error = FMT_NULL; + internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); + if (error) + FMT_THROW(FormatError(error)); + return arg; } template const Char *BasicFormatter::format( - const Char *&format_str, const internal::Arg &arg) -{ - using internal::Arg; - const Char *s = format_str; - typename ArgFormatter::SpecType spec; - if (*s == ':') - { - if (arg.type == Arg::CUSTOM) - { - arg.custom.format(this, arg.custom.value, &s); - return s; - } - ++s; - // Parse fill and alignment. - if (Char c = *s) - { - const Char *p = s + 1; - spec.align_ = ALIGN_DEFAULT; - do - { - switch (*p) - { - case '<': - spec.align_ = ALIGN_LEFT; - break; - case '>': - spec.align_ = ALIGN_RIGHT; - break; - case '=': - spec.align_ = ALIGN_NUMERIC; - break; - case '^': - spec.align_ = ALIGN_CENTER; - break; - } - if (spec.align_ != ALIGN_DEFAULT) - { - if (p != s) - { - if (c == '}') break; - if (c == '{') - FMT_THROW(FormatError("invalid fill character '{'")); - s += 2; - spec.fill_ = c; - } - else ++s; - if (spec.align_ == ALIGN_NUMERIC) - require_numeric_argument(arg, '='); - break; - } - } - while (--p >= s); - } - - // Parse sign. - switch (*s) - { - case '+': - check_sign(s, arg); - spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + const Char *&format_str, const internal::Arg &arg) { + using internal::Arg; + const Char *s = format_str; + typename ArgFormatter::SpecType spec; + if (*s == ':') { + if (arg.type == Arg::CUSTOM) { + arg.custom.format(this, arg.custom.value, &s); + return s; + } + ++s; + // Parse fill and alignment. + if (Char c = *s) { + const Char *p = s + 1; + spec.align_ = ALIGN_DEFAULT; + do { + switch (*p) { + case '<': + spec.align_ = ALIGN_LEFT; break; - case '-': - check_sign(s, arg); - spec.flags_ |= MINUS_FLAG; + case '>': + spec.align_ = ALIGN_RIGHT; break; - case ' ': - check_sign(s, arg); - spec.flags_ |= SIGN_FLAG; - break; - } - - if (*s == '#') - { - require_numeric_argument(arg, '#'); - spec.flags_ |= HASH_FLAG; - ++s; - } - - // Parse zero flag. - if (*s == '0') - { - require_numeric_argument(arg, '0'); + case '=': spec.align_ = ALIGN_NUMERIC; - spec.fill_ = '0'; - ++s; + break; + case '^': + spec.align_ = ALIGN_CENTER; + break; } - - // Parse width. - if ('0' <= *s && *s <= '9') - { - spec.width_ = internal::parse_nonnegative_int(s); + if (spec.align_ != ALIGN_DEFAULT) { + if (p != s) { + if (c == '}') break; + if (c == '{') + FMT_THROW(FormatError("invalid fill character '{'")); + s += 2; + spec.fill_ = c; + } else ++s; + if (spec.align_ == ALIGN_NUMERIC) + require_numeric_argument(arg, '='); + break; } - else if (*s == '{') - { - ++s; - Arg width_arg = internal::is_name_start(*s) ? - parse_arg_name(s) : parse_arg_index(s); - if (*s++ != '}') - FMT_THROW(FormatError("invalid format string")); - ULongLong value = 0; - switch (width_arg.type) - { - case Arg::INT: - if (width_arg.int_value < 0) - FMT_THROW(FormatError("negative width")); - value = width_arg.int_value; - break; - case Arg::UINT: - value = width_arg.uint_value; - break; - case Arg::LONG_LONG: - if (width_arg.long_long_value < 0) - FMT_THROW(FormatError("negative width")); - value = width_arg.long_long_value; - break; - case Arg::ULONG_LONG: - value = width_arg.ulong_long_value; - break; - default: - FMT_THROW(FormatError("width is not integer")); - } - if (value > (std::numeric_limits::max)()) - FMT_THROW(FormatError("number is too big")); - spec.width_ = static_cast(value); - } - - // Parse precision. - if (*s == '.') - { - ++s; - spec.precision_ = 0; - if ('0' <= *s && *s <= '9') - { - spec.precision_ = internal::parse_nonnegative_int(s); - } - else if (*s == '{') - { - ++s; - Arg precision_arg = internal::is_name_start(*s) ? - parse_arg_name(s) : 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 > (std::numeric_limits::max)()) - FMT_THROW(FormatError("number is too big")); - spec.precision_ = static_cast(value); - } - else - { - FMT_THROW(FormatError("missing precision specifier")); - } - if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) - { - FMT_THROW(FormatError( - fmt::format("precision not allowed in {} format specifier", - arg.type == Arg::POINTER ? "pointer" : "integer"))); - } - } - - // Parse type. - if (*s != '}' && *s) - spec.type_ = static_cast(*s++); + } while (--p >= s); } - if (*s++ != '}') - FMT_THROW(FormatError("missing '}' in format string")); + // Parse sign. + switch (*s) { + case '+': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '-': + check_sign(s, arg); + spec.flags_ |= MINUS_FLAG; + break; + case ' ': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } - // Format argument. - ArgFormatter(*this, spec, s - 1).visit(arg); - return s; + if (*s == '#') { + require_numeric_argument(arg, '#'); + spec.flags_ |= HASH_FLAG; + ++s; + } + + // Parse zero flag. + if (*s == '0') { + require_numeric_argument(arg, '0'); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + ++s; + } + + // Parse width. + if ('0' <= *s && *s <= '9') { + spec.width_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg width_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (width_arg.type) { + case Arg::INT: + if (width_arg.int_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.int_value; + break; + case Arg::UINT: + value = width_arg.uint_value; + break; + case Arg::LONG_LONG: + if (width_arg.long_long_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = width_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("width is not integer")); + } + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + spec.width_ = static_cast(value); + } + + // Parse precision. + if (*s == '.') { + ++s; + spec.precision_ = 0; + if ('0' <= *s && *s <= '9') { + spec.precision_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg precision_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : 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")); + } + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + 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")); + + // Format argument. + ArgFormatter(*this, spec, s - 1).visit(arg); + return s; } template -void BasicFormatter::format(BasicCStringRef format_str) -{ - const Char *s = format_str.c_str(); - const Char *start = s; - 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); - internal::Arg arg = internal::is_name_start(*s) ? - parse_arg_name(s) : parse_arg_index(s); - start = s = format(s, arg); +void BasicFormatter::format(BasicCStringRef format_str) { + const Char *s = format_str.c_str(); + const Char *start = s; + while (*s) { + Char c = *s++; + if (c != '{' && c != '}') continue; + if (*s == c) { + write(writer_, start, s); + start = ++s; + continue; } - write(writer_, start, s); + if (c == '}') + FMT_THROW(FormatError("unmatched '}' in format string")); + write(writer_, start, s - 1); + internal::Arg arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + start = s = format(s, arg); + } + write(writer_, start, s); } template -struct ArgJoin -{ - It first; - It last; - BasicCStringRef sep; +struct ArgJoin { + It first; + It last; + BasicCStringRef sep; - ArgJoin(It first, It last, const BasicCStringRef& sep) : - first(first), - last(last), - sep(sep) {} + ArgJoin(It first, It last, const BasicCStringRef& sep) : + first(first), + last(last), + sep(sep) {} }; template -ArgJoin join(It first, It last, const BasicCStringRef& sep) -{ - return ArgJoin(first, last, sep); +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); } template -ArgJoin join(It first, It last, const BasicCStringRef& sep) -{ - return ArgJoin(first, last, sep); +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); } #if FMT_HAS_GXX_CXX11 template auto join(const Range& range, const BasicCStringRef& sep) --> ArgJoin -{ - return join(std::begin(range), std::end(range), sep); + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); } template auto join(const Range& range, const BasicCStringRef& sep) --> ArgJoin -{ - return join(std::begin(range), std::end(range), sep); + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); } #endif template void format_arg(fmt::BasicFormatter &f, - const Char *&format_str, const ArgJoin& e) -{ - const Char* end = format_str; - if (*end == ':') - ++end; - while (*end && *end != '}') - ++end; - if (*end != '}') - FMT_THROW(FormatError("missing '}' in format string")); + const Char *&format_str, const ArgJoin& e) { + const Char* end = format_str; + if (*end == ':') + ++end; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); - It it = e.first; - if (it != e.last) - { - const Char* save = format_str; - f.format(format_str, internal::MakeArg >(*it++)); - while (it != e.last) - { - f.writer().write(e.sep); - format_str = save; - f.format(format_str, internal::MakeArg >(*it++)); - } + It it = e.first; + if (it != e.last) { + const Char* save = format_str; + f.format(format_str, internal::MakeArg >(*it++)); + while (it != e.last) { + f.writer().write(e.sep); + format_str = save; + f.format(format_str, internal::MakeArg >(*it++)); } - format_str = end + 1; + } + format_str = end + 1; } } // namespace fmt #if FMT_USE_USER_DEFINED_LITERALS -namespace fmt -{ -namespace internal -{ +namespace fmt { +namespace internal { template -struct UdlFormat -{ - const Char *str; +struct UdlFormat { + const Char *str; - template - auto operator()(Args && ... args) const - -> decltype(format(str, std::forward(args)...)) - { - return format(str, std::forward(args)...); - } + template + auto operator()(Args && ... args) const + -> decltype(format(str, std::forward(args)...)) { + return format(str, std::forward(args)...); + } }; template -struct UdlArg -{ - const Char *str; +struct UdlArg { + const Char *str; - template - NamedArgWithType operator=(T &&value) const - { - return {str, std::forward(value)}; - } + template + NamedArgWithType operator=(T &&value) const { + return {str, std::forward(value)}; + } }; } // namespace internal -inline namespace literals -{ +inline namespace literals { /** \rst @@ -4605,15 +4131,9 @@ inline namespace literals \endrst */ inline internal::UdlFormat -operator"" _format(const char *s, std::size_t) -{ - return {s}; -} +operator"" _format(const char *s, std::size_t) { return {s}; } inline internal::UdlFormat -operator"" _format(const wchar_t *s, std::size_t) -{ - return {s}; -} +operator"" _format(const wchar_t *s, std::size_t) { return {s}; } /** \rst @@ -4626,15 +4146,9 @@ operator"" _format(const wchar_t *s, std::size_t) \endrst */ inline internal::UdlArg -operator"" _a(const char *s, std::size_t) -{ - return {s}; -} +operator"" _a(const char *s, std::size_t) { return {s}; } inline internal::UdlArg -operator"" _a(const wchar_t *s, std::size_t) -{ - return {s}; -} +operator"" _a(const wchar_t *s, std::size_t) { return {s}; } } // inline namespace literals } // namespace fmt diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h index cfb8e035..6848aac2 100644 --- a/include/spdlog/fmt/bundled/ostream.h +++ b/include/spdlog/fmt/bundled/ostream.h @@ -13,65 +13,59 @@ #include "format.h" #include -namespace fmt -{ +namespace fmt { -namespace internal -{ +namespace internal { template -class FormatBuf : public std::basic_streambuf -{ -private: - typedef typename std::basic_streambuf::int_type int_type; - typedef typename std::basic_streambuf::traits_type traits_type; +class FormatBuf : public std::basic_streambuf { + private: + typedef typename std::basic_streambuf::int_type int_type; + typedef typename std::basic_streambuf::traits_type traits_type; - Buffer &buffer_; + Buffer &buffer_; -public: - FormatBuf(Buffer &buffer) : buffer_(buffer) {} + public: + FormatBuf(Buffer &buffer) : buffer_(buffer) {} -protected: - // The put-area is actually always empty. This makes the implementation - // simpler and has the advantage that the streambuf and the buffer are always - // in sync and sputc never writes into uninitialized memory. The obvious - // disadvantage is that each call to sputc always results in a (virtual) call - // to overflow. There is no disadvantage here for sputn since this always - // results in a call to xsputn. + protected: + // The put-area is actually always empty. This makes the implementation + // simpler and has the advantage that the streambuf and the buffer are always + // in sync and sputc never writes into uninitialized memory. The obvious + // disadvantage is that each call to sputc always results in a (virtual) call + // to overflow. There is no disadvantage here for sputn since this always + // results in a call to xsputn. - int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE - { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast(ch)); - return ch; - } + int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } - std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE - { - buffer_.append(s, s + count); - return count; - } + std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE { + buffer_.append(s, s + count); + return count; + } }; Yes &convert(std::ostream &); -struct DummyStream : std::ostream -{ - DummyStream(); // Suppress a bogus warning in MSVC. - // Hide all operator<< overloads from std::ostream. - void operator<<(Null<>); +struct DummyStream : std::ostream { + DummyStream(); // Suppress a bogus warning in MSVC. + + // Hide all operator<< overloads from std::ostream. + template + typename EnableIf::type operator<<(const T &); }; No &operator<<(std::ostream &, int); -template -struct ConvertToIntImpl -{ - // Convert to int only if T doesn't have an overloaded operator<<. - enum - { - value = sizeof(convert(get() << get())) == sizeof(No) - }; +template +struct ConvertToIntImpl { + // Convert to int only if T doesn't have an overloaded operator<<. + enum { + value = sizeof(convert(get() << get())) == sizeof(No) + }; }; // Write the content of w to os. @@ -81,17 +75,17 @@ FMT_API void write(std::ostream &os, Writer &w); // Formats a value. template void format_arg(BasicFormatter &f, - const Char *&format_str, const T &value) -{ - internal::MemoryBuffer buffer; + const Char *&format_str, const T &value) { + internal::MemoryBuffer buffer; - internal::FormatBuf format_buf(buffer); - std::basic_ostream output(&format_buf); - output << value; + internal::FormatBuf format_buf(buffer); + std::basic_ostream output(&format_buf); + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); + output << value; - BasicStringRef str(&buffer[0], buffer.size()); - typedef internal::MakeArg< BasicFormatter > MakeArg; - format_str = f.format(format_str, MakeArg(str)); + BasicStringRef str(&buffer[0], buffer.size()); + typedef internal::MakeArg< BasicFormatter > MakeArg; + format_str = f.format(format_str, MakeArg(str)); } /** diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h index 69327250..88512de5 100644 --- a/include/spdlog/fmt/bundled/posix.h +++ b/include/spdlog/fmt/bundled/posix.h @@ -64,134 +64,112 @@ #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) -namespace fmt -{ +namespace fmt { // An error code. -class ErrorCode -{ -private: - int value_; +class ErrorCode { + private: + int value_; -public: -explicit ErrorCode(int value = 0) FMT_NOEXCEPT : - value_(value) {} + public: + explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {} - int get() const FMT_NOEXCEPT - { - return value_; - } + int get() const FMT_NOEXCEPT { return value_; } }; // A buffered file. -class BufferedFile -{ -private: - FILE *file_; +class BufferedFile { + private: + FILE *file_; - friend class File; + friend class File; - explicit BufferedFile(FILE *f) : file_(f) {} + explicit BufferedFile(FILE *f) : file_(f) {} -public: - // Constructs a BufferedFile object which doesn't represent any file. -BufferedFile() FMT_NOEXCEPT : - file_(FMT_NULL) {} + public: + // Constructs a BufferedFile object which doesn't represent any file. + BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {} - // Destroys the object closing the file it represents if any. - FMT_API ~BufferedFile() FMT_NOEXCEPT; + // Destroys the object closing the file it represents if any. + FMT_API ~BufferedFile() FMT_NOEXCEPT; #if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. -private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy - { - FILE *file; - }; + private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy { + FILE *file; + }; public: - // A "move constructor" for moving from a temporary. -BufferedFile(Proxy p) FMT_NOEXCEPT : - file_(p.file) {} + // A "move constructor" for moving from a temporary. + BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {} - // A "move constructor" for moving from an lvalue. -BufferedFile(BufferedFile &f) FMT_NOEXCEPT : - file_(f.file_) - { - f.file_ = FMT_NULL; - } + // A "move constructor" for moving from an lvalue. + BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) { + f.file_ = FMT_NULL; + } - // A "move assignment operator" for moving from a temporary. - BufferedFile &operator=(Proxy p) - { - close(); - file_ = p.file; - return *this; - } + // A "move assignment operator" for moving from a temporary. + BufferedFile &operator=(Proxy p) { + close(); + file_ = p.file; + return *this; + } - // A "move assignment operator" for moving from an lvalue. - BufferedFile &operator=(BufferedFile &other) - { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } + // A "move assignment operator" for moving from an lvalue. + BufferedFile &operator=(BufferedFile &other) { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } - // Returns a proxy object for moving from a temporary: - // BufferedFile file = BufferedFile(...); - operator Proxy() FMT_NOEXCEPT - { - Proxy p = {file_}; - file_ = FMT_NULL; - return p; - } + // Returns a proxy object for moving from a temporary: + // BufferedFile file = BufferedFile(...); + operator Proxy() FMT_NOEXCEPT { + Proxy p = {file_}; + file_ = FMT_NULL; + return p; + } #else -private: - FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile); + private: + FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile); -public: -BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : - file_(other.file_) - { - other.file_ = FMT_NULL; - } + public: + BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) { + other.file_ = FMT_NULL; + } - BufferedFile& operator=(BufferedFile &&other) - { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } + BufferedFile& operator=(BufferedFile &&other) { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } #endif - // Opens a file. - FMT_API BufferedFile(CStringRef filename, CStringRef mode); + // Opens a file. + FMT_API BufferedFile(CStringRef filename, CStringRef mode); - // Closes the file. - FMT_API void close(); + // Closes the file. + FMT_API void close(); - // Returns the pointer to a FILE object representing this file. - FILE *get() const FMT_NOEXCEPT - { - return file_; - } + // Returns the pointer to a FILE object representing this file. + FILE *get() const FMT_NOEXCEPT { return file_; } - // We place parentheses around fileno to workaround a bug in some versions - // of MinGW that define fileno as a macro. - FMT_API int (fileno)() const; + // We place parentheses around fileno to workaround a bug in some versions + // of MinGW that define fileno as a macro. + FMT_API int (fileno)() const; - void print(CStringRef format_str, const ArgList &args) - { - fmt::print(file_, format_str, args); - } - FMT_VARIADIC(void, print, CStringRef) + void print(CStringRef format_str, const ArgList &args) { + fmt::print(file_, format_str, args); + } + FMT_VARIADIC(void, print, CStringRef) }; // A file. Closed file is represented by a File object with descriptor -1. @@ -200,141 +178,125 @@ BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. -class File -{ -private: - int fd_; // File descriptor. +class File { + private: + int fd_; // File descriptor. - // Constructs a File object with a given descriptor. - explicit File(int fd) : fd_(fd) {} + // Constructs a File object with a given descriptor. + explicit File(int fd) : fd_(fd) {} -public: - // Possible values for the oflag argument to the constructor. - enum - { - RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. - WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. - RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. - }; + public: + // Possible values for the oflag argument to the constructor. + enum { + RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. + WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. + RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. + }; - // Constructs a File object which doesn't represent any file. -File() FMT_NOEXCEPT : - fd_(-1) {} + // Constructs a File object which doesn't represent any file. + File() FMT_NOEXCEPT : fd_(-1) {} - // Opens a file and constructs a File object representing this file. - FMT_API File(CStringRef path, int oflag); + // Opens a file and constructs a File object representing this file. + FMT_API File(CStringRef path, int oflag); #if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. -private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy - { - int fd; - }; + private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy { + int fd; + }; -public: - // A "move constructor" for moving from a temporary. -File(Proxy p) FMT_NOEXCEPT : - fd_(p.fd) {} + public: + // A "move constructor" for moving from a temporary. + File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} - // A "move constructor" for moving from an lvalue. -File(File &other) FMT_NOEXCEPT : - fd_(other.fd_) - { - other.fd_ = -1; - } + // A "move constructor" for moving from an lvalue. + File(File &other) FMT_NOEXCEPT : fd_(other.fd_) { + other.fd_ = -1; + } - // A "move assignment operator" for moving from a temporary. - File &operator=(Proxy p) - { - close(); - fd_ = p.fd; - return *this; - } + // A "move assignment operator" for moving from a temporary. + File &operator=(Proxy p) { + close(); + fd_ = p.fd; + return *this; + } - // A "move assignment operator" for moving from an lvalue. - File &operator=(File &other) - { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } + // A "move assignment operator" for moving from an lvalue. + File &operator=(File &other) { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } - // Returns a proxy object for moving from a temporary: - // File file = File(...); - operator Proxy() FMT_NOEXCEPT - { - Proxy p = {fd_}; - fd_ = -1; - return p; - } + // Returns a proxy object for moving from a temporary: + // File file = File(...); + operator Proxy() FMT_NOEXCEPT { + Proxy p = {fd_}; + fd_ = -1; + return p; + } #else -private: - FMT_DISALLOW_COPY_AND_ASSIGN(File); + private: + FMT_DISALLOW_COPY_AND_ASSIGN(File); -public: -File(File &&other) FMT_NOEXCEPT : - fd_(other.fd_) - { - other.fd_ = -1; - } + public: + File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) { + other.fd_ = -1; + } - File& operator=(File &&other) - { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } + File& operator=(File &&other) { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } #endif - // Destroys the object closing the file it represents if any. - FMT_API ~File() FMT_NOEXCEPT; + // Destroys the object closing the file it represents if any. + FMT_API ~File() FMT_NOEXCEPT; - // Returns the file descriptor. - int descriptor() const FMT_NOEXCEPT - { - return fd_; - } + // Returns the file descriptor. + int descriptor() const FMT_NOEXCEPT { return fd_; } - // Closes the file. - FMT_API void close(); + // Closes the file. + FMT_API void close(); - // Returns the file size. The size has signed type for consistency with - // stat::st_size. - FMT_API LongLong size() const; + // Returns the file size. The size has signed type for consistency with + // stat::st_size. + FMT_API LongLong size() const; - // Attempts to read count bytes from the file into the specified buffer. - FMT_API std::size_t read(void *buffer, std::size_t count); + // Attempts to read count bytes from the file into the specified buffer. + FMT_API std::size_t read(void *buffer, std::size_t count); - // Attempts to write count bytes from the specified buffer to the file. - FMT_API std::size_t write(const void *buffer, std::size_t count); + // Attempts to write count bytes from the specified buffer to the file. + FMT_API std::size_t write(const void *buffer, std::size_t count); - // Duplicates a file descriptor with the dup function and returns - // the duplicate as a file object. - FMT_API static File dup(int fd); + // Duplicates a file descriptor with the dup function and returns + // the duplicate as a file object. + FMT_API static File dup(int fd); - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd); + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd); - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT; + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT; - // Creates a pipe setting up read_end and write_end file objects for reading - // and writing respectively. - FMT_API static void pipe(File &read_end, File &write_end); + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + FMT_API static void pipe(File &read_end, File &write_end); - // Creates a BufferedFile object associated with this file and detaches - // this File object from the file. - FMT_API BufferedFile fdopen(const char *mode); + // Creates a BufferedFile object associated with this file and detaches + // this File object from the file. + FMT_API BufferedFile fdopen(const char *mode); }; // Returns the memory page size. @@ -347,77 +309,58 @@ long getpagesize(); #ifdef FMT_LOCALE // A "C" numeric locale. -class Locale -{ -private: +class Locale { + private: # ifdef _MSC_VER - typedef _locale_t locale_t; + typedef _locale_t locale_t; - enum { LC_NUMERIC_MASK = LC_NUMERIC }; + enum { LC_NUMERIC_MASK = LC_NUMERIC }; - static locale_t newlocale(int category_mask, const char *locale, locale_t) - { - return _create_locale(category_mask, locale); - } + static locale_t newlocale(int category_mask, const char *locale, locale_t) { + return _create_locale(category_mask, locale); + } - static void freelocale(locale_t locale) - { - _free_locale(locale); - } + static void freelocale(locale_t locale) { + _free_locale(locale); + } - static double strtod_l(const char *nptr, char **endptr, _locale_t locale) - { - return _strtod_l(nptr, endptr, locale); - } + static double strtod_l(const char *nptr, char **endptr, _locale_t locale) { + return _strtod_l(nptr, endptr, locale); + } # endif - locale_t locale_; + locale_t locale_; - FMT_DISALLOW_COPY_AND_ASSIGN(Locale); + FMT_DISALLOW_COPY_AND_ASSIGN(Locale); -public: - typedef locale_t Type; + public: + typedef locale_t Type; - Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) - { - if (!locale_) - FMT_THROW(fmt::SystemError(errno, "cannot create locale")); - } - ~Locale() - { - freelocale(locale_); - } + Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) { + if (!locale_) + FMT_THROW(fmt::SystemError(errno, "cannot create locale")); + } + ~Locale() { freelocale(locale_); } - Type get() const - { - return locale_; - } + Type get() const { return locale_; } - // Converts string to floating-point number and advances str past the end - // of the parsed input. - double strtod(const char *&str) const - { - char *end = FMT_NULL; - double result = strtod_l(str, &end, locale_); - str = end; - return result; - } + // Converts string to floating-point number and advances str past the end + // of the parsed input. + double strtod(const char *&str) const { + char *end = FMT_NULL; + double result = strtod_l(str, &end, locale_); + str = end; + return result; + } }; #endif // FMT_LOCALE } // namespace fmt #if !FMT_USE_RVALUE_REFERENCES -namespace std -{ +namespace std { // For compatibility with C++98. -inline fmt::BufferedFile &move(fmt::BufferedFile &f) -{ - return f; -} -inline fmt::File &move(fmt::File &f) -{ - return f; -} +inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; } +inline fmt::File &move(fmt::File &f) { return f; } } #endif diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h index 7861b460..46205a78 100644 --- a/include/spdlog/fmt/bundled/printf.h +++ b/include/spdlog/fmt/bundled/printf.h @@ -15,118 +15,78 @@ #include "ostream.h" -namespace fmt -{ -namespace internal -{ +namespace fmt { +namespace internal { // 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 = std::numeric_limits::max(); - return value <= max; - } - static bool fits_in_int(bool) - { - return true; - } +struct IntChecker { + template + static bool fits_in_int(T value) { + unsigned max = std::numeric_limits::max(); + return value <= max; + } + static bool fits_in_int(bool) { return true; } }; template <> -struct IntChecker -{ - template - static bool fits_in_int(T value) - { - return value >= std::numeric_limits::min() && - value <= std::numeric_limits::max(); - } - static bool fits_in_int(int) - { - return true; - } +struct IntChecker { + template + static bool fits_in_int(T value) { + return value >= std::numeric_limits::min() && + value <= std::numeric_limits::max(); + } + static bool fits_in_int(int) { return true; } }; -class PrecisionHandler : public ArgVisitor -{ -public: - void report_unhandled_arg() - { - FMT_THROW(FormatError("precision is not integer")); - } +class PrecisionHandler : public ArgVisitor { + public: + void report_unhandled_arg() { + FMT_THROW(FormatError("precision is not integer")); + } - template - int visit_any_int(T value) - { - if (!IntChecker::is_signed>::fits_in_int(value)) - FMT_THROW(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(FormatError("number is too big")); + return static_cast(value); + } }; // IsZeroInt::visit(arg) returns true iff arg is a zero integer. -class IsZeroInt : public ArgVisitor -{ -public: - template - bool visit_any_int(T value) - { - return value == 0; - } +class IsZeroInt : public ArgVisitor { + public: + template + bool visit_any_int(T value) { return value == 0; } }; // returns the default type for format specific "%s" -class DefaultType : public ArgVisitor -{ -public: - char visit_char(int) - { - return 'c'; - } +class DefaultType : public ArgVisitor { + public: + char visit_char(int) { return 'c'; } - char visit_bool(bool) - { - return 's'; - } + char visit_bool(bool) { return 's'; } - char visit_pointer(const void *) - { - return 'p'; - } + char visit_pointer(const void *) { return 'p'; } - template - char visit_any_int(T) - { - return 'd'; - } + template + char visit_any_int(T) { return 'd'; } - template - char visit_any_double(T) - { - return 'g'; - } + template + char visit_any_double(T) { return 'g'; } - char visit_unhandled_arg() - { - return 's'; - } + char visit_unhandled_arg() { return 's'; } }; template -struct is_same -{ - enum { value = 0 }; +struct is_same { + enum { value = 0 }; }; template -struct is_same -{ - enum { value = 1 }; +struct is_same { + enum { value = 1 }; }; // An argument visitor that converts an integer argument to T for printf, @@ -134,128 +94,108 @@ struct is_same // corresponding signed or unsigned type depending on the type specifier: // 'd' and 'i' - signed, other - unsigned) template -class ArgConverter : public ArgVisitor, void> -{ -private: - internal::Arg &arg_; - wchar_t type_; +class ArgConverter : public ArgVisitor, void> { + private: + internal::Arg &arg_; + wchar_t type_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); -public: - ArgConverter(internal::Arg &arg, wchar_t type) - : arg_(arg), type_(type) {} + public: + ArgConverter(internal::Arg &arg, wchar_t type) + : arg_(arg), type_(type) {} - void visit_bool(bool value) - { - if (type_ != 's') - visit_any_int(value); + void visit_bool(bool value) { + if (type_ != 's') + visit_any_int(value); + } + + void visit_char(int value) { + if (type_ != 's') + visit_any_int(value); + } + + template + void visit_any_int(U value) { + bool is_signed = type_ == 'd' || type_ == 'i'; + if (type_ == 's') { + is_signed = std::numeric_limits::is_signed; } - void visit_char(char value) - { - if (type_ != 's') - visit_any_int(value); - } - - template - void visit_any_int(U value) - { - bool is_signed = type_ == 'd' || type_ == 'i'; - if (type_ == 's') - { - is_signed = std::numeric_limits::is_signed; - } - - using internal::Arg; - typedef typename internal::Conditional< + using internal::Arg; + typedef typename internal::Conditional< is_same::value, U, T>::type TargetType; - if (sizeof(TargetType) <= sizeof(int)) - { - // Extra casts are used to silence warnings. - if (is_signed) - { - arg_.type = Arg::INT; - arg_.int_value = static_cast(static_cast(value)); - } - else - { - arg_.type = Arg::UINT; - typedef typename internal::MakeUnsigned::Type Unsigned; - arg_.uint_value = static_cast(static_cast(value)); - } - } - else - { - if (is_signed) - { - arg_.type = Arg::LONG_LONG; - // glibc's printf doesn't sign extend arguments of smaller types: - // std::printf("%lld", -42); // prints "4294967254" - // but we don't have to do the same because it's a UB. - arg_.long_long_value = static_cast(value); - } - else - { - arg_.type = Arg::ULONG_LONG; - arg_.ulong_long_value = - static_cast::Type>(value); - } - } + if (const_check(sizeof(TargetType) <= 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; + typedef typename internal::MakeUnsigned::Type Unsigned; + arg_.uint_value = static_cast(static_cast(value)); + } + } else { + if (is_signed) { + arg_.type = Arg::LONG_LONG; + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + arg_.long_long_value = static_cast(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 ArgVisitor -{ -private: - internal::Arg &arg_; +class CharConverter : public ArgVisitor { + private: + internal::Arg &arg_; - FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); -public: - explicit CharConverter(internal::Arg &arg) : arg_(arg) {} + public: + explicit CharConverter(internal::Arg &arg) : arg_(arg) {} - template - void visit_any_int(T value) - { - arg_.type = internal::Arg::CHAR; - arg_.int_value = static_cast(value); - } + template + void visit_any_int(T value) { + arg_.type = internal::Arg::CHAR; + arg_.int_value = static_cast(value); + } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -class WidthHandler : public ArgVisitor -{ -private: - FormatSpec &spec_; +class WidthHandler : public ArgVisitor { + private: + FormatSpec &spec_; - FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); -public: - explicit WidthHandler(FormatSpec &spec) : spec_(spec) {} + public: + explicit WidthHandler(FormatSpec &spec) : spec_(spec) {} - void report_unhandled_arg() - { - FMT_THROW(FormatError("width is not integer")); - } - - template - unsigned visit_any_int(T value) - { - typedef typename internal::IntTraits::MainType UnsignedType; - UnsignedType width = static_cast(value); - if (internal::is_negative(value)) - { - spec_.align_ = ALIGN_LEFT; - width = 0 - width; - } - unsigned int_max = std::numeric_limits::max(); - if (width > int_max) - FMT_THROW(FormatError("number is too big")); - return static_cast(width); + void report_unhandled_arg() { + FMT_THROW(FormatError("width is not integer")); + } + + template + unsigned visit_any_int(T value) { + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType width = static_cast(value); + if (internal::is_negative(value)) { + spec_.align_ = ALIGN_LEFT; + width = 0 - width; } + unsigned int_max = std::numeric_limits::max(); + if (width > int_max) + FMT_THROW(FormatError("number is too big")); + return static_cast(width); + } }; } // namespace internal @@ -278,359 +218,314 @@ public: */ template class BasicPrintfArgFormatter : - public internal::ArgFormatterBase -{ -private: - void write_null_pointer() - { - this->spec().type_ = 0; - this->write("(nil)"); + public internal::ArgFormatterBase { + private: + void write_null_pointer() { + this->spec().type_ = 0; + this->write("(nil)"); + } + + typedef internal::ArgFormatterBase Base; + + public: + /** + \rst + Constructs an argument formatter object. + *writer* is a reference to the output writer and *spec* contains format + specifier information for standard argument types. + \endrst + */ + BasicPrintfArgFormatter(BasicWriter &w, Spec &s) + : internal::ArgFormatterBase(w, s) {} + + /** Formats an argument of type ``bool``. */ + void visit_bool(bool value) { + Spec &fmt_spec = this->spec(); + if (fmt_spec.type_ != 's') + return this->visit_any_int(value); + fmt_spec.type_ = 0; + this->write(value); + } + + /** Formats a character. */ + void visit_char(int value) { + const Spec &fmt_spec = this->spec(); + BasicWriter &w = this->writer(); + if (fmt_spec.type_ && fmt_spec.type_ != 'c') + w.write_int(value, fmt_spec); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (fmt_spec.width_ > 1) { + Char fill = ' '; + out = w.grow_buffer(fmt_spec.width_); + if (fmt_spec.align_ != ALIGN_LEFT) { + std::fill_n(out, fmt_spec.width_ - 1, fill); + out += fmt_spec.width_ - 1; + } else { + std::fill_n(out + 1, fmt_spec.width_ - 1, fill); + } + } else { + out = w.grow_buffer(1); } + *out = static_cast(value); + } - typedef internal::ArgFormatterBase Base; + /** Formats a null-terminated C string. */ + void visit_cstring(const char *value) { + if (value) + Base::visit_cstring(value); + else if (this->spec().type_ == 'p') + write_null_pointer(); + else + this->write("(null)"); + } -public: - /** - \rst - Constructs an argument formatter object. - *writer* is a reference to the output writer and *spec* contains format - specifier information for standard argument types. - \endrst - */ - BasicPrintfArgFormatter(BasicWriter &w, Spec &s) - : internal::ArgFormatterBase(w, s) {} + /** Formats a pointer. */ + void visit_pointer(const void *value) { + if (value) + return Base::visit_pointer(value); + this->spec().type_ = 0; + write_null_pointer(); + } - /** Formats an argument of type ``bool``. */ - void visit_bool(bool value) - { - Spec &fmt_spec = this->spec(); - if (fmt_spec.type_ != 's') - return this->visit_any_int(value); - fmt_spec.type_ = 0; - this->write(value); - } - - /** Formats a character. */ - void visit_char(int value) - { - const Spec &fmt_spec = this->spec(); - BasicWriter &w = this->writer(); - if (fmt_spec.type_ && fmt_spec.type_ != 'c') - w.write_int(value, fmt_spec); - typedef typename BasicWriter::CharPtr CharPtr; - CharPtr out = CharPtr(); - if (fmt_spec.width_ > 1) - { - Char fill = ' '; - out = w.grow_buffer(fmt_spec.width_); - if (fmt_spec.align_ != ALIGN_LEFT) - { - std::fill_n(out, fmt_spec.width_ - 1, fill); - out += fmt_spec.width_ - 1; - } - else - { - std::fill_n(out + 1, fmt_spec.width_ - 1, fill); - } - } - else - { - out = w.grow_buffer(1); - } - *out = static_cast(value); - } - - /** Formats a null-terminated C string. */ - void visit_cstring(const char *value) - { - if (value) - Base::visit_cstring(value); - else if (this->spec().type_ == 'p') - write_null_pointer(); - else - this->write("(null)"); - } - - /** Formats a pointer. */ - void visit_pointer(const void *value) - { - if (value) - return Base::visit_pointer(value); - this->spec().type_ = 0; - write_null_pointer(); - } - - /** Formats an argument of a custom (user-defined) type. */ - void visit_custom(internal::Arg::CustomValue c) - { - BasicFormatter formatter(ArgList(), this->writer()); - const Char format_str[] = {'}', 0}; - const Char *format = format_str; - c.format(&formatter, c.value, &format); - } + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) { + BasicFormatter formatter(ArgList(), this->writer()); + const Char format_str[] = {'}', 0}; + const Char *format = format_str; + c.format(&formatter, c.value, &format); + } }; /** The default printf argument formatter. */ template class PrintfArgFormatter : - public BasicPrintfArgFormatter, Char, FormatSpec> -{ -public: - /** Constructs an argument formatter object. */ - PrintfArgFormatter(BasicWriter &w, FormatSpec &s) - : BasicPrintfArgFormatter, Char, FormatSpec>(w, s) {} + public BasicPrintfArgFormatter, Char, FormatSpec> { + public: + /** Constructs an argument formatter object. */ + PrintfArgFormatter(BasicWriter &w, FormatSpec &s) + : BasicPrintfArgFormatter, Char, FormatSpec>(w, s) {} }; /** This template formats data and writes the output to a writer. */ template > -class PrintfFormatter : private internal::FormatterBase -{ -private: - BasicWriter &writer_; +class PrintfFormatter : private internal::FormatterBase { + private: + BasicWriter &writer_; - void parse_flags(FormatSpec &spec, const Char *&s); + 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. - internal::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. + internal::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: - /** - \rst - Constructs a ``PrintfFormatter`` object. References to the arguments and - the writer are stored in the formatter object so make sure they have - appropriate lifetimes. - \endrst - */ - explicit PrintfFormatter(const ArgList &al, BasicWriter &w) - : FormatterBase(al), writer_(w) {} + public: + /** + \rst + Constructs a ``PrintfFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + explicit PrintfFormatter(const ArgList &al, BasicWriter &w) + : FormatterBase(al), writer_(w) {} - /** Formats stored arguments and writes the output to the writer. */ - void format(BasicCStringRef format_str); + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); }; template -void 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; - } +void 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; } + } } template internal::Arg PrintfFormatter::get_arg(const Char *s, - unsigned arg_index) -{ - (void)s; - const char *error = FMT_NULL; - internal::Arg arg = arg_index == std::numeric_limits::max() ? - next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); - if (error) - FMT_THROW(FormatError(!*s ? "invalid format string" : error)); - return arg; + unsigned arg_index) { + (void)s; + const char *error = FMT_NULL; + internal::Arg arg = arg_index == std::numeric_limits::max() ? + next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); + if (error) + FMT_THROW(FormatError(!*s ? "invalid format string" : error)); + return arg; } template unsigned PrintfFormatter::parse_header( - const Char *&s, FormatSpec &spec) -{ - unsigned arg_index = std::numeric_limits::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 = internal::parse_nonnegative_int(s); - if (*s == '$') // value is an argument index - { - ++s; - arg_index = value; - } - else - { - if (c == '0') - spec.fill_ = '0'; - if (value != 0) - { - // Nonzero value means that we parsed width and don't need to - // parse it or flags again, so return now. - spec.width_ = value; - return arg_index; - } - } + const Char *&s, FormatSpec &spec) { + unsigned arg_index = std::numeric_limits::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 = internal::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_ = internal::parse_nonnegative_int(s); - } - else if (*s == '*') - { - ++s; - spec.width_ = internal::WidthHandler(spec).visit(get_arg(s)); - } - return arg_index; + } + parse_flags(spec, s); + // Parse width. + if (*s >= '0' && *s <= '9') { + spec.width_ = internal::parse_nonnegative_int(s); + } else if (*s == '*') { + ++s; + spec.width_ = internal::WidthHandler(spec).visit(get_arg(s)); + } + return arg_index; } template -void PrintfFormatter::format(BasicCStringRef format_str) -{ - const Char *start = format_str.c_str(); - 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_ = static_cast(internal::parse_nonnegative_int(s)); - } - else if (*s == '*') - { - ++s; - spec.precision_ = internal::PrecisionHandler().visit(get_arg(s)); - } - else - { - spec.precision_ = 0; - } - } - - using internal::Arg; - Arg arg = get_arg(s, arg_index); - if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg)) - spec.flags_ &= ~internal::to_unsigned(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. - using internal::ArgConverter; - 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 (spec.type_ == 's') - { - // set the format type to the default if 's' is specified - spec.type_ = internal::DefaultType().visit(arg); - } - - 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 - internal::CharConverter(arg).visit(arg); - break; - } - } - - start = s; - - // Format argument. - AF(writer_, spec).visit(arg); +void PrintfFormatter::format(BasicCStringRef format_str) { + const Char *start = format_str.c_str(); + const Char *s = start; + while (*s) { + Char c = *s++; + if (c != '%') continue; + if (*s == c) { + write(writer_, start, s); + start = ++s; + continue; } - write(writer_, start, s); + write(writer_, start, s - 1); + + FormatSpec spec; + spec.align_ = ALIGN_RIGHT; + + // Parse argument index, flags and width. + unsigned arg_index = parse_header(s, spec); + + // Parse precision. + if (*s == '.') { + ++s; + if ('0' <= *s && *s <= '9') { + spec.precision_ = static_cast(internal::parse_nonnegative_int(s)); + } else if (*s == '*') { + ++s; + spec.precision_ = internal::PrecisionHandler().visit(get_arg(s)); + } else { + spec.precision_ = 0; + } + } + + using internal::Arg; + Arg arg = get_arg(s, arg_index); + if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg)) + spec.flags_ &= ~internal::to_unsigned(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. + using internal::ArgConverter; + 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 (spec.type_ == 's') { + // set the format type to the default if 's' is specified + spec.type_ = internal::DefaultType().visit(arg); + } + + 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 + internal::CharConverter(arg).visit(arg); + break; + } + } + + start = s; + + // Format argument. + AF(writer_, spec).visit(arg); + } + write(writer_, start, s); } -inline void printf(Writer &w, CStringRef format, ArgList args) -{ - PrintfFormatter(args, w).format(format); +inline void printf(Writer &w, CStringRef format, ArgList args) { + PrintfFormatter(args, w).format(format); } FMT_VARIADIC(void, printf, Writer &, CStringRef) -inline void printf(WWriter &w, WCStringRef format, ArgList args) -{ - PrintfFormatter(args, w).format(format); +inline void printf(WWriter &w, WCStringRef format, ArgList args) { + PrintfFormatter(args, w).format(format); } FMT_VARIADIC(void, printf, WWriter &, WCStringRef) @@ -643,19 +538,17 @@ FMT_VARIADIC(void, printf, WWriter &, WCStringRef) std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ -inline std::string sprintf(CStringRef format, ArgList args) -{ - MemoryWriter w; - printf(w, format, args); - return w.str(); +inline std::string sprintf(CStringRef format, ArgList args) { + MemoryWriter w; + printf(w, format, args); + return w.str(); } FMT_VARIADIC(std::string, sprintf, CStringRef) -inline std::wstring sprintf(WCStringRef format, ArgList args) -{ - WMemoryWriter w; - printf(w, format, args); - return w.str(); +inline std::wstring sprintf(WCStringRef format, ArgList args) { + WMemoryWriter w; + printf(w, format, args); + return w.str(); } FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef) @@ -680,9 +573,8 @@ FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef) fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ -inline int printf(CStringRef format, ArgList args) -{ - return fprintf(stdout, format, args); +inline int printf(CStringRef format, ArgList args) { + return fprintf(stdout, format, args); } FMT_VARIADIC(int, printf, CStringRef) @@ -695,12 +587,11 @@ FMT_VARIADIC(int, printf, CStringRef) fprintf(cerr, "Don't %s!", "panic"); \endrst */ -inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) -{ - MemoryWriter w; - printf(w, format_str, args); - internal::write(os, w); - return static_cast(w.size()); +inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) { + MemoryWriter w; + printf(w, format_str, args); + internal::write(os, w); + return static_cast(w.size()); } FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef) } // namespace fmt diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h index 206d0920..c98b0e01 100644 --- a/include/spdlog/fmt/bundled/time.h +++ b/include/spdlog/fmt/bundled/time.h @@ -19,160 +19,120 @@ # pragma warning(disable: 4996) // "deprecated" functions #endif -namespace fmt -{ +namespace fmt { template void format_arg(BasicFormatter &f, - const char *&format_str, const std::tm &tm) -{ - if (*format_str == ':') - ++format_str; - const char *end = format_str; - while (*end && *end != '}') - ++end; - if (*end != '}') - FMT_THROW(FormatError("missing '}' in format string")); - internal::MemoryBuffer format; - format.append(format_str, end + 1); - format[format.size() - 1] = '\0'; - Buffer &buffer = f.writer().buffer(); - std::size_t start = buffer.size(); - for (;;) - { - std::size_t size = buffer.capacity() - start; - std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm); - if (count != 0) - { - buffer.resize(start + count); - break; - } - if (size >= format.size() * 256) - { - // If the buffer is 256 times larger than the format string, assume - // that `strftime` gives an empty result. There doesn't seem to be a - // better way to distinguish the two cases: - // https://github.com/fmtlib/fmt/issues/367 - break; - } - const std::size_t MIN_GROWTH = 10; - buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); + const char *&format_str, const std::tm &tm) { + if (*format_str == ':') + ++format_str; + const char *end = format_str; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); + internal::MemoryBuffer format; + format.append(format_str, end + 1); + format[format.size() - 1] = '\0'; + Buffer &buffer = f.writer().buffer(); + std::size_t start = buffer.size(); + for (;;) { + std::size_t size = buffer.capacity() - start; + std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm); + if (count != 0) { + buffer.resize(start + count); + break; } - format_str = end + 1; + if (size >= format.size() * 256) { + // If the buffer is 256 times larger than the format string, assume + // that `strftime` gives an empty result. There doesn't seem to be a + // better way to distinguish the two cases: + // https://github.com/fmtlib/fmt/issues/367 + break; + } + const std::size_t MIN_GROWTH = 10; + buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); + } + format_str = end + 1; } -namespace internal -{ -inline Null<> localtime_r(...) -{ - return Null<>(); -} -inline Null<> localtime_s(...) -{ - return Null<>(); -} -inline Null<> gmtime_r(...) -{ - return Null<>(); -} -inline Null<> gmtime_s(...) -{ - return Null<>(); -} +namespace internal{ +inline Null<> localtime_r(...) { return Null<>(); } +inline Null<> localtime_s(...) { return Null<>(); } +inline Null<> gmtime_r(...) { return Null<>(); } +inline Null<> gmtime_s(...) { return Null<>(); } } // Thread-safe replacement for std::localtime -inline std::tm localtime(std::time_t time) -{ - struct LocalTime - { - std::time_t time_; - std::tm tm_; +inline std::tm localtime(std::time_t time) { + struct LocalTime { + std::time_t time_; + std::tm tm_; - LocalTime(std::time_t t): time_(t) {} + LocalTime(std::time_t t): time_(t) {} - bool run() - { - using namespace fmt::internal; - return handle(localtime_r(&time_, &tm_)); - } + bool run() { + using namespace fmt::internal; + return handle(localtime_r(&time_, &tm_)); + } - bool handle(std::tm *tm) - { - return tm != FMT_NULL; - } + bool handle(std::tm *tm) { return tm != FMT_NULL; } - bool handle(internal::Null<>) - { - using namespace fmt::internal; - return fallback(localtime_s(&tm_, &time_)); - } + bool handle(internal::Null<>) { + using namespace fmt::internal; + return fallback(localtime_s(&tm_, &time_)); + } - bool fallback(int res) - { - return res == 0; - } + bool fallback(int res) { return res == 0; } - bool fallback(internal::Null<>) - { - using namespace fmt::internal; - std::tm *tm = std::localtime(&time_); - if (tm) tm_ = *tm; - return tm != FMT_NULL; - } - }; - LocalTime lt(time); - if (lt.run()) - return lt.tm_; - // Too big time values may be unsupported. - FMT_THROW(fmt::FormatError("time_t value out of range")); - return std::tm(); + bool fallback(internal::Null<>) { + using namespace fmt::internal; + std::tm *tm = std::localtime(&time_); + if (tm) tm_ = *tm; + return tm != FMT_NULL; + } + }; + LocalTime lt(time); + if (lt.run()) + return lt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); } // Thread-safe replacement for std::gmtime -inline std::tm gmtime(std::time_t time) -{ - struct GMTime - { - std::time_t time_; - std::tm tm_; +inline std::tm gmtime(std::time_t time) { + struct GMTime { + std::time_t time_; + std::tm tm_; - GMTime(std::time_t t): time_(t) {} + GMTime(std::time_t t): time_(t) {} - bool run() - { - using namespace fmt::internal; - return handle(gmtime_r(&time_, &tm_)); - } + bool run() { + using namespace fmt::internal; + return handle(gmtime_r(&time_, &tm_)); + } - bool handle(std::tm *tm) - { - return tm != FMT_NULL; - } + bool handle(std::tm *tm) { return tm != FMT_NULL; } - bool handle(internal::Null<>) - { - using namespace fmt::internal; - return fallback(gmtime_s(&tm_, &time_)); - } + bool handle(internal::Null<>) { + using namespace fmt::internal; + return fallback(gmtime_s(&tm_, &time_)); + } - bool fallback(int res) - { - return res == 0; - } + bool fallback(int res) { return res == 0; } - bool fallback(internal::Null<>) - { - std::tm *tm = std::gmtime(&time_); - if (tm != FMT_NULL) tm_ = *tm; - return tm != FMT_NULL; - } - }; - GMTime gt(time); - if (gt.run()) - return gt.tm_; - // Too big time values may be unsupported. - FMT_THROW(fmt::FormatError("time_t value out of range")); - return std::tm(); + bool fallback(internal::Null<>) { + std::tm *tm = std::gmtime(&time_); + if (tm != FMT_NULL) tm_ = *tm; + return tm != FMT_NULL; + } + }; + GMTime gt(time); + if (gt.run()) + return gt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); } } //namespace fmt From abc0d43995533745b322f42e610a76d1e8983c62 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 23 Feb 2018 18:33:03 +0200 Subject: [PATCH 20/39] astyle --- include/spdlog/details/os.h | 2 +- include/spdlog/fmt/bundled/format.h | 5139 +++++++++++++++----------- include/spdlog/fmt/bundled/ostream.h | 97 +- include/spdlog/fmt/bundled/posix.h | 469 +-- include/spdlog/fmt/bundled/printf.h | 927 +++-- include/spdlog/fmt/bundled/time.h | 222 +- tests/test_pattern_formatter.cpp | 54 +- 7 files changed, 3893 insertions(+), 3017 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 26d1fd16..e647e32a 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -439,7 +439,7 @@ inline int pid() { #ifdef _WIN32 - return static_cast(::GetCurrentProcessId()); + return static_cast(::GetCurrentProcessId()); #else return static_cast(::getpid()); #endif diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h index 561a9e07..971c58e2 100644 --- a/include/spdlog/fmt/bundled/format.h +++ b/include/spdlog/fmt/bundled/format.h @@ -356,22 +356,25 @@ typedef __int64 intmax_t; #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) # include // _BitScanReverse, _BitScanReverse64 -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ // avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning # ifndef __clang__ # pragma intrinsic(_BitScanReverse) # endif -inline uint32_t clz(uint32_t x) { - unsigned long r = 0; - _BitScanReverse(&r, x); +inline uint32_t clz(uint32_t x) +{ + unsigned long r = 0; + _BitScanReverse(&r, x); - assert(x != 0); - // Static analysis complains about using uninitialized data - // "r", but the only way that can happen is if "x" is 0, - // which the callers guarantee to not happen. + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. # pragma warning(suppress: 6102) - return 31 - r; + return 31 - r; } # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) @@ -380,106 +383,143 @@ inline uint32_t clz(uint32_t x) { # pragma intrinsic(_BitScanReverse64) # endif -inline uint32_t clzll(uint64_t x) { - unsigned long r = 0; +inline uint32_t clzll(uint64_t x) +{ + unsigned long r = 0; # ifdef _WIN64 - _BitScanReverse64(&r, x); + _BitScanReverse64(&r, x); # else - // Scan the high 32 bits. - if (_BitScanReverse(&r, static_cast(x >> 32))) - return 63 - (r + 32); + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); - // Scan the low 32 bits. - _BitScanReverse(&r, static_cast(x)); + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); # endif - assert(x != 0); - // Static analysis complains about using uninitialized data - // "r", but the only way that can happen is if "x" is 0, - // which the callers guarantee to not happen. + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. # pragma warning(suppress: 6102) - return 63 - r; + return 63 - r; } # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) } } #endif -namespace fmt { -namespace internal { -struct DummyInt { - int data[2]; - operator int() const { return 0; } +namespace fmt +{ +namespace internal +{ +struct DummyInt +{ + int data[2]; + operator int() const + { + return 0; + } }; typedef std::numeric_limits FPUtil; // Dummy implementations of system functions such as signbit and ecvt called // if the latter are not available. -inline DummyInt signbit(...) { return DummyInt(); } -inline DummyInt _ecvt_s(...) { return DummyInt(); } -inline DummyInt isinf(...) { return DummyInt(); } -inline DummyInt _finite(...) { return DummyInt(); } -inline DummyInt isnan(...) { return DummyInt(); } -inline DummyInt _isnan(...) { return DummyInt(); } +inline DummyInt signbit(...) +{ + return DummyInt(); +} +inline DummyInt _ecvt_s(...) +{ + return DummyInt(); +} +inline DummyInt isinf(...) +{ + return DummyInt(); +} +inline DummyInt _finite(...) +{ + return DummyInt(); +} +inline DummyInt isnan(...) +{ + return DummyInt(); +} +inline DummyInt _isnan(...) +{ + return DummyInt(); +} // A helper function to suppress bogus "conditional expression is constant" // warnings. template -inline T const_check(T value) { return value; } +inline T const_check(T value) +{ + return value; +} } } // namespace fmt -namespace std { +namespace std +{ // Standard permits specialization of std::numeric_limits. This specialization // is used to resolve ambiguity between isinf and std::isinf in glibc: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 // and the same for isnan and signbit. template <> class numeric_limits : - public std::numeric_limits { - public: - // Portable version of isinf. - template - static bool isinfinity(T x) { - using namespace fmt::internal; - // The resolution "priority" is: - // isinf macro > std::isinf > ::isinf > fmt::internal::isinf - if (const_check(sizeof(isinf(x)) == sizeof(bool) || - sizeof(isinf(x)) == sizeof(int))) { - return isinf(x) != 0; + public std::numeric_limits +{ +public: + // Portable version of isinf. + template + static bool isinfinity(T x) + { + using namespace fmt::internal; + // The resolution "priority" is: + // isinf macro > std::isinf > ::isinf > fmt::internal::isinf + if (const_check(sizeof(isinf(x)) == sizeof(bool) || + sizeof(isinf(x)) == sizeof(int))) + { + return isinf(x) != 0; + } + return !_finite(static_cast(x)); } - return !_finite(static_cast(x)); - } - // Portable version of isnan. - template - static bool isnotanumber(T x) { - using namespace fmt::internal; - if (const_check(sizeof(isnan(x)) == sizeof(bool) || - sizeof(isnan(x)) == sizeof(int))) { - return isnan(x) != 0; + // Portable version of isnan. + template + static bool isnotanumber(T x) + { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) == sizeof(bool) || + sizeof(isnan(x)) == sizeof(int))) + { + return isnan(x) != 0; + } + return _isnan(static_cast(x)) != 0; } - return _isnan(static_cast(x)) != 0; - } - // Portable version of signbit. - static bool isnegative(double x) { - using namespace fmt::internal; - if (const_check(sizeof(signbit(x)) == sizeof(bool) || - sizeof(signbit(x)) == sizeof(int))) { - return signbit(x) != 0; + // Portable version of signbit. + static bool isnegative(double x) + { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) == sizeof(bool) || + sizeof(signbit(x)) == sizeof(int))) + { + return signbit(x) != 0; + } + if (x < 0) return true; + if (!isnotanumber(x)) return false; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); + return sign != 0; } - if (x < 0) return true; - if (!isnotanumber(x)) return false; - int dec = 0, sign = 0; - char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. - _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); - return sign != 0; - } }; } // namespace std -namespace fmt { +namespace fmt +{ // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -534,96 +574,112 @@ class BasicFormatter; \endrst */ template -class BasicStringRef { - private: - const Char *data_; - std::size_t size_; +class BasicStringRef +{ +private: + const Char *data_; + std::size_t size_; - 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) {} +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) {} - /** - \rst - Constructs a string reference object from a C string computing - the size with ``std::char_traits::length``. - \endrst - */ - BasicStringRef(const Char *s) - : data_(s), size_(std::char_traits::length(s)) {} + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + BasicStringRef(const Char *s) + : data_(s), size_(std::char_traits::length(s)) {} - /** - \rst - Constructs a string reference from a ``std::basic_string`` object. - \endrst - */ - template - BasicStringRef( - const std::basic_string, Allocator> &s) - : data_(s.c_str()), size_(s.size()) {} + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()), size_(s.size()) {} #if FMT_HAS_STRING_VIEW - /** - \rst - Constructs a string reference from a ``std::basic_string_view`` object. - \endrst - */ - BasicStringRef( - const std::basic_string_view> &s) - : data_(s.data()), size_(s.size()) {} + /** + \rst + Constructs a string reference from a ``std::basic_string_view`` object. + \endrst + */ + BasicStringRef( + const std::basic_string_view> &s) + : data_(s.data()), size_(s.size()) {} - /** - \rst - Converts a string reference to an ``std::string_view`` object. - \endrst - */ - explicit operator std::basic_string_view() const FMT_NOEXCEPT { - return std::basic_string_view(data_, size_); - } + /** + \rst + Converts a string reference to an ``std::string_view`` object. + \endrst + */ + explicit operator std::basic_string_view() const FMT_NOEXCEPT + { + return std::basic_string_view(data_, size_); + } #endif - /** - \rst - Converts a string reference to an ``std::string`` object. - \endrst - */ - std::basic_string to_string() const { - return std::basic_string(data_, size_); - } + /** + \rst + Converts a string reference to an ``std::string`` object. + \endrst + */ + std::basic_string to_string() const + { + return std::basic_string(data_, size_); + } - /** Returns a pointer to the string data. */ - const Char *data() const { return data_; } + /** Returns a pointer to the string data. */ + const Char *data() const + { + return data_; + } - /** Returns the string size. */ - std::size_t size() const { return size_; } + /** Returns the string size. */ + std::size_t size() const + { + return size_; + } - // Lexicographically compare this string reference to other. - int compare(BasicStringRef other) const { - std::size_t size = size_ < other.size_ ? size_ : other.size_; - int result = std::char_traits::compare(data_, other.data_, size); - if (result == 0) - result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - return result; - } + // Lexicographically compare this string reference to other. + int compare(BasicStringRef other) const + { + std::size_t size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) == 0; - } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) != 0; - } - friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) < 0; - } - friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) <= 0; - } - friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) > 0; - } - friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) { - return lhs.compare(rhs) >= 0; - } + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) != 0; + } + friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) + { + return lhs.compare(rhs) >= 0; + } }; typedef BasicStringRef StringRef; @@ -655,45 +711,54 @@ typedef BasicStringRef WStringRef; \endrst */ template -class BasicCStringRef { - private: - const Char *data_; +class BasicCStringRef +{ +private: + const Char *data_; - public: - /** Constructs a string reference object from a C string. */ - BasicCStringRef(const Char *s) : data_(s) {} +public: + /** Constructs a string reference object from a C string. */ + BasicCStringRef(const Char *s) : data_(s) {} - /** - \rst - Constructs a string reference from a ``std::basic_string`` object. - \endrst - */ - template - BasicCStringRef( - const std::basic_string, Allocator> &s) - : data_(s.c_str()) {} + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicCStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()) {} - /** Returns the pointer to a C string. */ - const Char *c_str() const { return data_; } + /** Returns the pointer to a C string. */ + const Char *c_str() const + { + return data_; + } }; typedef BasicCStringRef CStringRef; typedef BasicCStringRef WCStringRef; /** A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error { - public: - explicit FormatError(CStringRef message) - : std::runtime_error(message.c_str()) {} - FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} - FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; +class FormatError : public std::runtime_error +{ +public: + explicit FormatError(CStringRef message) + : std::runtime_error(message.c_str()) {} + FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} + FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; }; -namespace internal { +namespace internal +{ // 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 <> \ @@ -708,9 +773,10 @@ FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong); // Casts nonnegative integer to unsigned. template -inline typename MakeUnsigned::Type to_unsigned(Int value) { - FMT_ASSERT(value >= 0, "negative value"); - return static_cast::Type>(value); +inline typename MakeUnsigned::Type to_unsigned(Int value) +{ + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::Type>(value); } // The number of characters to store in the MemoryBuffer object itself @@ -720,12 +786,16 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if FMT_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 @@ -735,266 +805,328 @@ inline T *make_ptr(T *ptr, std::size_t) { return ptr; } \endrst */ 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 = FMT_NULL, std::size_t capacity = 0) - : ptr_(ptr), size_(0), capacity_(capacity) {} + Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0) + : ptr_(ptr), size_(0), capacity_(capacity) {} - /** - \rst - Increases the buffer capacity to hold at least *size* elements updating - ``ptr_`` and ``capacity_``. - \endrst - */ - virtual void grow(std::size_t size) = 0; + /** + \rst + Increases the buffer capacity to hold at least *size* elements updating + ``ptr_`` and ``capacity_``. + \endrst + */ + 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 may not be 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; + } - /** - \rst - Reserves space to store at least *capacity* elements. - \endrst - */ - void reserve(std::size_t capacity) { - if (capacity > capacity_) - grow(capacity); - } + /** + \rst + Reserves space to store at least *capacity* elements. + \endrst + */ + void reserve(std::size_t capacity) + { + if (capacity > capacity_) + grow(capacity); + } - void clear() FMT_NOEXCEPT { size_ = 0; } + void clear() FMT_NOEXCEPT { size_ = 0; } - void push_back(const T &value) { - if (size_ == capacity_) - grow(size_ + 1); - ptr_[size_++] = value; - } + void push_back(const T &value) + { + if (size_ == capacity_) + grow(size_ + 1); + ptr_[size_++] = value; + } - /** Appends data to the end of the buffer. */ - template - void append(const U *begin, const U *end); + /** Appends data to the end of the buffer. */ + template + void append(const U *begin, const U *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 template -void Buffer::append(const U *begin, const U *end) { - FMT_ASSERT(end >= begin, "negative value"); - std::size_t new_size = size_ + static_cast(end - begin); - if (new_size > capacity_) - grow(new_size); - std::uninitialized_copy(begin, end, - internal::make_ptr(ptr_, capacity_) + size_); - size_ = new_size; +void Buffer::append(const U *begin, const U *end) +{ + FMT_ASSERT(end >= begin, "negative value"); + std::size_t new_size = size_ + static_cast(end - begin); + if (new_size > capacity_) + grow(new_size); + std::uninitialized_copy(begin, end, + internal::make_ptr(ptr_, capacity_) + size_); + size_ = new_size; } -namespace internal { +namespace internal +{ // A memory buffer for trivially copyable/constructible 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]; - // Deallocate memory allocated by the buffer. - void deallocate() { - if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); - } + // Deallocate memory allocated by the buffer. + void deallocate() + { + if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); + } - protected: - void grow(std::size_t size) FMT_OVERRIDE; +protected: + void grow(std::size_t size) FMT_OVERRIDE; - public: - explicit MemoryBuffer(const Allocator &alloc = Allocator()) - : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() FMT_OVERRIDE { deallocate(); } +public: + explicit MemoryBuffer(const Allocator &alloc = Allocator()) + : Allocator(alloc), Buffer(data_, SIZE) {} + ~MemoryBuffer() FMT_OVERRIDE { deallocate(); } #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::uninitialized_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 deallocating. - 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::uninitialized_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 deallocating. + other.ptr_ = other.data_; + } } - } - public: - MemoryBuffer(MemoryBuffer &&other) { - move(other); - } +public: + MemoryBuffer(MemoryBuffer &&other) + { + move(other); + } - MemoryBuffer &operator=(MemoryBuffer &&other) { - assert(this != &other); - deallocate(); - move(other); - return *this; - } + MemoryBuffer &operator=(MemoryBuffer &&other) + { + assert(this != &other); + deallocate(); + 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 = this->capacity_ + this->capacity_ / 2; - if (size > new_capacity) - new_capacity = size; +void MemoryBuffer::grow(std::size_t size) +{ + std::size_t new_capacity = this->capacity_ + this->capacity_ / 2; + if (size > new_capacity) + new_capacity = size; #if FMT_USE_ALLOCATOR_TRAITS - T *new_ptr = - std::allocator_traits::allocate(*this, new_capacity, FMT_NULL); + T *new_ptr = + std::allocator_traits::allocate(*this, new_capacity, FMT_NULL); #else - T *new_ptr = this->allocate(new_capacity, FMT_NULL); + T *new_ptr = this->allocate(new_capacity, FMT_NULL); #endif - // The following code doesn't throw, so the raw pointer above doesn't leak. - std::uninitialized_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_) - Allocator::deallocate(old_ptr, old_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_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_) + Allocator::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) {} +class FixedBuffer : public fmt::Buffer +{ +public: + FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} - protected: - FMT_API void grow(std::size_t size) FMT_OVERRIDE; +protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; }; template -class BasicCharTraits { - public: +class BasicCharTraits +{ +public: #if FMT_SECURE_SCL - typedef stdext::checked_array_iterator CharPtr; + typedef stdext::checked_array_iterator CharPtr; #else - typedef Char *CharPtr; + typedef Char *CharPtr; #endif - static Char cast(int value) { return static_cast(value); } + static Char cast(int value) + { + return static_cast(value); + } }; template class CharTraits; template <> -class CharTraits : public BasicCharTraits { - private: - // Conversion from wchar_t to char is not allowed. - static char convert(wchar_t); +class CharTraits : public BasicCharTraits +{ +private: + // Conversion from wchar_t to char is not allowed. + static char convert(wchar_t); - public: - static char convert(char value) { return value; } +public: + static char convert(char value) + { + return value; + } - // Formats a floating-point number. - template - FMT_API 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 + FMT_API static int format_float(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); }; #if FMT_USE_EXTERN_TEMPLATES extern template int CharTraits::format_float - (char *buffer, std::size_t size, - const char* format, unsigned width, int precision, double value); +(char *buffer, std::size_t size, + const char* format, unsigned width, int precision, double value); extern template int CharTraits::format_float - (char *buffer, std::size_t size, - const char* format, unsigned width, int precision, long double value); +(char *buffer, std::size_t size, + const char* format, unsigned width, int precision, long double value); #endif template <> -class CharTraits : public BasicCharTraits { - public: - static wchar_t convert(char value) { return value; } - static wchar_t convert(wchar_t value) { return value; } +class CharTraits : public BasicCharTraits +{ +public: + static wchar_t convert(char value) + { + return value; + } + static wchar_t convert(wchar_t value) + { + return value; + } - template - FMT_API static int format_float(wchar_t *buffer, std::size_t size, - const wchar_t *format, unsigned width, int precision, T value); + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); }; #if FMT_USE_EXTERN_TEMPLATES extern template int CharTraits::format_float - (wchar_t *buffer, std::size_t size, - const wchar_t* format, unsigned width, int precision, double value); +(wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, double value); extern template int CharTraits::format_float - (wchar_t *buffer, std::size_t size, - const wchar_t* format, unsigned width, int precision, long double value); +(wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, long double value); #endif // 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; }; @@ -1003,10 +1135,11 @@ FMT_API FMT_NORETURN void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct FMT_API BasicData { - static const uint32_t POWERS_OF_10_32[]; - static const uint64_t POWERS_OF_10_64[]; - static const char DIGITS[]; +struct FMT_API BasicData +{ + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const char DIGITS[]; }; #if FMT_USE_EXTERN_TEMPLATES @@ -1018,63 +1151,70 @@ typedef BasicData<> Data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) { - // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. - int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; - return to_unsigned(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. + int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1; } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) { - unsigned count = 1; - for (;;) { - // Integer division is slow so do it for a group of four digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - if (n < 10) return count; - if (n < 100) return count + 1; - if (n < 1000) return count + 2; - if (n < 10000) return count + 3; - n /= 10000u; - count += 4; - } +inline unsigned count_digits(uint64_t n) +{ + unsigned count = 1; + for (;;) + { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } } #endif #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) { - int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; - return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; +inline unsigned count_digits(uint32_t n) +{ + int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; } #endif // A functor that doesn't add a thousands separator. -struct NoThousandsSep { - template - void operator()(Char *) {} +struct NoThousandsSep +{ + template + void operator()(Char *) {} }; // A functor that adds a thousands separator. -class ThousandsSep { - private: - fmt::StringRef sep_; +class ThousandsSep +{ +private: + fmt::StringRef sep_; - // Index of a decimal digit with the least significant digit having index 0. - unsigned digit_index_; + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; - public: - explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} +public: + explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} - template - void operator()(Char *&buffer) { - if (++digit_index_ % 3 != 0) - return; - buffer -= sep_.size(); - std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), - internal::make_ptr(buffer, sep_.size())); - } + template + void operator()(Char *&buffer) + { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), + internal::make_ptr(buffer, sep_.size())); + } }; // Formats a decimal unsigned integer value writing into buffer. @@ -1082,33 +1222,37 @@ class ThousandsSep { // add a thousands separator if necessary. template inline void format_decimal(Char *buffer, UInt value, unsigned num_digits, - ThousandsSep thousands_sep) { - buffer += 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 = static_cast((value % 100) * 2); - value /= 100; + ThousandsSep thousands_sep) +{ + buffer += 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 = static_cast((value % 100) * 2); + value /= 100; + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; + thousands_sep(buffer); + } + if (value < 10) + { + *--buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); *--buffer = Data::DIGITS[index + 1]; thousands_sep(buffer); *--buffer = Data::DIGITS[index]; - thousands_sep(buffer); - } - if (value < 10) { - *--buffer = static_cast('0' + value); - return; - } - unsigned index = static_cast(value * 2); - *--buffer = Data::DIGITS[index + 1]; - thousands_sep(buffer); - *--buffer = Data::DIGITS[index]; } template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { - format_decimal(buffer, value, num_digits, NoThousandsSep()); - return; +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) +{ + format_decimal(buffer, value, num_digits, NoThousandsSep()); + return; } #ifndef _WIN32 @@ -1122,36 +1266,62 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { #if FMT_USE_WINDOWS_H // 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: - FMT_API 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: + FMT_API 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() {} - FMT_API 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() {} + FMT_API 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. - FMT_API 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. + FMT_API int convert(WStringRef s); }; FMT_API void format_windows_error(fmt::Writer &out, int error_code, @@ -1159,50 +1329,56 @@ FMT_API void format_windows_error(fmt::Writer &out, int error_code, #endif // A formatting argument value. -struct Value { - template - struct StringValue { - const Char *value; - std::size_t size; - }; +struct Value +{ + template + struct StringValue + { + const Char *value; + std::size_t size; + }; - typedef void (*FormatFunc)( - void *formatter, const void *arg, void *format_str_ptr); + typedef void (*FormatFunc)( + void *formatter, const void *arg, void *format_str_ptr); - struct CustomValue { - const void *value; - FormatFunc format; - }; + 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; - }; + 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, NAMED_ARG, - // Integer types should go first, - INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, - // followed by floating-point types. - DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, - CSTRING, STRING, WSTRING, POINTER, CUSTOM - }; + enum Type + { + NONE, NAMED_ARG, + // Integer types should go first, + INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, + // followed by floating-point types. + DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, + CSTRING, STRING, WSTRING, POINTER, CUSTOM + }; }; // A formatting argument. It is a trivially copyable/constructible type to // allow storage in internal::MemoryBuffer. -struct Arg : Value { - Type type; +struct Arg : Value +{ + Type type; }; template @@ -1216,15 +1392,17 @@ struct Null {}; // A helper class template to enable or disable overloads taking wide // characters and strings in MakeValue. template -struct WCharHelper { - typedef Null Supported; - typedef T Unsupported; +struct WCharHelper +{ + typedef Null Supported; + typedef T Unsupported; }; template -struct WCharHelper { - typedef T Supported; - typedef Null Unsupported; +struct WCharHelper +{ + typedef T Supported; + typedef Null Unsupported; }; typedef char Yes[1]; @@ -1238,29 +1416,35 @@ Yes &convert(fmt::ULongLong); No &convert(...); template -struct ConvertToIntImpl { - enum { value = ENABLE_CONVERSION }; +struct ConvertToIntImpl +{ + enum { value = ENABLE_CONVERSION }; }; template -struct ConvertToIntImpl2 { - enum { value = false }; +struct ConvertToIntImpl2 +{ + enum { value = false }; }; template -struct ConvertToIntImpl2 { - enum { - // Don't convert numeric types. - value = ConvertToIntImpl::is_specialized>::value - }; +struct ConvertToIntImpl2 +{ + enum + { + // Don't convert numeric types. + value = ConvertToIntImpl::is_specialized>::value + }; }; template -struct ConvertToInt { - enum { - enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) - }; - enum { value = ConvertToIntImpl2::value }; +struct ConvertToInt +{ + enum + { + enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) + }; + enum { value = ConvertToIntImpl2::value }; }; #define FMT_DISABLE_CONVERSION_TO_INT(Type) \ @@ -1276,26 +1460,45 @@ template struct EnableIf {}; template -struct EnableIf { typedef T type; }; +struct EnableIf +{ + typedef T type; +}; template -struct Conditional { typedef T type; }; +struct Conditional +{ + typedef T type; +}; template -struct Conditional { typedef F type; }; +struct Conditional +{ + typedef F type; +}; // For bcc32 which doesn't understand ! in template arguments. template -struct Not { enum { value = 0 }; }; +struct Not +{ + enum { value = 0 }; +}; template <> -struct Not { enum { value = 1 }; }; +struct Not +{ + enum { value = 1 }; +}; template -struct FalseType { enum { value = 0 }; }; +struct FalseType +{ + enum { value = 0 }; +}; -template struct LConvCheck { - LConvCheck(int) {} +template struct LConvCheck +{ + LConvCheck(int) {} }; // Returns the thousands separator for the current locale. @@ -1303,11 +1506,15 @@ template struct LConvCheck { // ``lconv`` is stubbed as an empty struct. template inline StringRef thousands_sep( - LConv *lc, LConvCheck = 0) { - return lc->thousands_sep; + LConv *lc, LConvCheck = 0) +{ + return lc->thousands_sep; } -inline fmt::StringRef thousands_sep(...) { return ""; } +inline fmt::StringRef thousands_sep(...) +{ + return ""; +} #define FMT_CONCAT(a, b) a##b @@ -1331,66 +1538,71 @@ inline fmt::StringRef thousands_sep(...) { return ""; } #endif template -void format_arg(Formatter&, ...) { - FMT_STATIC_ASSERT(FalseType::value, - "Cannot format argument. To enable the use of ostream " - "operator<< include fmt/ostream.h. Otherwise provide " - "an overload of format_arg."); +void format_arg(Formatter&, ...) +{ + FMT_STATIC_ASSERT(FalseType::value, + "Cannot format argument. To enable the use of ostream " + "operator<< include fmt/ostream.h. Otherwise provide " + "an overload of format_arg."); } // Makes an Arg object from any type. template -class MakeValue : public Arg { - public: - typedef typename Formatter::Char Char; +class MakeValue : public Arg +{ +public: + typedef typename Formatter::Char Char; - 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); +private: + // The following two methods are private to disallow formatting of + // arbitrary pointers. If you want to output a pointer cast it to + // "void *" or "const void *". In particular, this forbids formatting + // of "[const] volatile char *" which is printed as bool by iostreams. + // Do not implement! + template + MakeValue(const T *value); + template + MakeValue(T *value); - // The following methods are private to disallow formatting of wide - // characters and strings into narrow strings as in - // fmt::format("{}", L"test"); - // To fix this, use a wide format string: fmt::format(L"{}", L"test"). + // 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"). #if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); #endif - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); #if FMT_HAS_STRING_VIEW - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); #endif - MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); - void set_string(StringRef str) { - string.value = str.data(); - string.size = str.size(); - } + void set_string(StringRef str) + { + string.value = str.data(); + string.size = str.size(); + } - void set_string(WStringRef str) { - wstring.value = str.data(); - wstring.size = str.size(); - } + void set_string(WStringRef str) + { + wstring.value = str.data(); + wstring.size = str.size(); + } - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) { - format_arg(*static_cast(formatter), - *static_cast(format_str_ptr), - *static_cast(arg)); - } + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg( + void *formatter, const void *arg, void *format_str_ptr) + { + format_arg(*static_cast(formatter), + *static_cast(format_str_ptr), + *static_cast(arg)); + } - public: - MakeValue() {} +public: + MakeValue() {} #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ MakeValue(Type value) { field = rhs; } \ @@ -1399,81 +1611,95 @@ class MakeValue : public Arg { #define FMT_MAKE_VALUE(Type, field, TYPE) \ FMT_MAKE_VALUE_(Type, field, TYPE, value) - FMT_MAKE_VALUE(bool, int_value, BOOL) - 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, BOOL) + 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 (const_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(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 (const_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 (const_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; - } + MakeValue(unsigned long value) + { + if (const_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, INT) - FMT_MAKE_VALUE(unsigned char, uint_value, UINT) - 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, INT) + FMT_MAKE_VALUE(unsigned char, uint_value, UINT) + FMT_MAKE_VALUE(char, int_value, CHAR) #if __cplusplus >= 201103L - template < - typename T, - typename = typename std::enable_if< - std::is_enum::value && ConvertToInt::value>::type> - MakeValue(T value) { int_value = value; } + template < + typename T, + typename = typename std::enable_if< + std::is_enum::value && ConvertToInt::value>::type> + MakeValue(T value) + { + int_value = value; + } - template < - typename T, - typename = typename std::enable_if< - std::is_enum::value && ConvertToInt::value>::type> - static uint64_t type(T) { return Arg::INT; } + template < + typename T, + typename = typename std::enable_if< + std::is_enum::value && ConvertToInt::value>::type> + static uint64_t type(T) + { + return Arg::INT; + } #endif #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) - MakeValue(typename WCharHelper::Supported value) { - int_value = value; - } - static uint64_t type(wchar_t) { return Arg::CHAR; } + MakeValue(typename WCharHelper::Supported value) + { + int_value = value; + } + static uint64_t type(wchar_t) + { + return Arg::CHAR; + } #endif #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(signed char *, sstring.value, CSTRING) - FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) - FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING) - FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) - FMT_MAKE_STR_VALUE(const std::string &, STRING) + FMT_MAKE_VALUE(char *, string.value, CSTRING) + FMT_MAKE_VALUE(const char *, string.value, CSTRING) + FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING) + FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) + FMT_MAKE_STR_VALUE(const std::string &, STRING) #if FMT_HAS_STRING_VIEW - FMT_MAKE_STR_VALUE(const std::string_view &, STRING) + FMT_MAKE_STR_VALUE(const std::string_view &, STRING) #endif - FMT_MAKE_STR_VALUE(StringRef, STRING) - FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str()) + FMT_MAKE_STR_VALUE(StringRef, STRING) + FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str()) #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ MakeValue(typename WCharHelper::Supported value) { \ @@ -1481,78 +1707,98 @@ class MakeValue : public Arg { } \ static uint64_t type(Type) { return Arg::TYPE; } - FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) #if FMT_HAS_STRING_VIEW - FMT_MAKE_WSTR_VALUE(const std::wstring_view &, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring_view &, WSTRING) #endif - FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) - FMT_MAKE_VALUE(void *, pointer, POINTER) - FMT_MAKE_VALUE(const void *, pointer, POINTER) + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) - template - MakeValue(const T &value, - typename EnableIf::value>::value, int>::type = 0) { - custom.value = &value; - custom.format = &format_custom_arg; - } + template + MakeValue(const T &value, + typename EnableIf::value>::value, int>::type = 0) + { + custom.value = &value; + custom.format = &format_custom_arg; + } - template - static typename EnableIf::value>::value, uint64_t>::type - type(const T &) { - return Arg::CUSTOM; - } + template + static typename EnableIf::value>::value, uint64_t>::type + type(const T &) + { + return Arg::CUSTOM; + } - // Additional template param `Char_` is needed here because make_type always - // uses char. - template - MakeValue(const NamedArg &value) { pointer = &value; } - template - MakeValue(const NamedArgWithType &value) { pointer = &value; } + // Additional template param `Char_` is needed here because make_type always + // uses char. + template + MakeValue(const NamedArg &value) + { + pointer = &value; + } + template + MakeValue(const NamedArgWithType &value) + { + pointer = &value; + } - template - static uint64_t type(const NamedArg &) { return Arg::NAMED_ARG; } - template - static uint64_t type(const NamedArgWithType &) { return Arg::NAMED_ARG; } + template + static uint64_t type(const NamedArg &) + { + return Arg::NAMED_ARG; + } + template + static uint64_t type(const NamedArgWithType &) + { + return Arg::NAMED_ARG; + } }; template -class MakeArg : public Arg { +class MakeArg : public Arg +{ public: - MakeArg() { - type = Arg::NONE; - } + MakeArg() + { + type = Arg::NONE; + } - template - MakeArg(const T &value) - : Arg(MakeValue(value)) { - type = static_cast(MakeValue::type(value)); - } + template + MakeArg(const T &value) + : Arg(MakeValue(value)) + { + type = static_cast(MakeValue::type(value)); + } }; template -struct NamedArg : Arg { - BasicStringRef name; +struct NamedArg : Arg +{ + BasicStringRef name; - template - NamedArg(BasicStringRef argname, const T &value) - : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} + template + NamedArg(BasicStringRef argname, const T &value) + : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} }; template -struct NamedArgWithType : NamedArg { - NamedArgWithType(BasicStringRef argname, const T &value) - : NamedArg(argname, value) {} +struct NamedArgWithType : NamedArg +{ + NamedArgWithType(BasicStringRef argname, const T &value) + : NamedArg(argname, value) {} }; -class RuntimeError : public std::runtime_error { - protected: - RuntimeError() : std::runtime_error("") {} - RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} - FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; +class RuntimeError : public std::runtime_error +{ +protected: + RuntimeError() : std::runtime_error("") {} + RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} + FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; }; template @@ -1560,73 +1806,84 @@ class ArgMap; } // namespace internal /** 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_; - }; +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_; + }; - internal::Arg::Type type(unsigned index) const { - return type(types_, index); - } - - template - friend class internal::ArgMap; - - public: - // Maximum number of arguments with packed types. - enum { MAX_PACKED_ARGS = 16 }; - - ArgList() : types_(0) {} - - ArgList(ULongLong types, const internal::Value *values) - : types_(types), values_(values) {} - ArgList(ULongLong types, const internal::Arg *args) - : types_(types), args_(args) {} - - uint64_t types() const { return types_; } - - /** 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; + internal::Arg::Type type(unsigned index) const + { + return type(types_, index); } - 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]; - } - static internal::Arg::Type type(uint64_t types, unsigned index) { - unsigned shift = index * 4; - uint64_t mask = 0xf; - return static_cast( - (types & (mask << shift)) >> shift); - } + template + friend class internal::ArgMap; + +public: + // Maximum number of arguments with packed types. + enum { MAX_PACKED_ARGS = 16 }; + + ArgList() : types_(0) {} + + ArgList(ULongLong types, const internal::Value *values) + : types_(types), values_(values) {} + ArgList(ULongLong types, const internal::Arg *args) + : types_(types), args_(args) {} + + uint64_t types() const + { + return types_; + } + + /** 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]; + } + + static internal::Arg::Type type(uint64_t types, unsigned index) + { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast( + (types & (mask << shift)) >> shift); + } }; #define FMT_DISPATCH(call) static_cast(this)->call @@ -1656,148 +1913,169 @@ class ArgList { \endrst */ template -class ArgVisitor { - private: - typedef internal::Arg Arg; +class ArgVisitor +{ +private: + typedef internal::Arg Arg; - public: - void report_unhandled_arg() {} +public: + void report_unhandled_arg() {} - Result visit_unhandled_arg() { - FMT_DISPATCH(report_unhandled_arg()); - return Result(); - } - - /** Visits an ``int`` argument. **/ - Result visit_int(int value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``long long`` argument. **/ - Result visit_long_long(LongLong value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an ``unsigned`` argument. **/ - Result visit_uint(unsigned value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an ``unsigned long long`` argument. **/ - Result visit_ulong_long(ULongLong value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``bool`` argument. **/ - Result visit_bool(bool value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits a ``char`` or ``wchar_t`` argument. **/ - Result visit_char(int value) { - return FMT_DISPATCH(visit_any_int(value)); - } - - /** Visits an argument of any integral type. **/ - template - Result visit_any_int(T) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a ``double`` argument. **/ - Result visit_double(double value) { - return FMT_DISPATCH(visit_any_double(value)); - } - - /** Visits a ``long double`` argument. **/ - Result visit_long_double(long double value) { - return FMT_DISPATCH(visit_any_double(value)); - } - - /** Visits a ``double`` or ``long double`` argument. **/ - template - Result visit_any_double(T) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a null-terminated C string (``const char *``) argument. **/ - Result visit_cstring(const char *) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a string argument. **/ - Result visit_string(Arg::StringValue) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a wide string argument. **/ - Result visit_wstring(Arg::StringValue) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits a pointer argument. **/ - Result visit_pointer(const void *) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** Visits an argument of a custom (user-defined) type. **/ - Result visit_custom(Arg::CustomValue) { - return FMT_DISPATCH(visit_unhandled_arg()); - } - - /** - \rst - Visits an argument dispatching to the appropriate visit method based on - the argument type. For example, if the argument type is ``double`` then - the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be - called. - \endrst - */ - Result visit(const Arg &arg) { - switch (arg.type) { - case Arg::NONE: - case Arg::NAMED_ARG: - FMT_ASSERT(false, "invalid argument type"); - break; - 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::BOOL: - return FMT_DISPATCH(visit_bool(arg.int_value != 0)); - case Arg::CHAR: - return FMT_DISPATCH(visit_char(arg.int_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::CSTRING: - return FMT_DISPATCH(visit_cstring(arg.string.value)); - 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_unhandled_arg() + { + FMT_DISPATCH(report_unhandled_arg()); + return Result(); + } + + /** Visits an ``int`` argument. **/ + Result visit_int(int value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``long long`` argument. **/ + Result visit_long_long(LongLong value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned`` argument. **/ + Result visit_uint(unsigned value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned long long`` argument. **/ + Result visit_ulong_long(ULongLong value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``bool`` argument. **/ + Result visit_bool(bool value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``char`` or ``wchar_t`` argument. **/ + Result visit_char(int value) + { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an argument of any integral type. **/ + template + Result visit_any_int(T) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a ``double`` argument. **/ + Result visit_double(double value) + { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``long double`` argument. **/ + Result visit_long_double(long double value) + { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``double`` or ``long double`` argument. **/ + template + Result visit_any_double(T) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a null-terminated C string (``const char *``) argument. **/ + Result visit_cstring(const char *) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a string argument. **/ + Result visit_string(Arg::StringValue) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a wide string argument. **/ + Result visit_wstring(Arg::StringValue) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a pointer argument. **/ + Result visit_pointer(const void *) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits an argument of a custom (user-defined) type. **/ + Result visit_custom(Arg::CustomValue) + { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be + called. + \endrst + */ + Result visit(const Arg &arg) + { + switch (arg.type) + { + case Arg::NONE: + case Arg::NAMED_ARG: + FMT_ASSERT(false, "invalid argument type"); + break; + 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::BOOL: + return FMT_DISPATCH(visit_bool(arg.int_value != 0)); + case Arg::CHAR: + return FMT_DISPATCH(visit_char(arg.int_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::CSTRING: + return FMT_DISPATCH(visit_cstring(arg.string.value)); + 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)); + } + return Result(); } - return Result(); - } }; -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. @@ -1805,94 +2083,162 @@ 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 type_prefix() 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 type_prefix() 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; } - char type_prefix() const { return TYPE; } + bool flag(unsigned) const + { + return false; + } + char type() const + { + return TYPE; + } + char type_prefix() 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_; } - char type_prefix() const { return type_; } + bool flag(unsigned f) const + { + return (flags_ & f) != 0; + } + int precision() const + { + return precision_; + } + char type() const + { + return type_; + } + char type_prefix() const + { + return type_; + } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT { - private: - T value_; +class IntFormatSpec : public SpecT +{ +private: + T value_; - public: - IntFormatSpec(T val, const SpecT &spec = SpecT()) - : SpecT(spec), value_(val) {} +public: + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} - T value() const { return value_; } + T value() const + { + return value_; + } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec { - private: - const Char *str_; +class StrFormatSpec : public AlignSpec +{ +private: + const Char *str_; - public: - template - StrFormatSpec(const Char *str, unsigned width, FillChar fill) - : AlignSpec(width, fill), str_(str) { - internal::CharTraits::convert(FillChar()); - } +public: + template + StrFormatSpec(const Char *str, unsigned width, FillChar fill) + : AlignSpec(width, fill), str_(str) + { + internal::CharTraits::convert(FillChar()); + } - const Char *str() const { return str_; } + const Char *str() const + { + return str_; + } }; /** @@ -2005,235 +2351,293 @@ FMT_DEFINE_INT_FORMATTERS(ULongLong) */ 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); } -namespace internal { +namespace internal +{ template -class ArgMap { - private: - typedef std::vector< +class ArgMap +{ +private: + typedef std::vector< std::pair, internal::Arg> > MapType; - typedef typename MapType::value_type Pair; + typedef typename MapType::value_type Pair; - MapType map_; + MapType map_; - public: - void init(const ArgList &args); +public: + void init(const ArgList &args); - const internal::Arg *find(const fmt::BasicStringRef &name) const { - // The list is unsorted, so just return the first matching name. - for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); - it != end; ++it) { - if (it->first == name) - return &it->second; + const internal::Arg *find(const fmt::BasicStringRef &name) const + { + // The list is unsorted, so just return the first matching name. + for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); + it != end; ++it) + { + if (it->first == name) + return &it->second; + } + return FMT_NULL; } - return FMT_NULL; - } }; template -void ArgMap::init(const ArgList &args) { - if (!map_.empty()) - return; - typedef internal::NamedArg NamedArg; - const NamedArg *named_arg = FMT_NULL; - bool use_values = - args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; - if (use_values) { - for (unsigned i = 0;/*nothing*/; ++i) { - internal::Arg::Type arg_type = args.type(i); - switch (arg_type) { - case internal::Arg::NONE: +void ArgMap::init(const ArgList &args) +{ + if (!map_.empty()) + return; + typedef internal::NamedArg NamedArg; + const NamedArg *named_arg = FMT_NULL; + bool use_values = + args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; + if (use_values) + { + for (unsigned i = 0;/*nothing*/; ++i) + { + internal::Arg::Type arg_type = args.type(i); + switch (arg_type) + { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.values_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/ + ; + } + } return; - case internal::Arg::NAMED_ARG: - named_arg = static_cast(args.values_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); - break; - default: - /*nothing*/; - } } - return; - } - for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { - internal::Arg::Type arg_type = args.type(i); - if (arg_type == internal::Arg::NAMED_ARG) { - named_arg = static_cast(args.args_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); + for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) + { + internal::Arg::Type arg_type = args.type(i); + if (arg_type == internal::Arg::NAMED_ARG) + { + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + } } - } - for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { - switch (args.args_[i].type) { - case internal::Arg::NONE: - return; - case internal::Arg::NAMED_ARG: - named_arg = static_cast(args.args_[i].pointer); - map_.push_back(Pair(named_arg->name, *named_arg)); - break; - default: - /*nothing*/; + for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) + { + switch (args.args_[i].type) + { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/ + ; + } } - } } template -class ArgFormatterBase : public ArgVisitor { - private: - BasicWriter &writer_; - Spec &spec_; +class ArgFormatterBase : public ArgVisitor +{ +private: + BasicWriter &writer_; + Spec &spec_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); - void write_pointer(const void *p) { - spec_.flags_ = HASH_FLAG; - spec_.type_ = 'x'; - writer_.write_int(reinterpret_cast(p), spec_); - } - - // workaround MSVC two-phase lookup issue - typedef internal::Arg Arg; - - protected: - BasicWriter &writer() { return writer_; } - Spec &spec() { return spec_; } - - void write(bool value) { - const char *str_value = value ? "true" : "false"; - Arg::StringValue str = { str_value, std::strlen(str_value) }; - writer_.write_str(str, spec_); - } - - void write(const char *value) { - Arg::StringValue str = {value, value ? std::strlen(value) : 0}; - writer_.write_str(str, spec_); - } - - public: - typedef Spec SpecType; - - ArgFormatterBase(BasicWriter &w, Spec &s) - : writer_(w), spec_(s) {} - - template - void visit_any_int(T value) { writer_.write_int(value, spec_); } - - template - void visit_any_double(T value) { writer_.write_double(value, spec_); } - - void visit_bool(bool value) { - if (spec_.type_) { - visit_any_int(value); - return; + void write_pointer(const void *p) + { + spec_.flags_ = HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), spec_); } - write(value); - } - void visit_char(int value) { - if (spec_.type_ && spec_.type_ != 'c') { - spec_.flags_ |= CHAR_FLAG; - writer_.write_int(value, spec_); - return; + // workaround MSVC two-phase lookup issue + typedef internal::Arg Arg; + +protected: + BasicWriter &writer() + { + return writer_; } - if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) - FMT_THROW(FormatError("invalid format specifier for char")); - typedef typename BasicWriter::CharPtr CharPtr; - Char fill = internal::CharTraits::cast(spec_.fill()); - CharPtr out = CharPtr(); - const unsigned CHAR_SIZE = 1; - if (spec_.width_ > CHAR_SIZE) { - out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == ALIGN_RIGHT) { - std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); - out += spec_.width_ - CHAR_SIZE; - } else if (spec_.align_ == ALIGN_CENTER) { - out = writer_.fill_padding(out, spec_.width_, - internal::const_check(CHAR_SIZE), fill); - } else { - std::uninitialized_fill_n(out + CHAR_SIZE, - spec_.width_ - CHAR_SIZE, fill); - } - } else { - out = writer_.grow_buffer(CHAR_SIZE); + Spec &spec() + { + return spec_; } - *out = internal::CharTraits::cast(value); - } - void visit_cstring(const char *value) { - if (spec_.type_ == 'p') - return write_pointer(value); - write(value); - } + void write(bool value) + { + const char *str_value = value ? "true" : "false"; + Arg::StringValue str = { str_value, std::strlen(str_value) }; + writer_.write_str(str, spec_); + } - // Qualification with "internal" here and below is a workaround for nvcc. - void visit_string(internal::Arg::StringValue value) { - writer_.write_str(value, spec_); - } + void write(const char *value) + { + Arg::StringValue str = {value, value ? std::strlen(value) : 0}; + writer_.write_str(str, spec_); + } - using ArgVisitor::visit_wstring; +public: + typedef Spec SpecType; - void visit_wstring(internal::Arg::StringValue value) { - writer_.write_str(value, spec_); - } + ArgFormatterBase(BasicWriter &w, Spec &s) + : writer_(w), spec_(s) {} - void visit_pointer(const void *value) { - if (spec_.type_ && spec_.type_ != 'p') - report_unknown_type(spec_.type_, "pointer"); - write_pointer(value); - } + template + void visit_any_int(T value) + { + writer_.write_int(value, spec_); + } + + template + void visit_any_double(T value) + { + writer_.write_double(value, spec_); + } + + void visit_bool(bool value) + { + if (spec_.type_) + { + visit_any_int(value); + return; + } + write(value); + } + + void visit_char(int value) + { + if (spec_.type_ && spec_.type_ != 'c') + { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; + } + if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) + FMT_THROW(FormatError("invalid format specifier for char")); + typedef typename BasicWriter::CharPtr CharPtr; + Char fill = internal::CharTraits::cast(spec_.fill()); + CharPtr out = CharPtr(); + const unsigned CHAR_SIZE = 1; + if (spec_.width_ > CHAR_SIZE) + { + out = writer_.grow_buffer(spec_.width_); + if (spec_.align_ == ALIGN_RIGHT) + { + std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); + out += spec_.width_ - CHAR_SIZE; + } + else if (spec_.align_ == ALIGN_CENTER) + { + out = writer_.fill_padding(out, spec_.width_, + internal::const_check(CHAR_SIZE), fill); + } + else + { + std::uninitialized_fill_n(out + CHAR_SIZE, + spec_.width_ - CHAR_SIZE, fill); + } + } + else + { + out = writer_.grow_buffer(CHAR_SIZE); + } + *out = internal::CharTraits::cast(value); + } + + void visit_cstring(const char *value) + { + if (spec_.type_ == 'p') + return write_pointer(value); + write(value); + } + + // Qualification with "internal" here and below is a workaround for nvcc. + void visit_string(internal::Arg::StringValue value) + { + writer_.write_str(value, spec_); + } + + using ArgVisitor::visit_wstring; + + void visit_wstring(internal::Arg::StringValue value) + { + writer_.write_str(value, spec_); + } + + void visit_pointer(const void *value) + { + if (spec_.type_ && spec_.type_ != 'p') + report_unknown_type(spec_.type_, "pointer"); + write_pointer(value); + } }; -class FormatterBase { - private: - ArgList args_; - int next_arg_index_; +class FormatterBase +{ +private: + ArgList args_; + int next_arg_index_; - // Returns the argument with specified index. - FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); + // Returns the argument with specified index. + FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); - protected: - const ArgList &args() const { return args_; } - - explicit FormatterBase(const ArgList &args) { - args_ = args; - next_arg_index_ = 0; - } - - // Returns the next argument. - Arg next_arg(const char *&error) { - if (next_arg_index_ >= 0) - return do_get_arg(internal::to_unsigned(next_arg_index_++), error); - error = "cannot switch from manual to automatic argument indexing"; - return Arg(); - } - - // Checks if manual indexing is used and returns the argument with - // specified index. - Arg get_arg(unsigned arg_index, const char *&error) { - return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); - } - - bool check_no_auto_index(const char *&error) { - if (next_arg_index_ > 0) { - error = "cannot switch from automatic to manual argument indexing"; - return false; +protected: + const ArgList &args() const + { + return args_; } - next_arg_index_ = -1; - return true; - } - template - void write(BasicWriter &w, const Char *start, const Char *end) { - if (start != end) - w << BasicStringRef(start, internal::to_unsigned(end - start)); - } + explicit FormatterBase(const ArgList &args) + { + args_ = args; + next_arg_index_ = 0; + } + + // Returns the next argument. + Arg next_arg(const char *&error) + { + if (next_arg_index_ >= 0) + return do_get_arg(internal::to_unsigned(next_arg_index_++), error); + error = "cannot switch from manual to automatic argument indexing"; + return Arg(); + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + Arg get_arg(unsigned arg_index, const char *&error) + { + return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); + } + + bool check_no_auto_index(const char *&error) + { + if (next_arg_index_ > 0) + { + error = "cannot switch from automatic to manual argument indexing"; + return false; + } + next_arg_index_ = -1; + return true; + } + + template + void write(BasicWriter &w, const Char *start, const Char *end) + { + if (start != end) + w << BasicStringRef(start, internal::to_unsigned(end - start)); + } }; } // namespace internal @@ -2255,87 +2659,94 @@ class FormatterBase { \endrst */ template -class BasicArgFormatter : public internal::ArgFormatterBase { - private: - BasicFormatter &formatter_; - const Char *format_; +class BasicArgFormatter : public internal::ArgFormatterBase +{ +private: + BasicFormatter &formatter_; + const Char *format_; - public: - /** - \rst - Constructs an argument formatter object. - *formatter* is a reference to the main formatter object, *spec* contains - format specifier information for standard argument types, and *fmt* points - to the part of the format string being parsed for custom argument types. - \endrst - */ - BasicArgFormatter(BasicFormatter &formatter, - Spec &spec, const Char *fmt) - : internal::ArgFormatterBase(formatter.writer(), spec), - formatter_(formatter), format_(fmt) {} +public: + /** + \rst + Constructs an argument formatter object. + *formatter* is a reference to the main formatter object, *spec* contains + format specifier information for standard argument types, and *fmt* points + to the part of the format string being parsed for custom argument types. + \endrst + */ + BasicArgFormatter(BasicFormatter &formatter, + Spec &spec, const Char *fmt) + : internal::ArgFormatterBase(formatter.writer(), spec), + formatter_(formatter), format_(fmt) {} - /** Formats an argument of a custom (user-defined) type. */ - void visit_custom(internal::Arg::CustomValue c) { - c.format(&formatter_, c.value, &format_); - } + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) + { + c.format(&formatter_, c.value, &format_); + } }; /** The default argument formatter. */ template class ArgFormatter : - public BasicArgFormatter, Char, FormatSpec> { - public: - /** Constructs an argument formatter object. */ - ArgFormatter(BasicFormatter &formatter, - FormatSpec &spec, const Char *fmt) - : BasicArgFormatter, - Char, FormatSpec>(formatter, spec, fmt) {} + public BasicArgFormatter, Char, FormatSpec> +{ +public: + /** Constructs an argument formatter object. */ + ArgFormatter(BasicFormatter &formatter, + FormatSpec &spec, const Char *fmt) + : BasicArgFormatter, + Char, FormatSpec>(formatter, spec, fmt) {} }; /** This template formats data and writes the output to a writer. */ template -class BasicFormatter : private internal::FormatterBase { - public: - /** The character type for the output. */ - typedef CharType Char; +class BasicFormatter : private internal::FormatterBase +{ +public: + /** The character type for the output. */ + typedef CharType Char; - private: - BasicWriter &writer_; - internal::ArgMap map_; +private: + BasicWriter &writer_; + internal::ArgMap map_; - FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); - using internal::FormatterBase::get_arg; + using internal::FormatterBase::get_arg; - // Checks if manual indexing is used and returns the argument with - // specified name. - internal::Arg get_arg(BasicStringRef arg_name, const char *&error); + // Checks if manual indexing is used and returns the argument with + // specified name. + internal::Arg get_arg(BasicStringRef arg_name, const char *&error); - // 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); - // Parses argument name and returns corresponding argument. - internal::Arg parse_arg_name(const Char *&s); + // Parses argument name and returns corresponding argument. + internal::Arg parse_arg_name(const Char *&s); - public: - /** - \rst - Constructs a ``BasicFormatter`` object. References to the arguments and - the writer are stored in the formatter object so make sure they have - appropriate lifetimes. - \endrst - */ - BasicFormatter(const ArgList &args, BasicWriter &w) - : internal::FormatterBase(args), writer_(w) {} +public: + /** + \rst + Constructs a ``BasicFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + BasicFormatter(const ArgList &args, BasicWriter &w) + : internal::FormatterBase(args), writer_(w) {} - /** Returns a reference to the writer associated with this formatter. */ - BasicWriter &writer() { return writer_; } + /** Returns a reference to the writer associated with this formatter. */ + BasicWriter &writer() + { + return writer_; + } - /** Formats stored arguments and writes the output to the writer. */ - void format(BasicCStringRef format_str); + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); - // Formats a single argument and advances format_str, a format string pointer. - const Char *format(const Char *&format_str, const internal::Arg &arg); + // Formats a single argument and advances format_str, a format string pointer. + const Char *format(const Char *&format_str, const internal::Arg &arg); }; // Generates a comma-separated list with results of applying f to @@ -2357,24 +2768,31 @@ class BasicFormatter : private internal::FormatterBase { # 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< BasicFormatter >::type(arg); +inline uint64_t make_type(const T &arg) +{ + return MakeValue< BasicFormatter >::type(arg); } template -struct ArgArray; + struct ArgArray; template -struct ArgArray { - // '+' is used to silence GCC -Wduplicated-branches warning. - typedef Value Type[N > 0 ? N : +1]; +struct ArgArray +{ + // '+' is used to silence GCC -Wduplicated-branches warning. + typedef Value Type[N > 0 ? N : +1]; - template - static Value make(const T &value) { +template +static Value make(const T &value) +{ #ifdef __clang__ Value result = MakeValue(value); // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang: @@ -2384,41 +2802,48 @@ struct ArgArray { #else return MakeValue(value); #endif - } -}; +} + }; template -struct ArgArray { - typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE +struct ArgArray +{ + typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE - template - static Arg make(const T &value) { return MakeArg(value); } + template + static Arg make(const T &value) + { + return MakeArg(value); + } }; #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 @@ -2525,45 +2950,50 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { An error returned by an operating system or a language runtime, for example a file opening error. */ -class SystemError : public internal::RuntimeError { - private: - FMT_API void init(int err_code, CStringRef format_str, ArgList args); +class SystemError : public internal::RuntimeError +{ +private: + FMT_API void init(int err_code, CStringRef format_str, ArgList args); - protected: - int error_code_; +protected: + int error_code_; - typedef char Char; // For FMT_VARIADIC_CTOR. + typedef char Char; // For FMT_VARIADIC_CTOR. - SystemError() {} + SystemError() {} - public: - /** - \rst - Constructs a :class:`fmt::SystemError` object with a description - formatted with `fmt::format_system_error`. *message* and additional - arguments passed into the constructor are formatted similarly to - `fmt::format`. +public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with a description + formatted with `fmt::format_system_error`. *message* and additional + arguments passed into the constructor are formatted similarly to + `fmt::format`. - **Example**:: + **Example**:: - // This throws a SystemError with the description - // cannot open file 'madeup': No such file or directory - // or similar (system message may vary). - const char *filename = "madeup"; - std::FILE *file = std::fopen(filename, "r"); - if (!file) - throw fmt::SystemError(errno, "cannot open file '{}'", filename); - \endrst - */ - SystemError(int error_code, CStringRef message) { - init(error_code, message, ArgList()); - } - FMT_DEFAULTED_COPY_CTOR(SystemError) - FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) + // 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, CStringRef message) + { + init(error_code, message, ArgList()); + } + FMT_DEFAULTED_COPY_CTOR(SystemError) + FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) - FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; + FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE; - int error_code() const { return error_code_; } + int error_code() const + { + return error_code_; + } }; /** @@ -2604,649 +3034,771 @@ FMT_API void format_system_error(fmt::Writer &out, int error_code, \endrst */ template -class BasicWriter { - private: - // Output buffer. - 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 FMT_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); - } - - // Writes an unsigned decimal integer. - template - Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) { - unsigned num_digits = internal::count_digits(value); - Char *ptr = get(grow_buffer(prefix_size + num_digits)); - internal::format_decimal(ptr + prefix_size, value, num_digits); - return ptr; - } - - // Writes a decimal integer. - template - void write_decimal(Int value) { - typedef typename internal::IntTraits::MainType MainType; - MainType abs_value = static_cast(value); - if (internal::is_negative(value)) { - abs_value = 0 - abs_value; - *write_unsigned_decimal(abs_value, 1) = '-'; - } else { - write_unsigned_decimal(abs_value, 0); + // 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::uninitialized_copy(prefix, prefix + prefix_size, p); - return p + size - 1; - } + // Writes an unsigned decimal integer. + template + Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) + { + unsigned num_digits = internal::count_digits(value); + Char *ptr = get(grow_buffer(prefix_size + num_digits)); + internal::format_decimal(ptr + prefix_size, value, num_digits); + return ptr; + } - template - CharPtr prepare_int_buffer(unsigned num_digits, - const Spec &spec, const char *prefix, unsigned prefix_size); + // Writes a decimal integer. + template + void write_decimal(Int value) + { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) + { + abs_value = 0 - abs_value; + *write_unsigned_decimal(abs_value, 1) = '-'; + } + else + { + write_unsigned_decimal(abs_value, 0); + } + } - // Formats an integer. - template - void write_int(T value, Spec spec); + // 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::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } - // Formats a floating-point number (double or long double). - template - void write_double(T value, const Spec &spec); + template + CharPtr prepare_int_buffer(unsigned num_digits, + const Spec &spec, const char *prefix, unsigned prefix_size); - // Writes a formatted string. - template - CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); + // Formats an integer. + template + void write_int(T value, Spec spec); - template - void write_str(const internal::Arg::StringValue &str, - const Spec &spec); + // Formats a floating-point number (double or long double). + template + void write_double(T value, const Spec &spec); - // This following methods are private to disallow writing wide characters - // and strings to a char stream. If you want to print a wide string as a - // pointer as std::ostream does, cast it to const void*. - // Do not implement! - void operator<<(typename internal::WCharHelper::Unsupported); - void operator<<( - typename internal::WCharHelper::Unsupported); + // Writes a formatted string. + template + CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); - // Appends floating-point length specifier to the format string. - // The second argument is only used for overload resolution. - void append_float_length(Char *&format_ptr, long double) { - *format_ptr++ = 'L'; - } + template + void write_str(const internal::Arg::StringValue &str, + const Spec &spec); - template - void append_float_length(Char *&, T) {} + // 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); - template - friend class internal::ArgFormatterBase; + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(Char *&format_ptr, long double) + { + *format_ptr++ = 'L'; + } - template - friend class BasicPrintfArgFormatter; + template + void append_float_length(Char *&, T) {} - protected: - /** - Constructs a ``BasicWriter`` object. - */ - explicit BasicWriter(Buffer &b) : buffer_(b) {} + template + friend class internal::ArgFormatterBase; - public: - /** - \rst - Destroys a ``BasicWriter`` object. - \endrst - */ - virtual ~BasicWriter() {} + template + friend class BasicPrintfArgFormatter; - /** - Returns the total number of characters written. - */ - std::size_t size() const { return buffer_.size(); } +protected: + /** + Constructs a ``BasicWriter`` object. + */ + explicit BasicWriter(Buffer &b) : buffer_(b) {} - /** - Returns a pointer to the output buffer content. No terminating null - character is appended. - */ - const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } +public: + /** + \rst + Destroys a ``BasicWriter`` object. + \endrst + */ + virtual ~BasicWriter() {} - /** - 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]; - } + /** + Returns the total number of characters written. + */ + std::size_t size() const + { + return buffer_.size(); + } - /** - \rst - Returns the content of the output buffer as an `std::string`. - \endrst - */ - std::basic_string str() const { - return std::basic_string(&buffer_[0], buffer_.size()); - } + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const Char *data() const FMT_NOEXCEPT + { + return &buffer_[0]; + } - /** - \rst - Writes formatted data. + /** + 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]; + } - *args* is an argument list representing arbitrary arguments. + /** + \rst + Returns the content of the output buffer as an `std::string`. + \endrst + */ + std::basic_string str() const + { + return std::basic_string(&buffer_[0], buffer_.size()); + } - **Example**:: + /** + \rst + Writes formatted data. - MemoryWriter out; - out.write("Current point:\n"); - out.write("({:+f}, {:+f})", -3.14, 3.14); + *args* is an argument list representing arbitrary arguments. - This will write the following output to the ``out`` object: + **Example**:: - .. code-block:: none + MemoryWriter out; + out.write("Current point:\n"); + out.write("({:+f}, {:+f})", -3.14, 3.14); - Current point: - (-3.140000, +3.140000) + This will write the following output to the ``out`` object: - The output can be accessed using :func:`data()`, :func:`c_str` or - :func:`str` methods. + .. code-block:: none - See also :ref:`syntax`. - \endrst - */ - void write(BasicCStringRef format, ArgList args) { - BasicFormatter(args, *this).format(format); - } - FMT_VARIADIC_VOID(write, BasicCStringRef) + Current point: + (-3.140000, +3.140000) - BasicWriter &operator<<(int value) { - write_decimal(value); - return *this; - } - BasicWriter &operator<<(unsigned value) { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(long value) { - write_decimal(value); - return *this; - } - BasicWriter &operator<<(unsigned long value) { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(LongLong value) { - write_decimal(value); - return *this; - } + The output can be accessed using :func:`data()`, :func:`c_str` or + :func:`str` methods. - /** - \rst - Formats *value* and writes it to the stream. - \endrst - */ - BasicWriter &operator<<(ULongLong value) { - return *this << IntFormatSpec(value); - } + See also :ref:`syntax`. + \endrst + */ + void write(BasicCStringRef format, ArgList args) + { + BasicFormatter(args, *this).format(format); + } + FMT_VARIADIC_VOID(write, BasicCStringRef) - BasicWriter &operator<<(double value) { - write_double(value, FormatSpec()); - return *this; - } + BasicWriter &operator<<(int value) + { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned value) + { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) + { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned long value) + { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) + { + write_decimal(value); + return *this; + } - /** - \rst - Formats *value* using the general format for floating-point numbers - (``'g'``) and writes it to the stream. - \endrst - */ - BasicWriter &operator<<(long double value) { - write_double(value, FormatSpec()); - return *this; - } + /** + \rst + Formats *value* and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(ULongLong value) + { + return *this << IntFormatSpec(value); + } - /** - Writes a character to the stream. - */ - BasicWriter &operator<<(char value) { - buffer_.push_back(value); - return *this; - } + BasicWriter &operator<<(double value) + { + write_double(value, FormatSpec()); + return *this; + } - BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) { - buffer_.push_back(value); - return *this; - } + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(long double value) + { + write_double(value, FormatSpec()); + return *this; + } - /** - \rst - Writes *value* to the stream. - \endrst - */ - BasicWriter &operator<<(fmt::BasicStringRef value) { - const Char *str = value.data(); - buffer_.append(str, str + value.size()); - return *this; - } + /** + Writes a character to the stream. + */ + BasicWriter &operator<<(char value) + { + buffer_.push_back(value); + return *this; + } - BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) { - const char *str = value.data(); - buffer_.append(str, str + value.size()); - return *this; - } + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) + { + buffer_.push_back(value); + return *this; + } - template - BasicWriter &operator<<(IntFormatSpec spec) { - internal::CharTraits::convert(FillChar()); - write_int(spec.value(), spec); - return *this; - } + /** + \rst + Writes *value* to the stream. + \endrst + */ + BasicWriter &operator<<(fmt::BasicStringRef value) + { + const Char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } - template - BasicWriter &operator<<(const StrFormatSpec &spec) { - const StrChar *s = spec.str(); - write_str(s, std::char_traits::length(s), spec); - return *this; - } + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) + { + const char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } - void clear() FMT_NOEXCEPT { buffer_.clear(); } + template + BasicWriter &operator<<(IntFormatSpec spec) + { + internal::CharTraits::convert(FillChar()); + write_int(spec.value(), spec); + return *this; + } - Buffer &buffer() FMT_NOEXCEPT { return buffer_; } + template + BasicWriter &operator<<(const StrFormatSpec &spec) + { + const StrChar *s = spec.str(); + write_str(s, std::char_traits::length(s), spec); + return *this; + } + + void clear() FMT_NOEXCEPT { buffer_.clear(); } + + Buffer &buffer() FMT_NOEXCEPT { return buffer_; } }; 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 = internal::CharTraits::cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) { - std::uninitialized_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::uninitialized_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 = internal::CharTraits::cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) + { + std::uninitialized_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::uninitialized_fill_n(out + size, spec.width() - size, fill); + } } - } else { - out = grow_buffer(size); - } - std::uninitialized_copy(s, s + size, out); - return out; + else + { + out = grow_buffer(size); + } + std::uninitialized_copy(s, s + size, out); + return out; } template template void BasicWriter::write_str( - const internal::Arg::StringValue &s, const Spec &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")); + const internal::Arg::StringValue &s, const Spec &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")); + } } - } - std::size_t precision = static_cast(spec.precision_); - if (spec.precision_ >= 0 && precision < str_size) - str_size = precision; - write_str(str_value, str_size, spec); + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < str_size) + str_size = precision; + write_str(str_value, str_size, spec); } 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 = internal::CharTraits::cast(fill); - std::uninitialized_fill_n(buffer, left_padding, fill_char); - buffer += left_padding; - CharPtr content = buffer; - std::uninitialized_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 = internal::CharTraits::cast(fill); + std::uninitialized_fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::uninitialized_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 = internal::CharTraits::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 + internal::to_unsigned(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::uninitialized_fill(p, p + fill_size, fill); + const char *prefix, unsigned prefix_size) +{ + unsigned width = spec.width(); + Alignment align = spec.align(); + Char fill = internal::CharTraits::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 + internal::to_unsigned(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::uninitialized_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::uninitialized_fill(p, p + fill_size, fill); + } + return result; } - CharPtr result = prepare_int_buffer( - num_digits, subspec, prefix, prefix_size); - if (align == ALIGN_LEFT) { - CharPtr p = grow_buffer(fill_size); - std::uninitialized_fill(p, p + fill_size, fill); + unsigned size = prefix_size + num_digits; + if (width <= size) + { + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; } - return result; - } - unsigned size = prefix_size + num_digits; - if (width <= size) { - CharPtr p = grow_buffer(size); - std::uninitialized_copy(prefix, prefix + prefix_size, p); - return p + size - 1; - } - CharPtr p = grow_buffer(width); - CharPtr end = p + width; - if (align == ALIGN_LEFT) { - std::uninitialized_copy(prefix, prefix + prefix_size, p); - p += size; - std::uninitialized_fill(p, end, fill); - } else if (align == ALIGN_CENTER) { - p = fill_padding(p, width, size, fill); - std::uninitialized_copy(prefix, prefix + prefix_size, p); - p += size; - } else { - if (align == ALIGN_NUMERIC) { - if (prefix_size != 0) { - p = std::uninitialized_copy(prefix, prefix + prefix_size, p); - size -= prefix_size; - } - } else { - std::uninitialized_copy(prefix, prefix + prefix_size, end - size); + CharPtr p = grow_buffer(width); + CharPtr end = p + width; + if (align == ALIGN_LEFT) + { + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + std::uninitialized_fill(p, end, fill); } - std::uninitialized_fill(p, end - size, fill); - p = end; - } - return p - 1; + else if (align == ALIGN_CENTER) + { + p = fill_padding(p, width, size, fill); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + } + else + { + if (align == ALIGN_NUMERIC) + { + if (prefix_size != 0) + { + p = std::uninitialized_copy(prefix, prefix + prefix_size, p); + size -= prefix_size; + } + } + else + { + std::uninitialized_copy(prefix, prefix + prefix_size, end - size); + } + std::uninitialized_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 = static_cast(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; - internal::format_decimal(get(p), abs_value, 0); - break; - } - case 'x': case 'X': { - UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = spec.type_prefix(); +void BasicWriter::write_int(T value, Spec spec) +{ + unsigned prefix_size = 0; + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType abs_value = static_cast(value); + char prefix[4] = ""; + if (internal::is_negative(value)) + { + prefix[0] = '-'; + ++prefix_size; + abs_value = 0 - abs_value; } - 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_prefix(); + else if (spec.flag(SIGN_FLAG)) + { + prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; + ++prefix_size; } - 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-- = static_cast('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-- = static_cast('0' + (n & 7)); - } while ((n >>= 3) != 0); - break; - } - case 'n': { - unsigned num_digits = internal::count_digits(abs_value); - fmt::StringRef sep = ""; + 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; + internal::format_decimal(get(p), abs_value, 0); + break; + } + case 'x': + case 'X': + { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) + { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); + } + 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_prefix(); + } + 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-- = static_cast('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-- = static_cast('0' + (n & 7)); + } + while ((n >>= 3) != 0); + break; + } + case 'n': + { + unsigned num_digits = internal::count_digits(abs_value); + fmt::StringRef sep = ""; #if !(defined(ANDROID) || defined(__ANDROID__)) - sep = internal::thousands_sep(std::localeconv()); + sep = internal::thousands_sep(std::localeconv()); #endif - unsigned size = static_cast( - num_digits + sep.size() * ((num_digits - 1) / 3)); - CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; - internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); - break; - } - default: - internal::report_unknown_type( - spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); - break; - } + unsigned size = static_cast( + num_digits + sep.size() * ((num_digits - 1) / 3)); + CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); + break; + } + default: + internal::report_unknown_type( + spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); + break; + } } template template -void BasicWriter::write_double(T value, const Spec &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': +void BasicWriter::write_double(T value, const Spec &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': #if FMT_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; - } - - char sign = 0; - // Use isnegative instead of value < 0 because the latter is always - // false for NaN. - if (internal::FPUtil::isnegative(static_cast(value))) { - sign = '-'; - value = -value; - } else if (spec.flag(SIGN_FLAG)) { - sign = spec.flag(PLUS_FLAG) ? '+' : ' '; - } - - if (internal::FPUtil::isnotanumber(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; + case 'E': + case 'G': + case 'A': + upper = true; + break; + default: + internal::report_unknown_type(type, "double"); + break; } - CharPtr out = write_str(nan, nan_size, spec); - if (sign) - *out = sign; - return; - } - if (internal::FPUtil::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; + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::FPUtil::isnegative(static_cast(value))) + { + sign = '-'; + value = -value; } - CharPtr out = write_str(inf, inf_size, spec); + else if (spec.flag(SIGN_FLAG)) + { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } + + if (internal::FPUtil::isnotanumber(value)) + { + // Format NaN ourselves because sprintf's output is not consistent + // across platforms. + std::size_t nan_size = 4; + const char *nan = upper ? " NAN" : " nan"; + if (!sign) + { + --nan_size; + ++nan; + } + CharPtr out = write_str(nan, nan_size, spec); + if (sign) + *out = sign; + return; + } + + if (internal::FPUtil::isinfinity(value)) + { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t inf_size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) + { + --inf_size; + ++inf; + } + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } + + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); if (sign) - *out = sign; - return; - } + { + buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u)); + if (width > 0) + --width; + ++offset; + } - std::size_t offset = buffer_.size(); - unsigned width = spec.width(); - if (sign) { - buffer_.reserve(buffer_.size() + (width > 1u ? 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++ = '*'; + } - // 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'; - append_float_length(format_ptr, value); - *format_ptr++ = type; - *format_ptr = '\0'; - - // Format using snprintf. - Char fill = internal::CharTraits::cast(spec.fill()); - unsigned n = 0; - Char *start = FMT_NULL; - for (;;) { - std::size_t buffer_size = buffer_.capacity() - offset; + // Format using snprintf. + Char fill = internal::CharTraits::cast(spec.fill()); + unsigned n = 0; + Char *start = FMT_NULL; + for (;;) + { + std::size_t buffer_size = buffer_.capacity() - offset; #if FMT_MSC_VER - // MSVC's vsnprintf_s doesn't work with zero size, so reserve - // space for at least one extra character to make the size non-zero. - // Note that the buffer's capacity will increase by more than 1. - if (buffer_size == 0) { - buffer_.reserve(offset + 1); - buffer_size = buffer_.capacity() - offset; - } + // 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 - start = &buffer_[offset]; - int result = internal::CharTraits::format_float( - start, buffer_size, format, width_for_sprintf, spec.precision(), value); - if (result >= 0) { - n = internal::to_unsigned(result); - if (offset + n < buffer_.capacity()) - break; // The buffer is large enough - continue with formatting. - buffer_.reserve(offset + n + 1); - } else { - // If result is negative we ask to increase the capacity by at least 1, - // but as std::vector, the buffer grows exponentially. - buffer_.reserve(buffer_.capacity() + 1); + start = &buffer_[offset]; + int result = internal::CharTraits::format_float( + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (result >= 0) + { + n = internal::to_unsigned(result); + if (offset + n < buffer_.capacity()) + break; // The buffer is large enough - continue with formatting. + buffer_.reserve(offset + n + 1); + } + else + { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer_.reserve(buffer_.capacity() + 1); + } } - } - 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() > n) { - width = spec.width(); - CharPtr p = grow_buffer(width); - std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); - fill_padding(p, spec.width(), n, fill); - return; - } - if (spec.fill() != ' ' || sign) { - while (*start == ' ') - *start++ = fill; if (sign) - *(start - 1) = sign; - } - grow_buffer(n); + { + 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() > n) + { + width = spec.width(); + CharPtr p = grow_buffer(width); + std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); + fill_padding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) + { + while (*start == ' ') + *start++ = fill; + if (sign) + *(start - 1) = sign; + } + grow_buffer(n); } /** @@ -3284,34 +3836,37 @@ void BasicWriter::write_double(T value, const Spec &spec) { \endrst */ template > -class BasicMemoryWriter : public BasicWriter { - private: - internal::MemoryBuffer buffer_; +class BasicMemoryWriter : public BasicWriter +{ +private: + internal::MemoryBuffer buffer_; - public: - explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) - : BasicWriter(buffer_), buffer_(alloc) {} +public: + explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) + : BasicWriter(buffer_), buffer_(alloc) {} #if FMT_USE_RVALUE_REFERENCES - /** - \rst - Constructs a :class:`fmt::BasicMemoryWriter` object moving the content - of the other object to it. - \endrst - */ - 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. - \endrst - */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { - buffer_ = std::move(other.buffer_); - return *this; - } + /** + \rst + Moves the content of the other ``BasicMemoryWriter`` object to this one. + \endrst + */ + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) + { + buffer_ = std::move(other.buffer_); + return *this; + } #endif }; @@ -3339,29 +3894,30 @@ typedef BasicMemoryWriter WMemoryWriter; \endrst */ template -class BasicArrayWriter : public BasicWriter { - private: - internal::FixedBuffer buffer_; +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) {} +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) {} - /** - \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) {} + /** + \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; @@ -3375,43 +3931,45 @@ FMT_API void report_system_error(int error_code, #if FMT_USE_WINDOWS_H /** A Windows error. */ -class WindowsError : public SystemError { - private: - FMT_API void init(int error_code, CStringRef format_str, ArgList args); +class WindowsError : public SystemError +{ +private: + FMT_API void init(int error_code, CStringRef format_str, ArgList args); - public: - /** - \rst - Constructs a :class:`fmt::WindowsError` object with the description - of the form +public: + /** + \rst + Constructs a :class:`fmt::WindowsError` object with the description + of the form - .. parsed-literal:: - **: ** + .. parsed-literal:: + **: ** - where ** is the formatted message and ** is the - system message corresponding to the error code. - *error_code* is a Windows error code as given by ``GetLastError``. - If *error_code* is not a valid error code such as -1, the system message - will look like "error -1". + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". - **Example**:: + **Example**:: - // This throws a WindowsError with the description - // cannot open file 'madeup': The system cannot find the file specified. - // or similar (system message may vary). - const char *filename = "madeup"; - LPOFSTRUCT of = LPOFSTRUCT(); - HFILE file = OpenFile(filename, &of, OF_READ); - if (file == HFILE_ERROR) { - throw fmt::WindowsError(GetLastError(), - "cannot open file '{}'", filename); - } - \endrst - */ - WindowsError(int error_code, CStringRef message) { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) + // 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, CStringRef message) + { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) }; // Reports a Windows error without throwing an exception. @@ -3440,16 +3998,18 @@ FMT_API void print_colored(Color c, CStringRef format, ArgList args); std::string message = format("The answer is {}", 42); \endrst */ -inline std::string format(CStringRef format_str, ArgList args) { - MemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::string format(CStringRef format_str, ArgList args) +{ + MemoryWriter w; + w.write(format_str, args); + return w.str(); } -inline std::wstring format(WCStringRef format_str, ArgList args) { - WMemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::wstring format(WCStringRef format_str, ArgList args) +{ + WMemoryWriter w; + w.write(format_str, args); + return w.str(); } /** @@ -3477,106 +4037,132 @@ FMT_API void print(CStringRef format_str, ArgList 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_; +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 = static_cast((value % 100) * 2); - value /= 100; - *--buffer_end = internal::Data::DIGITS[index + 1]; - *--buffer_end = internal::Data::DIGITS[index]; + // 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 = static_cast((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; } - if (value < 10) { - *--buffer_end = static_cast('0' + value); - 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_ = '-'; } - 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_ = '-'; - } +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 internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1); + } - /** Returns the number of characters written to the output buffer. */ - std::size_t size() const { - return internal::to_unsigned(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_; + } - /** - Returns a pointer to the output buffer content. No terminating null - character is appended. - */ - 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_; + } - /** - 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_; - } - - /** - \rst - Returns the content of the output buffer as an ``std::string``. - \endrst - */ - std::string str() const { return std::string(str_, size()); } + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + 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) { - typedef typename internal::IntTraits::MainType MainType; - MainType abs_value = static_cast(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; +inline void format_decimal(char *&buffer, T value) +{ + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) + { + *buffer++ = '-'; + abs_value = 0 - abs_value; } - 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; + 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; } /** @@ -3590,13 +4176,15 @@ inline void format_decimal(char *&buffer, T value) { \endrst */ template -inline internal::NamedArgWithType arg(StringRef name, const T &arg) { - return internal::NamedArgWithType(name, arg); +inline internal::NamedArgWithType arg(StringRef name, const T &arg) +{ + return internal::NamedArgWithType(name, arg); } template -inline internal::NamedArgWithType arg(WStringRef name, const T &arg) { - return internal::NamedArgWithType(name, arg); +inline internal::NamedArgWithType arg(WStringRef name, const T &arg) +{ + return internal::NamedArgWithType(name, arg); } // The following two functions are deleted intentionally to disable @@ -3739,386 +4327,447 @@ void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) -namespace fmt { +namespace fmt +{ FMT_VARIADIC(std::string, format, CStringRef) FMT_VARIADIC_W(std::wstring, format, WCStringRef) FMT_VARIADIC(void, print, CStringRef) FMT_VARIADIC(void, print, std::FILE *, CStringRef) FMT_VARIADIC(void, print_colored, Color, CStringRef) -namespace internal { +namespace internal +{ template -inline bool is_name_start(Char c) { - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +inline bool is_name_start(Char c) +{ + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; } // 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 -unsigned parse_nonnegative_int(const Char *&s) { - assert('0' <= *s && *s <= '9'); - unsigned value = 0; - // Convert to unsigned to prevent a warning. - unsigned max_int = (std::numeric_limits::max)(); - unsigned big = max_int / 10; - do { - // Check for overflow. - if (value > big) { - value = max_int + 1; - break; +unsigned parse_nonnegative_int(const Char *&s) +{ + assert('0' <= *s && *s <= '9'); + unsigned value = 0; + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + unsigned big = max_int / 10; + do + { + // Check for overflow. + if (value > big) + { + value = max_int + 1; + break; + } + value = value * 10 + (*s - '0'); + ++s; } - value = value * 10 + (*s - '0'); - ++s; - } while ('0' <= *s && *s <= '9'); - // Convert to unsigned to prevent a warning. - if (value > max_int) - FMT_THROW(FormatError("number is too big")); - return value; + while ('0' <= *s && *s <= '9'); + // Convert to unsigned to prevent a warning. + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + return value; } -inline void require_numeric_argument(const Arg &arg, char spec) { - if (arg.type > Arg::LAST_NUMERIC_TYPE) { - std::string message = - fmt::format("format specifier '{}' requires numeric argument", spec); - FMT_THROW(fmt::FormatError(message)); - } +inline void require_numeric_argument(const Arg &arg, char spec) +{ + if (arg.type > Arg::LAST_NUMERIC_TYPE) + { + std::string message = + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); + } } template -void check_sign(const Char *&s, const Arg &arg) { - char sign = static_cast(*s); - require_numeric_argument(arg, sign); - if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { - FMT_THROW(FormatError(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(FormatError(fmt::format( + "format specifier '{}' requires signed argument", sign))); + } + ++s; } } // namespace internal template inline internal::Arg BasicFormatter::get_arg( - BasicStringRef arg_name, const char *&error) { - if (check_no_auto_index(error)) { - map_.init(args()); - const internal::Arg *arg = map_.find(arg_name); - if (arg) - return *arg; - error = "argument not found"; - } - return internal::Arg(); + BasicStringRef arg_name, const char *&error) +{ + if (check_no_auto_index(error)) + { + map_.init(args()); + const internal::Arg *arg = map_.find(arg_name); + if (arg) + return *arg; + error = "argument not found"; + } + return internal::Arg(); } template -inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) { - const char *error = FMT_NULL; - internal::Arg arg = *s < '0' || *s > '9' ? - next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); - if (error) { - FMT_THROW(FormatError( - *s != '}' && *s != ':' ? "invalid format string" : error)); - } - return arg; +inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) +{ + const char *error = FMT_NULL; + internal::Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); + if (error) + { + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); + } + return arg; } template -inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) { - assert(internal::is_name_start(*s)); - const Char *start = s; - Char c; - do { - c = *++s; - } while (internal::is_name_start(c) || ('0' <= c && c <= '9')); - const char *error = FMT_NULL; - internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); - if (error) - FMT_THROW(FormatError(error)); - return arg; +inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) +{ + assert(internal::is_name_start(*s)); + const Char *start = s; + Char c; + do + { + c = *++s; + } + while (internal::is_name_start(c) || ('0' <= c && c <= '9')); + const char *error = FMT_NULL; + internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); + if (error) + FMT_THROW(FormatError(error)); + return arg; } template const Char *BasicFormatter::format( - const Char *&format_str, const internal::Arg &arg) { - using internal::Arg; - const Char *s = format_str; - typename ArgFormatter::SpecType spec; - if (*s == ':') { - if (arg.type == Arg::CUSTOM) { - arg.custom.format(this, arg.custom.value, &s); - return s; - } - ++s; - // Parse fill and alignment. - if (Char c = *s) { - const Char *p = s + 1; - spec.align_ = ALIGN_DEFAULT; - do { - switch (*p) { - case '<': - spec.align_ = ALIGN_LEFT; - break; - case '>': - spec.align_ = ALIGN_RIGHT; - break; - case '=': - spec.align_ = ALIGN_NUMERIC; - break; - case '^': - spec.align_ = ALIGN_CENTER; - break; + const Char *&format_str, const internal::Arg &arg) +{ + using internal::Arg; + const Char *s = format_str; + typename ArgFormatter::SpecType spec; + if (*s == ':') + { + if (arg.type == Arg::CUSTOM) + { + arg.custom.format(this, arg.custom.value, &s); + return s; } - if (spec.align_ != ALIGN_DEFAULT) { - if (p != s) { - if (c == '}') break; - if (c == '{') - FMT_THROW(FormatError("invalid fill character '{'")); - s += 2; - spec.fill_ = c; - } else ++s; - if (spec.align_ == ALIGN_NUMERIC) - require_numeric_argument(arg, '='); - break; - } - } 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 zero flag. - if (*s == '0') { - require_numeric_argument(arg, '0'); - spec.align_ = ALIGN_NUMERIC; - spec.fill_ = '0'; - ++s; - } - - // Parse width. - if ('0' <= *s && *s <= '9') { - spec.width_ = internal::parse_nonnegative_int(s); - } else if (*s == '{') { - ++s; - Arg width_arg = internal::is_name_start(*s) ? - parse_arg_name(s) : parse_arg_index(s); - if (*s++ != '}') - FMT_THROW(FormatError("invalid format string")); - ULongLong value = 0; - switch (width_arg.type) { - case Arg::INT: - if (width_arg.int_value < 0) - FMT_THROW(FormatError("negative width")); - value = width_arg.int_value; - break; - case Arg::UINT: - value = width_arg.uint_value; - break; - case Arg::LONG_LONG: - if (width_arg.long_long_value < 0) - FMT_THROW(FormatError("negative width")); - value = width_arg.long_long_value; - break; - case Arg::ULONG_LONG: - value = width_arg.ulong_long_value; - break; - default: - FMT_THROW(FormatError("width is not integer")); - } - unsigned max_int = (std::numeric_limits::max)(); - if (value > max_int) - FMT_THROW(FormatError("number is too big")); - spec.width_ = static_cast(value); - } - - // Parse precision. - if (*s == '.') { - ++s; - spec.precision_ = 0; - if ('0' <= *s && *s <= '9') { - spec.precision_ = internal::parse_nonnegative_int(s); - } else if (*s == '{') { ++s; - Arg precision_arg = internal::is_name_start(*s) ? - parse_arg_name(s) : 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")); + // 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); } - unsigned max_int = (std::numeric_limits::max)(); - if (value > max_int) - 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 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 zero flag. + if (*s == '0') + { + require_numeric_argument(arg, '0'); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + ++s; + } + + // Parse width. + if ('0' <= *s && *s <= '9') + { + spec.width_ = internal::parse_nonnegative_int(s); + } + else if (*s == '{') + { + ++s; + Arg width_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (width_arg.type) + { + case Arg::INT: + if (width_arg.int_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.int_value; + break; + case Arg::UINT: + value = width_arg.uint_value; + break; + case Arg::LONG_LONG: + if (width_arg.long_long_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = width_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("width is not integer")); + } + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + spec.width_ = static_cast(value); + } + + // Parse precision. + if (*s == '.') + { + ++s; + spec.precision_ = 0; + if ('0' <= *s && *s <= '9') + { + spec.precision_ = internal::parse_nonnegative_int(s); + } + else if (*s == '{') + { + ++s; + Arg precision_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : 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")); + } + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + 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++); } - // Parse type. - if (*s != '}' && *s) - spec.type_ = static_cast(*s++); - } + if (*s++ != '}') + FMT_THROW(FormatError("missing '}' in format string")); - if (*s++ != '}') - FMT_THROW(FormatError("missing '}' in format string")); - - // Format argument. - ArgFormatter(*this, spec, s - 1).visit(arg); - return s; + // Format argument. + ArgFormatter(*this, spec, s - 1).visit(arg); + return s; } template -void BasicFormatter::format(BasicCStringRef format_str) { - const Char *s = format_str.c_str(); - const Char *start = s; - while (*s) { - Char c = *s++; - if (c != '{' && c != '}') continue; - if (*s == c) { - write(writer_, start, s); - start = ++s; - continue; +void BasicFormatter::format(BasicCStringRef format_str) +{ + const Char *s = format_str.c_str(); + const Char *start = s; + 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); + internal::Arg arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + start = s = format(s, arg); } - if (c == '}') - FMT_THROW(FormatError("unmatched '}' in format string")); - write(writer_, start, s - 1); - internal::Arg arg = internal::is_name_start(*s) ? - parse_arg_name(s) : parse_arg_index(s); - start = s = format(s, arg); - } - write(writer_, start, s); + write(writer_, start, s); } template -struct ArgJoin { - It first; - It last; - BasicCStringRef sep; +struct ArgJoin +{ + It first; + It last; + BasicCStringRef sep; - ArgJoin(It first, It last, const BasicCStringRef& sep) : - first(first), - last(last), - sep(sep) {} + ArgJoin(It first, It last, const BasicCStringRef& sep) : + first(first), + last(last), + sep(sep) {} }; template -ArgJoin join(It first, It last, const BasicCStringRef& sep) { - return ArgJoin(first, last, sep); +ArgJoin join(It first, It last, const BasicCStringRef& sep) +{ + return ArgJoin(first, last, sep); } template -ArgJoin join(It first, It last, const BasicCStringRef& sep) { - return ArgJoin(first, last, sep); +ArgJoin join(It first, It last, const BasicCStringRef& sep) +{ + return ArgJoin(first, last, sep); } #if FMT_HAS_GXX_CXX11 template auto join(const Range& range, const BasicCStringRef& sep) - -> ArgJoin { - return join(std::begin(range), std::end(range), sep); +-> ArgJoin +{ + return join(std::begin(range), std::end(range), sep); } template auto join(const Range& range, const BasicCStringRef& sep) - -> ArgJoin { - return join(std::begin(range), std::end(range), sep); +-> ArgJoin +{ + return join(std::begin(range), std::end(range), sep); } #endif template void format_arg(fmt::BasicFormatter &f, - const Char *&format_str, const ArgJoin& e) { - const Char* end = format_str; - if (*end == ':') - ++end; - while (*end && *end != '}') - ++end; - if (*end != '}') - FMT_THROW(FormatError("missing '}' in format string")); + const Char *&format_str, const ArgJoin& e) +{ + const Char* end = format_str; + if (*end == ':') + ++end; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); - It it = e.first; - if (it != e.last) { - const Char* save = format_str; - f.format(format_str, internal::MakeArg >(*it++)); - while (it != e.last) { - f.writer().write(e.sep); - format_str = save; - f.format(format_str, internal::MakeArg >(*it++)); + It it = e.first; + if (it != e.last) + { + const Char* save = format_str; + f.format(format_str, internal::MakeArg >(*it++)); + while (it != e.last) + { + f.writer().write(e.sep); + format_str = save; + f.format(format_str, internal::MakeArg >(*it++)); + } } - } - format_str = end + 1; + format_str = end + 1; } } // namespace fmt #if FMT_USE_USER_DEFINED_LITERALS -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ template -struct UdlFormat { - const Char *str; +struct UdlFormat +{ + const Char *str; - template - auto operator()(Args && ... args) const - -> decltype(format(str, std::forward(args)...)) { - return format(str, std::forward(args)...); - } + template + auto operator()(Args && ... args) const + -> decltype(format(str, std::forward(args)...)) + { + return format(str, std::forward(args)...); + } }; template -struct UdlArg { - const Char *str; +struct UdlArg +{ + const Char *str; - template - NamedArgWithType operator=(T &&value) const { - return {str, std::forward(value)}; - } + template + NamedArgWithType operator=(T &&value) const + { + return {str, std::forward(value)}; + } }; } // namespace internal -inline namespace literals { +inline namespace literals +{ /** \rst @@ -4131,9 +4780,15 @@ inline namespace literals { \endrst */ inline internal::UdlFormat -operator"" _format(const char *s, std::size_t) { return {s}; } +operator"" _format(const char *s, std::size_t) +{ + return {s}; +} inline internal::UdlFormat -operator"" _format(const wchar_t *s, std::size_t) { return {s}; } +operator"" _format(const wchar_t *s, std::size_t) +{ + return {s}; +} /** \rst @@ -4146,9 +4801,15 @@ operator"" _format(const wchar_t *s, std::size_t) { return {s}; } \endrst */ inline internal::UdlArg -operator"" _a(const char *s, std::size_t) { return {s}; } +operator"" _a(const char *s, std::size_t) +{ + return {s}; +} inline internal::UdlArg -operator"" _a(const wchar_t *s, std::size_t) { return {s}; } +operator"" _a(const wchar_t *s, std::size_t) +{ + return {s}; +} } // inline namespace literals } // namespace fmt diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h index 6848aac2..f1b09dfc 100644 --- a/include/spdlog/fmt/bundled/ostream.h +++ b/include/spdlog/fmt/bundled/ostream.h @@ -13,59 +13,67 @@ #include "format.h" #include -namespace fmt { +namespace fmt +{ -namespace internal { +namespace internal +{ template -class FormatBuf : public std::basic_streambuf { - private: - typedef typename std::basic_streambuf::int_type int_type; - typedef typename std::basic_streambuf::traits_type traits_type; +class FormatBuf : public std::basic_streambuf +{ +private: + typedef typename std::basic_streambuf::int_type int_type; + typedef typename std::basic_streambuf::traits_type traits_type; - Buffer &buffer_; + Buffer &buffer_; - public: - FormatBuf(Buffer &buffer) : buffer_(buffer) {} +public: + FormatBuf(Buffer &buffer) : buffer_(buffer) {} - protected: - // The put-area is actually always empty. This makes the implementation - // simpler and has the advantage that the streambuf and the buffer are always - // in sync and sputc never writes into uninitialized memory. The obvious - // disadvantage is that each call to sputc always results in a (virtual) call - // to overflow. There is no disadvantage here for sputn since this always - // results in a call to xsputn. +protected: + // The put-area is actually always empty. This makes the implementation + // simpler and has the advantage that the streambuf and the buffer are always + // in sync and sputc never writes into uninitialized memory. The obvious + // disadvantage is that each call to sputc always results in a (virtual) call + // to overflow. There is no disadvantage here for sputn since this always + // results in a call to xsputn. - int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast(ch)); - return ch; - } + int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE + { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } - std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE { - buffer_.append(s, s + count); - return count; - } + std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE + { + buffer_.append(s, s + count); + return count; + } }; Yes &convert(std::ostream &); -struct DummyStream : std::ostream { - DummyStream(); // Suppress a bogus warning in MSVC. +struct DummyStream : std::ostream +{ + DummyStream(); // Suppress a bogus warning in MSVC. - // Hide all operator<< overloads from std::ostream. - template - typename EnableIf::type operator<<(const T &); + // Hide all operator<< overloads from std::ostream. + template + typename EnableIf::type operator<<(const T &); }; No &operator<<(std::ostream &, int); template -struct ConvertToIntImpl { - // Convert to int only if T doesn't have an overloaded operator<<. - enum { - value = sizeof(convert(get() << get())) == sizeof(No) - }; +struct ConvertToIntImpl +{ + // Convert to int only if T doesn't have an overloaded operator<<. + enum + { + value = sizeof(convert(get() << get())) == sizeof(No) + }; }; // Write the content of w to os. @@ -75,17 +83,18 @@ FMT_API void write(std::ostream &os, Writer &w); // Formats a value. template void format_arg(BasicFormatter &f, - const Char *&format_str, const T &value) { - internal::MemoryBuffer buffer; + const Char *&format_str, const T &value) +{ + internal::MemoryBuffer buffer; - internal::FormatBuf format_buf(buffer); - std::basic_ostream output(&format_buf); - output.exceptions(std::ios_base::failbit | std::ios_base::badbit); - output << value; + internal::FormatBuf format_buf(buffer); + std::basic_ostream output(&format_buf); + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); + output << value; - BasicStringRef str(&buffer[0], buffer.size()); - typedef internal::MakeArg< BasicFormatter > MakeArg; - format_str = f.format(format_str, MakeArg(str)); + BasicStringRef str(&buffer[0], buffer.size()); + typedef internal::MakeArg< BasicFormatter > MakeArg; + format_str = f.format(format_str, MakeArg(str)); } /** diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h index 88512de5..69327250 100644 --- a/include/spdlog/fmt/bundled/posix.h +++ b/include/spdlog/fmt/bundled/posix.h @@ -64,112 +64,134 @@ #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) -namespace fmt { +namespace fmt +{ // An error code. -class ErrorCode { - private: - int value_; +class ErrorCode +{ +private: + int value_; - public: - explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {} +public: +explicit ErrorCode(int value = 0) FMT_NOEXCEPT : + value_(value) {} - int get() const FMT_NOEXCEPT { return value_; } + int get() const FMT_NOEXCEPT + { + return value_; + } }; // A buffered file. -class BufferedFile { - private: - FILE *file_; +class BufferedFile +{ +private: + FILE *file_; - friend class File; + friend class File; - explicit BufferedFile(FILE *f) : file_(f) {} - - public: - // Constructs a BufferedFile object which doesn't represent any file. - BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {} - - // Destroys the object closing the file it represents if any. - FMT_API ~BufferedFile() FMT_NOEXCEPT; - -#if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. - - private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy { - FILE *file; - }; + explicit BufferedFile(FILE *f) : file_(f) {} public: - // A "move constructor" for moving from a temporary. - BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {} + // Constructs a BufferedFile object which doesn't represent any file. +BufferedFile() FMT_NOEXCEPT : + file_(FMT_NULL) {} - // A "move constructor" for moving from an lvalue. - BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) { - f.file_ = FMT_NULL; - } + // Destroys the object closing the file it represents if any. + FMT_API ~BufferedFile() FMT_NOEXCEPT; - // A "move assignment operator" for moving from a temporary. - BufferedFile &operator=(Proxy p) { - close(); - file_ = p.file; - return *this; - } +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. - // A "move assignment operator" for moving from an lvalue. - BufferedFile &operator=(BufferedFile &other) { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + FILE *file; + }; - // Returns a proxy object for moving from a temporary: - // BufferedFile file = BufferedFile(...); - operator Proxy() FMT_NOEXCEPT { - Proxy p = {file_}; - file_ = FMT_NULL; - return p; - } +public: + // A "move constructor" for moving from a temporary. +BufferedFile(Proxy p) FMT_NOEXCEPT : + file_(p.file) {} + + // A "move constructor" for moving from an lvalue. +BufferedFile(BufferedFile &f) FMT_NOEXCEPT : + file_(f.file_) + { + f.file_ = FMT_NULL; + } + + // A "move assignment operator" for moving from a temporary. + BufferedFile &operator=(Proxy p) + { + close(); + file_ = p.file; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + BufferedFile &operator=(BufferedFile &other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // BufferedFile file = BufferedFile(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {file_}; + file_ = FMT_NULL; + return p; + } #else - private: - FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile); +private: + FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile); - public: - BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) { - other.file_ = FMT_NULL; - } +public: +BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : + file_(other.file_) + { + other.file_ = FMT_NULL; + } - BufferedFile& operator=(BufferedFile &&other) { - close(); - file_ = other.file_; - other.file_ = FMT_NULL; - return *this; - } + BufferedFile& operator=(BufferedFile &&other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } #endif - // Opens a file. - FMT_API BufferedFile(CStringRef filename, CStringRef mode); + // Opens a file. + FMT_API BufferedFile(CStringRef filename, CStringRef mode); - // Closes the file. - FMT_API void close(); + // Closes the file. + FMT_API void close(); - // Returns the pointer to a FILE object representing this file. - FILE *get() const FMT_NOEXCEPT { return file_; } + // Returns the pointer to a FILE object representing this file. + FILE *get() const FMT_NOEXCEPT + { + return file_; + } - // We place parentheses around fileno to workaround a bug in some versions - // of MinGW that define fileno as a macro. - FMT_API int (fileno)() const; + // We place parentheses around fileno to workaround a bug in some versions + // of MinGW that define fileno as a macro. + FMT_API int (fileno)() const; - void print(CStringRef format_str, const ArgList &args) { - fmt::print(file_, format_str, args); - } - FMT_VARIADIC(void, print, CStringRef) + void print(CStringRef format_str, const ArgList &args) + { + fmt::print(file_, format_str, args); + } + FMT_VARIADIC(void, print, CStringRef) }; // A file. Closed file is represented by a File object with descriptor -1. @@ -178,125 +200,141 @@ public: // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. -class File { - private: - int fd_; // File descriptor. +class File +{ +private: + int fd_; // File descriptor. - // Constructs a File object with a given descriptor. - explicit File(int fd) : fd_(fd) {} + // Constructs a File object with a given descriptor. + explicit File(int fd) : fd_(fd) {} - public: - // Possible values for the oflag argument to the constructor. - enum { - RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. - WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. - RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. - }; +public: + // Possible values for the oflag argument to the constructor. + enum + { + RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. + WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. + RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. + }; - // Constructs a File object which doesn't represent any file. - File() FMT_NOEXCEPT : fd_(-1) {} + // Constructs a File object which doesn't represent any file. +File() FMT_NOEXCEPT : + fd_(-1) {} - // Opens a file and constructs a File object representing this file. - FMT_API File(CStringRef path, int oflag); + // Opens a file and constructs a File object representing this file. + FMT_API File(CStringRef path, int oflag); #if !FMT_USE_RVALUE_REFERENCES - // Emulate a move constructor and a move assignment operator if rvalue - // references are not supported. + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. - private: - // A proxy object to emulate a move constructor. - // It is private to make it impossible call operator Proxy directly. - struct Proxy { - int fd; - }; +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + int fd; + }; - public: - // A "move constructor" for moving from a temporary. - File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} +public: + // A "move constructor" for moving from a temporary. +File(Proxy p) FMT_NOEXCEPT : + fd_(p.fd) {} - // A "move constructor" for moving from an lvalue. - File(File &other) FMT_NOEXCEPT : fd_(other.fd_) { - other.fd_ = -1; - } + // A "move constructor" for moving from an lvalue. +File(File &other) FMT_NOEXCEPT : + fd_(other.fd_) + { + other.fd_ = -1; + } - // A "move assignment operator" for moving from a temporary. - File &operator=(Proxy p) { - close(); - fd_ = p.fd; - return *this; - } + // A "move assignment operator" for moving from a temporary. + File &operator=(Proxy p) + { + close(); + fd_ = p.fd; + return *this; + } - // A "move assignment operator" for moving from an lvalue. - File &operator=(File &other) { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } + // A "move assignment operator" for moving from an lvalue. + File &operator=(File &other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } - // Returns a proxy object for moving from a temporary: - // File file = File(...); - operator Proxy() FMT_NOEXCEPT { - Proxy p = {fd_}; - fd_ = -1; - return p; - } + // Returns a proxy object for moving from a temporary: + // File file = File(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {fd_}; + fd_ = -1; + return p; + } #else - private: - FMT_DISALLOW_COPY_AND_ASSIGN(File); +private: + FMT_DISALLOW_COPY_AND_ASSIGN(File); - public: - File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) { - other.fd_ = -1; - } +public: +File(File &&other) FMT_NOEXCEPT : + fd_(other.fd_) + { + other.fd_ = -1; + } - File& operator=(File &&other) { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } + File& operator=(File &&other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } #endif - // Destroys the object closing the file it represents if any. - FMT_API ~File() FMT_NOEXCEPT; + // Destroys the object closing the file it represents if any. + FMT_API ~File() FMT_NOEXCEPT; - // Returns the file descriptor. - int descriptor() const FMT_NOEXCEPT { return fd_; } + // Returns the file descriptor. + int descriptor() const FMT_NOEXCEPT + { + return fd_; + } - // Closes the file. - FMT_API void close(); + // Closes the file. + FMT_API void close(); - // Returns the file size. The size has signed type for consistency with - // stat::st_size. - FMT_API LongLong size() const; + // Returns the file size. The size has signed type for consistency with + // stat::st_size. + FMT_API LongLong size() const; - // Attempts to read count bytes from the file into the specified buffer. - FMT_API std::size_t read(void *buffer, std::size_t count); + // Attempts to read count bytes from the file into the specified buffer. + FMT_API std::size_t read(void *buffer, std::size_t count); - // Attempts to write count bytes from the specified buffer to the file. - FMT_API std::size_t write(const void *buffer, std::size_t count); + // Attempts to write count bytes from the specified buffer to the file. + FMT_API std::size_t write(const void *buffer, std::size_t count); - // Duplicates a file descriptor with the dup function and returns - // the duplicate as a file object. - FMT_API static File dup(int fd); + // Duplicates a file descriptor with the dup function and returns + // the duplicate as a file object. + FMT_API static File dup(int fd); - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd); + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd); - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT; + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT; - // Creates a pipe setting up read_end and write_end file objects for reading - // and writing respectively. - FMT_API static void pipe(File &read_end, File &write_end); + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + FMT_API static void pipe(File &read_end, File &write_end); - // Creates a BufferedFile object associated with this file and detaches - // this File object from the file. - FMT_API BufferedFile fdopen(const char *mode); + // Creates a BufferedFile object associated with this file and detaches + // this File object from the file. + FMT_API BufferedFile fdopen(const char *mode); }; // Returns the memory page size. @@ -309,58 +347,77 @@ long getpagesize(); #ifdef FMT_LOCALE // A "C" numeric locale. -class Locale { - private: +class Locale +{ +private: # ifdef _MSC_VER - typedef _locale_t locale_t; + typedef _locale_t locale_t; - enum { LC_NUMERIC_MASK = LC_NUMERIC }; + enum { LC_NUMERIC_MASK = LC_NUMERIC }; - static locale_t newlocale(int category_mask, const char *locale, locale_t) { - return _create_locale(category_mask, locale); - } + static locale_t newlocale(int category_mask, const char *locale, locale_t) + { + return _create_locale(category_mask, locale); + } - static void freelocale(locale_t locale) { - _free_locale(locale); - } + static void freelocale(locale_t locale) + { + _free_locale(locale); + } - static double strtod_l(const char *nptr, char **endptr, _locale_t locale) { - return _strtod_l(nptr, endptr, locale); - } + static double strtod_l(const char *nptr, char **endptr, _locale_t locale) + { + return _strtod_l(nptr, endptr, locale); + } # endif - locale_t locale_; + locale_t locale_; - FMT_DISALLOW_COPY_AND_ASSIGN(Locale); + FMT_DISALLOW_COPY_AND_ASSIGN(Locale); - public: - typedef locale_t Type; +public: + typedef locale_t Type; - Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) { - if (!locale_) - FMT_THROW(fmt::SystemError(errno, "cannot create locale")); - } - ~Locale() { freelocale(locale_); } + Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) + { + if (!locale_) + FMT_THROW(fmt::SystemError(errno, "cannot create locale")); + } + ~Locale() + { + freelocale(locale_); + } - Type get() const { return locale_; } + Type get() const + { + return locale_; + } - // Converts string to floating-point number and advances str past the end - // of the parsed input. - double strtod(const char *&str) const { - char *end = FMT_NULL; - double result = strtod_l(str, &end, locale_); - str = end; - return result; - } + // Converts string to floating-point number and advances str past the end + // of the parsed input. + double strtod(const char *&str) const + { + char *end = FMT_NULL; + double result = strtod_l(str, &end, locale_); + str = end; + return result; + } }; #endif // FMT_LOCALE } // namespace fmt #if !FMT_USE_RVALUE_REFERENCES -namespace std { +namespace std +{ // For compatibility with C++98. -inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; } -inline fmt::File &move(fmt::File &f) { return f; } +inline fmt::BufferedFile &move(fmt::BufferedFile &f) +{ + return f; +} +inline fmt::File &move(fmt::File &f) +{ + return f; +} } #endif diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h index 46205a78..14242143 100644 --- a/include/spdlog/fmt/bundled/printf.h +++ b/include/spdlog/fmt/bundled/printf.h @@ -15,78 +15,118 @@ #include "ostream.h" -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ // 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 = std::numeric_limits::max(); - return value <= max; - } - static bool fits_in_int(bool) { return true; } +struct IntChecker +{ + template + static bool fits_in_int(T value) + { + unsigned max = std::numeric_limits::max(); + return value <= max; + } + static bool fits_in_int(bool) + { + return true; + } }; template <> -struct IntChecker { - template - static bool fits_in_int(T value) { - return value >= std::numeric_limits::min() && - value <= std::numeric_limits::max(); - } - static bool fits_in_int(int) { return true; } +struct IntChecker +{ + template + static bool fits_in_int(T value) + { + return value >= std::numeric_limits::min() && + value <= std::numeric_limits::max(); + } + static bool fits_in_int(int) + { + return true; + } }; -class PrecisionHandler : public ArgVisitor { - public: - void report_unhandled_arg() { - FMT_THROW(FormatError("precision is not integer")); - } +class PrecisionHandler : public ArgVisitor +{ +public: + void report_unhandled_arg() + { + FMT_THROW(FormatError("precision is not integer")); + } - template - int visit_any_int(T value) { - if (!IntChecker::is_signed>::fits_in_int(value)) - FMT_THROW(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(FormatError("number is too big")); + return static_cast(value); + } }; // IsZeroInt::visit(arg) returns true iff arg is a zero integer. -class IsZeroInt : public ArgVisitor { - public: - template - bool visit_any_int(T value) { return value == 0; } +class IsZeroInt : public ArgVisitor +{ +public: + template + bool visit_any_int(T value) + { + return value == 0; + } }; // returns the default type for format specific "%s" -class DefaultType : public ArgVisitor { - public: - char visit_char(int) { return 'c'; } +class DefaultType : public ArgVisitor +{ +public: + char visit_char(int) + { + return 'c'; + } - char visit_bool(bool) { return 's'; } + char visit_bool(bool) + { + return 's'; + } - char visit_pointer(const void *) { return 'p'; } + char visit_pointer(const void *) + { + return 'p'; + } - template - char visit_any_int(T) { return 'd'; } + template + char visit_any_int(T) + { + return 'd'; + } - template - char visit_any_double(T) { return 'g'; } + template + char visit_any_double(T) + { + return 'g'; + } - char visit_unhandled_arg() { return 's'; } + char visit_unhandled_arg() + { + return 's'; + } }; template -struct is_same { - enum { value = 0 }; +struct is_same +{ + enum { value = 0 }; }; template -struct is_same { - enum { value = 1 }; +struct is_same +{ + enum { value = 1 }; }; // An argument visitor that converts an integer argument to T for printf, @@ -94,108 +134,128 @@ struct is_same { // corresponding signed or unsigned type depending on the type specifier: // 'd' and 'i' - signed, other - unsigned) template -class ArgConverter : public ArgVisitor, void> { - private: - internal::Arg &arg_; - wchar_t type_; +class ArgConverter : public ArgVisitor, void> +{ +private: + internal::Arg &arg_; + wchar_t type_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); - public: - ArgConverter(internal::Arg &arg, wchar_t type) - : arg_(arg), type_(type) {} +public: + ArgConverter(internal::Arg &arg, wchar_t type) + : arg_(arg), type_(type) {} - void visit_bool(bool value) { - if (type_ != 's') - visit_any_int(value); - } - - void visit_char(int value) { - if (type_ != 's') - visit_any_int(value); - } - - template - void visit_any_int(U value) { - bool is_signed = type_ == 'd' || type_ == 'i'; - if (type_ == 's') { - is_signed = std::numeric_limits::is_signed; + void visit_bool(bool value) + { + if (type_ != 's') + visit_any_int(value); } - using internal::Arg; - typedef typename internal::Conditional< + void visit_char(int value) + { + if (type_ != 's') + visit_any_int(value); + } + + template + void visit_any_int(U value) + { + bool is_signed = type_ == 'd' || type_ == 'i'; + if (type_ == 's') + { + is_signed = std::numeric_limits::is_signed; + } + + using internal::Arg; + typedef typename internal::Conditional< is_same::value, U, T>::type TargetType; - if (const_check(sizeof(TargetType) <= 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; - typedef typename internal::MakeUnsigned::Type Unsigned; - arg_.uint_value = static_cast(static_cast(value)); - } - } else { - if (is_signed) { - arg_.type = Arg::LONG_LONG; - // glibc's printf doesn't sign extend arguments of smaller types: - // std::printf("%lld", -42); // prints "4294967254" - // but we don't have to do the same because it's a UB. - arg_.long_long_value = static_cast(value); - } else { - arg_.type = Arg::ULONG_LONG; - arg_.ulong_long_value = - static_cast::Type>(value); - } + if (const_check(sizeof(TargetType) <= 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; + typedef typename internal::MakeUnsigned::Type Unsigned; + arg_.uint_value = static_cast(static_cast(value)); + } + } + else + { + if (is_signed) + { + arg_.type = Arg::LONG_LONG; + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + arg_.long_long_value = static_cast(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 ArgVisitor { - private: - internal::Arg &arg_; +class CharConverter : public ArgVisitor +{ +private: + internal::Arg &arg_; - FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); - public: - explicit CharConverter(internal::Arg &arg) : arg_(arg) {} +public: + explicit CharConverter(internal::Arg &arg) : arg_(arg) {} - template - void visit_any_int(T value) { - arg_.type = internal::Arg::CHAR; - arg_.int_value = static_cast(value); - } + template + void visit_any_int(T value) + { + arg_.type = internal::Arg::CHAR; + arg_.int_value = static_cast(value); + } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -class WidthHandler : public ArgVisitor { - private: - FormatSpec &spec_; +class WidthHandler : public ArgVisitor +{ +private: + FormatSpec &spec_; - FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); - public: - explicit WidthHandler(FormatSpec &spec) : spec_(spec) {} +public: + explicit WidthHandler(FormatSpec &spec) : spec_(spec) {} - void report_unhandled_arg() { - FMT_THROW(FormatError("width is not integer")); - } - - template - unsigned visit_any_int(T value) { - typedef typename internal::IntTraits::MainType UnsignedType; - UnsignedType width = static_cast(value); - if (internal::is_negative(value)) { - spec_.align_ = ALIGN_LEFT; - width = 0 - width; + void report_unhandled_arg() + { + FMT_THROW(FormatError("width is not integer")); + } + + template + unsigned visit_any_int(T value) + { + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType width = static_cast(value); + if (internal::is_negative(value)) + { + spec_.align_ = ALIGN_LEFT; + width = 0 - width; + } + unsigned int_max = std::numeric_limits::max(); + if (width > int_max) + FMT_THROW(FormatError("number is too big")); + return static_cast(width); } - unsigned int_max = std::numeric_limits::max(); - if (width > int_max) - FMT_THROW(FormatError("number is too big")); - return static_cast(width); - } }; } // namespace internal @@ -218,314 +278,359 @@ class WidthHandler : public ArgVisitor { */ template class BasicPrintfArgFormatter : - public internal::ArgFormatterBase { - private: - void write_null_pointer() { - this->spec().type_ = 0; - this->write("(nil)"); - } - - typedef internal::ArgFormatterBase Base; - - public: - /** - \rst - Constructs an argument formatter object. - *writer* is a reference to the output writer and *spec* contains format - specifier information for standard argument types. - \endrst - */ - BasicPrintfArgFormatter(BasicWriter &w, Spec &s) - : internal::ArgFormatterBase(w, s) {} - - /** Formats an argument of type ``bool``. */ - void visit_bool(bool value) { - Spec &fmt_spec = this->spec(); - if (fmt_spec.type_ != 's') - return this->visit_any_int(value); - fmt_spec.type_ = 0; - this->write(value); - } - - /** Formats a character. */ - void visit_char(int value) { - const Spec &fmt_spec = this->spec(); - BasicWriter &w = this->writer(); - if (fmt_spec.type_ && fmt_spec.type_ != 'c') - w.write_int(value, fmt_spec); - typedef typename BasicWriter::CharPtr CharPtr; - CharPtr out = CharPtr(); - if (fmt_spec.width_ > 1) { - Char fill = ' '; - out = w.grow_buffer(fmt_spec.width_); - if (fmt_spec.align_ != ALIGN_LEFT) { - std::fill_n(out, fmt_spec.width_ - 1, fill); - out += fmt_spec.width_ - 1; - } else { - std::fill_n(out + 1, fmt_spec.width_ - 1, fill); - } - } else { - out = w.grow_buffer(1); + public internal::ArgFormatterBase +{ +private: + void write_null_pointer() + { + this->spec().type_ = 0; + this->write("(nil)"); } - *out = static_cast(value); - } - /** Formats a null-terminated C string. */ - void visit_cstring(const char *value) { - if (value) - Base::visit_cstring(value); - else if (this->spec().type_ == 'p') - write_null_pointer(); - else - this->write("(null)"); - } + typedef internal::ArgFormatterBase Base; - /** Formats a pointer. */ - void visit_pointer(const void *value) { - if (value) - return Base::visit_pointer(value); - this->spec().type_ = 0; - write_null_pointer(); - } +public: + /** + \rst + Constructs an argument formatter object. + *writer* is a reference to the output writer and *spec* contains format + specifier information for standard argument types. + \endrst + */ + BasicPrintfArgFormatter(BasicWriter &w, Spec &s) + : internal::ArgFormatterBase(w, s) {} - /** Formats an argument of a custom (user-defined) type. */ - void visit_custom(internal::Arg::CustomValue c) { - BasicFormatter formatter(ArgList(), this->writer()); - const Char format_str[] = {'}', 0}; - const Char *format = format_str; - c.format(&formatter, c.value, &format); - } + /** Formats an argument of type ``bool``. */ + void visit_bool(bool value) + { + Spec &fmt_spec = this->spec(); + if (fmt_spec.type_ != 's') + return this->visit_any_int(value); + fmt_spec.type_ = 0; + this->write(value); + } + + /** Formats a character. */ + void visit_char(int value) + { + const Spec &fmt_spec = this->spec(); + BasicWriter &w = this->writer(); + if (fmt_spec.type_ && fmt_spec.type_ != 'c') + w.write_int(value, fmt_spec); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (fmt_spec.width_ > 1) + { + Char fill = ' '; + out = w.grow_buffer(fmt_spec.width_); + if (fmt_spec.align_ != ALIGN_LEFT) + { + std::fill_n(out, fmt_spec.width_ - 1, fill); + out += fmt_spec.width_ - 1; + } + else + { + std::fill_n(out + 1, fmt_spec.width_ - 1, fill); + } + } + else + { + out = w.grow_buffer(1); + } + *out = static_cast(value); + } + + /** Formats a null-terminated C string. */ + void visit_cstring(const char *value) + { + if (value) + Base::visit_cstring(value); + else if (this->spec().type_ == 'p') + write_null_pointer(); + else + this->write("(null)"); + } + + /** Formats a pointer. */ + void visit_pointer(const void *value) + { + if (value) + return Base::visit_pointer(value); + this->spec().type_ = 0; + write_null_pointer(); + } + + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) + { + BasicFormatter formatter(ArgList(), this->writer()); + const Char format_str[] = {'}', 0}; + const Char *format = format_str; + c.format(&formatter, c.value, &format); + } }; /** The default printf argument formatter. */ template class PrintfArgFormatter : - public BasicPrintfArgFormatter, Char, FormatSpec> { - public: - /** Constructs an argument formatter object. */ - PrintfArgFormatter(BasicWriter &w, FormatSpec &s) - : BasicPrintfArgFormatter, Char, FormatSpec>(w, s) {} + public BasicPrintfArgFormatter, Char, FormatSpec> +{ +public: + /** Constructs an argument formatter object. */ + PrintfArgFormatter(BasicWriter &w, FormatSpec &s) + : BasicPrintfArgFormatter, Char, FormatSpec>(w, s) {} }; /** This template formats data and writes the output to a writer. */ template > -class PrintfFormatter : private internal::FormatterBase { - private: - BasicWriter &writer_; +class PrintfFormatter : private internal::FormatterBase +{ +private: + BasicWriter &writer_; - void parse_flags(FormatSpec &spec, const Char *&s); + 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. - internal::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. + internal::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: - /** - \rst - Constructs a ``PrintfFormatter`` object. References to the arguments and - the writer are stored in the formatter object so make sure they have - appropriate lifetimes. - \endrst - */ - explicit PrintfFormatter(const ArgList &al, BasicWriter &w) - : FormatterBase(al), writer_(w) {} +public: + /** + \rst + Constructs a ``PrintfFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + explicit PrintfFormatter(const ArgList &al, BasicWriter &w) + : FormatterBase(al), writer_(w) {} - /** Formats stored arguments and writes the output to the writer. */ - void format(BasicCStringRef format_str); + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); }; template -void 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; +void 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; + } } - } } template internal::Arg PrintfFormatter::get_arg(const Char *s, - unsigned arg_index) { - (void)s; - const char *error = FMT_NULL; - internal::Arg arg = arg_index == std::numeric_limits::max() ? - next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); - if (error) - FMT_THROW(FormatError(!*s ? "invalid format string" : error)); - return arg; + unsigned arg_index) +{ + (void)s; + const char *error = FMT_NULL; + internal::Arg arg = arg_index == std::numeric_limits::max() ? + next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); + if (error) + FMT_THROW(FormatError(!*s ? "invalid format string" : error)); + return arg; } template unsigned PrintfFormatter::parse_header( - const Char *&s, FormatSpec &spec) { - unsigned arg_index = std::numeric_limits::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 = internal::parse_nonnegative_int(s); - if (*s == '$') { // value is an argument index - ++s; - arg_index = value; - } else { - if (c == '0') - spec.fill_ = '0'; - if (value != 0) { - // Nonzero value means that we parsed width and don't need to - // parse it or flags again, so return now. - spec.width_ = value; - return arg_index; - } + const Char *&s, FormatSpec &spec) +{ + unsigned arg_index = std::numeric_limits::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 = internal::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_ = internal::parse_nonnegative_int(s); - } else if (*s == '*') { - ++s; - spec.width_ = internal::WidthHandler(spec).visit(get_arg(s)); - } - return arg_index; + parse_flags(spec, s); + // Parse width. + if (*s >= '0' && *s <= '9') + { + spec.width_ = internal::parse_nonnegative_int(s); + } + else if (*s == '*') + { + ++s; + spec.width_ = internal::WidthHandler(spec).visit(get_arg(s)); + } + return arg_index; } template -void PrintfFormatter::format(BasicCStringRef format_str) { - const Char *start = format_str.c_str(); - const Char *s = start; - while (*s) { - Char c = *s++; - if (c != '%') continue; - if (*s == c) { - write(writer_, start, s); - start = ++s; - continue; +void PrintfFormatter::format(BasicCStringRef format_str) +{ + const Char *start = format_str.c_str(); + 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_ = static_cast(internal::parse_nonnegative_int(s)); + } + else if (*s == '*') + { + ++s; + spec.precision_ = internal::PrecisionHandler().visit(get_arg(s)); + } + else + { + spec.precision_ = 0; + } + } + + using internal::Arg; + Arg arg = get_arg(s, arg_index); + if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg)) + spec.flags_ &= ~internal::to_unsigned(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. + using internal::ArgConverter; + 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 (spec.type_ == 's') + { + // set the format type to the default if 's' is specified + spec.type_ = internal::DefaultType().visit(arg); + } + + 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 + internal::CharConverter(arg).visit(arg); + break; + } + } + + start = s; + + // Format argument. + AF(writer_, spec).visit(arg); } - 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_ = static_cast(internal::parse_nonnegative_int(s)); - } else if (*s == '*') { - ++s; - spec.precision_ = internal::PrecisionHandler().visit(get_arg(s)); - } else { - spec.precision_ = 0; - } - } - - using internal::Arg; - Arg arg = get_arg(s, arg_index); - if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg)) - spec.flags_ &= ~internal::to_unsigned(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. - using internal::ArgConverter; - 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 (spec.type_ == 's') { - // set the format type to the default if 's' is specified - spec.type_ = internal::DefaultType().visit(arg); - } - - 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 - internal::CharConverter(arg).visit(arg); - break; - } - } - - start = s; - - // Format argument. - AF(writer_, spec).visit(arg); - } - write(writer_, start, s); + write(writer_, start, s); } -inline void printf(Writer &w, CStringRef format, ArgList args) { - PrintfFormatter(args, w).format(format); +inline void printf(Writer &w, CStringRef format, ArgList args) +{ + PrintfFormatter(args, w).format(format); } FMT_VARIADIC(void, printf, Writer &, CStringRef) -inline void printf(WWriter &w, WCStringRef format, ArgList args) { - PrintfFormatter(args, w).format(format); +inline void printf(WWriter &w, WCStringRef format, ArgList args) +{ + PrintfFormatter(args, w).format(format); } FMT_VARIADIC(void, printf, WWriter &, WCStringRef) @@ -538,17 +643,19 @@ FMT_VARIADIC(void, printf, WWriter &, WCStringRef) std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ -inline std::string sprintf(CStringRef format, ArgList args) { - MemoryWriter w; - printf(w, format, args); - return w.str(); +inline std::string sprintf(CStringRef format, ArgList args) +{ + MemoryWriter w; + printf(w, format, args); + return w.str(); } FMT_VARIADIC(std::string, sprintf, CStringRef) -inline std::wstring sprintf(WCStringRef format, ArgList args) { - WMemoryWriter w; - printf(w, format, args); - return w.str(); +inline std::wstring sprintf(WCStringRef format, ArgList args) +{ + WMemoryWriter w; + printf(w, format, args); + return w.str(); } FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef) @@ -573,8 +680,9 @@ FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef) fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ -inline int printf(CStringRef format, ArgList args) { - return fprintf(stdout, format, args); +inline int printf(CStringRef format, ArgList args) +{ + return fprintf(stdout, format, args); } FMT_VARIADIC(int, printf, CStringRef) @@ -587,11 +695,12 @@ FMT_VARIADIC(int, printf, CStringRef) fprintf(cerr, "Don't %s!", "panic"); \endrst */ -inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) { - MemoryWriter w; - printf(w, format_str, args); - internal::write(os, w); - return static_cast(w.size()); +inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) +{ + MemoryWriter w; + printf(w, format_str, args); + internal::write(os, w); + return static_cast(w.size()); } FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef) } // namespace fmt diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h index c98b0e01..206d0920 100644 --- a/include/spdlog/fmt/bundled/time.h +++ b/include/spdlog/fmt/bundled/time.h @@ -19,120 +19,160 @@ # pragma warning(disable: 4996) // "deprecated" functions #endif -namespace fmt { +namespace fmt +{ template void format_arg(BasicFormatter &f, - const char *&format_str, const std::tm &tm) { - if (*format_str == ':') - ++format_str; - const char *end = format_str; - while (*end && *end != '}') - ++end; - if (*end != '}') - FMT_THROW(FormatError("missing '}' in format string")); - internal::MemoryBuffer format; - format.append(format_str, end + 1); - format[format.size() - 1] = '\0'; - Buffer &buffer = f.writer().buffer(); - std::size_t start = buffer.size(); - for (;;) { - std::size_t size = buffer.capacity() - start; - std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm); - if (count != 0) { - buffer.resize(start + count); - break; + const char *&format_str, const std::tm &tm) +{ + if (*format_str == ':') + ++format_str; + const char *end = format_str; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); + internal::MemoryBuffer format; + format.append(format_str, end + 1); + format[format.size() - 1] = '\0'; + Buffer &buffer = f.writer().buffer(); + std::size_t start = buffer.size(); + for (;;) + { + std::size_t size = buffer.capacity() - start; + std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm); + if (count != 0) + { + buffer.resize(start + count); + break; + } + if (size >= format.size() * 256) + { + // If the buffer is 256 times larger than the format string, assume + // that `strftime` gives an empty result. There doesn't seem to be a + // better way to distinguish the two cases: + // https://github.com/fmtlib/fmt/issues/367 + break; + } + const std::size_t MIN_GROWTH = 10; + buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); } - if (size >= format.size() * 256) { - // If the buffer is 256 times larger than the format string, assume - // that `strftime` gives an empty result. There doesn't seem to be a - // better way to distinguish the two cases: - // https://github.com/fmtlib/fmt/issues/367 - break; - } - const std::size_t MIN_GROWTH = 10; - buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); - } - format_str = end + 1; + format_str = end + 1; } -namespace internal{ -inline Null<> localtime_r(...) { return Null<>(); } -inline Null<> localtime_s(...) { return Null<>(); } -inline Null<> gmtime_r(...) { return Null<>(); } -inline Null<> gmtime_s(...) { return Null<>(); } +namespace internal +{ +inline Null<> localtime_r(...) +{ + return Null<>(); +} +inline Null<> localtime_s(...) +{ + return Null<>(); +} +inline Null<> gmtime_r(...) +{ + return Null<>(); +} +inline Null<> gmtime_s(...) +{ + return Null<>(); +} } // Thread-safe replacement for std::localtime -inline std::tm localtime(std::time_t time) { - struct LocalTime { - std::time_t time_; - std::tm tm_; +inline std::tm localtime(std::time_t time) +{ + struct LocalTime + { + std::time_t time_; + std::tm tm_; - LocalTime(std::time_t t): time_(t) {} + LocalTime(std::time_t t): time_(t) {} - bool run() { - using namespace fmt::internal; - return handle(localtime_r(&time_, &tm_)); - } + bool run() + { + using namespace fmt::internal; + return handle(localtime_r(&time_, &tm_)); + } - bool handle(std::tm *tm) { return tm != FMT_NULL; } + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } - bool handle(internal::Null<>) { - using namespace fmt::internal; - return fallback(localtime_s(&tm_, &time_)); - } + bool handle(internal::Null<>) + { + using namespace fmt::internal; + return fallback(localtime_s(&tm_, &time_)); + } - bool fallback(int res) { return res == 0; } + bool fallback(int res) + { + return res == 0; + } - bool fallback(internal::Null<>) { - using namespace fmt::internal; - std::tm *tm = std::localtime(&time_); - if (tm) tm_ = *tm; - return tm != FMT_NULL; - } - }; - LocalTime lt(time); - if (lt.run()) - return lt.tm_; - // Too big time values may be unsupported. - FMT_THROW(fmt::FormatError("time_t value out of range")); - return std::tm(); + bool fallback(internal::Null<>) + { + using namespace fmt::internal; + std::tm *tm = std::localtime(&time_); + if (tm) tm_ = *tm; + return tm != FMT_NULL; + } + }; + LocalTime lt(time); + if (lt.run()) + return lt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); } // Thread-safe replacement for std::gmtime -inline std::tm gmtime(std::time_t time) { - struct GMTime { - std::time_t time_; - std::tm tm_; +inline std::tm gmtime(std::time_t time) +{ + struct GMTime + { + std::time_t time_; + std::tm tm_; - GMTime(std::time_t t): time_(t) {} + GMTime(std::time_t t): time_(t) {} - bool run() { - using namespace fmt::internal; - return handle(gmtime_r(&time_, &tm_)); - } + bool run() + { + using namespace fmt::internal; + return handle(gmtime_r(&time_, &tm_)); + } - bool handle(std::tm *tm) { return tm != FMT_NULL; } + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } - bool handle(internal::Null<>) { - using namespace fmt::internal; - return fallback(gmtime_s(&tm_, &time_)); - } + bool handle(internal::Null<>) + { + using namespace fmt::internal; + return fallback(gmtime_s(&tm_, &time_)); + } - bool fallback(int res) { return res == 0; } + bool fallback(int res) + { + return res == 0; + } - bool fallback(internal::Null<>) { - std::tm *tm = std::gmtime(&time_); - if (tm != FMT_NULL) tm_ = *tm; - return tm != FMT_NULL; - } - }; - GMTime gt(time); - if (gt.run()) - return gt.tm_; - // Too big time values may be unsupported. - FMT_THROW(fmt::FormatError("time_t value out of range")); - return std::tm(); + bool fallback(internal::Null<>) + { + std::tm *tm = std::gmtime(&time_); + if (tm != FMT_NULL) tm_ = *tm; + return tm != FMT_NULL; + } + }; + GMTime gt(time); + if (gt.run()) + return gt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); } } //namespace fmt diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp index 38fad954..e80fd37d 100644 --- a/tests/test_pattern_formatter.cpp +++ b/tests/test_pattern_formatter.cpp @@ -3,63 +3,63 @@ // log to str and return it static std::string log_to_str(const std::string& msg, std::shared_ptr formatter = nullptr) { - std::ostringstream oss; - auto oss_sink = std::make_shared(oss); - spdlog::logger oss_logger("pattern_tester", oss_sink); - oss_logger.set_level(spdlog::level::info); - if (formatter) oss_logger.set_formatter(formatter); - oss_logger.info(msg); - return oss.str(); + std::ostringstream oss; + auto oss_sink = std::make_shared(oss); + spdlog::logger oss_logger("pattern_tester", oss_sink); + oss_logger.set_level(spdlog::level::info); + if (formatter) oss_logger.set_formatter(formatter); + oss_logger.info(msg); + return oss.str(); } TEST_CASE("custom eol", "[pattern_formatter]") { - std::string msg = "Hello custom eol test"; - std::string eol = ";)"; - auto formatter = std::make_shared("%v", spdlog::pattern_time_type::local, ";)"); + std::string msg = "Hello custom eol test"; + std::string eol = ";)"; + auto formatter = std::make_shared("%v", spdlog::pattern_time_type::local, ";)"); - REQUIRE(log_to_str(msg, formatter) == msg + eol); + REQUIRE(log_to_str(msg, formatter) == msg + eol); } TEST_CASE("empty format", "[pattern_formatter]") { - auto formatter = std::make_shared("", spdlog::pattern_time_type::local, ""); - REQUIRE(log_to_str("Some message", formatter) == ""); + auto formatter = std::make_shared("", spdlog::pattern_time_type::local, ""); + REQUIRE(log_to_str("Some message", formatter) == ""); } TEST_CASE("empty format2", "[pattern_formatter]") { - auto formatter = std::make_shared("", spdlog::pattern_time_type::local, "\n"); - REQUIRE(log_to_str("Some message", formatter) == "\n"); + auto formatter = std::make_shared("", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "\n"); } TEST_CASE("level", "[pattern_formatter]") { - auto formatter = std::make_shared("[%l] %v", spdlog::pattern_time_type::local, "\n"); - REQUIRE(log_to_str("Some message", formatter) == "[info] Some message\n"); + auto formatter = std::make_shared("[%l] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[info] Some message\n"); } TEST_CASE("short level", "[pattern_formatter]") { - auto formatter = std::make_shared("[%L] %v", spdlog::pattern_time_type::local, "\n"); - REQUIRE(log_to_str("Some message", formatter) == "[I] Some message\n"); + auto formatter = std::make_shared("[%L] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[I] Some message\n"); } TEST_CASE("name", "[pattern_formatter]") { - auto formatter = std::make_shared("[%n] %v", spdlog::pattern_time_type::local, "\n"); - REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n"); + auto formatter = std::make_shared("[%n] %v", spdlog::pattern_time_type::local, "\n"); + REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n"); } TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") { - using namespace::std::chrono; - auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); - auto now_tm = spdlog::details::os::localtime(); - std::stringstream oss; - oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; - REQUIRE(log_to_str("Some message", formatter) == oss.str()); + using namespace::std::chrono; + auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); + auto now_tm = spdlog::details::os::localtime(); + std::stringstream oss; + oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; + REQUIRE(log_to_str("Some message", formatter) == oss.str()); } From 7f4c1bb77c24676419d5b042f79af801c52a8bcd Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sat, 24 Feb 2018 22:35:09 +0100 Subject: [PATCH 21/39] modernize-use-using --- include/spdlog/common.h | 4 ++-- include/spdlog/details/mpmc_bounded_q.h | 2 +- include/spdlog/details/registry.h | 6 ++++-- include/spdlog/sinks/ansicolor_sink.h | 10 +++++----- include/spdlog/sinks/dist_sink.h | 5 +++-- include/spdlog/sinks/file_sinks.h | 13 +++++++------ include/spdlog/sinks/msvc_sink.h | 4 ++-- include/spdlog/sinks/null_sink.h | 5 +++-- include/spdlog/sinks/ostream_sink.h | 5 +++-- include/spdlog/sinks/stdout_sinks.h | 10 +++++----- include/spdlog/sinks/wincolor_sink.h | 10 +++++----- include/spdlog/sinks/windebug_sink.h | 4 ++-- 12 files changed, 42 insertions(+), 36 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 6c7ab149..97e58247 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -75,7 +75,7 @@ using log_err_handler = std::function; //Log level enum namespace level { -typedef enum +enum level_enum { trace = 0, debug = 1, @@ -84,7 +84,7 @@ typedef enum err = 4, critical = 5, off = 6 -} level_enum; +}; #if !defined(SPDLOG_LEVEL_NAMES) #define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" } diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h index 102df855..887f530f 100644 --- a/include/spdlog/details/mpmc_bounded_q.h +++ b/include/spdlog/details/mpmc_bounded_q.h @@ -157,7 +157,7 @@ private: size_t const max_size_; static size_t const cacheline_size = 64; - typedef char cacheline_pad_t[cacheline_size]; + using cacheline_pad_t = char[cacheline_size]; cacheline_pad_t pad0_; cell_t* const buffer_; diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index b68b9f5a..28d8d2fa 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -216,10 +216,12 @@ private: std::chrono::milliseconds _flush_interval_ms; std::function _worker_teardown_cb = nullptr; }; + #ifdef SPDLOG_NO_REGISTRY_MUTEX -typedef registry_t registry; +using registry = registry_t; #else -typedef registry_t registry; +using registry = registry_t; #endif + } } diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index bd0e3222..2063b079 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -116,6 +116,9 @@ public: {} }; +using ansicolor_stdout_sink_mt = ansicolor_stdout_sink; +using ansicolor_stdout_sink_st = ansicolor_stdout_sink; + template class ansicolor_stderr_sink: public ansicolor_sink { @@ -124,11 +127,8 @@ public: {} }; -typedef ansicolor_stdout_sink ansicolor_stdout_sink_mt; -typedef ansicolor_stdout_sink ansicolor_stdout_sink_st; - -typedef ansicolor_stderr_sink ansicolor_stderr_sink_mt; -typedef ansicolor_stderr_sink ansicolor_stderr_sink_st; +using ansicolor_stderr_sink_mt = ansicolor_stderr_sink; +using ansicolor_stderr_sink_st = ansicolor_stderr_sink; } // namespace sinks } // namespace spdlog diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 537efe1d..604c5a7d 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/include/spdlog/sinks/dist_sink.h @@ -66,7 +66,8 @@ public: } }; -typedef dist_sink dist_sink_mt; -typedef dist_sink dist_sink_st; +using dist_sink_mt = dist_sink; +using dist_sink_st = dist_sink; + } } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index e13c81a6..baef4a46 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -55,8 +55,8 @@ private: bool _force_flush; }; -typedef simple_file_sink simple_file_sink_mt; -typedef simple_file_sink simple_file_sink_st; +using simple_file_sink_mt = simple_file_sink; +using simple_file_sink_st = simple_file_sink; /* * Rotating file sink based on size @@ -149,8 +149,8 @@ private: details::file_helper _file_helper; }; -typedef rotating_file_sink rotating_file_sink_mt; -typedef rotating_file_sinkrotating_file_sink_st; +using rotating_file_sink_mt = rotating_file_sink; +using rotating_file_sink_st = rotating_file_sink; /* * Default generator of daily log file names. @@ -247,7 +247,8 @@ private: details::file_helper _file_helper; }; -typedef daily_file_sink daily_file_sink_mt; -typedef daily_file_sink daily_file_sink_st; +using daily_file_sink_mt = daily_file_sink; +using daily_file_sink_st = daily_file_sink; + } } diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h index 22b52c8f..879ae81f 100644 --- a/include/spdlog/sinks/msvc_sink.h +++ b/include/spdlog/sinks/msvc_sink.h @@ -42,8 +42,8 @@ protected: {} }; -typedef msvc_sink msvc_sink_mt; -typedef msvc_sink msvc_sink_st; +using msvc_sink_mt = msvc_sink; +using msvc_sink_st = msvc_sink; } } diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h index 7605ac68..deda0373 100644 --- a/include/spdlog/sinks/null_sink.h +++ b/include/spdlog/sinks/null_sink.h @@ -26,8 +26,9 @@ protected: {} }; -typedef null_sink null_sink_st; -typedef null_sink null_sink_mt; + +using null_sink_mt = null_sink; +using null_sink_st = null_sink; } } diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h index 1e5b261c..8ab9caab 100644 --- a/include/spdlog/sinks/ostream_sink.h +++ b/include/spdlog/sinks/ostream_sink.h @@ -41,7 +41,8 @@ protected: bool _force_flush; }; -typedef ostream_sink ostream_sink_mt; -typedef ostream_sink ostream_sink_st; +using ostream_sink_mt = ostream_sink; +using ostream_sink_st = ostream_sink; + } } diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index dfbfccd5..6867ba4e 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -42,9 +42,8 @@ protected: } }; -typedef stdout_sink stdout_sink_st; -typedef stdout_sink stdout_sink_mt; - +using stdout_sink_mt = stdout_sink; +using stdout_sink_st = stdout_sink; template class stderr_sink SPDLOG_FINAL : public base_sink @@ -71,7 +70,8 @@ protected: } }; -typedef stderr_sink stderr_sink_mt; -typedef stderr_sink stderr_sink_st; +using stderr_sink_mt = stderr_sink; +using stderr_sink_st = stderr_sink; + } } diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index d8211fb1..bd612407 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -85,7 +85,7 @@ private: back_color &= static_cast(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)); // keep the background color unchanged SetConsoleTextAttribute(out_handle_, attribs | back_color); - return orig_buffer_info.wAttributes; //return orig attribs + return orig_buffer_info.wAttributes; //return orig attribs } }; @@ -100,8 +100,8 @@ public: {} }; -typedef wincolor_stdout_sink wincolor_stdout_sink_mt; -typedef wincolor_stdout_sink wincolor_stdout_sink_st; +using wincolor_stdout_sink_mt = wincolor_stdout_sink; +using wincolor_stdout_sink_st = wincolor_stdout_sink; // // windows color console to stderr @@ -114,8 +114,8 @@ public: {} }; -typedef wincolor_stderr_sink wincolor_stderr_sink_mt; -typedef wincolor_stderr_sink wincolor_stderr_sink_st; +using wincolor_stderr_sink_mt = wincolor_stderr_sink; +using wincolor_stderr_sink_st = wincolor_stderr_sink; } } diff --git a/include/spdlog/sinks/windebug_sink.h b/include/spdlog/sinks/windebug_sink.h index c22e9522..16e8e540 100644 --- a/include/spdlog/sinks/windebug_sink.h +++ b/include/spdlog/sinks/windebug_sink.h @@ -20,8 +20,8 @@ namespace sinks template using windebug_sink = msvc_sink; -typedef msvc_sink_mt windebug_sink_mt; -typedef msvc_sink_st windebug_sink_st; +using windebug_sink_mt = msvc_sink_mt; +using windebug_sink_st = msvc_sink_st; } } From fb6df0512fc995d07f757a220af2dae927edffe8 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sat, 24 Feb 2018 23:56:56 +0100 Subject: [PATCH 22/39] modernize-use-override --- include/spdlog/async_logger.h | 6 +++--- include/spdlog/common.h | 4 ++-- include/spdlog/formatter.h | 5 ++--- include/spdlog/sinks/ansicolor_sink.h | 8 +++++--- include/spdlog/sinks/base_sink.h | 4 ++-- include/spdlog/sinks/dist_sink.h | 5 +---- include/spdlog/sinks/file_sinks.h | 6 ++++-- include/spdlog/sinks/msvc_sink.h | 4 +--- include/spdlog/sinks/null_sink.h | 2 +- include/spdlog/sinks/ostream_sink.h | 3 +-- include/spdlog/sinks/sink.h | 5 +---- include/spdlog/sinks/stdout_sinks.h | 5 +++-- include/spdlog/sinks/syslog_sink.h | 3 ++- include/spdlog/sinks/wincolor_sink.h | 18 +++++++++--------- include/spdlog/sinks/windebug_sink.h | 2 +- 15 files changed, 38 insertions(+), 42 deletions(-) diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index e9fcd5f4..4b1190cc 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -31,7 +31,7 @@ namespace details class async_log_helper; } -class async_logger SPDLOG_FINAL :public logger +class async_logger SPDLOG_FINAL : public logger { public: template @@ -65,8 +65,8 @@ public: void flush() override; // Error handler - virtual void set_error_handler(log_err_handler) override; - virtual log_err_handler error_handler() override; + void set_error_handler(log_err_handler) override; + log_err_handler error_handler() override; protected: void _sink_it(details::log_msg& msg) override; diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 97e58247..c5ecc73a 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -136,7 +136,7 @@ namespace os std::string errno_str(int err_num); } } -class spdlog_ex: public std::exception +class spdlog_ex : public std::exception { public: spdlog_ex(const std::string& msg):_msg(msg) @@ -149,9 +149,9 @@ public: { return _msg.c_str(); } + private: std::string _msg; - }; // diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index b69d7eb1..580deac2 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -21,18 +21,18 @@ class flag_formatter; class formatter { public: - virtual ~formatter() {} + virtual ~formatter() = default; virtual void format(details::log_msg& msg) = 0; }; class pattern_formatter SPDLOG_FINAL : public formatter { - public: explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string& eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter&) = delete; pattern_formatter& operator=(const pattern_formatter&) = delete; void format(details::log_msg& msg) override; + private: const std::string _eol; const std::string _pattern; @@ -45,4 +45,3 @@ private: } #include "details/pattern_formatter_impl.h" - diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index 2063b079..1b70c735 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -23,7 +23,7 @@ namespace sinks * If no color terminal detected, omit the escape codes. */ template -class ansicolor_sink: public base_sink +class ansicolor_sink : public base_sink { public: ansicolor_sink(FILE* file): target_file_(file) @@ -37,7 +37,8 @@ public: colors_[level::critical] = bold + on_red; colors_[level::off] = reset; } - virtual ~ansicolor_sink() + + ~ansicolor_sink() override { _flush(); } @@ -79,7 +80,7 @@ public: const std::string on_white = "\033[47m"; protected: - virtual void _sink_it(const details::log_msg& msg) override + void _sink_it(const details::log_msg& msg) override { // Wrap the originally formatted message in color codes. // If color is not supported in the terminal, log as is instead. @@ -102,6 +103,7 @@ protected: { fflush(target_file_); } + FILE* target_file_; bool should_do_colors_; std::unordered_map colors_; diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h index 23c85653..63d67445 100644 --- a/include/spdlog/sinks/base_sink.h +++ b/include/spdlog/sinks/base_sink.h @@ -22,11 +22,10 @@ namespace spdlog namespace sinks { template -class base_sink:public sink +class base_sink : public sink { public: base_sink():_mutex() {} - virtual ~base_sink() = default; base_sink(const base_sink&) = delete; base_sink& operator=(const base_sink&) = delete; @@ -36,6 +35,7 @@ public: std::lock_guard lock(_mutex); _sink_it(msg); } + void flush() SPDLOG_FINAL override { std::lock_guard lock(_mutex); diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 604c5a7d..39f162c5 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/include/spdlog/sinks/dist_sink.h @@ -22,13 +22,12 @@ namespace spdlog namespace sinks { template -class dist_sink: public base_sink +class dist_sink : public base_sink { public: explicit dist_sink() :_sinks() {} dist_sink(const dist_sink&) = delete; dist_sink& operator=(const dist_sink&) = delete; - virtual ~dist_sink() = default; protected: std::vector> _sinks; @@ -51,8 +50,6 @@ protected: } public: - - void add_sink(std::shared_ptr sink) { std::lock_guard lock(base_sink::_mutex); diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index baef4a46..f4abd81b 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -26,7 +26,7 @@ namespace sinks * Trivial file sink with single file as target */ template -class simple_file_sink SPDLOG_FINAL : public base_sink < Mutex > +class simple_file_sink SPDLOG_FINAL : public base_sink { public: explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false) @@ -46,10 +46,12 @@ protected: if(_force_flush) _file_helper.flush(); } + void _flush() override { _file_helper.flush(); } + private: details::file_helper _file_helper; bool _force_flush; @@ -112,7 +114,6 @@ protected: _file_helper.flush(); } - private: // Rotate files: // log.txt -> log.1.txt @@ -142,6 +143,7 @@ private: } _file_helper.reopen(true); } + filename_t _base_filename; std::size_t _max_size; std::size_t _max_files; diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h index 879ae81f..d230613e 100644 --- a/include/spdlog/sinks/msvc_sink.h +++ b/include/spdlog/sinks/msvc_sink.h @@ -23,15 +23,13 @@ namespace sinks * MSVC sink (logging using OutputDebugStringA) */ template -class msvc_sink : public base_sink < Mutex > +class msvc_sink : public base_sink { public: explicit msvc_sink() { } - - protected: void _sink_it(const details::log_msg& msg) override { diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h index deda0373..9a4fd08d 100644 --- a/include/spdlog/sinks/null_sink.h +++ b/include/spdlog/sinks/null_sink.h @@ -16,7 +16,7 @@ namespace sinks { template -class null_sink : public base_sink < Mutex > +class null_sink : public base_sink { protected: void _sink_it(const details::log_msg&) override diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h index 8ab9caab..9648cc05 100644 --- a/include/spdlog/sinks/ostream_sink.h +++ b/include/spdlog/sinks/ostream_sink.h @@ -16,13 +16,12 @@ namespace spdlog namespace sinks { template -class ostream_sink: public base_sink +class ostream_sink : public base_sink { public: explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {} ostream_sink(const ostream_sink&) = delete; ostream_sink& operator=(const ostream_sink&) = delete; - virtual ~ostream_sink() = default; protected: void _sink_it(const details::log_msg& msg) override diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index af61b54c..8fb045c6 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -3,7 +3,6 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) // - #pragma once #include "../details/log_msg.h" @@ -20,7 +19,7 @@ public: _level = level::trace; } - virtual ~sink() {} + virtual ~sink() = default; virtual void log(const details::log_msg& msg) = 0; virtual void flush() = 0; @@ -30,7 +29,6 @@ public: private: level_t _level; - }; inline bool sink::should_log(level::level_enum msg_level) const @@ -50,4 +48,3 @@ inline level::level_enum sink::level() const } } - diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index 6867ba4e..0bdb8cec 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -50,13 +50,14 @@ class stderr_sink SPDLOG_FINAL : public base_sink { using MyType = stderr_sink; public: - stderr_sink() - {} + explicit stderr_sink() {} + static std::shared_ptr instance() { static std::shared_ptr instance = std::make_shared(); return instance; } + protected: void _sink_it(const details::log_msg& msg) override { diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index c4a726a8..98fad055 100644 --- a/include/spdlog/sinks/syslog_sink.h +++ b/include/spdlog/sinks/syslog_sink.h @@ -44,7 +44,8 @@ public: //set ident to be program name if empty ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility); } - ~syslog_sink() + + ~syslog_sink() override { ::closelog(); } diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index bd612407..0ceb172a 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -21,8 +21,8 @@ namespace sinks /* * Windows color console sink. Uses WriteConsoleA to write to the console with colors */ -template -class wincolor_sink: public base_sink +template +class wincolor_sink : public base_sink { public: const WORD BOLD = FOREGROUND_INTENSITY; @@ -42,7 +42,7 @@ public: colors_[level::off] = 0; } - virtual ~wincolor_sink() + ~wincolor_sink() override { this->flush(); } @@ -58,7 +58,7 @@ public: } protected: - virtual void _sink_it(const details::log_msg& msg) override + void _sink_it(const details::log_msg& msg) override { auto color = colors_[msg.level]; auto orig_attribs = set_console_attribs(color); @@ -66,7 +66,7 @@ protected: SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors } - virtual void _flush() override + void _flush() override { // windows console always flushed? } @@ -92,8 +92,8 @@ private: // // windows color console to stdout // -template -class wincolor_stdout_sink: public wincolor_sink +template +class wincolor_stdout_sink : public wincolor_sink { public: wincolor_stdout_sink() : wincolor_sink(GetStdHandle(STD_OUTPUT_HANDLE)) @@ -106,8 +106,8 @@ using wincolor_stdout_sink_st = wincolor_stdout_sink; // // windows color console to stderr // -template -class wincolor_stderr_sink: public wincolor_sink +template +class wincolor_stderr_sink : public wincolor_sink { public: wincolor_stderr_sink() : wincolor_sink(GetStdHandle(STD_ERROR_HANDLE)) diff --git a/include/spdlog/sinks/windebug_sink.h b/include/spdlog/sinks/windebug_sink.h index 16e8e540..37d67245 100644 --- a/include/spdlog/sinks/windebug_sink.h +++ b/include/spdlog/sinks/windebug_sink.h @@ -17,7 +17,7 @@ namespace sinks /* * Windows debug sink (logging using OutputDebugStringA, synonym for msvc_sink) */ -template +template using windebug_sink = msvc_sink; using windebug_sink_mt = msvc_sink_mt; From 9ebb9ff3180e4c1e9dc363fa6d717be3cc3fcb98 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 00:16:18 +0100 Subject: [PATCH 23/39] readability-implicit-bool-cast --- include/spdlog/details/file_helper.h | 6 +++--- include/spdlog/details/os.h | 6 +++--- include/spdlog/sinks/file_sinks.h | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index dff788ff..754f6885 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -46,7 +46,6 @@ public: void open(const filename_t& fname, bool truncate = false) { - close(); auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab"); _filename = fname; @@ -76,7 +75,7 @@ public: void close() { - if (_fd) + if (_fd != nullptr) { std::fclose(_fd); _fd = nullptr; @@ -93,8 +92,9 @@ public: size_t size() const { - if (!_fd) + if (_fd == nullptr) { throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename)); + } return os::filesize(_fd); } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index e647e32a..1f44e680 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -170,7 +170,7 @@ inline void prevent_child_fd(FILE *f) //fopen_s on non windows for writing -inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode) +inline bool fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode) { #ifdef _WIN32 #ifdef SPDLOG_WCHAR_FILENAMES @@ -482,9 +482,9 @@ inline bool in_terminal(FILE* file) { #ifdef _WIN32 - return _isatty(_fileno(file)) ? true : false; + return _isatty(_fileno(file)) != 0; #else - return isatty(fileno(file)) ? true : false; + return isatty(fileno(file)) != 0; #endif } } //os diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index f4abd81b..0266f9ae 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -84,7 +84,7 @@ public: static filename_t calc_filename(const filename_t& filename, std::size_t index) { typename std::conditional::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w; - if (index) + if (index != 0u) { filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename); @@ -136,7 +136,7 @@ private: throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target), errno); } } - if (details::file_helper::file_exists(src) && details::os::rename(src, target)) + if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0) { throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); } From d5a3bb52345591fd10b3952cbc3959cba217c340 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 00:24:47 +0100 Subject: [PATCH 24/39] readability-else-after-return --- include/spdlog/details/async_log_helper.h | 11 ++++------- include/spdlog/details/os.h | 5 +---- include/spdlog/details/pattern_formatter_impl.h | 6 +++--- include/spdlog/sinks/file_sinks.h | 6 +++--- 4 files changed, 11 insertions(+), 17 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 82282db9..179a3db6 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -328,13 +328,10 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_ // Handle empty queue.. // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue - else - { - auto now = details::os::now(); - handle_flush_interval(now, last_flush); - sleep_or_yield(now, last_pop); - return !_terminate_requested; - } + auto now = details::os::now(); + handle_flush_interval(now, last_flush); + sleep_or_yield(now, last_pop); + return !_terminate_requested; } // flush all sinks if _flush_interval_ms has expired diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 1f44e680..a3597ca6 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -403,10 +403,7 @@ inline std::string errno_to_string(char buf[256], int res) { return std::string(buf); } - else - { - return "Unknown error"; - } + return "Unknown error"; } // Return errno string (thread safe) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 72f29270..86c89370 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -662,10 +662,10 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg) { - if (_pattern_time == pattern_time_type::local) + if (_pattern_time == pattern_time_type::local) { return details::os::localtime(log_clock::to_time_t(msg.time)); - else - return details::os::gmtime(log_clock::to_time_t(msg.time)); + } + return details::os::gmtime(log_clock::to_time_t(msg.time)); } inline void spdlog::pattern_formatter::format(details::log_msg& msg) diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 0266f9ae..929ec30d 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -236,10 +236,10 @@ private: 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) + if (rotation_time > now) { return rotation_time; - else - return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24)); + } + return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24)); } filename_t _base_filename; From 7aed498540cb0f4c2623e40f214de28ec47f0075 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 00:31:14 +0100 Subject: [PATCH 25/39] modernize-use-default-member-init --- include/spdlog/details/file_helper.h | 6 ++---- include/spdlog/details/pattern_formatter_impl.h | 9 ++++----- include/spdlog/sinks/sink.h | 7 +------ 3 files changed, 7 insertions(+), 15 deletions(-) diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index 754f6885..7deff3ae 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -31,9 +31,7 @@ public: const int open_tries = 5; const int open_interval = 10; - explicit file_helper() : - _fd(nullptr) - {} + explicit file_helper() {} file_helper(const file_helper&) = delete; file_helper& operator=(const file_helper&) = delete; @@ -138,7 +136,7 @@ public: return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); } private: - FILE* _fd; + FILE* _fd{ nullptr }; filename_t _filename; }; } diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 86c89370..5dc257d1 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -310,13 +310,12 @@ class T_formatter SPDLOG_FINAL:public flag_formatter }; // ISO 8601 offset from UTC in timezone (+-HH:MM) -class z_formatter SPDLOG_FINAL:public flag_formatter +class z_formatter SPDLOG_FINAL : public flag_formatter { public: const std::chrono::seconds cache_refresh = std::chrono::seconds(5); - z_formatter():_last_update(std::chrono::seconds(0)), _offset_minutes(0) - {} + z_formatter() {} z_formatter(const z_formatter&) = delete; z_formatter& operator=(const z_formatter&) = delete; @@ -347,8 +346,8 @@ public: pad_n_join(msg.formatted, h, m, ':'); } private: - log_clock::time_point _last_update; - int _offset_minutes; + log_clock::time_point _last_update{ std::chrono::seconds(0) }; + int _offset_minutes{ 0 }; std::mutex _mutex; int get_cached_offset(const log_msg& msg, const std::tm& tm_time) diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index 8fb045c6..770a2d30 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -14,11 +14,6 @@ namespace sinks class sink { public: - sink() - { - _level = level::trace; - } - virtual ~sink() = default; virtual void log(const details::log_msg& msg) = 0; virtual void flush() = 0; @@ -28,7 +23,7 @@ public: level::level_enum level() const; private: - level_t _level; + level_t _level{ level::trace }; }; inline bool sink::should_log(level::level_enum msg_level) const From 68f91822ede7b2aed8714a8b2678361e29a5cc18 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 00:54:14 +0100 Subject: [PATCH 26/39] performance-unnecessary-value-param --- include/spdlog/details/async_log_helper.h | 12 ++++-------- include/spdlog/details/async_logger_impl.h | 2 +- include/spdlog/details/logger_impl.h | 10 +++++----- include/spdlog/details/spdlog_impl.h | 12 ++++-------- tests/test_pattern_formatter.cpp | 12 ++---------- 5 files changed, 16 insertions(+), 32 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 179a3db6..2439df5f 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -207,10 +207,10 @@ inline spdlog::details::async_log_helper::async_log_helper( const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb): - _formatter(formatter), + _formatter(std::move(formatter)), _sinks(sinks), _q(queue_size), - _err_handler(err_handler), + _err_handler(std::move(err_handler)), _flush_requested(false), _terminate_requested(false), _overflow_policy(overflow_policy), @@ -349,10 +349,9 @@ inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock:: inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter) { - _formatter = msg_formatter; + _formatter = std::move(msg_formatter); } - // spin, yield or sleep. use the time passed since last message as a hint inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time) { @@ -389,8 +388,5 @@ inline void spdlog::details::async_log_helper::wait_empty_q() inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler) { - _err_handler = err_handler; + _err_handler = std::move(err_handler); } - - - diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h index 83732117..d9a1e424 100644 --- a/include/spdlog/details/async_logger_impl.h +++ b/include/spdlog/details/async_logger_impl.h @@ -48,7 +48,7 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name, const std::function& worker_teardown_cb) : async_logger(logger_name, { - single_sink + std::move(single_sink) }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index df69102d..e45a6d69 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -39,7 +39,7 @@ inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list si inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink): logger(logger_name, { - single_sink + std::move(single_sink) }) {} @@ -49,7 +49,7 @@ inline spdlog::logger::~logger() = default; inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter) { - _set_formatter(msg_formatter); + _set_formatter(std::move(msg_formatter)); } inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time) @@ -281,7 +281,7 @@ inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler) { - _err_handler = err_handler; + _err_handler = std::move(err_handler); } inline spdlog::log_err_handler spdlog::logger::error_handler() @@ -289,7 +289,6 @@ inline spdlog::log_err_handler spdlog::logger::error_handler() return _err_handler; } - inline void spdlog::logger::flush_on(level::level_enum log_level) { _flush_level.store(log_level); @@ -330,9 +329,10 @@ inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_tim { _formatter = std::make_shared(pattern, pattern_time); } + inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter) { - _formatter = msg_formatter; + _formatter = std::move(msg_formatter); } inline void spdlog::logger::flush() diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 9733a733..003aff16 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -34,7 +34,7 @@ inline void spdlog::register_logger(std::shared_ptr logger) { - return details::registry::instance().register_logger(logger); + return details::registry::instance().register_logger(std::move(logger)); } inline std::shared_ptr spdlog::get(const std::string& name) @@ -183,13 +183,11 @@ inline std::shared_ptr spdlog::create(const std::string& logger_ } //Create logger with multiple sinks - inline std::shared_ptr spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks) { return details::registry::instance().create(logger_name, sinks); } - template inline std::shared_ptr spdlog::create(const std::string& logger_name, Args... args) { @@ -197,7 +195,6 @@ inline std::shared_ptr spdlog::create(const std::string& logger_ return details::registry::instance().create(logger_name, { sink }); } - template inline std::shared_ptr spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end) { @@ -224,7 +221,7 @@ inline std::shared_ptr spdlog::create_async(const std::string& l inline void spdlog::set_formatter(spdlog::formatter_ptr f) { - details::registry::instance().formatter(f); + details::registry::instance().formatter(std::move(f)); } inline void spdlog::set_pattern(const std::string& format_string) @@ -244,10 +241,9 @@ inline void spdlog::flush_on(level::level_enum log_level) inline void spdlog::set_error_handler(log_err_handler handler) { - return details::registry::instance().set_error_handler(handler); + return details::registry::instance().set_error_handler(std::move(handler)); } - inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) { details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb); @@ -260,7 +256,7 @@ inline void spdlog::set_sync_mode() inline void spdlog::apply_all(std::function)> fun) { - details::registry::instance().apply_all(fun); + details::registry::instance().apply_all(std::move(fun)); } inline void spdlog::drop_all() diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp index e80fd37d..b8810c96 100644 --- a/tests/test_pattern_formatter.cpp +++ b/tests/test_pattern_formatter.cpp @@ -1,7 +1,7 @@ #include "includes.h" // log to str and return it -static std::string log_to_str(const std::string& msg, std::shared_ptr formatter = nullptr) +static std::string log_to_str(const std::string& msg, const std::shared_ptr& formatter = nullptr) { std::ostringstream oss; auto oss_sink = std::make_shared(oss); @@ -11,6 +11,7 @@ static std::string log_to_str(const std::string& msg, std::shared_ptr("[%L] %v", spdlog::pattern_time_type::local, "\n"); @@ -51,19 +51,11 @@ TEST_CASE("name", "[pattern_formatter]") REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n"); } - TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") { - using namespace::std::chrono; auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); auto now_tm = spdlog::details::os::localtime(); std::stringstream oss; oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; REQUIRE(log_to_str("Some message", formatter) == oss.str()); } - - - - - - From e5bbe57f01b26abb1ff3bd461100df38c64b458a Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 01:15:35 +0100 Subject: [PATCH 27/39] cppcoreguidelines-pro-type-member --- include/spdlog/details/log_msg.h | 8 +++----- include/spdlog/details/os.h | 15 +++++++-------- include/spdlog/details/registry.h | 2 +- 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index a9fe9201..8d39a010 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -8,7 +8,6 @@ #include "../common.h" #include "../details/os.h" - #include #include @@ -21,8 +20,7 @@ struct log_msg log_msg() = default; log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), - level(lvl), - msg_id(0) + level(lvl) { #ifndef SPDLOG_NO_DATETIME time = os::now(); @@ -38,13 +36,13 @@ struct log_msg log_msg(log_msg&& other) = delete; - const std::string *logger_name; + const std::string *logger_name{ nullptr }; level::level_enum level; log_clock::time_point time; size_t thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; - size_t msg_id; + size_t msg_id{ 0 }; }; } } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index a3597ca6..6cc42d45 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -81,10 +81,10 @@ inline std::tm localtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm; + std::tm tm{}; localtime_s(&tm, &time_tt); #else - std::tm tm; + std::tm tm{}; localtime_r(&time_tt, &tm); #endif return tm; @@ -96,15 +96,14 @@ inline std::tm localtime() return localtime(now_t); } - inline std::tm gmtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm; + std::tm tm{}; gmtime_s(&tm, &time_tt); #else - std::tm tm; + std::tm tm{}; gmtime_r(&time_tt, &tm); #endif return tm; @@ -220,7 +219,7 @@ inline bool file_exists(const filename_t& filename) #endif return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)); #else //common linux/unix all have the stat system call - struct stat buffer; + struct stat buffer{}; return (stat(filename.c_str(), &buffer) == 0); #endif } @@ -250,11 +249,11 @@ inline size_t filesize(FILE *f) int fd = fileno(f); //64 bits(but not in osx or cygwin, where fstat64 is deprecated) #if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) - struct stat64 st; + struct stat64 st{}; if (fstat64(fd, &st) == 0) return static_cast(st.st_size); #else // unix 32 bits or cygwin - struct stat st; + struct stat st{}; if (fstat(fd, &st) == 0) return static_cast(st.st_size); #endif diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 28d8d2fa..a7ef0888 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -213,7 +213,7 @@ private: size_t _async_q_size = 0; async_overflow_policy _overflow_policy = async_overflow_policy::block_retry; std::function _worker_warmup_cb = nullptr; - std::chrono::milliseconds _flush_interval_ms; + std::chrono::milliseconds _flush_interval_ms{ 0 }; std::function _worker_teardown_cb = nullptr; }; From 1e1ca231012fd0854f9b1e3b3e89a646a4351af0 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 01:25:15 +0100 Subject: [PATCH 28/39] modernize-use-equals-default --- include/spdlog/details/file_helper.h | 3 +- .../spdlog/details/pattern_formatter_impl.h | 68 ++++++++----------- include/spdlog/details/registry.h | 3 +- include/spdlog/sinks/stdout_sinks.h | 9 ++- 4 files changed, 39 insertions(+), 44 deletions(-) diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index 7deff3ae..996b7b2d 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -31,7 +31,7 @@ public: const int open_tries = 5; const int open_interval = 10; - explicit file_helper() {} + explicit file_helper() = default; file_helper(const file_helper&) = delete; file_helper& operator=(const file_helper&) = delete; @@ -135,6 +135,7 @@ public: // finally - return a valid base and extension tuple return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); } + private: FILE* _fd{ nullptr }; filename_t _filename; diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 5dc257d1..b3cc380b 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -27,8 +27,7 @@ namespace details class flag_formatter { public: - virtual ~flag_formatter() - {} + virtual ~flag_formatter() = default; virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0; }; @@ -118,7 +117,6 @@ class B_formatter:public flag_formatter } }; - //write 2 ints separated by sep with padding of 2 static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep) { @@ -133,9 +131,8 @@ static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v return w; } - //Date and time representation (Thu Aug 23 15:35:46 2014) -class c_formatter SPDLOG_FINAL:public flag_formatter +class c_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -144,9 +141,8 @@ class c_formatter SPDLOG_FINAL:public flag_formatter } }; - // year - 2 digit -class C_formatter SPDLOG_FINAL:public flag_formatter +class C_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -154,10 +150,8 @@ class C_formatter SPDLOG_FINAL:public flag_formatter } }; - - // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 -class D_formatter SPDLOG_FINAL:public flag_formatter +class D_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -165,9 +159,8 @@ class D_formatter SPDLOG_FINAL:public flag_formatter } }; - // year - 4 digit -class Y_formatter SPDLOG_FINAL:public flag_formatter +class Y_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -176,7 +169,7 @@ class Y_formatter SPDLOG_FINAL:public flag_formatter }; // month 1-12 -class m_formatter SPDLOG_FINAL:public flag_formatter +class m_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -185,7 +178,7 @@ class m_formatter SPDLOG_FINAL:public flag_formatter }; // day of month 1-31 -class d_formatter SPDLOG_FINAL:public flag_formatter +class d_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -194,7 +187,7 @@ class d_formatter SPDLOG_FINAL:public flag_formatter }; // hours in 24 format 0-23 -class H_formatter SPDLOG_FINAL:public flag_formatter +class H_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -203,7 +196,7 @@ class H_formatter SPDLOG_FINAL:public flag_formatter }; // hours in 12 format 1-12 -class I_formatter SPDLOG_FINAL:public flag_formatter +class I_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -212,7 +205,7 @@ class I_formatter SPDLOG_FINAL:public flag_formatter }; // minutes 0-59 -class M_formatter SPDLOG_FINAL:public flag_formatter +class M_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -221,7 +214,7 @@ class M_formatter SPDLOG_FINAL:public flag_formatter }; // seconds 0-59 -class S_formatter SPDLOG_FINAL:public flag_formatter +class S_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -230,7 +223,7 @@ class S_formatter SPDLOG_FINAL:public flag_formatter }; // milliseconds -class e_formatter SPDLOG_FINAL:public flag_formatter +class e_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -241,7 +234,7 @@ class e_formatter SPDLOG_FINAL:public flag_formatter }; // microseconds -class f_formatter SPDLOG_FINAL:public flag_formatter +class f_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -252,7 +245,7 @@ class f_formatter SPDLOG_FINAL:public flag_formatter }; // nanoseconds -class F_formatter SPDLOG_FINAL:public flag_formatter +class F_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -262,7 +255,7 @@ class F_formatter SPDLOG_FINAL:public flag_formatter } }; -class E_formatter SPDLOG_FINAL:public flag_formatter +class E_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -273,7 +266,7 @@ class E_formatter SPDLOG_FINAL:public flag_formatter }; // AM/PM -class p_formatter SPDLOG_FINAL:public flag_formatter +class p_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -281,9 +274,8 @@ class p_formatter SPDLOG_FINAL:public flag_formatter } }; - // 12 hour clock 02:55:02 pm -class r_formatter SPDLOG_FINAL:public flag_formatter +class r_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -292,7 +284,7 @@ class r_formatter SPDLOG_FINAL:public flag_formatter }; // 24-hour HH:MM time, equivalent to %H:%M -class R_formatter SPDLOG_FINAL:public flag_formatter +class R_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -301,7 +293,7 @@ class R_formatter SPDLOG_FINAL:public flag_formatter }; // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S -class T_formatter SPDLOG_FINAL:public flag_formatter +class T_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -315,7 +307,7 @@ class z_formatter SPDLOG_FINAL : public flag_formatter public: const std::chrono::seconds cache_refresh = std::chrono::seconds(5); - z_formatter() {} + z_formatter() = default; z_formatter(const z_formatter&) = delete; z_formatter& operator=(const z_formatter&) = delete; @@ -363,10 +355,8 @@ private: } }; - - // Thread id -class t_formatter SPDLOG_FINAL:public flag_formatter +class t_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -375,7 +365,7 @@ class t_formatter SPDLOG_FINAL:public flag_formatter }; // Current pid -class pid_formatter SPDLOG_FINAL:public flag_formatter +class pid_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -384,7 +374,7 @@ class pid_formatter SPDLOG_FINAL:public flag_formatter }; // message counter formatter -class i_formatter SPDLOG_FINAL :public flag_formatter +class i_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -392,7 +382,7 @@ class i_formatter SPDLOG_FINAL :public flag_formatter } }; -class v_formatter SPDLOG_FINAL:public flag_formatter +class v_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -400,7 +390,7 @@ class v_formatter SPDLOG_FINAL:public flag_formatter } }; -class ch_formatter SPDLOG_FINAL:public flag_formatter +class ch_formatter SPDLOG_FINAL : public flag_formatter { public: explicit ch_formatter(char ch): _ch(ch) @@ -415,11 +405,11 @@ private: //aggregate user chars to display as is -class aggregate_formatter SPDLOG_FINAL:public flag_formatter +class aggregate_formatter SPDLOG_FINAL : public flag_formatter { public: - aggregate_formatter() - {} + aggregate_formatter() = default; + void add_ch(char ch) { _str += ch; @@ -434,7 +424,7 @@ private: // Full info formatter // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v -class full_formatter SPDLOG_FINAL:public flag_formatter +class full_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index a7ef0888..3c134601 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -194,7 +194,7 @@ public: } private: - registry_t() {} + registry_t() = default; registry_t(const registry_t&) = delete; registry_t& operator=(const registry_t&) = delete; @@ -203,6 +203,7 @@ private: if (_loggers.find(logger_name) != _loggers.end()) throw spdlog_ex("logger with name '" + logger_name + "' already exists"); } + Mutex _mutex; std::unordered_map > _loggers; formatter_ptr _formatter; diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index 0bdb8cec..0567a05d 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -21,14 +21,16 @@ template class stdout_sink SPDLOG_FINAL : public base_sink { using MyType = stdout_sink; + public: - stdout_sink() - {} + explicit stdout_sink() = default; + static std::shared_ptr instance() { static std::shared_ptr instance = std::make_shared(); return instance; } + protected: void _sink_it(const details::log_msg& msg) override { @@ -49,8 +51,9 @@ template class stderr_sink SPDLOG_FINAL : public base_sink { using MyType = stderr_sink; + public: - explicit stderr_sink() {} + explicit stderr_sink() = default; static std::shared_ptr instance() { From ad624432d85936facc410eed108e4106a3174d6a Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 01:40:46 +0100 Subject: [PATCH 29/39] google-explicit-constructor --- include/spdlog/common.h | 6 +++--- include/spdlog/details/async_log_helper.h | 4 ++-- include/spdlog/details/mpmc_bounded_q.h | 11 +++++------ include/spdlog/details/null_mutex.h | 2 +- include/spdlog/details/registry.h | 9 +++++---- include/spdlog/logger.h | 2 +- include/spdlog/sinks/ansicolor_sink.h | 2 +- 7 files changed, 18 insertions(+), 18 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index c5ecc73a..3a691b34 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -106,7 +106,6 @@ using level_hasher = std::hash; } //level - // // Async overflow policy - block by default. // @@ -139,12 +138,14 @@ std::string errno_str(int err_num); class spdlog_ex : public std::exception { public: - spdlog_ex(const std::string& msg):_msg(msg) + explicit spdlog_ex(std::string msg) : _msg(std::move(msg)) {} + spdlog_ex(const std::string& msg, int last_errno) { _msg = msg + ": " + details::os::errno_str(last_errno); } + const char* what() const SPDLOG_NOEXCEPT override { return _msg.c_str(); @@ -163,5 +164,4 @@ using filename_t = std::wstring; using filename_t = std::string; #endif - } //spdlog diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 2439df5f..ece3eb51 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -67,7 +67,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: msg_id(other.msg_id) {} - async_msg(async_msg_type m_type): + explicit async_msg(async_msg_type m_type): level(level::info), thread_id(0), msg_type(m_type), @@ -91,7 +91,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: async_msg& operator=(const async_msg& other) = delete; // construct from log_msg - async_msg(const details::log_msg& m): + explicit async_msg(const details::log_msg& m): level(m.level), time(m.time), thread_id(m.thread_id), diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h index 887f530f..6187f3b9 100644 --- a/include/spdlog/details/mpmc_bounded_q.h +++ b/include/spdlog/details/mpmc_bounded_q.h @@ -53,13 +53,13 @@ namespace spdlog namespace details { -template +template class mpmc_bounded_queue { public: - using item_type = T; - mpmc_bounded_queue(size_t buffer_size) + + explicit mpmc_bounded_queue(size_t buffer_size) :max_size_(buffer_size), buffer_(new cell_t[buffer_size]), buffer_mask_(buffer_size - 1) @@ -79,6 +79,8 @@ public: delete[] buffer_; } + mpmc_bounded_queue(mpmc_bounded_queue const&) = delete; + void operator=(mpmc_bounded_queue const&) = delete; bool enqueue(T&& data) { @@ -167,9 +169,6 @@ private: cacheline_pad_t pad2_; std::atomic dequeue_pos_; cacheline_pad_t pad3_; - - mpmc_bounded_queue(mpmc_bounded_queue const&) = delete; - void operator= (mpmc_bounded_queue const&) = delete; }; } // ns details diff --git a/include/spdlog/details/null_mutex.h b/include/spdlog/details/null_mutex.h index 67b0aeee..82b0ed84 100644 --- a/include/spdlog/details/null_mutex.h +++ b/include/spdlog/details/null_mutex.h @@ -27,7 +27,7 @@ struct null_atomic_int int value; null_atomic_int() = default; - null_atomic_int(int val):value(val) + explicit null_atomic_int(int val) : value(val) {} int load(std::memory_order) const diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 3c134601..07881ae0 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -26,9 +26,12 @@ namespace spdlog { namespace details { -template class registry_t +template +class registry_t { public: + registry_t(const registry_t&) = delete; + registry_t& operator=(const registry_t&) = delete; void register_logger(std::shared_ptr logger) { @@ -38,7 +41,6 @@ public: _loggers[logger_name] = logger; } - std::shared_ptr get(const std::string& logger_name) { std::lock_guard lock(_mutex); @@ -111,6 +113,7 @@ public: std::lock_guard lock(_mutex); _loggers.clear(); } + std::shared_ptr create(const std::string& logger_name, sinks_init_list sinks) { return create(logger_name, sinks.begin(), sinks.end()); @@ -195,8 +198,6 @@ public: private: registry_t() = default; - registry_t(const registry_t&) = delete; - registry_t& operator=(const registry_t&) = delete; void throw_if_exists(const std::string &logger_name) { diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 742f667f..3e27a95e 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -25,7 +25,7 @@ namespace spdlog class logger { public: - logger(const std::string& logger_name, sink_ptr single_sink); + logger(const std::string& name, sink_ptr single_sink); logger(const std::string& name, sinks_init_list); template logger(const std::string& name, const It& begin, const It& end); diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index 1b70c735..4bd884cc 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -26,7 +26,7 @@ template class ansicolor_sink : public base_sink { public: - ansicolor_sink(FILE* file): target_file_(file) + explicit ansicolor_sink(FILE* file) : target_file_(file) { should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal(); colors_[level::trace] = cyan; From 9ce66f2c9aaec41025798683b61a308185f4b101 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 01:58:09 +0100 Subject: [PATCH 30/39] modernize-pass-by-value --- include/spdlog/details/async_log_helper.h | 45 +++++++++---------- include/spdlog/details/logger_impl.h | 4 +- .../spdlog/details/pattern_formatter_impl.h | 5 ++- include/spdlog/formatter.h | 2 +- include/spdlog/logger.h | 4 +- include/spdlog/sinks/file_sinks.h | 15 ++++--- 6 files changed, 37 insertions(+), 38 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index ece3eb51..d63eebfd 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -43,6 +43,7 @@ class async_log_helper flush, terminate }; + struct async_msg { std::string logger_name; @@ -56,24 +57,23 @@ class async_log_helper async_msg() = default; ~async_msg() = default; - -async_msg(async_msg&& other) SPDLOG_NOEXCEPT: - logger_name(std::move(other.logger_name)), - level(std::move(other.level)), - time(std::move(other.time)), - thread_id(other.thread_id), - txt(std::move(other.txt)), - msg_type(std::move(other.msg_type)), - msg_id(other.msg_id) - {} - - explicit async_msg(async_msg_type m_type): + explicit async_msg(async_msg_type m_type) : level(level::info), thread_id(0), msg_type(m_type), msg_id(0) {} + async_msg(async_msg&& other) SPDLOG_NOEXCEPT : + logger_name(std::move(other.logger_name)), + level(std::move(other.level)), + time(std::move(other.time)), + thread_id(other.thread_id), + txt(std::move(other.txt)), + msg_type(std::move(other.msg_type)), + msg_id(other.msg_id) + {} + async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT { logger_name = std::move(other.logger_name); @@ -104,7 +104,6 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: #endif } - // copy into log_msg void fill_log_msg(log_msg &msg) { @@ -118,21 +117,19 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: }; public: - using item_type = async_msg; using q_type = details::mpmc_bounded_queue; using clock = std::chrono::steady_clock; - async_log_helper(formatter_ptr formatter, - const std::vector& sinks, + std::vector sinks, size_t queue_size, const log_err_handler err_handler, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, - const std::function& worker_warmup_cb = nullptr, + std::function worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), - const std::function& worker_teardown_cb = nullptr); + std::function worker_teardown_cb = nullptr); void log(const details::log_msg& msg); @@ -200,23 +197,23 @@ private: /////////////////////////////////////////////////////////////////////////////// inline spdlog::details::async_log_helper::async_log_helper( formatter_ptr formatter, - const std::vector& sinks, + std::vector sinks, size_t queue_size, log_err_handler err_handler, const async_overflow_policy overflow_policy, - const std::function& worker_warmup_cb, + std::function worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, - const std::function& worker_teardown_cb): + std::function worker_teardown_cb): _formatter(std::move(formatter)), - _sinks(sinks), + _sinks(std::move(sinks)), _q(queue_size), _err_handler(std::move(err_handler)), _flush_requested(false), _terminate_requested(false), _overflow_policy(overflow_policy), - _worker_warmup_cb(worker_warmup_cb), + _worker_warmup_cb(std::move(worker_warmup_cb)), _flush_interval_ms(flush_interval_ms), - _worker_teardown_cb(worker_teardown_cb) + _worker_teardown_cb(std::move(worker_teardown_cb)) { _worker_thread = std::thread(&async_log_helper::worker_loop, this); } diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index e45a6d69..e2011182 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -14,8 +14,8 @@ // create logger with given name, sinks and the default pattern formatter // all other ctors will call this one template -inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end): - _name(logger_name), +inline spdlog::logger::logger(std::string logger_name, const It& begin, const It& end): + _name(std::move(logger_name)), _sinks(begin, end), _formatter(std::make_shared("%+")), _level(level::info), diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index b3cc380b..dbe07f42 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -476,8 +476,9 @@ class full_formatter SPDLOG_FINAL : public flag_formatter /////////////////////////////////////////////////////////////////////////////// // pattern_formatter inline impl /////////////////////////////////////////////////////////////////////////////// -inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time, const std::string& eol) - : _eol(eol), _pattern_time(pattern_time) +inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time, std::string eol) : + _eol(std::move(eol)), + _pattern_time(pattern_time) { compile_pattern(pattern); } diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index 580deac2..203dc31a 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -28,7 +28,7 @@ public: class pattern_formatter SPDLOG_FINAL : public formatter { public: - explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string& eol = spdlog::details::os::default_eol); + explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter&) = delete; pattern_formatter& operator=(const pattern_formatter&) = delete; void format(details::log_msg& msg) override; diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 3e27a95e..8d456b9b 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -28,13 +28,13 @@ public: logger(const std::string& name, sink_ptr single_sink); logger(const std::string& name, sinks_init_list); template - logger(const std::string& name, const It& begin, const It& end); + logger(std::string name, const It& begin, const It& end); virtual ~logger(); + logger(const logger&) = delete; logger& operator=(const logger&) = delete; - template void log(level::level_enum lvl, const char* fmt, const Args&... args); template void log(level::level_enum lvl, const char* msg); template void trace(const char* fmt, const Arg1&, const Args&... args); diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 929ec30d..6af7eb7d 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -25,7 +25,7 @@ namespace sinks /* * Trivial file sink with single file as target */ -template +template class simple_file_sink SPDLOG_FINAL : public base_sink { public: @@ -63,13 +63,13 @@ using simple_file_sink_st = simple_file_sink; /* * Rotating file sink based on size */ -template -class rotating_file_sink SPDLOG_FINAL : public base_sink < Mutex > +template +class rotating_file_sink SPDLOG_FINAL : public base_sink { public: - rotating_file_sink(const filename_t &base_filename, + rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files) : - _base_filename(base_filename), + _base_filename(std::move(base_filename)), _max_size(max_size), _max_files(max_files), _current_size(0), @@ -197,9 +197,10 @@ class daily_file_sink SPDLOG_FINAL :public base_sink < Mutex > public: //create daily file sink which rotates on given time daily_file_sink( - const filename_t& base_filename, + filename_t base_filename, int rotation_hour, - int rotation_minute) : _base_filename(base_filename), + int rotation_minute) : + _base_filename(std::move(base_filename)), _rotation_h(rotation_hour), _rotation_m(rotation_minute) { From af50d5ef1f4eeb87ef25d3070efbbbc1ce61526c Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 02:19:26 +0100 Subject: [PATCH 31/39] readability-inconsistent-declaration-parameter-name --- include/spdlog/async_logger.h | 4 ++-- include/spdlog/details/async_logger_impl.h | 14 +++++++------- include/spdlog/details/logger_impl.h | 12 ++++++------ include/spdlog/sinks/file_sinks.h | 4 +--- 4 files changed, 16 insertions(+), 18 deletions(-) diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index 4b1190cc..c6a69f48 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -44,7 +44,7 @@ public: const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); - async_logger(const std::string& logger_name, + async_logger(const std::string& name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, @@ -52,7 +52,7 @@ public: const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); - async_logger(const std::string& logger_name, + async_logger(const std::string& name, sink_ptr single_sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h index d9a1e424..dabc729b 100644 --- a/include/spdlog/details/async_logger_impl.h +++ b/include/spdlog/details/async_logger_impl.h @@ -17,7 +17,7 @@ #include template -inline spdlog::async_logger::async_logger(const std::string& logger_name, +inline spdlog::async_logger::async_logger(const std::string& name, const It& begin, const It& end, size_t queue_size, @@ -25,28 +25,28 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - logger(logger_name, begin, end), + logger(name, begin, end), _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb)) { } -inline spdlog::async_logger::async_logger(const std::string& logger_name, - sinks_init_list sinks_list, +inline spdlog::async_logger::async_logger(const std::string& name, + sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} + async_logger(name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} -inline spdlog::async_logger::async_logger(const std::string& logger_name, +inline spdlog::async_logger::async_logger(const std::string& name, sink_ptr single_sink, size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - async_logger(logger_name, + async_logger(name, { std::move(single_sink) }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index e2011182..ff62417d 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -14,8 +14,8 @@ // create logger with given name, sinks and the default pattern formatter // all other ctors will call this one template -inline spdlog::logger::logger(std::string logger_name, const It& begin, const It& end): - _name(std::move(logger_name)), +inline spdlog::logger::logger(std::string name, const It& begin, const It& end): + _name(std::move(name)), _sinks(begin, end), _formatter(std::make_shared("%+")), _level(level::info), @@ -30,14 +30,14 @@ inline spdlog::logger::logger(std::string logger_name, const It& begin, const It } // ctor with sinks as init list -inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list): - logger(logger_name, sinks_list.begin(), sinks_list.end()) +inline spdlog::logger::logger(const std::string& name, sinks_init_list sinks): + logger(name, sinks.begin(), sinks.end()) {} // ctor with single sink -inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink): - logger(logger_name, +inline spdlog::logger::logger(const std::string& name, spdlog::sink_ptr single_sink): + logger(name, { std::move(single_sink) }) diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 6af7eb7d..6794bdaf 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -71,9 +71,7 @@ public: std::size_t max_size, std::size_t max_files) : _base_filename(std::move(base_filename)), _max_size(max_size), - _max_files(max_files), - _current_size(0), - _file_helper() + _max_files(max_files) { _file_helper.open(calc_filename(_base_filename, 0)); _current_size = _file_helper.size(); //expensive. called only once From 0c94ce003993a10251ed472d109106f7abe344c2 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 02:43:26 +0100 Subject: [PATCH 32/39] deleted copy op and a little format --- include/spdlog/async_logger.h | 5 ++--- include/spdlog/common.h | 2 +- include/spdlog/details/async_log_helper.h | 4 +++- include/spdlog/details/async_logger_impl.h | 6 +++--- include/spdlog/details/log_msg.h | 2 +- include/spdlog/details/logger_impl.h | 4 ++-- include/spdlog/details/os.h | 4 ++-- .../spdlog/details/pattern_formatter_impl.h | 20 +++++++++---------- include/spdlog/details/registry.h | 6 +++--- include/spdlog/sinks/base_sink.h | 2 +- include/spdlog/sinks/sink.h | 1 + include/spdlog/sinks/wincolor_sink.h | 4 ++-- include/spdlog/spdlog.h | 4 ++-- include/spdlog/tweakme.h | 4 ++-- 14 files changed, 35 insertions(+), 33 deletions(-) diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index c6a69f48..7ddcca25 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -39,7 +39,7 @@ public: const It& begin, const It& end, size_t queue_size, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, + const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); @@ -55,7 +55,7 @@ public: async_logger(const std::string& name, sink_ptr single_sink, size_t queue_size, - const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, + const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); @@ -78,5 +78,4 @@ private: }; } - #include "details/async_logger_impl.h" diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 3a691b34..cbdf5f56 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -87,7 +87,7 @@ enum level_enum }; #if !defined(SPDLOG_LEVEL_NAMES) -#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" } +#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" } #endif static const char* level_names[] SPDLOG_LEVEL_NAMES; diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index d63eebfd..b39b2c10 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -136,6 +136,9 @@ public: // stop logging and join the back thread ~async_log_helper(); + async_log_helper(const async_log_helper&) = delete; + async_log_helper& operator=(const async_log_helper&) = delete; + void set_formatter(formatter_ptr); void flush(bool wait_for_q); @@ -155,7 +158,6 @@ private: bool _terminate_requested; - // overflow policy const async_overflow_policy _overflow_policy; diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h index dabc729b..9f2b2283 100644 --- a/include/spdlog/details/async_logger_impl.h +++ b/include/spdlog/details/async_logger_impl.h @@ -21,7 +21,7 @@ inline spdlog::async_logger::async_logger(const std::string& name, const It& begin, const It& end, size_t queue_size, - const async_overflow_policy overflow_policy, + const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : @@ -33,7 +33,7 @@ inline spdlog::async_logger::async_logger(const std::string& name, inline spdlog::async_logger::async_logger(const std::string& name, sinks_init_list sinks, size_t queue_size, - const async_overflow_policy overflow_policy, + const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : @@ -42,7 +42,7 @@ inline spdlog::async_logger::async_logger(const std::string& name, inline spdlog::async_logger::async_logger(const std::string& name, sink_ptr single_sink, size_t queue_size, - const async_overflow_policy overflow_policy, + const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index 8d39a010..8b441cab 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -31,7 +31,7 @@ struct log_msg #endif } - log_msg(const log_msg& other) = delete; + log_msg(const log_msg& other) = delete; log_msg& operator=(log_msg&& other) = delete; log_msg(log_msg&& other) = delete; diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index ff62417d..0ff1773b 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -21,7 +21,7 @@ inline spdlog::logger::logger(std::string name, const It& begin, const It& end): _level(level::info), _flush_level(level::off), _last_err_time(0), - _msg_counter(1) // message counter will start from 1. 0-message id will be reserved for controll messages + _msg_counter(1) // message counter will start from 1. 0-message id will be reserved for controll messages { _err_handler = [this](const std::string &msg) { @@ -349,7 +349,7 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg) auto tm_time = details::os::localtime(now); char date_buf[100]; std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); - details::log_msg err_msg; + details::log_msg err_msg; err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::default_eol); sinks::stderr_sink_mt::instance()->log(err_msg); _last_err_time = now; diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 6cc42d45..7f8d524f 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -331,12 +331,12 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) inline size_t _thread_id() { #ifdef _WIN32 - return static_cast(::GetCurrentThreadId()); + return static_cast(::GetCurrentThreadId()); #elif __linux__ # if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) # define SYS_gettid __NR_gettid # endif - return static_cast(syscall(SYS_gettid)); + return static_cast(syscall(SYS_gettid)); #elif __FreeBSD__ long tid; thr_self(&tid); diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index dbe07f42..32e7d60d 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -36,7 +36,7 @@ public: /////////////////////////////////////////////////////////////////////// namespace { -class name_formatter:public flag_formatter +class name_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -46,7 +46,7 @@ class name_formatter:public flag_formatter } // log level appender -class level_formatter:public flag_formatter +class level_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -55,7 +55,7 @@ class level_formatter:public flag_formatter }; // short log level appender -class short_level_formatter:public flag_formatter +class short_level_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { @@ -79,7 +79,7 @@ static int to12h(const tm& t) //Abbreviated weekday name static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; -class a_formatter:public flag_formatter +class a_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -89,7 +89,7 @@ class a_formatter:public flag_formatter //Full weekday name static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; -class A_formatter:public flag_formatter +class A_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -98,8 +98,8 @@ class A_formatter:public flag_formatter }; //Abbreviated month -static const std::string months[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec" }; -class b_formatter:public flag_formatter +static const std::string months[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec" }; +class b_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -109,7 +109,7 @@ class b_formatter:public flag_formatter //Full month name static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; -class B_formatter:public flag_formatter +class B_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { @@ -186,7 +186,7 @@ class d_formatter SPDLOG_FINAL : public flag_formatter } }; -// hours in 24 format 0-23 +// hours in 24 format 0-23 class H_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override @@ -195,7 +195,7 @@ class H_formatter SPDLOG_FINAL : public flag_formatter } }; -// hours in 12 format 1-12 +// hours in 12 format 1-12 class I_formatter SPDLOG_FINAL : public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 07881ae0..6bd8bb2d 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -214,9 +214,9 @@ private: bool _async_mode = false; size_t _async_q_size = 0; async_overflow_policy _overflow_policy = async_overflow_policy::block_retry; - std::function _worker_warmup_cb = nullptr; - std::chrono::milliseconds _flush_interval_ms{ 0 }; - std::function _worker_teardown_cb = nullptr; + std::function _worker_warmup_cb; + std::chrono::milliseconds _flush_interval_ms; + std::function _worker_teardown_cb; }; #ifdef SPDLOG_NO_REGISTRY_MUTEX diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h index 63d67445..1d975892 100644 --- a/include/spdlog/sinks/base_sink.h +++ b/include/spdlog/sinks/base_sink.h @@ -25,7 +25,7 @@ template class base_sink : public sink { public: - base_sink():_mutex() {} + base_sink() = default; base_sink(const base_sink&) = delete; base_sink& operator=(const base_sink&) = delete; diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index 770a2d30..ff7a144e 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -15,6 +15,7 @@ class sink { public: virtual ~sink() = default; + virtual void log(const details::log_msg& msg) = 0; virtual void flush() = 0; diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index 0ceb172a..3b4495b0 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -22,7 +22,7 @@ namespace sinks * Windows color console sink. Uses WriteConsoleA to write to the console with colors */ template -class wincolor_sink : public base_sink +class wincolor_sink : public base_sink { public: const WORD BOLD = FOREGROUND_INTENSITY; @@ -50,7 +50,7 @@ public: wincolor_sink(const wincolor_sink& other) = delete; wincolor_sink& operator=(const wincolor_sink& other) = delete; - // change the color for the given level + // change the color for the given level void set_color(level::level_enum level, WORD color) { std::lock_guard lock(base_sink::_mutex); diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 8bfffd01..076833d0 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -56,7 +56,7 @@ void set_error_handler(log_err_handler); // // async_overflow_policy (optional, block_retry by default): // 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. +// async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows. // // worker_warmup_cb (optional): // callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity) @@ -84,7 +84,7 @@ std::shared_ptr rotating_logger_mt(const std::string& logger_name, const std::shared_ptr rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files); // -// Create file logger which creates new file on the given time (default in 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 filename_t& filename, int hour=0, int minute=0); std::shared_ptr daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0); diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h index ad01a09c..c5509622 100644 --- a/include/spdlog/tweakme.h +++ b/include/spdlog/tweakme.h @@ -54,7 +54,7 @@ /////////////////////////////////////////////////////////////////////////////// // Uncomment if logger name logging is not needed. -// This will prevent spdlog from copying the logger name on each log call. +// This will prevent spdlog from copying the logger name on each log call. // // #define SPDLOG_NO_NAME /////////////////////////////////////////////////////////////////////////////// @@ -156,5 +156,5 @@ /////////////////////////////////////////////////////////////////////////////// // Uncomment to customize level names (e.g. "MT TRACE") // -// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" } +// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" } /////////////////////////////////////////////////////////////////////////////// From 17caf77784dc8266732a95171c8ab55c109b7aee Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 12:12:34 +0100 Subject: [PATCH 33/39] google-build-namespaces --- include/spdlog/details/os.h | 4 ++-- include/spdlog/details/pattern_formatter_impl.h | 4 ---- tests/file_helper.cpp | 13 ++----------- 3 files changed, 4 insertions(+), 17 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 7f8d524f..eea83013 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -317,9 +317,9 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) } }; - long int offset_seconds = helper::calculate_gmt_offset(tm); + auto offset_seconds = helper::calculate_gmt_offset(tm); #else - long int offset_seconds = tm.tm_gmtoff; + auto offset_seconds = tm.tm_gmtoff; #endif return static_cast(offset_seconds / 60); diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 32e7d60d..53c96119 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -34,8 +34,6 @@ public: /////////////////////////////////////////////////////////////////////// // name & level pattern appenders /////////////////////////////////////////////////////////////////////// -namespace -{ class name_formatter : public flag_formatter { void format(details::log_msg& msg, const std::tm&) override @@ -43,7 +41,6 @@ class name_formatter : public flag_formatter msg.formatted << *msg.logger_name; } }; -} // log level appender class level_formatter : public flag_formatter @@ -344,7 +341,6 @@ private: int get_cached_offset(const log_msg& msg, const std::tm& tm_time) { - using namespace std::chrono; std::lock_guard l(_mutex); if (msg.time - _last_update >= cache_refresh) { diff --git a/tests/file_helper.cpp b/tests/file_helper.cpp index d127c8f0..f57397eb 100644 --- a/tests/file_helper.cpp +++ b/tests/file_helper.cpp @@ -3,7 +3,8 @@ */ #include "includes.h" -using namespace spdlog::details; +using spdlog::details::log_msg; +using spdlog::details::file_helper; static const std::string target_filename = "logs/file_helper_test.txt"; @@ -15,7 +16,6 @@ static void write_with_helper(file_helper &helper, size_t howmany) helper.flush(); } - TEST_CASE("file_helper_filename", "[file_helper::filename()]]") { prepare_logdir(); @@ -25,8 +25,6 @@ TEST_CASE("file_helper_filename", "[file_helper::filename()]]") REQUIRE(helper.filename() == target_filename); } - - TEST_CASE("file_helper_size", "[file_helper::size()]]") { prepare_logdir(); @@ -40,7 +38,6 @@ TEST_CASE("file_helper_size", "[file_helper::size()]]") REQUIRE(get_filesize(target_filename) == expected_size); } - TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]") { prepare_logdir(); @@ -73,8 +70,6 @@ TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]") REQUIRE(helper.size() == expected_size); } - - static void test_split_ext(const char* fname, const char* expect_base, const char* expect_ext) { spdlog::filename_t filename(fname); @@ -91,7 +86,6 @@ static void test_split_ext(const char* fname, const char* expect_base, const cha REQUIRE(ext == expected_ext); } - TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion()]]") { test_split_ext("mylog.txt", "mylog", ".txt"); @@ -113,6 +107,3 @@ TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion( test_split_ext(".", ".", ""); test_split_ext("..txt", ".", ".txt"); } - - - From 35a843f8b6bd8fa9077bc7bbf3c1baf87c1bd38d Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 12:24:21 +0100 Subject: [PATCH 34/39] modernize-return-braced-init-list --- include/spdlog/sinks/file_sinks.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 6794bdaf..f124117d 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -238,7 +238,7 @@ private: if (rotation_time > now) { return rotation_time; } - return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24)); + return{ rotation_time + std::chrono::hours(24) }; } filename_t _base_filename; From 5355bd3a8fa722268c5338df1cce0591b05a3ab2 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 12:39:37 +0100 Subject: [PATCH 35/39] readability-named-parameter --- include/spdlog/details/async_log_helper.h | 2 +- include/spdlog/logger.h | 38 +++++++++++------------ include/spdlog/spdlog.h | 4 +-- tests/test_misc.cpp | 6 ---- 4 files changed, 22 insertions(+), 28 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index b39b2c10..0dbc107c 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -139,7 +139,7 @@ public: async_log_helper(const async_log_helper&) = delete; async_log_helper& operator=(const async_log_helper&) = delete; - void set_formatter(formatter_ptr); + void set_formatter(formatter_ptr msg_formatter); void flush(bool wait_for_q); diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 8d456b9b..5502d273 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -26,8 +26,9 @@ class logger { public: logger(const std::string& name, sink_ptr single_sink); - logger(const std::string& name, sinks_init_list); - template + logger(const std::string& name, sinks_init_list sinks); + + template logger(std::string name, const It& begin, const It& end); virtual ~logger(); @@ -44,7 +45,6 @@ public: template void error(const char* fmt, const Arg1&, const Args&... args); template void critical(const char* fmt, const Arg1&, const Args&... args); - #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT template void log(level::level_enum lvl, const wchar_t* msg); template void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args); @@ -57,19 +57,19 @@ public: #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT template void log(level::level_enum lvl, const T&); - template void trace(const T&); - template void debug(const T&); - template void info(const T&); - template void warn(const T&); - template void error(const T&); - template void critical(const T&); + template void trace(const T& msg); + template void debug(const T& msg); + template void info(const T& msg); + template void warn(const T& msg); + template void error(const T& msg); + template void critical(const T& msg); - bool should_log(level::level_enum) const; - void set_level(level::level_enum); + bool should_log(level::level_enum msg_level) const; + void set_level(level::level_enum log_level); level::level_enum level() const; const std::string& name() const; - void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local); - void set_formatter(formatter_ptr); + void set_pattern(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local); + void set_formatter(formatter_ptr msg_formatter); // automatically call flush() if message level >= log_level void flush_on(level::level_enum log_level); @@ -79,22 +79,22 @@ public: const std::vector& sinks() const; // error handler - virtual void set_error_handler(log_err_handler); + virtual void set_error_handler(log_err_handler err_handler); virtual log_err_handler error_handler(); protected: - virtual void _sink_it(details::log_msg&); - virtual void _set_pattern(const std::string&, pattern_time_type); - virtual void _set_formatter(formatter_ptr); + virtual void _sink_it(details::log_msg& msg); + virtual void _set_pattern(const std::string& pattern, pattern_time_type pattern_time); + virtual void _set_formatter(formatter_ptr msg_formatter); // default error handler: print the error to stderr with the max rate of 1 message/minute virtual void _default_err_handler(const std::string &msg); // return true if the given message level should trigger a flush - bool _should_flush_on(const details::log_msg&); + bool _should_flush_on(const details::log_msg& msg); // increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)) - void _incr_msg_counter(details::log_msg &msg); + void _incr_msg_counter(details::log_msg& msg); const std::string _name; std::vector _sinks; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 076833d0..8965e59f 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -46,7 +46,7 @@ void flush_on(level::level_enum log_level); // // Set global error handler // -void set_error_handler(log_err_handler); +void set_error_handler(log_err_handler handler); // // Turn on async mode (off by default) and set the queue size for each async_logger. @@ -129,7 +129,7 @@ std::shared_ptr create(const std::string& logger_name, const It& sinks_b // Example: // spdlog::create("mylog", "dailylog_filename"); template -std::shared_ptr create(const std::string& logger_name, Args...); +std::shared_ptr create(const std::string& logger_name, Args... args); // Create and register an async logger with a single sink std::shared_ptr create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); diff --git a/tests/test_misc.cpp b/tests/test_misc.cpp index 4f6ee72c..9afaa932 100644 --- a/tests/test_misc.cpp +++ b/tests/test_misc.cpp @@ -1,4 +1,3 @@ - #include "includes.h" template @@ -16,11 +15,6 @@ std::string log_info(const T& what, spdlog::level::level_enum logger_level = spd return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol)); } - - - - - TEST_CASE("basic_logging ", "[basic_logging]") { //const char From de642b6263e4ffb78e502e46cd8aa553399f159c Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Sun, 25 Feb 2018 12:41:18 +0100 Subject: [PATCH 36/39] astyle applied --- include/spdlog/details/async_log_helper.h | 16 ++++++++-------- include/spdlog/details/file_helper.h | 3 ++- include/spdlog/details/os.h | 14 +++++++------- include/spdlog/details/pattern_formatter_impl.h | 3 ++- include/spdlog/sinks/file_sinks.h | 3 ++- 5 files changed, 21 insertions(+), 18 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 0dbc107c..6faf2f7c 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -64,14 +64,14 @@ class async_log_helper msg_id(0) {} - async_msg(async_msg&& other) SPDLOG_NOEXCEPT : - logger_name(std::move(other.logger_name)), - level(std::move(other.level)), - time(std::move(other.time)), - thread_id(other.thread_id), - txt(std::move(other.txt)), - msg_type(std::move(other.msg_type)), - msg_id(other.msg_id) +async_msg(async_msg&& other) SPDLOG_NOEXCEPT : + logger_name(std::move(other.logger_name)), + level(std::move(other.level)), + time(std::move(other.time)), + thread_id(other.thread_id), + txt(std::move(other.txt)), + msg_type(std::move(other.msg_type)), + msg_id(other.msg_id) {} async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index 996b7b2d..d7ccf59b 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -90,7 +90,8 @@ public: size_t size() const { - if (_fd == nullptr) { + if (_fd == nullptr) + { throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename)); } return os::filesize(_fd); diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index eea83013..dc9ef5b3 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -81,10 +81,10 @@ inline std::tm localtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm{}; + std::tm tm {}; localtime_s(&tm, &time_tt); #else - std::tm tm{}; + std::tm tm {}; localtime_r(&time_tt, &tm); #endif return tm; @@ -100,10 +100,10 @@ inline std::tm gmtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm{}; + std::tm tm {}; gmtime_s(&tm, &time_tt); #else - std::tm tm{}; + std::tm tm {}; gmtime_r(&time_tt, &tm); #endif return tm; @@ -219,7 +219,7 @@ inline bool file_exists(const filename_t& filename) #endif return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)); #else //common linux/unix all have the stat system call - struct stat buffer{}; + struct stat buffer {}; return (stat(filename.c_str(), &buffer) == 0); #endif } @@ -249,11 +249,11 @@ inline size_t filesize(FILE *f) int fd = fileno(f); //64 bits(but not in osx or cygwin, where fstat64 is deprecated) #if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) - struct stat64 st{}; + struct stat64 st {}; if (fstat64(fd, &st) == 0) return static_cast(st.st_size); #else // unix 32 bits or cygwin - struct stat st{}; + struct stat st {}; if (fstat(fd, &st) == 0) return static_cast(st.st_size); #endif diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 53c96119..b5ee6d02 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -648,7 +648,8 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg) { - if (_pattern_time == pattern_time_type::local) { + if (_pattern_time == pattern_time_type::local) + { return details::os::localtime(log_clock::to_time_t(msg.time)); } return details::os::gmtime(log_clock::to_time_t(msg.time)); diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index f124117d..39f7b7bb 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -235,7 +235,8 @@ private: 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) { + if (rotation_time > now) + { return rotation_time; } return{ rotation_time + std::chrono::hours(24) }; From 84d3c90b93afd52a7ba3d659d144b996a36fa82b Mon Sep 17 00:00:00 2001 From: gabime Date: Wed, 28 Feb 2018 00:11:50 +0200 Subject: [PATCH 37/39] Fixed g++ 4.9 warnings after the clang-tidy fixes --- include/spdlog/async_logger.h | 6 +++--- include/spdlog/details/async_logger_impl.h | 14 +++++++------- include/spdlog/details/logger_impl.h | 12 ++++++------ include/spdlog/details/os.h | 14 +++++++------- 4 files changed, 23 insertions(+), 23 deletions(-) diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index 7ddcca25..be577a3b 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -35,7 +35,7 @@ class async_logger SPDLOG_FINAL : public logger { public: template - async_logger(const std::string& name, + async_logger(const std::string& logger_name, const It& begin, const It& end, size_t queue_size, @@ -44,7 +44,7 @@ public: const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); - async_logger(const std::string& name, + async_logger(const std::string& logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, @@ -52,7 +52,7 @@ public: const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function& worker_teardown_cb = nullptr); - async_logger(const std::string& name, + async_logger(const std::string& logger_name, sink_ptr single_sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h index 9f2b2283..72bd4f98 100644 --- a/include/spdlog/details/async_logger_impl.h +++ b/include/spdlog/details/async_logger_impl.h @@ -17,7 +17,7 @@ #include template -inline spdlog::async_logger::async_logger(const std::string& name, +inline spdlog::async_logger::async_logger(const std::string& logger_name, const It& begin, const It& end, size_t queue_size, @@ -25,28 +25,28 @@ inline spdlog::async_logger::async_logger(const std::string& name, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - logger(name, begin, end), + logger(logger_name, begin, end), _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb)) { } -inline spdlog::async_logger::async_logger(const std::string& name, - sinks_init_list sinks, +inline spdlog::async_logger::async_logger(const std::string& logger_name, + sinks_init_list sinks_list, size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - async_logger(name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} + async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} -inline spdlog::async_logger::async_logger(const std::string& name, +inline spdlog::async_logger::async_logger(const std::string& logger_name, sink_ptr single_sink, size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) : - async_logger(name, + async_logger(logger_name, { std::move(single_sink) }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {} diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index 0ff1773b..11cbc7e4 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -14,8 +14,8 @@ // create logger with given name, sinks and the default pattern formatter // all other ctors will call this one template -inline spdlog::logger::logger(std::string name, const It& begin, const It& end): - _name(std::move(name)), +inline spdlog::logger::logger(std::string logger_name, const It& begin, const It& end): + _name(std::move(logger_name)), _sinks(begin, end), _formatter(std::make_shared("%+")), _level(level::info), @@ -30,14 +30,14 @@ inline spdlog::logger::logger(std::string name, const It& begin, const It& end): } // ctor with sinks as init list -inline spdlog::logger::logger(const std::string& name, sinks_init_list sinks): - logger(name, sinks.begin(), sinks.end()) +inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list): + logger(logger_name, sinks_list.begin(), sinks_list.end()) {} // ctor with single sink -inline spdlog::logger::logger(const std::string& name, spdlog::sink_ptr single_sink): - logger(name, +inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink): + logger(logger_name, { std::move(single_sink) }) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index dc9ef5b3..4de7b9f8 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -81,10 +81,10 @@ inline std::tm localtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm {}; + std::tm tm; localtime_s(&tm, &time_tt); #else - std::tm tm {}; + std::tm tm; localtime_r(&time_tt, &tm); #endif return tm; @@ -100,10 +100,10 @@ inline std::tm gmtime(const std::time_t &time_tt) { #ifdef _WIN32 - std::tm tm {}; + std::tm tm; gmtime_s(&tm, &time_tt); #else - std::tm tm {}; + std::tm tm; gmtime_r(&time_tt, &tm); #endif return tm; @@ -219,7 +219,7 @@ inline bool file_exists(const filename_t& filename) #endif return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)); #else //common linux/unix all have the stat system call - struct stat buffer {}; + struct stat buffer; return (stat(filename.c_str(), &buffer) == 0); #endif } @@ -249,11 +249,11 @@ inline size_t filesize(FILE *f) int fd = fileno(f); //64 bits(but not in osx or cygwin, where fstat64 is deprecated) #if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__) - struct stat64 st {}; + struct stat64 st ; if (fstat64(fd, &st) == 0) return static_cast(st.st_size); #else // unix 32 bits or cygwin - struct stat st {}; + struct stat st; if (fstat(fd, &st) == 0) return static_cast(st.st_size); #endif From d044369e3b4e064f9e67d99c8c8cb1bbc6ecfc86 Mon Sep 17 00:00:00 2001 From: Thiago Bastos Date: Mon, 5 Mar 2018 20:00:48 +0100 Subject: [PATCH 38/39] Fix implicit conversion warnings (-Wsign-conversion) --- include/spdlog/sinks/syslog_sink.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index 98fad055..d1ffc5c8 100644 --- a/include/spdlog/sinks/syslog_sink.h +++ b/include/spdlog/sinks/syslog_sink.h @@ -33,13 +33,13 @@ public: syslog_sink(const std::string& ident = "", int syslog_option=0, int syslog_facility=LOG_USER): _ident(ident) { - _priorities[static_cast(level::trace)] = LOG_DEBUG; - _priorities[static_cast(level::debug)] = LOG_DEBUG; - _priorities[static_cast(level::info)] = LOG_INFO; - _priorities[static_cast(level::warn)] = LOG_WARNING; - _priorities[static_cast(level::err)] = LOG_ERR; - _priorities[static_cast(level::critical)] = LOG_CRIT; - _priorities[static_cast(level::off)] = LOG_INFO; + _priorities[static_cast(level::trace)] = LOG_DEBUG; + _priorities[static_cast(level::debug)] = LOG_DEBUG; + _priorities[static_cast(level::info)] = LOG_INFO; + _priorities[static_cast(level::warn)] = LOG_WARNING; + _priorities[static_cast(level::err)] = LOG_ERR; + _priorities[static_cast(level::critical)] = LOG_CRIT; + _priorities[static_cast(level::off)] = LOG_INFO; //set ident to be program name if empty ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility); @@ -73,7 +73,7 @@ private: // int syslog_prio_from_level(const details::log_msg &msg) const { - return _priorities[static_cast(msg.level)]; + return _priorities[static_cast(msg.level)]; } }; } From e8a39c894ffbb3e03328278e4be7a106a31a433e Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Tue, 6 Mar 2018 10:31:36 +0200 Subject: [PATCH 39/39] Update test_pattern_formatter.cpp --- tests/test_pattern_formatter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp index b8810c96..51b0f35d 100644 --- a/tests/test_pattern_formatter.cpp +++ b/tests/test_pattern_formatter.cpp @@ -56,6 +56,6 @@ TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") auto formatter = std::make_shared("%D %v", spdlog::pattern_time_type::local, "\n"); auto now_tm = spdlog::details::os::localtime(); std::stringstream oss; - oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; + oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << std::setw(2) << now_tm.tm_mday << "/" << std::setw(2) << (now_tm.tm_year + 1900) % 1000 << " Some message\n"; REQUIRE(log_to_str("Some message", formatter) == oss.str()); }