From 559bcf088f9425708cf93f15db584b03e52d799d Mon Sep 17 00:00:00 2001 From: Aurumaker72 Date: Thu, 2 Jan 2025 15:33:25 +0100 Subject: [PATCH] Lib/Dev: Unformat contents of lib directory Messed up by initial formatting pass --- lib/argh.h | 880 +-- lib/ini.h | 67 +- lib/libdeflate-x64/libdeflate.h | 184 +- lib/libdeflate/libdeflate.h | 130 +- lib/lua-x64/include/lauxlib.h | 234 +- lib/lua-x64/include/lua.h | 549 +- lib/lua-x64/include/lua.hpp | 2 +- lib/lua-x64/include/luaconf.h | 388 +- lib/lua-x64/include/lualib.h | 51 +- lib/lua/include/lauxlib.h | 234 +- lib/lua/include/lua.h | 549 +- lib/lua/include/lua.hpp | 2 +- lib/lua/include/luaconf.h | 388 +- lib/lua/include/lualib.h | 51 +- lib/md5.c | 130 +- lib/md5.h | 29 +- lib/microlru.h | 226 +- lib/spdlog/async.h | 133 +- lib/spdlog/async_logger-inl.h | 55 +- lib/spdlog/async_logger.h | 79 +- lib/spdlog/cfg/argv.h | 39 +- lib/spdlog/cfg/env.h | 29 +- lib/spdlog/cfg/helpers-inl.h | 175 +- lib/spdlog/cfg/helpers.h | 40 +- lib/spdlog/common-inl.h | 79 +- lib/spdlog/common.h | 570 +- lib/spdlog/details/backtracer-inl.h | 123 +- lib/spdlog/details/backtracer.h | 56 +- lib/spdlog/details/circular_q.h | 219 +- lib/spdlog/details/console_globals.h | 40 +- lib/spdlog/details/file_helper-inl.h | 275 +- lib/spdlog/details/file_helper.h | 102 +- lib/spdlog/details/fmt_helper.h | 245 +- lib/spdlog/details/log_msg-inl.h | 55 +- lib/spdlog/details/log_msg.h | 50 +- lib/spdlog/details/log_msg_buffer-inl.h | 94 +- lib/spdlog/details/log_msg_buffer.h | 46 +- lib/spdlog/details/mpmc_blocking_q.h | 322 +- lib/spdlog/details/null_mutex.h | 54 +- lib/spdlog/details/os-inl.h | 988 ++- lib/spdlog/details/os.h | 153 +- lib/spdlog/details/periodic_worker-inl.h | 32 +- lib/spdlog/details/periodic_worker.h | 79 +- lib/spdlog/details/registry-inl.h | 517 +- lib/spdlog/details/registry.h | 168 +- lib/spdlog/details/synchronous_factory.h | 28 +- lib/spdlog/details/tcp_client-windows.h | 229 +- lib/spdlog/details/tcp_client.h | 196 +- lib/spdlog/details/thread_pool-inl.h | 232 +- lib/spdlog/details/thread_pool.h | 177 +- lib/spdlog/details/udp_client-windows.h | 165 +- lib/spdlog/details/udp_client.h | 124 +- lib/spdlog/details/windows_include.h | 4 +- lib/spdlog/fmt/bin_to_hex.h | 283 +- lib/spdlog/fmt/bundled/args.h | 391 +- lib/spdlog/fmt/bundled/chrono.h | 4158 ++++++----- lib/spdlog/fmt/bundled/color.h | 984 +-- lib/spdlog/fmt/bundled/compile.h | 917 ++- lib/spdlog/fmt/bundled/core.h | 4715 ++++++------ lib/spdlog/fmt/bundled/format-inl.h | 2446 ++++--- lib/spdlog/fmt/bundled/format.h | 7941 ++++++++++----------- lib/spdlog/fmt/bundled/os.h | 518 +- lib/spdlog/fmt/bundled/ostream.h | 324 +- lib/spdlog/fmt/bundled/printf.h | 1207 ++-- lib/spdlog/fmt/bundled/ranges.h | 1109 +-- lib/spdlog/fmt/bundled/std.h | 788 +- lib/spdlog/fmt/bundled/xchar.h | 283 +- lib/spdlog/fmt/chrono.h | 20 +- lib/spdlog/fmt/compile.h | 20 +- lib/spdlog/fmt/fmt.h | 27 +- lib/spdlog/fmt/ostr.h | 20 +- lib/spdlog/fmt/ranges.h | 20 +- lib/spdlog/fmt/std.h | 20 +- lib/spdlog/fmt/xchar.h | 20 +- lib/spdlog/formatter.h | 17 +- lib/spdlog/fwd.h | 23 +- lib/spdlog/logger-inl.h | 315 +- lib/spdlog/logger.h | 611 +- lib/spdlog/mdc.h | 62 +- lib/spdlog/pattern_formatter-inl.h | 2098 +++--- lib/spdlog/pattern_formatter.h | 183 +- lib/spdlog/sinks/android_sink.h | 260 +- lib/spdlog/sinks/ansicolor_sink-inl.h | 253 +- lib/spdlog/sinks/ansicolor_sink.h | 200 +- lib/spdlog/sinks/base_sink-inl.h | 33 +- lib/spdlog/sinks/base_sink.h | 68 +- lib/spdlog/sinks/basic_file_sink-inl.h | 65 +- lib/spdlog/sinks/basic_file_sink.h | 92 +- lib/spdlog/sinks/callback_sink.h | 89 +- lib/spdlog/sinks/daily_file_sink.h | 412 +- lib/spdlog/sinks/dist_sink.h | 135 +- lib/spdlog/sinks/dup_filter_sink.h | 117 +- lib/spdlog/sinks/hourly_file_sink.h | 323 +- lib/spdlog/sinks/kafka_sink.h | 180 +- lib/spdlog/sinks/mongo_sink.h | 147 +- lib/spdlog/sinks/msvc_sink.h | 101 +- lib/spdlog/sinks/null_sink.h | 64 +- lib/spdlog/sinks/ostream_sink.h | 66 +- lib/spdlog/sinks/qt_sinks.h | 501 +- lib/spdlog/sinks/ringbuffer_sink.h | 95 +- lib/spdlog/sinks/rotating_file_sink-inl.h | 246 +- lib/spdlog/sinks/rotating_file_sink.h | 112 +- lib/spdlog/sinks/sink-inl.h | 14 +- lib/spdlog/sinks/sink.h | 48 +- lib/spdlog/sinks/stdout_color_sinks-inl.h | 55 +- lib/spdlog/sinks/stdout_color_sinks.h | 52 +- lib/spdlog/sinks/stdout_sinks-inl.h | 216 +- lib/spdlog/sinks/stdout_sinks.h | 102 +- lib/spdlog/sinks/syslog_sink.h | 173 +- lib/spdlog/sinks/systemd_sink.h | 198 +- lib/spdlog/sinks/tcp_sink.h | 89 +- lib/spdlog/sinks/udp_sink.h | 78 +- lib/spdlog/sinks/win_eventlog_sink.h | 447 +- lib/spdlog/sinks/wincolor_sink-inl.h | 317 +- lib/spdlog/sinks/wincolor_sink.h | 129 +- lib/spdlog/spdlog-inl.h | 84 +- lib/spdlog/spdlog.h | 577 +- lib/spdlog/stopwatch.h | 61 +- lib/spdlog/tweakme.h | 10 +- lib/speex/arch.h | 140 +- lib/speex/speex_resampler.c | 363 +- lib/speex/speex_resampler.h | 176 +- lib/xxhash/xxh64.h | 80 +- lib/zlib-x64/zconf.h | 722 +- lib/zlib-x64/zlib.h | 434 +- lib/zlib/zconf.h | 386 +- lib/zlib/zlib.h | 287 +- 127 files changed, 24575 insertions(+), 23808 deletions(-) diff --git a/lib/argh.h b/lib/argh.h index 77c72730..00b71a5e 100644 --- a/lib/argh.h +++ b/lib/argh.h @@ -1,461 +1,485 @@ #pragma once #include -#include -#include -#include -#include #include +#include #include #include +#include +#include +#include namespace argh { - // Terminology: - // A command line is composed of 2 types of args: - // 1. Positional args, i.e. free standing values - // 2. Options: args beginning with '-'. We identify two kinds: - // 2.1: Flags: boolean options => (exist ? true : false) - // 2.2: Parameters: a name followed by a non-option value + // Terminology: + // A command line is composed of 2 types of args: + // 1. Positional args, i.e. free standing values + // 2. Options: args beginning with '-'. We identify two kinds: + // 2.1: Flags: boolean options => (exist ? true : false) + // 2.2: Parameters: a name followed by a non-option value #if !defined(__GNUC__) || (__GNUC__ >= 5) - using string_stream = std::istringstream; + using string_stream = std::istringstream; #else // Until GCC 5, istringstream did not have a move constructor. // stringstream_proxy is used instead, as a workaround. - class stringstream_proxy { - public: - stringstream_proxy() = default; - - // Construct with a value. - stringstream_proxy(std::string const& value) : stream_(value) {} - - // Copy constructor. - stringstream_proxy(const stringstream_proxy& other) : stream_(other.stream_.str()) { stream_.setstate(other.stream_.rdstate()); } - - void setstate(std::ios_base::iostate state) { stream_.setstate(state); } - - // Stream out the value of the parameter. - // If the conversion was not possible, the stream will enter the fail state, - // and operator bool will return false. - template - stringstream_proxy& operator>>(T& thing) - { - stream_ >> thing; - return *this; - } - - // Get the string value. - std::string str() const { return stream_.str(); } - - std::stringbuf* rdbuf() const { return stream_.rdbuf(); } - - // Check the state of the stream. - // False when the most recent stream operation failed - explicit operator bool() const { return !!stream_; } - - ~stringstream_proxy() = default; - - private: - std::istringstream stream_; - }; - using string_stream = stringstream_proxy; + class stringstream_proxy + { + public: + stringstream_proxy() = default; + + // Construct with a value. + stringstream_proxy(std::string const& value) : + stream_(value) + {} + + // Copy constructor. + stringstream_proxy(const stringstream_proxy& other) : + stream_(other.stream_.str()) + { + stream_.setstate(other.stream_.rdstate()); + } + + void setstate(std::ios_base::iostate state) { stream_.setstate(state); } + + // Stream out the value of the parameter. + // If the conversion was not possible, the stream will enter the fail state, + // and operator bool will return false. + template + stringstream_proxy& operator >> (T& thing) + { + stream_ >> thing; + return *this; + } + + + // Get the string value. + std::string str() const { return stream_.str(); } + + std::stringbuf* rdbuf() const { return stream_.rdbuf(); } + + // Check the state of the stream. + // False when the most recent stream operation failed + explicit operator bool() const { return !!stream_; } + + ~stringstream_proxy() = default; + private: + std::istringstream stream_; + }; + using string_stream = stringstream_proxy; #endif - class multimap_iteration_wrapper { - public: - using container_t = std::multimap; - using iterator_t = container_t::const_iterator; - using difference_t = container_t::difference_type; - explicit multimap_iteration_wrapper(const iterator_t& lb, const iterator_t& ub) : lb_(lb), ub_(ub) {} - - iterator_t begin() const { return lb_; } - iterator_t end() const { return ub_; } - difference_t size() const { return std::distance(lb_, ub_); } - - private: - iterator_t lb_; - iterator_t ub_; - }; - - class parser { - public: - enum Mode { - PREFER_FLAG_FOR_UNREG_OPTION = 1 << 0, - PREFER_PARAM_FOR_UNREG_OPTION = 1 << 1, - NO_SPLIT_ON_EQUALSIGN = 1 << 2, - SINGLE_DASH_IS_MULTIFLAG = 1 << 3, - }; - - parser() = default; - - parser(std::initializer_list pre_reg_names) { add_params(pre_reg_names); } - - parser(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION) { parse(argv, mode); } - - parser(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION) { parse(argc, argv, mode); } - - void add_param(std::string const& name); - void add_params(std::string const& name); - - void add_param(std::initializer_list init_list); - void add_params(std::initializer_list init_list); - - void parse(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION); - void parse(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION); - - std::multiset const& flags() const { return flags_; } - std::multimap const& params() const { return params_; } - multimap_iteration_wrapper params(std::string const& name) const; - std::vector const& pos_args() const { return pos_args_; } - - // begin() and end() for using range-for over positional args. - std::vector::const_iterator begin() const { return pos_args_.cbegin(); } - std::vector::const_iterator end() const { return pos_args_.cend(); } - size_t size() const { return pos_args_.size(); } - - ////////////////////////////////////////////////////////////////////////// - // Accessors - - // flag (boolean) accessors: return true if the flag appeared, otherwise - // false. - bool operator[](std::string const& name) const; - - // multiple flag (boolean) accessors: return true if at least one of the flag - // appeared, otherwise false. - bool operator[](std::initializer_list init_list) const; - - // returns positional arg string by order. Like argv[] but without the options - std::string const& operator[](size_t ind) const; - - // returns a std::istream that can be used to convert a positional arg to a - // typed value. - string_stream operator()(size_t ind) const; - - // same as above, but with a default value in case the arg is missing (index - // out of range). - template - string_stream operator()(size_t ind, T&& def_val) const; - - // parameter accessors, give a name get an std::istream that can be used to - // convert to a typed value. call .str() on result to get as string - string_stream operator()(std::string const& name) const; - - // accessor for a parameter with multiple names, give a list of names, get an - // std::istream that can be used to convert to a typed value. call .str() on - // result to get as string returns the first value in the list to be found. - string_stream operator()(std::initializer_list init_list) const; - - // same as above, but with a default value in case the param was missing. - // Non-string def_val types must have an operator<<() (output stream operator) - // If T only has an input stream operator, pass the string version of the type - // as in "3" instead of 3. - template - string_stream operator()(std::string const& name, T&& def_val) const; - - // same as above but for a list of names. returns the first value to be found. - template - string_stream operator()(std::initializer_list init_list, T&& def_val) const; - - private: - string_stream bad_stream() const; - std::string trim_leading_dashes(std::string const& name) const; - bool is_number(std::string const& arg) const; - bool is_option(std::string const& arg) const; - bool got_flag(std::string const& name) const; - bool is_param(std::string const& name) const; - - private: - std::vector args_; - std::multimap params_; - std::vector pos_args_; - std::multiset flags_; - std::set registeredParams_; - std::string empty_; - }; - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::parse(const char* const argv[], int mode) - { - int argc = 0; - for (auto argvp = argv; *argvp; ++argc, ++argvp) - ; - parse(argc, argv, mode); - } - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::parse(int argc, const char* const argv[], int mode /*= PREFER_FLAG_FOR_UNREG_OPTION*/) - { - // clear out possible previous parsing remnants - flags_.clear(); - params_.clear(); - pos_args_.clear(); - - // convert to strings - args_.resize(static_cast(argc)); - std::transform(argv, argv + argc, args_.begin(), [](const char* const arg) { return arg; }); - - // parse line - for (auto i = 0u; i < args_.size(); ++i) - { - if (!is_option(args_[i])) + class multimap_iteration_wrapper + { + public: + using container_t = std::multimap; + using iterator_t = container_t::const_iterator; + using difference_t = container_t::difference_type; + explicit multimap_iteration_wrapper(const iterator_t& lb, const iterator_t& ub) + : lb_(lb) + , ub_(ub) + {} + + iterator_t begin() const { return lb_; } + iterator_t end() const { return ub_; } + difference_t size() const { return std::distance(lb_, ub_); } + + private: + iterator_t lb_; + iterator_t ub_; + }; + + class parser + { + public: + enum Mode { PREFER_FLAG_FOR_UNREG_OPTION = 1 << 0, + PREFER_PARAM_FOR_UNREG_OPTION = 1 << 1, + NO_SPLIT_ON_EQUALSIGN = 1 << 2, + SINGLE_DASH_IS_MULTIFLAG = 1 << 3, + }; + + parser() = default; + + parser(std::initializer_list pre_reg_names) + { add_params(pre_reg_names); } + + parser(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION) + { parse(argv, mode); } + + parser(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION) + { parse(argc, argv, mode); } + + void add_param(std::string const& name); + void add_params(std::string const& name); + + void add_param(std::initializer_list init_list); + void add_params(std::initializer_list init_list); + + void parse(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION); + void parse(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION); + + std::multiset const& flags() const { return flags_; } + std::multimap const& params() const { return params_; } + multimap_iteration_wrapper params(std::string const& name) const; + std::vector const& pos_args() const { return pos_args_; } + + // begin() and end() for using range-for over positional args. + std::vector::const_iterator begin() const { return pos_args_.cbegin(); } + std::vector::const_iterator end() const { return pos_args_.cend(); } + size_t size() const { return pos_args_.size(); } + + ////////////////////////////////////////////////////////////////////////// + // Accessors + + // flag (boolean) accessors: return true if the flag appeared, otherwise false. + bool operator[](std::string const& name) const; + + // multiple flag (boolean) accessors: return true if at least one of the flag appeared, otherwise false. + bool operator[](std::initializer_list init_list) const; + + // returns positional arg string by order. Like argv[] but without the options + std::string const& operator[](size_t ind) const; + + // returns a std::istream that can be used to convert a positional arg to a typed value. + string_stream operator()(size_t ind) const; + + // same as above, but with a default value in case the arg is missing (index out of range). + template + string_stream operator()(size_t ind, T&& def_val) const; + + // parameter accessors, give a name get an std::istream that can be used to convert to a typed value. + // call .str() on result to get as string + string_stream operator()(std::string const& name) const; + + // accessor for a parameter with multiple names, give a list of names, get an std::istream that can be used to convert to a typed value. + // call .str() on result to get as string + // returns the first value in the list to be found. + string_stream operator()(std::initializer_list init_list) const; + + // same as above, but with a default value in case the param was missing. + // Non-string def_val types must have an operator<<() (output stream operator) + // If T only has an input stream operator, pass the string version of the type as in "3" instead of 3. + template + string_stream operator()(std::string const& name, T&& def_val) const; + + // same as above but for a list of names. returns the first value to be found. + template + string_stream operator()(std::initializer_list init_list, T&& def_val) const; + + private: + string_stream bad_stream() const; + std::string trim_leading_dashes(std::string const& name) const; + bool is_number(std::string const& arg) const; + bool is_option(std::string const& arg) const; + bool got_flag(std::string const& name) const; + bool is_param(std::string const& name) const; + + private: + std::vector args_; + std::multimap params_; + std::vector pos_args_; + std::multiset flags_; + std::set registeredParams_; + std::string empty_; + }; + + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::parse(const char * const argv[], int mode) + { + int argc = 0; + for (auto argvp = argv; *argvp; ++argc, ++argvp); + parse(argc, argv, mode); + } + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::parse(int argc, const char* const argv[], int mode /*= PREFER_FLAG_FOR_UNREG_OPTION*/) + { + // clear out possible previous parsing remnants + flags_.clear(); + params_.clear(); + pos_args_.clear(); + + // convert to strings + args_.resize(static_cast(argc)); + std::transform(argv, argv + argc, args_.begin(), [](const char* const arg) { return arg; }); + + // parse line + for (auto i = 0u; i < args_.size(); ++i) + { + if (!is_option(args_[i])) + { + pos_args_.emplace_back(args_[i]); + continue; + } + + auto name = trim_leading_dashes(args_[i]); + + if (!(mode & NO_SPLIT_ON_EQUALSIGN)) + { + auto equalPos = name.find('='); + if (equalPos != std::string::npos) { - pos_args_.emplace_back(args_[i]); - continue; + params_.insert({ name.substr(0, equalPos), name.substr(equalPos + 1) }); + continue; } + } - auto name = trim_leading_dashes(args_[i]); - - if (!(mode & NO_SPLIT_ON_EQUALSIGN)) - { - auto equalPos = name.find('='); - if (equalPos != std::string::npos) - { - params_.insert({name.substr(0, equalPos), name.substr(equalPos + 1)}); - continue; - } - } + // if the option is unregistered and should be a multi-flag + if (1 == (args_[i].size() - name.size()) && // single dash + argh::parser::SINGLE_DASH_IS_MULTIFLAG & mode && // multi-flag mode + !is_param(name)) // unregistered + { + std::string keep_param; - // if the option is unregistered and should be a multi-flag - if (1 == (args_[i].size() - name.size()) && // single dash - argh::parser::SINGLE_DASH_IS_MULTIFLAG & mode && // multi-flag mode - !is_param(name)) // unregistered + if (!name.empty() && is_param(std::string(1ul, name.back()))) // last char is param { - std::string keep_param; - - if (!name.empty() && is_param(std::string(1ul, name.back()))) // last char is param - { - keep_param += name.back(); - name.resize(name.size() - 1); - } - - for (auto const& c : name) - { - flags_.emplace(std::string{c}); - } - - if (!keep_param.empty()) - { - name = keep_param; - } - else - { - continue; // do not consider other options for this arg - } + keep_param += name.back(); + name.resize(name.size() - 1); } - // any potential option will get as its value the next arg, unless that arg - // is an option too in that case it will be determined a flag. - if (i == args_.size() - 1 || is_option(args_[i + 1])) + for (auto const& c : name) { - flags_.emplace(name); - continue; + flags_.emplace(std::string{ c }); } - // if 'name' is a pre-registered option, then the next arg cannot be a free - // parameter to it is skipped otherwise we have 2 modes: - // PREFER_FLAG_FOR_UNREG_OPTION: a non-registered 'name' is determined a - // flag. - // The following value (the next arg) will be - // a free parameter. - // - // PREFER_PARAM_FOR_UNREG_OPTION: a non-registered 'name' is determined a - // parameter, the next arg - // will be the value of that option. - - assert(!(mode & argh::parser::PREFER_FLAG_FOR_UNREG_OPTION) || !(mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION)); - - bool preferParam = mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION; - - if (is_param(name) || preferParam) + if (!keep_param.empty()) { - params_.insert({name, args_[i + 1]}); - ++i; // skip next value, it is not a free parameter - continue; + name = keep_param; } else { - flags_.emplace(name); + continue; // do not consider other options for this arg } - } - } - - ////////////////////////////////////////////////////////////////////////// - - inline string_stream parser::bad_stream() const - { - string_stream bad; - bad.setstate(std::ios_base::failbit); - return bad; - } - - ////////////////////////////////////////////////////////////////////////// - - inline bool parser::is_number(std::string const& arg) const - { - // inefficient but simple way to determine if a string is a number (which can - // start with a '-') - std::istringstream istr(arg); - double number; - istr >> number; - return !(istr.fail() || istr.bad()); - } - - ////////////////////////////////////////////////////////////////////////// - - inline bool parser::is_option(std::string const& arg) const - { - assert(0 != arg.size()); - if (is_number(arg)) - return false; - return '-' == arg[0]; - } - - ////////////////////////////////////////////////////////////////////////// - - inline std::string parser::trim_leading_dashes(std::string const& name) const - { - auto pos = name.find_first_not_of('-'); - return std::string::npos != pos ? name.substr(pos) : name; - } - - ////////////////////////////////////////////////////////////////////////// - - inline bool argh::parser::got_flag(std::string const& name) const { return flags_.end() != flags_.find(trim_leading_dashes(name)); } - - ////////////////////////////////////////////////////////////////////////// - - inline bool argh::parser::is_param(std::string const& name) const { return registeredParams_.count(name); } - - ////////////////////////////////////////////////////////////////////////// - - inline bool parser::operator[](std::string const& name) const { return got_flag(name); } - - ////////////////////////////////////////////////////////////////////////// - - inline bool parser::operator[](std::initializer_list init_list) const - { - return std::any_of(init_list.begin(), init_list.end(), [&](char const* const name) { return got_flag(name); }); - } - - ////////////////////////////////////////////////////////////////////////// - - inline std::string const& parser::operator[](size_t ind) const - { - if (ind < pos_args_.size()) - return pos_args_[ind]; - return empty_; - } - - ////////////////////////////////////////////////////////////////////////// - - inline string_stream parser::operator()(std::string const& name) const - { - auto optIt = params_.find(trim_leading_dashes(name)); - if (params_.end() != optIt) + } + + // any potential option will get as its value the next arg, unless that arg is an option too + // in that case it will be determined a flag. + if (i == args_.size() - 1 || is_option(args_[i + 1])) + { + flags_.emplace(name); + continue; + } + + // if 'name' is a pre-registered option, then the next arg cannot be a free parameter to it is skipped + // otherwise we have 2 modes: + // PREFER_FLAG_FOR_UNREG_OPTION: a non-registered 'name' is determined a flag. + // The following value (the next arg) will be a free parameter. + // + // PREFER_PARAM_FOR_UNREG_OPTION: a non-registered 'name' is determined a parameter, the next arg + // will be the value of that option. + + assert(!(mode & argh::parser::PREFER_FLAG_FOR_UNREG_OPTION) + || !(mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION)); + + bool preferParam = mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION; + + if (is_param(name) || preferParam) + { + params_.insert({ name, args_[i + 1] }); + ++i; // skip next value, it is not a free parameter + continue; + } + else + { + flags_.emplace(name); + } + } + } + + ////////////////////////////////////////////////////////////////////////// + + inline string_stream parser::bad_stream() const + { + string_stream bad; + bad.setstate(std::ios_base::failbit); + return bad; + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool parser::is_number(std::string const& arg) const + { + // inefficient but simple way to determine if a string is a number (which can start with a '-') + std::istringstream istr(arg); + double number; + istr >> number; + return !(istr.fail() || istr.bad()); + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool parser::is_option(std::string const& arg) const + { + assert(0 != arg.size()); + if (is_number(arg)) + return false; + return '-' == arg[0]; + } + + ////////////////////////////////////////////////////////////////////////// + + inline std::string parser::trim_leading_dashes(std::string const& name) const + { + auto pos = name.find_first_not_of('-'); + return std::string::npos != pos ? name.substr(pos) : name; + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool argh::parser::got_flag(std::string const& name) const + { + return flags_.end() != flags_.find(trim_leading_dashes(name)); + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool argh::parser::is_param(std::string const& name) const + { + return registeredParams_.count(name); + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool parser::operator[](std::string const& name) const + { + return got_flag(name); + } + + ////////////////////////////////////////////////////////////////////////// + + inline bool parser::operator[](std::initializer_list init_list) const + { + return std::any_of(init_list.begin(), init_list.end(), [&](char const* const name) { return got_flag(name); }); + } + + ////////////////////////////////////////////////////////////////////////// + + inline std::string const& parser::operator[](size_t ind) const + { + if (ind < pos_args_.size()) + return pos_args_[ind]; + return empty_; + } + + ////////////////////////////////////////////////////////////////////////// + + inline string_stream parser::operator()(std::string const& name) const + { + auto optIt = params_.find(trim_leading_dashes(name)); + if (params_.end() != optIt) + return string_stream(optIt->second); + return bad_stream(); + } + + ////////////////////////////////////////////////////////////////////////// + + inline string_stream parser::operator()(std::initializer_list init_list) const + { + for (auto& name : init_list) + { + auto optIt = params_.find(trim_leading_dashes(name)); + if (params_.end() != optIt) return string_stream(optIt->second); - return bad_stream(); - } - - ////////////////////////////////////////////////////////////////////////// - - inline string_stream parser::operator()(std::initializer_list init_list) const - { - for (auto& name : init_list) - { - auto optIt = params_.find(trim_leading_dashes(name)); - if (params_.end() != optIt) - return string_stream(optIt->second); - } - return bad_stream(); - } - - ////////////////////////////////////////////////////////////////////////// - - template - string_stream parser::operator()(std::string const& name, T&& def_val) const - { - auto optIt = params_.find(trim_leading_dashes(name)); - if (params_.end() != optIt) + } + return bad_stream(); + } + + ////////////////////////////////////////////////////////////////////////// + + template + string_stream parser::operator()(std::string const& name, T&& def_val) const + { + auto optIt = params_.find(trim_leading_dashes(name)); + if (params_.end() != optIt) + return string_stream(optIt->second); + + std::ostringstream ostr; + ostr.precision(std::numeric_limits::max_digits10); + ostr << def_val; + return string_stream(ostr.str()); // use default + } + + ////////////////////////////////////////////////////////////////////////// + + // same as above but for a list of names. returns the first value to be found. + template + string_stream parser::operator()(std::initializer_list init_list, T&& def_val) const + { + for (auto& name : init_list) + { + auto optIt = params_.find(trim_leading_dashes(name)); + if (params_.end() != optIt) return string_stream(optIt->second); - - std::ostringstream ostr; - ostr.precision(std::numeric_limits::max_digits10); - ostr << def_val; - return string_stream(ostr.str()); // use default - } - - ////////////////////////////////////////////////////////////////////////// - - // same as above but for a list of names. returns the first value to be found. - template - string_stream parser::operator()(std::initializer_list init_list, T&& def_val) const - { - for (auto& name : init_list) - { - auto optIt = params_.find(trim_leading_dashes(name)); - if (params_.end() != optIt) - return string_stream(optIt->second); - } - std::ostringstream ostr; - ostr.precision(std::numeric_limits::max_digits10); - ostr << def_val; - return string_stream(ostr.str()); // use default - } - - ////////////////////////////////////////////////////////////////////////// - - inline string_stream parser::operator()(size_t ind) const - { - if (pos_args_.size() <= ind) - return bad_stream(); - - return string_stream(pos_args_[ind]); - } - - ////////////////////////////////////////////////////////////////////////// - - template - string_stream parser::operator()(size_t ind, T&& def_val) const - { - if (pos_args_.size() <= ind) - { - std::ostringstream ostr; - ostr.precision(std::numeric_limits::max_digits10); - ostr << def_val; - return string_stream(ostr.str()); - } - - return string_stream(pos_args_[ind]); - } - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::add_param(std::string const& name) { registeredParams_.insert(trim_leading_dashes(name)); } - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::add_param(std::initializer_list init_list) { parser::add_params(init_list); } - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::add_params(std::initializer_list init_list) - { - for (auto& name : init_list) - registeredParams_.insert(trim_leading_dashes(name)); - } - - ////////////////////////////////////////////////////////////////////////// - - inline void parser::add_params(const std::string& name) { parser::add_param(name); } - - ////////////////////////////////////////////////////////////////////////// - - inline multimap_iteration_wrapper parser::params(std::string const& name) const - { - auto trimmed_name = trim_leading_dashes(name); - return multimap_iteration_wrapper(params_.lower_bound(trimmed_name), params_.upper_bound(trimmed_name)); - } -} // namespace argh + } + std::ostringstream ostr; + ostr.precision(std::numeric_limits::max_digits10); + ostr << def_val; + return string_stream(ostr.str()); // use default + } + + ////////////////////////////////////////////////////////////////////////// + + inline string_stream parser::operator()(size_t ind) const + { + if (pos_args_.size() <= ind) + return bad_stream(); + + return string_stream(pos_args_[ind]); + } + + ////////////////////////////////////////////////////////////////////////// + + template + string_stream parser::operator()(size_t ind, T&& def_val) const + { + if (pos_args_.size() <= ind) + { + std::ostringstream ostr; + ostr.precision(std::numeric_limits::max_digits10); + ostr << def_val; + return string_stream(ostr.str()); + } + + return string_stream(pos_args_[ind]); + } + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::add_param(std::string const& name) + { + registeredParams_.insert(trim_leading_dashes(name)); + } + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::add_param(std::initializer_list init_list) + { + parser::add_params(init_list); + } + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::add_params(std::initializer_list init_list) + { + for (auto& name : init_list) + registeredParams_.insert(trim_leading_dashes(name)); + } + + ////////////////////////////////////////////////////////////////////////// + + inline void parser::add_params(const std::string &name) + { + parser::add_param(name); + } + + ////////////////////////////////////////////////////////////////////////// + + inline multimap_iteration_wrapper parser::params(std::string const& name) const + { + auto trimmed_name = trim_leading_dashes(name); + return multimap_iteration_wrapper(params_.lower_bound(trimmed_name), params_.upper_bound(trimmed_name)); + } +} diff --git a/lib/ini.h b/lib/ini.h index 6a20427e..37d0f4ff 100644 --- a/lib/ini.h +++ b/lib/ini.h @@ -2,23 +2,22 @@ * The MIT License (MIT) * Copyright (c) 2018 Danijel Durakovic * - * 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: + * 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 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. + * 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. * */ @@ -108,7 +107,8 @@ namespace mINI #ifndef MINI_CASE_SENSITIVE inline void toLower(std::string& str) { - std::transform(str.begin(), str.end(), str.begin(), [](const char c) { return static_cast(std::tolower(c)); }); + std::transform(str.begin(), str.end(), str.begin(), + [](const char c) { return static_cast(std::tolower(c)); }); } #endif inline void replace(std::string& str, std::string const& a, std::string const& b) @@ -127,7 +127,8 @@ namespace mINI } // namespace INIStringUtil template - class INIMap { + class INIMap + { private: using T_DataIndexMap = std::unordered_map; using T_DataItem = std::pair; @@ -260,7 +261,14 @@ namespace mINI { using T_ParseValues = std::pair; - enum class PDataType : char { PDATA_NONE, PDATA_COMMENT, PDATA_SECTION, PDATA_KEYVALUE, PDATA_UNKNOWN }; + enum class PDataType : char + { + PDATA_NONE, + PDATA_COMMENT, + PDATA_SECTION, + PDATA_KEYVALUE, + PDATA_UNKNOWN + }; inline PDataType parseLine(std::string line, T_ParseValues& parseData) { @@ -310,7 +318,8 @@ namespace mINI } } // namespace INIParser - class INIReader { + class INIReader + { public: using T_LineData = std::vector; using T_LineDataPtr = std::shared_ptr; @@ -328,8 +337,11 @@ namespace mINI fileReadStream.seekg(0, std::ios::beg); if (fileSize >= 3) { - const char header[3] = {static_cast(fileReadStream.get()), static_cast(fileReadStream.get()), static_cast(fileReadStream.get())}; - isBOM = (header[0] == static_cast(0xEF) && header[1] == static_cast(0xBB) && header[2] == static_cast(0xBF)); + const char header[3] = {static_cast(fileReadStream.get()), + static_cast(fileReadStream.get()), + static_cast(fileReadStream.get())}; + isBOM = (header[0] == static_cast(0xEF) && header[1] == static_cast(0xBB) && + header[2] == static_cast(0xBF)); } else { @@ -414,7 +426,8 @@ namespace mINI T_LineDataPtr getLines() { return lineData; } }; - class INIGenerator { + class INIGenerator + { private: std::ofstream fileWriteStream; @@ -472,7 +485,8 @@ namespace mINI } }; - class INIWriter { + class INIWriter + { private: using T_LineData = std::vector; using T_LineDataPtr = std::shared_ptr; @@ -543,7 +557,8 @@ namespace mINI auto lineNorm = *line; INIStringUtil::replace(lineNorm, "\\=", " "); auto equalsAt = lineNorm.find_first_of('='); - auto valueAt = lineNorm.find_first_not_of(INIStringUtil::whitespaceDelimiters, equalsAt + 1); + auto valueAt = + lineNorm.find_first_not_of(INIStringUtil::whitespaceDelimiters, equalsAt + 1); std::string outputLine = line->substr(0, valueAt); if (prettyPrint && equalsAt + 1 == valueAt) { @@ -662,7 +677,8 @@ namespace mINI { if (fileIsBOM) { - const char utf8_BOM[3] = {static_cast(0xEF), static_cast(0xBB), static_cast(0xBF)}; + const char utf8_BOM[3] = {static_cast(0xEF), static_cast(0xBB), + static_cast(0xBF)}; fileWriteStream.write(utf8_BOM, 3); } if (output.size()) @@ -684,7 +700,8 @@ namespace mINI } }; - class INIFile { + class INIFile + { private: std::string filename; diff --git a/lib/libdeflate-x64/libdeflate.h b/lib/libdeflate-x64/libdeflate.h index ea700f84..526dae16 100644 --- a/lib/libdeflate-x64/libdeflate.h +++ b/lib/libdeflate-x64/libdeflate.h @@ -12,9 +12,9 @@ extern "C" { #endif -#define LIBDEFLATE_VERSION_MAJOR 1 -#define LIBDEFLATE_VERSION_MINOR 22 -#define LIBDEFLATE_VERSION_STRING "1.22" +#define LIBDEFLATE_VERSION_MAJOR 1 +#define LIBDEFLATE_VERSION_MINOR 22 +#define LIBDEFLATE_VERSION_STRING "1.22" /* * Users of libdeflate.dll on Windows can define LIBDEFLATE_DLL to cause @@ -23,11 +23,11 @@ extern "C" { * optimization that is irrelevant for most use cases of libdeflate. */ #ifndef LIBDEFLATEAPI -#if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__)) -#define LIBDEFLATEAPI __declspec(dllimport) -#else -#define LIBDEFLATEAPI -#endif +# if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__)) +# define LIBDEFLATEAPI __declspec(dllimport) +# else +# define LIBDEFLATEAPI +# endif #endif /* ========================================================================== */ @@ -55,12 +55,15 @@ struct libdeflate_options; * A single compressor is not safe to use by multiple threads concurrently. * However, different threads may use different compressors concurrently. */ -LIBDEFLATEAPI struct libdeflate_compressor* libdeflate_alloc_compressor(int compression_level); +LIBDEFLATEAPI struct libdeflate_compressor * +libdeflate_alloc_compressor(int compression_level); /* * Like libdeflate_alloc_compressor(), but adds the 'options' argument. */ -LIBDEFLATEAPI struct libdeflate_compressor* libdeflate_alloc_compressor_ex(int compression_level, const struct libdeflate_options* options); +LIBDEFLATEAPI struct libdeflate_compressor * +libdeflate_alloc_compressor_ex(int compression_level, + const struct libdeflate_options *options); /* * libdeflate_deflate_compress() performs raw DEFLATE compression on a buffer of @@ -78,7 +81,10 @@ LIBDEFLATEAPI struct libdeflate_compressor* libdeflate_alloc_compressor_ex(int c * break when libdeflate is updated. (This property isn't specific to * libdeflate; the same is true for zlib and other compression libraries too.) */ -LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_deflate_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * libdeflate_deflate_compress_bound() returns a worst-case upper bound on the @@ -104,40 +110,53 @@ LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor* c * libdeflate_deflate_compress() returns 0, indicating that the compressed data * did not fit into the provided output buffer. */ -LIBDEFLATEAPI size_t libdeflate_deflate_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_deflate_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but uses the zlib wrapper format instead * of raw DEFLATE. */ -LIBDEFLATEAPI size_t libdeflate_zlib_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_zlib_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_zlib_compress() rather than with * libdeflate_deflate_compress(). */ -LIBDEFLATEAPI size_t libdeflate_zlib_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_zlib_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but uses the gzip wrapper format instead * of raw DEFLATE. */ -LIBDEFLATEAPI size_t libdeflate_gzip_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_gzip_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_gzip_compress() rather than with * libdeflate_deflate_compress(). */ -LIBDEFLATEAPI size_t libdeflate_gzip_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_gzip_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * libdeflate_free_compressor() frees a compressor that was allocated with * libdeflate_alloc_compressor(). If a NULL pointer is passed in, no action is * taken. */ -LIBDEFLATEAPI void libdeflate_free_compressor(struct libdeflate_compressor* compressor); +LIBDEFLATEAPI void +libdeflate_free_compressor(struct libdeflate_compressor *compressor); /* ========================================================================== */ /* Decompression */ @@ -158,32 +177,34 @@ struct libdeflate_options; * A single decompressor is not safe to use by multiple threads concurrently. * However, different threads may use different decompressors concurrently. */ -LIBDEFLATEAPI struct libdeflate_decompressor* libdeflate_alloc_decompressor(void); +LIBDEFLATEAPI struct libdeflate_decompressor * +libdeflate_alloc_decompressor(void); /* * Like libdeflate_alloc_decompressor(), but adds the 'options' argument. */ -LIBDEFLATEAPI struct libdeflate_decompressor* libdeflate_alloc_decompressor_ex(const struct libdeflate_options* options); +LIBDEFLATEAPI struct libdeflate_decompressor * +libdeflate_alloc_decompressor_ex(const struct libdeflate_options *options); /* * Result of a call to libdeflate_deflate_decompress(), * libdeflate_zlib_decompress(), or libdeflate_gzip_decompress(). */ enum libdeflate_result { - /* Decompression was successful. */ - LIBDEFLATE_SUCCESS = 0, + /* Decompression was successful. */ + LIBDEFLATE_SUCCESS = 0, - /* Decompression failed because the compressed data was invalid, - * corrupt, or otherwise unsupported. */ - LIBDEFLATE_BAD_DATA = 1, + /* Decompression failed because the compressed data was invalid, + * corrupt, or otherwise unsupported. */ + LIBDEFLATE_BAD_DATA = 1, - /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have - * decompressed to fewer than 'out_nbytes_avail' bytes. */ - LIBDEFLATE_SHORT_OUTPUT = 2, + /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have + * decompressed to fewer than 'out_nbytes_avail' bytes. */ + LIBDEFLATE_SHORT_OUTPUT = 2, - /* The data would have decompressed to more than 'out_nbytes_avail' - * bytes. */ - LIBDEFLATE_INSUFFICIENT_SPACE = 3, + /* The data would have decompressed to more than 'out_nbytes_avail' + * bytes. */ + LIBDEFLATE_INSUFFICIENT_SPACE = 3, }; /* @@ -217,7 +238,11 @@ enum libdeflate_result { * not large enough but no other problems were encountered, or another * nonzero result code if decompression failed for another reason. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but adds the 'actual_in_nbytes_ret' @@ -225,7 +250,12 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdef * then the actual compressed size of the DEFLATE stream (aligned to the next * byte boundary) is written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the zlib wrapper format @@ -235,7 +265,11 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress_ex(struct lib * than 'in_nbytes'. If you need to know exactly where the zlib stream ended, * use libdeflate_zlib_decompress_ex(). */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_zlib_decompress(), but adds the 'actual_in_nbytes_ret' @@ -244,7 +278,12 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflat * buffer was decompressed), then the actual number of input bytes consumed is * written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the gzip wrapper format @@ -254,7 +293,11 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress_ex(struct libdef * will be decompressed. Use libdeflate_gzip_decompress_ex() if you need * multi-member support. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_gzip_decompress(), but adds the 'actual_in_nbytes_ret' @@ -263,14 +306,20 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflat * buffer was decompressed), then the actual number of input bytes consumed is * written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * libdeflate_free_decompressor() frees a decompressor that was allocated with * libdeflate_alloc_decompressor(). If a NULL pointer is passed in, no action * is taken. */ -LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor* decompressor); +LIBDEFLATEAPI void +libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor); /* ========================================================================== */ /* Checksums */ @@ -282,7 +331,9 @@ LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor* * required initial value for 'adler' is 1. This value is also returned when * 'buffer' is specified as NULL. */ -LIBDEFLATEAPI uint32_t libdeflate_adler32(uint32_t adler, const void* buffer, size_t len); +LIBDEFLATEAPI uint32_t +libdeflate_adler32(uint32_t adler, const void *buffer, size_t len); + /* * libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data @@ -290,7 +341,8 @@ LIBDEFLATEAPI uint32_t libdeflate_adler32(uint32_t adler, const void* buffer, si * initial value for 'crc' is 0. This value is also returned when 'buffer' is * specified as NULL. */ -LIBDEFLATEAPI uint32_t libdeflate_crc32(uint32_t crc, const void* buffer, size_t len); +LIBDEFLATEAPI uint32_t +libdeflate_crc32(uint32_t crc, const void *buffer, size_t len); /* ========================================================================== */ /* Custom memory allocator */ @@ -307,7 +359,9 @@ LIBDEFLATEAPI uint32_t libdeflate_crc32(uint32_t crc, const void* buffer, size_t * This doesn't affect the free() function that will be used to free * (de)compressors that were already in existence when this is called. */ -LIBDEFLATEAPI void libdeflate_set_memory_allocator(void* (*malloc_func)(size_t), void (*free_func)(void*)); +LIBDEFLATEAPI void +libdeflate_set_memory_allocator(void *(*malloc_func)(size_t), + void (*free_func)(void *)); /* * Advanced options. This is the options structure that @@ -323,31 +377,31 @@ LIBDEFLATEAPI void libdeflate_set_memory_allocator(void* (*malloc_func)(size_t), */ struct libdeflate_options { - /* - * This field must be set to the struct size. This field exists for - * extensibility, so that fields can be appended to this struct in - * future versions of libdeflate while still supporting old binaries. - */ - size_t sizeof_options; - - /* - * An optional custom memory allocator to use for this (de)compressor. - * 'malloc_func' must be a function that behaves like malloc(), and - * 'free_func' must be a function that behaves like free(). - * - * This is useful in cases where a process might have multiple users of - * libdeflate who want to use different memory allocators. For example, - * a library might want to use libdeflate with a custom memory allocator - * without interfering with user code that might use libdeflate too. - * - * This takes priority over the "global" memory allocator (which by - * default is malloc() and free(), but can be changed by - * libdeflate_set_memory_allocator()). Moreover, libdeflate will never - * call the "global" memory allocator if a per-(de)compressor custom - * allocator is always given. - */ - void* (*malloc_func)(size_t); - void (*free_func)(void*); + /* + * This field must be set to the struct size. This field exists for + * extensibility, so that fields can be appended to this struct in + * future versions of libdeflate while still supporting old binaries. + */ + size_t sizeof_options; + + /* + * An optional custom memory allocator to use for this (de)compressor. + * 'malloc_func' must be a function that behaves like malloc(), and + * 'free_func' must be a function that behaves like free(). + * + * This is useful in cases where a process might have multiple users of + * libdeflate who want to use different memory allocators. For example, + * a library might want to use libdeflate with a custom memory allocator + * without interfering with user code that might use libdeflate too. + * + * This takes priority over the "global" memory allocator (which by + * default is malloc() and free(), but can be changed by + * libdeflate_set_memory_allocator()). Moreover, libdeflate will never + * call the "global" memory allocator if a per-(de)compressor custom + * allocator is always given. + */ + void *(*malloc_func)(size_t); + void (*free_func)(void *); }; #ifdef __cplusplus diff --git a/lib/libdeflate/libdeflate.h b/lib/libdeflate/libdeflate.h index aec8d8c6..5b90d874 100644 --- a/lib/libdeflate/libdeflate.h +++ b/lib/libdeflate/libdeflate.h @@ -12,9 +12,9 @@ extern "C" { #endif -#define LIBDEFLATE_VERSION_MAJOR 1 -#define LIBDEFLATE_VERSION_MINOR 17 -#define LIBDEFLATE_VERSION_STRING "1.17" +#define LIBDEFLATE_VERSION_MAJOR 1 +#define LIBDEFLATE_VERSION_MINOR 17 +#define LIBDEFLATE_VERSION_STRING "1.17" /* * Users of libdeflate.dll on Windows can define LIBDEFLATE_DLL to cause @@ -23,11 +23,11 @@ extern "C" { * optimization that is irrelevant for most use cases of libdeflate. */ #ifndef LIBDEFLATEAPI -#if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__)) -#define LIBDEFLATEAPI __declspec(dllimport) -#else -#define LIBDEFLATEAPI -#endif +# if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__)) +# define LIBDEFLATEAPI __declspec(dllimport) +# else +# define LIBDEFLATEAPI +# endif #endif /* ========================================================================== */ @@ -54,7 +54,8 @@ struct libdeflate_compressor; * A single compressor is not safe to use by multiple threads concurrently. * However, different threads may use different compressors concurrently. */ -LIBDEFLATEAPI struct libdeflate_compressor* libdeflate_alloc_compressor(int compression_level); +LIBDEFLATEAPI struct libdeflate_compressor * +libdeflate_alloc_compressor(int compression_level); /* * libdeflate_deflate_compress() performs raw DEFLATE compression on a buffer of @@ -83,13 +84,15 @@ LIBDEFLATEAPI struct libdeflate_compressor* libdeflate_alloc_compressor(int comp * out_nbytes = libdeflate_deflate_compress(c, in, in_nbytes, out, * libdeflate_deflate_compress_bound(in_nbytes)); * // The following assertion will fail. - * assert(libdeflate_deflate_compress(c, in, in_nbytes, out, out_nbytes) != - *0); + * assert(libdeflate_deflate_compress(c, in, in_nbytes, out, out_nbytes) != 0); * * To avoid this, either don't write tests like the above, or make sure to * include at least 9 bytes of slack space in 'out_nbytes_avail'. */ -LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_deflate_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * libdeflate_deflate_compress_bound() returns a worst-case upper bound on the @@ -115,40 +118,53 @@ LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor* c * libdeflate_deflate_compress() returns 0, indicating that the compressed data * did not fit into the provided output buffer. */ -LIBDEFLATEAPI size_t libdeflate_deflate_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_deflate_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but uses the zlib wrapper format instead * of raw DEFLATE. */ -LIBDEFLATEAPI size_t libdeflate_zlib_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_zlib_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_zlib_compress() rather than with * libdeflate_deflate_compress(). */ -LIBDEFLATEAPI size_t libdeflate_zlib_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_zlib_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but uses the gzip wrapper format instead * of raw DEFLATE. */ -LIBDEFLATEAPI size_t libdeflate_gzip_compress(struct libdeflate_compressor* compressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail); +LIBDEFLATEAPI size_t +libdeflate_gzip_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_gzip_compress() rather than with * libdeflate_deflate_compress(). */ -LIBDEFLATEAPI size_t libdeflate_gzip_compress_bound(struct libdeflate_compressor* compressor, size_t in_nbytes); +LIBDEFLATEAPI size_t +libdeflate_gzip_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); /* * libdeflate_free_compressor() frees a compressor that was allocated with * libdeflate_alloc_compressor(). If a NULL pointer is passed in, no action is * taken. */ -LIBDEFLATEAPI void libdeflate_free_compressor(struct libdeflate_compressor* compressor); +LIBDEFLATEAPI void +libdeflate_free_compressor(struct libdeflate_compressor *compressor); /* ========================================================================== */ /* Decompression */ @@ -168,27 +184,28 @@ struct libdeflate_decompressor; * A single decompressor is not safe to use by multiple threads concurrently. * However, different threads may use different decompressors concurrently. */ -LIBDEFLATEAPI struct libdeflate_decompressor* libdeflate_alloc_decompressor(void); +LIBDEFLATEAPI struct libdeflate_decompressor * +libdeflate_alloc_decompressor(void); /* * Result of a call to libdeflate_deflate_decompress(), * libdeflate_zlib_decompress(), or libdeflate_gzip_decompress(). */ enum libdeflate_result { - /* Decompression was successful. */ - LIBDEFLATE_SUCCESS = 0, + /* Decompression was successful. */ + LIBDEFLATE_SUCCESS = 0, - /* Decompression failed because the compressed data was invalid, - * corrupt, or otherwise unsupported. */ - LIBDEFLATE_BAD_DATA = 1, + /* Decompression failed because the compressed data was invalid, + * corrupt, or otherwise unsupported. */ + LIBDEFLATE_BAD_DATA = 1, - /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have - * decompressed to fewer than 'out_nbytes_avail' bytes. */ - LIBDEFLATE_SHORT_OUTPUT = 2, + /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have + * decompressed to fewer than 'out_nbytes_avail' bytes. */ + LIBDEFLATE_SHORT_OUTPUT = 2, - /* The data would have decompressed to more than 'out_nbytes_avail' - * bytes. */ - LIBDEFLATE_INSUFFICIENT_SPACE = 3, + /* The data would have decompressed to more than 'out_nbytes_avail' + * bytes. */ + LIBDEFLATE_INSUFFICIENT_SPACE = 3, }; /* @@ -222,7 +239,11 @@ enum libdeflate_result { * not large enough but no other problems were encountered, or another * nonzero result code if decompression failed for another reason. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but adds the 'actual_in_nbytes_ret' @@ -230,7 +251,12 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdef * then the actual compressed size of the DEFLATE stream (aligned to the next * byte boundary) is written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the zlib wrapper format @@ -240,7 +266,11 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress_ex(struct lib * than 'in_nbytes'. If you need to know exactly where the zlib stream ended, * use libdeflate_zlib_decompress_ex(). */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_zlib_decompress(), but adds the 'actual_in_nbytes_ret' @@ -249,7 +279,12 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflat * buffer was decompressed), then the actual number of input bytes consumed is * written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the gzip wrapper format @@ -259,7 +294,11 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress_ex(struct libdef * will be decompressed. Use libdeflate_gzip_decompress_ex() if you need * multi-member support. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); /* * Like libdeflate_gzip_decompress(), but adds the 'actual_in_nbytes_ret' @@ -268,14 +307,20 @@ LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflat * buffer was decompressed), then the actual number of input bytes consumed is * written to *actual_in_nbytes_ret. */ -LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress_ex(struct libdeflate_decompressor* decompressor, const void* in, size_t in_nbytes, void* out, size_t out_nbytes_avail, size_t* actual_in_nbytes_ret, size_t* actual_out_nbytes_ret); +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); /* * libdeflate_free_decompressor() frees a decompressor that was allocated with * libdeflate_alloc_decompressor(). If a NULL pointer is passed in, no action * is taken. */ -LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor* decompressor); +LIBDEFLATEAPI void +libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor); /* ========================================================================== */ /* Checksums */ @@ -287,7 +332,9 @@ LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor* * required initial value for 'adler' is 1. This value is also returned when * 'buffer' is specified as NULL. */ -LIBDEFLATEAPI uint32_t libdeflate_adler32(uint32_t adler, const void* buffer, size_t len); +LIBDEFLATEAPI uint32_t +libdeflate_adler32(uint32_t adler, const void *buffer, size_t len); + /* * libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data @@ -295,7 +342,8 @@ LIBDEFLATEAPI uint32_t libdeflate_adler32(uint32_t adler, const void* buffer, si * initial value for 'crc' is 0. This value is also returned when 'buffer' is * specified as NULL. */ -LIBDEFLATEAPI uint32_t libdeflate_crc32(uint32_t crc, const void* buffer, size_t len); +LIBDEFLATEAPI uint32_t +libdeflate_crc32(uint32_t crc, const void *buffer, size_t len); /* ========================================================================== */ /* Custom memory allocator */ @@ -309,7 +357,9 @@ LIBDEFLATEAPI uint32_t libdeflate_crc32(uint32_t crc, const void* buffer, size_t * There must not be any libdeflate_compressor or libdeflate_decompressor * structures in existence when calling this function. */ -LIBDEFLATEAPI void libdeflate_set_memory_allocator(void* (*malloc_func)(size_t), void (*free_func)(void*)); +LIBDEFLATEAPI void +libdeflate_set_memory_allocator(void *(*malloc_func)(size_t), + void (*free_func)(void *)); #ifdef __cplusplus } diff --git a/lib/lua-x64/include/lauxlib.h b/lib/lua-x64/include/lauxlib.h index ef7c3110..59fef6af 100644 --- a/lib/lua-x64/include/lauxlib.h +++ b/lib/lua-x64/include/lauxlib.h @@ -4,96 +4,117 @@ ** See Copyright Notice in lua.h */ + #ifndef lauxlib_h #define lauxlib_h + #include #include #include "lua.h" + /* global table */ -#define LUA_GNAME "_G" +#define LUA_GNAME "_G" + typedef struct luaL_Buffer luaL_Buffer; + /* extra error code for 'luaL_loadfilex' */ -#define LUA_ERRFILE (LUA_ERRERR + 1) +#define LUA_ERRFILE (LUA_ERRERR+1) + /* key, in the registry, for table of loaded modules */ -#define LUA_LOADED_TABLE "_LOADED" +#define LUA_LOADED_TABLE "_LOADED" + /* key, in the registry, for table of preloaded loaders */ -#define LUA_PRELOAD_TABLE "_PRELOAD" +#define LUA_PRELOAD_TABLE "_PRELOAD" + typedef struct luaL_Reg { - const char* name; - lua_CFunction func; + const char *name; + lua_CFunction func; } luaL_Reg; -#define LUAL_NUMSIZES (sizeof(lua_Integer) * 16 + sizeof(lua_Number)) -LUALIB_API void(luaL_checkversion_)(lua_State* L, lua_Number ver, size_t sz); -#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) -LUALIB_API int(luaL_getmetafield)(lua_State* L, int obj, const char* e); -LUALIB_API int(luaL_callmeta)(lua_State* L, int obj, const char* e); -LUALIB_API const char*(luaL_tolstring)(lua_State* L, int idx, size_t* len); -LUALIB_API int(luaL_argerror)(lua_State* L, int arg, const char* extramsg); -LUALIB_API int(luaL_typeerror)(lua_State* L, int arg, const char* tname); -LUALIB_API const char*(luaL_checklstring)(lua_State* L, int arg, size_t* l); -LUALIB_API const char*(luaL_optlstring)(lua_State* L, int arg, const char* def, size_t* l); -LUALIB_API lua_Number(luaL_checknumber)(lua_State* L, int arg); -LUALIB_API lua_Number(luaL_optnumber)(lua_State* L, int arg, lua_Number def); +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); +LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); +LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); +LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); -LUALIB_API lua_Integer(luaL_checkinteger)(lua_State* L, int arg); -LUALIB_API lua_Integer(luaL_optinteger)(lua_State* L, int arg, lua_Integer def); +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, + lua_Integer def); -LUALIB_API void(luaL_checkstack)(lua_State* L, int sz, const char* msg); -LUALIB_API void(luaL_checktype)(lua_State* L, int arg, int t); -LUALIB_API void(luaL_checkany)(lua_State* L, int arg); +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); +LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int arg); -LUALIB_API int(luaL_newmetatable)(lua_State* L, const char* tname); -LUALIB_API void(luaL_setmetatable)(lua_State* L, const char* tname); -LUALIB_API void*(luaL_testudata)(lua_State* L, int ud, const char* tname); -LUALIB_API void*(luaL_checkudata)(lua_State* L, int ud, const char* tname); +LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); +LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); +LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); -LUALIB_API void(luaL_where)(lua_State* L, int lvl); -LUALIB_API int(luaL_error)(lua_State* L, const char* fmt, ...); +LUALIB_API void (luaL_where) (lua_State *L, int lvl); +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); -LUALIB_API int(luaL_checkoption)(lua_State* L, int arg, const char* def, const char* const lst[]); +LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, + const char *const lst[]); + +LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); +LUALIB_API int (luaL_execresult) (lua_State *L, int stat); -LUALIB_API int(luaL_fileresult)(lua_State* L, int stat, const char* fname); -LUALIB_API int(luaL_execresult)(lua_State* L, int stat); /* predefined references */ -#define LUA_NOREF (-2) -#define LUA_REFNIL (-1) +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) -LUALIB_API int(luaL_ref)(lua_State* L, int t); -LUALIB_API void(luaL_unref)(lua_State* L, int t, int ref); +LUALIB_API int (luaL_ref) (lua_State *L, int t); +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); -LUALIB_API int(luaL_loadfilex)(lua_State* L, const char* filename, const char* mode); +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, + const char *mode); -#define luaL_loadfile(L, f) luaL_loadfilex(L, f, NULL) +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) -LUALIB_API int(luaL_loadbufferx)(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode); -LUALIB_API int(luaL_loadstring)(lua_State* L, const char* s); +LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); -LUALIB_API lua_State*(luaL_newstate)(void); +LUALIB_API lua_State *(luaL_newstate) (void); -LUALIB_API lua_Integer(luaL_len)(lua_State* L, int idx); +LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); -LUALIB_API void luaL_addgsub(luaL_Buffer* b, const char* s, const char* p, const char* r); -LUALIB_API const char*(luaL_gsub)(lua_State* L, const char* s, const char* p, const char* r); +LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, + const char *p, const char *r); +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, + const char *p, const char *r); -LUALIB_API void(luaL_setfuncs)(lua_State* L, const luaL_Reg* l, int nup); +LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); -LUALIB_API int(luaL_getsubtable)(lua_State* L, int idx, const char* fname); +LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); -LUALIB_API void(luaL_traceback)(lua_State* L, lua_State* L1, const char* msg, int level); +LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, + const char *msg, int level); -LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction openf, int glb); +LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, + lua_CFunction openf, int glb); /* ** =============================================================== @@ -101,31 +122,40 @@ LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction ** =============================================================== */ -#define luaL_newlibtable(L, l) lua_createtable(L, 0, sizeof(l) / sizeof((l)[0]) - 1) -#define luaL_newlib(L, l) (luaL_checkversion(L), luaL_newlibtable(L, l), luaL_setfuncs(L, l, 0)) +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) -#define luaL_argcheck(L, cond, arg, extramsg) ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) +#define luaL_argexpected(L,cond,arg,tname) \ + ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) -#define luaL_argexpected(L, cond, arg, tname) ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) -#define luaL_checkstring(L, n) (luaL_checklstring(L, (n), NULL)) -#define luaL_optstring(L, n, d) (luaL_optlstring(L, (n), (d), NULL)) +#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) -#define luaL_typename(L, i) lua_typename(L, lua_type(L, (i))) +#define luaL_dofile(L, fn) \ + (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) -#define luaL_dofile(L, fn) (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) +#define luaL_dostring(L, s) \ + (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) -#define luaL_dostring(L, s) (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) +#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) -#define luaL_getmetatable(L, n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) +#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) -#define luaL_opt(L, f, n, d) (lua_isnoneornil(L, (n)) ? (d) : f(L, (n))) +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) -#define luaL_loadbuffer(L, s, sz, n) luaL_loadbufferx(L, s, sz, n, NULL) /* push the value used to represent failure/error */ -#define luaL_pushfail(L) lua_pushnil(L) +#define luaL_pushfail(L) lua_pushnil(L) + /* ** {====================================================== @@ -134,38 +164,44 @@ LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction */ struct luaL_Buffer { - char* b; /* buffer address */ - size_t size; /* buffer size */ - size_t n; /* number of characters in buffer */ - lua_State* L; - union { - LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ - char b[LUAL_BUFFERSIZE]; /* initial buffer */ - } init; + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + union { + LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ + char b[LUAL_BUFFERSIZE]; /* initial buffer */ + } init; }; -#define luaL_bufflen(bf) ((bf)->n) -#define luaL_buffaddr(bf) ((bf)->b) -#define luaL_addchar(B, c) ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), ((B)->b[(B)->n++] = (c))) +#define luaL_bufflen(bf) ((bf)->n) +#define luaL_buffaddr(bf) ((bf)->b) + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) -#define luaL_addsize(B, s) ((B)->n += (s)) +#define luaL_addsize(B,s) ((B)->n += (s)) -#define luaL_buffsub(B, s) ((B)->n -= (s)) +#define luaL_buffsub(B,s) ((B)->n -= (s)) -LUALIB_API void(luaL_buffinit)(lua_State* L, luaL_Buffer* B); -LUALIB_API char*(luaL_prepbuffsize)(luaL_Buffer* B, size_t sz); -LUALIB_API void(luaL_addlstring)(luaL_Buffer* B, const char* s, size_t l); -LUALIB_API void(luaL_addstring)(luaL_Buffer* B, const char* s); -LUALIB_API void(luaL_addvalue)(luaL_Buffer* B); -LUALIB_API void(luaL_pushresult)(luaL_Buffer* B); -LUALIB_API void(luaL_pushresultsize)(luaL_Buffer* B, size_t sz); -LUALIB_API char*(luaL_buffinitsize)(lua_State* L, luaL_Buffer* B, size_t sz); +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); +LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); -#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) /* }====================================================== */ + + /* ** {====================================================== ** File handles for IO library @@ -178,11 +214,12 @@ LUALIB_API char*(luaL_buffinitsize)(lua_State* L, luaL_Buffer* B, size_t sz); ** after that initial structure). */ -#define LUA_FILEHANDLE "FILE*" +#define LUA_FILEHANDLE "FILE*" + typedef struct luaL_Stream { - FILE* f; /* stream (NULL for incompletely created streams) */ - lua_CFunction closef; /* to close stream (NULL for closed streams) */ + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ } luaL_Stream; /* }====================================================== */ @@ -195,21 +232,23 @@ typedef struct luaL_Stream { /* print a string */ #if !defined(lua_writestring) -#define lua_writestring(s, l) fwrite((s), sizeof(char), (l), stdout) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) #endif /* print a newline and flush the output */ #if !defined(lua_writeline) -#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) #endif /* print an error message */ #if !defined(lua_writestringerror) -#define lua_writestringerror(s, p) (fprintf(stderr, (s), (p)), fflush(stderr)) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) #endif /* }================================================================== */ + /* ** {============================================================ ** Compatibility with deprecated conversions @@ -217,16 +256,21 @@ typedef struct luaL_Stream { */ #if defined(LUA_COMPAT_APIINTCASTS) -#define luaL_checkunsigned(L, a) ((lua_Unsigned)luaL_checkinteger(L, a)) -#define luaL_optunsigned(L, a, d) ((lua_Unsigned)luaL_optinteger(L, a, (lua_Integer)(d))) +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) -#define luaL_checkint(L, n) ((int)luaL_checkinteger(L, (n))) -#define luaL_optint(L, n, d) ((int)luaL_optinteger(L, (n), (d))) +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) -#define luaL_checklong(L, n) ((long)luaL_checkinteger(L, (n))) -#define luaL_optlong(L, n, d) ((long)luaL_optinteger(L, (n), (d))) +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #endif /* }============================================================ */ + + #endif + + diff --git a/lib/lua-x64/include/lua.h b/lib/lua-x64/include/lua.h index fa3b074a..c9d64d7f 100644 --- a/lib/lua-x64/include/lua.h +++ b/lib/lua-x64/include/lua.h @@ -5,78 +5,91 @@ ** See Copyright Notice at the end of this file */ + #ifndef lua_h #define lua_h #include #include + #include "luaconf.h" -#define LUA_VERSION_MAJOR "5" -#define LUA_VERSION_MINOR "4" -#define LUA_VERSION_RELEASE "2" -#define LUA_VERSION_NUM 504 -#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "4" +#define LUA_VERSION_RELEASE "2" + +#define LUA_VERSION_NUM 504 +#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" -#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE -#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" -#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" /* mark for precompiled code ('Lua') */ -#define LUA_SIGNATURE "\x1bLua" +#define LUA_SIGNATURE "\x1bLua" /* option for multiple returns in 'lua_pcall' and 'lua_call' */ -#define LUA_MULTRET (-1) +#define LUA_MULTRET (-1) + /* ** Pseudo-indices ** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty ** space after that to help overflow detection) */ -#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) -#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) + /* thread status */ -#define LUA_OK 0 -#define LUA_YIELD 1 -#define LUA_ERRRUN 2 -#define LUA_ERRSYNTAX 3 -#define LUA_ERRMEM 4 -#define LUA_ERRERR 5 +#define LUA_OK 0 +#define LUA_YIELD 1 +#define LUA_ERRRUN 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRERR 5 + typedef struct lua_State lua_State; + /* ** basic types */ -#define LUA_TNONE (-1) +#define LUA_TNONE (-1) + +#define LUA_TNIL 0 +#define LUA_TBOOLEAN 1 +#define LUA_TLIGHTUSERDATA 2 +#define LUA_TNUMBER 3 +#define LUA_TSTRING 4 +#define LUA_TTABLE 5 +#define LUA_TFUNCTION 6 +#define LUA_TUSERDATA 7 +#define LUA_TTHREAD 8 + +#define LUA_NUMTYPES 9 -#define LUA_TNIL 0 -#define LUA_TBOOLEAN 1 -#define LUA_TLIGHTUSERDATA 2 -#define LUA_TNUMBER 3 -#define LUA_TSTRING 4 -#define LUA_TTABLE 5 -#define LUA_TFUNCTION 6 -#define LUA_TUSERDATA 7 -#define LUA_TTHREAD 8 -#define LUA_NUMTYPES 9 /* minimum Lua stack available to a C function */ -#define LUA_MINSTACK 20 +#define LUA_MINSTACK 20 + /* predefined values in the registry */ -#define LUA_RIDX_MAINTHREAD 1 -#define LUA_RIDX_GLOBALS 2 -#define LUA_RIDX_LAST LUA_RIDX_GLOBALS +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + /* type of numbers in Lua */ typedef LUA_NUMBER lua_Number; + /* type for integer functions */ typedef LUA_INTEGER lua_Integer; @@ -86,32 +99,39 @@ typedef LUA_UNSIGNED lua_Unsigned; /* type for continuation-function contexts */ typedef LUA_KCONTEXT lua_KContext; + /* ** Type for C functions registered with Lua */ -typedef int (*lua_CFunction)(lua_State* L); +typedef int (*lua_CFunction) (lua_State *L); /* ** Type for continuation functions */ -typedef int (*lua_KFunction)(lua_State* L, int status, lua_KContext ctx); +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + /* ** Type for functions that read/write blocks when loading/dumping Lua chunks */ -typedef const char* (*lua_Reader)(lua_State* L, void* ud, size_t* sz); +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); -typedef int (*lua_Writer)(lua_State* L, const void* p, size_t sz, void* ud); /* ** Type for memory-allocation functions */ -typedef void* (*lua_Alloc)(void* ud, void* ptr, size_t osize, size_t nsize); +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + /* ** Type for warning functions */ -typedef void (*lua_WarnFunction)(void* ud, const char* msg, int tocont); +typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont); + + + /* ** generic extra include file @@ -120,194 +140,215 @@ typedef void (*lua_WarnFunction)(void* ud, const char* msg, int tocont); #include LUA_USER_H #endif + /* ** RCS ident string */ extern const char lua_ident[]; + /* ** state manipulation */ -LUA_API lua_State*(lua_newstate)(lua_Alloc f, void* ud); -LUA_API void(lua_close)(lua_State* L); -LUA_API lua_State*(lua_newthread)(lua_State* L); -LUA_API int(lua_resetthread)(lua_State* L); +LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); +LUA_API void (lua_close) (lua_State *L); +LUA_API lua_State *(lua_newthread) (lua_State *L); +LUA_API int (lua_resetthread) (lua_State *L); + +LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + -LUA_API lua_CFunction(lua_atpanic)(lua_State* L, lua_CFunction panicf); +LUA_API lua_Number (lua_version) (lua_State *L); -LUA_API lua_Number(lua_version)(lua_State* L); /* ** basic stack manipulation */ -LUA_API int(lua_absindex)(lua_State* L, int idx); -LUA_API int(lua_gettop)(lua_State* L); -LUA_API void(lua_settop)(lua_State* L, int idx); -LUA_API void(lua_pushvalue)(lua_State* L, int idx); -LUA_API void(lua_rotate)(lua_State* L, int idx, int n); -LUA_API void(lua_copy)(lua_State* L, int fromidx, int toidx); -LUA_API int(lua_checkstack)(lua_State* L, int n); +LUA_API int (lua_absindex) (lua_State *L, int idx); +LUA_API int (lua_gettop) (lua_State *L); +LUA_API void (lua_settop) (lua_State *L, int idx); +LUA_API void (lua_pushvalue) (lua_State *L, int idx); +LUA_API void (lua_rotate) (lua_State *L, int idx, int n); +LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); +LUA_API int (lua_checkstack) (lua_State *L, int n); + +LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); -LUA_API void(lua_xmove)(lua_State* from, lua_State* to, int n); /* ** access functions (stack -> C) */ -LUA_API int(lua_isnumber)(lua_State* L, int idx); -LUA_API int(lua_isstring)(lua_State* L, int idx); -LUA_API int(lua_iscfunction)(lua_State* L, int idx); -LUA_API int(lua_isinteger)(lua_State* L, int idx); -LUA_API int(lua_isuserdata)(lua_State* L, int idx); -LUA_API int(lua_type)(lua_State* L, int idx); -LUA_API const char*(lua_typename)(lua_State* L, int tp); - -LUA_API lua_Number(lua_tonumberx)(lua_State* L, int idx, int* isnum); -LUA_API lua_Integer(lua_tointegerx)(lua_State* L, int idx, int* isnum); -LUA_API int(lua_toboolean)(lua_State* L, int idx); -LUA_API const char*(lua_tolstring)(lua_State* L, int idx, size_t* len); -LUA_API lua_Unsigned(lua_rawlen)(lua_State* L, int idx); -LUA_API lua_CFunction(lua_tocfunction)(lua_State* L, int idx); -LUA_API void*(lua_touserdata)(lua_State* L, int idx); -LUA_API lua_State*(lua_tothread)(lua_State* L, int idx); -LUA_API const void*(lua_topointer)(lua_State* L, int idx); +LUA_API int (lua_isnumber) (lua_State *L, int idx); +LUA_API int (lua_isstring) (lua_State *L, int idx); +LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isinteger) (lua_State *L, int idx); +LUA_API int (lua_isuserdata) (lua_State *L, int idx); +LUA_API int (lua_type) (lua_State *L, int idx); +LUA_API const char *(lua_typename) (lua_State *L, int tp); + +LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); +LUA_API int (lua_toboolean) (lua_State *L, int idx); +LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); +LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx); +LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); +LUA_API void *(lua_touserdata) (lua_State *L, int idx); +LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); +LUA_API const void *(lua_topointer) (lua_State *L, int idx); + /* ** Comparison and arithmetic functions */ -#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ -#define LUA_OPSUB 1 -#define LUA_OPMUL 2 -#define LUA_OPMOD 3 -#define LUA_OPPOW 4 -#define LUA_OPDIV 5 -#define LUA_OPIDIV 6 -#define LUA_OPBAND 7 -#define LUA_OPBOR 8 -#define LUA_OPBXOR 9 -#define LUA_OPSHL 10 -#define LUA_OPSHR 11 -#define LUA_OPUNM 12 -#define LUA_OPBNOT 13 - -LUA_API void(lua_arith)(lua_State* L, int op); - -#define LUA_OPEQ 0 -#define LUA_OPLT 1 -#define LUA_OPLE 2 - -LUA_API int(lua_rawequal)(lua_State* L, int idx1, int idx2); -LUA_API int(lua_compare)(lua_State* L, int idx1, int idx2, int op); +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 + +LUA_API void (lua_arith) (lua_State *L, int op); + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); + /* ** push functions (C -> stack) */ -LUA_API void(lua_pushnil)(lua_State* L); -LUA_API void(lua_pushnumber)(lua_State* L, lua_Number n); -LUA_API void(lua_pushinteger)(lua_State* L, lua_Integer n); -LUA_API const char*(lua_pushlstring)(lua_State* L, const char* s, size_t len); -LUA_API const char*(lua_pushstring)(lua_State* L, const char* s); -LUA_API const char*(lua_pushvfstring)(lua_State* L, const char* fmt, va_list argp); -LUA_API const char*(lua_pushfstring)(lua_State* L, const char* fmt, ...); -LUA_API void(lua_pushcclosure)(lua_State* L, lua_CFunction fn, int n); -LUA_API void(lua_pushboolean)(lua_State* L, int b); -LUA_API void(lua_pushlightuserdata)(lua_State* L, void* p); -LUA_API int(lua_pushthread)(lua_State* L); +LUA_API void (lua_pushnil) (lua_State *L); +LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); +LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); +LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); +LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, + va_list argp); +LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); +LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); +LUA_API void (lua_pushboolean) (lua_State *L, int b); +LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); +LUA_API int (lua_pushthread) (lua_State *L); + /* ** get functions (Lua -> stack) */ -LUA_API int(lua_getglobal)(lua_State* L, const char* name); -LUA_API int(lua_gettable)(lua_State* L, int idx); -LUA_API int(lua_getfield)(lua_State* L, int idx, const char* k); -LUA_API int(lua_geti)(lua_State* L, int idx, lua_Integer n); -LUA_API int(lua_rawget)(lua_State* L, int idx); -LUA_API int(lua_rawgeti)(lua_State* L, int idx, lua_Integer n); -LUA_API int(lua_rawgetp)(lua_State* L, int idx, const void* p); - -LUA_API void(lua_createtable)(lua_State* L, int narr, int nrec); -LUA_API void*(lua_newuserdatauv)(lua_State* L, size_t sz, int nuvalue); -LUA_API int(lua_getmetatable)(lua_State* L, int objindex); -LUA_API int(lua_getiuservalue)(lua_State* L, int idx, int n); +LUA_API int (lua_getglobal) (lua_State *L, const char *name); +LUA_API int (lua_gettable) (lua_State *L, int idx); +LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawget) (lua_State *L, int idx); +LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); + +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n); + /* ** set functions (stack -> Lua) */ -LUA_API void(lua_setglobal)(lua_State* L, const char* name); -LUA_API void(lua_settable)(lua_State* L, int idx); -LUA_API void(lua_setfield)(lua_State* L, int idx, const char* k); -LUA_API void(lua_seti)(lua_State* L, int idx, lua_Integer n); -LUA_API void(lua_rawset)(lua_State* L, int idx); -LUA_API void(lua_rawseti)(lua_State* L, int idx, lua_Integer n); -LUA_API void(lua_rawsetp)(lua_State* L, int idx, const void* p); -LUA_API int(lua_setmetatable)(lua_State* L, int objindex); -LUA_API int(lua_setiuservalue)(lua_State* L, int idx, int n); +LUA_API void (lua_setglobal) (lua_State *L, const char *name); +LUA_API void (lua_settable) (lua_State *L, int idx); +LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n); + /* ** 'load' and 'call' functions (load and run Lua code) */ -LUA_API void(lua_callk)(lua_State* L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k); -#define lua_call(L, n, r) lua_callk(L, (n), (r), 0, NULL) +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k); +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k); +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) -LUA_API int(lua_pcallk)(lua_State* L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k); -#define lua_pcall(L, n, r, f) lua_pcallk(L, (n), (r), (f), 0, NULL) +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, const char *mode); -LUA_API int(lua_load)(lua_State* L, lua_Reader reader, void* dt, const char* chunkname, const char* mode); +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); -LUA_API int(lua_dump)(lua_State* L, lua_Writer writer, void* data, int strip); /* ** coroutine functions */ -LUA_API int(lua_yieldk)(lua_State* L, int nresults, lua_KContext ctx, lua_KFunction k); -LUA_API int(lua_resume)(lua_State* L, lua_State* from, int narg, int* nres); -LUA_API int(lua_status)(lua_State* L); -LUA_API int(lua_isyieldable)(lua_State* L); +LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k); +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg, + int *nres); +LUA_API int (lua_status) (lua_State *L); +LUA_API int (lua_isyieldable) (lua_State *L); + +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) -#define lua_yield(L, n) lua_yieldk(L, (n), 0, NULL) /* ** Warning-related functions */ -LUA_API void(lua_setwarnf)(lua_State* L, lua_WarnFunction f, void* ud); -LUA_API void(lua_warning)(lua_State* L, const char* msg, int tocont); +LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud); +LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont); + /* ** garbage-collection function and options */ -#define LUA_GCSTOP 0 -#define LUA_GCRESTART 1 -#define LUA_GCCOLLECT 2 -#define LUA_GCCOUNT 3 -#define LUA_GCCOUNTB 4 -#define LUA_GCSTEP 5 -#define LUA_GCSETPAUSE 6 -#define LUA_GCSETSTEPMUL 7 -#define LUA_GCISRUNNING 9 -#define LUA_GCGEN 10 -#define LUA_GCINC 11 +#define LUA_GCSTOP 0 +#define LUA_GCRESTART 1 +#define LUA_GCCOLLECT 2 +#define LUA_GCCOUNT 3 +#define LUA_GCCOUNTB 4 +#define LUA_GCSTEP 5 +#define LUA_GCSETPAUSE 6 +#define LUA_GCSETSTEPMUL 7 +#define LUA_GCISRUNNING 9 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +LUA_API int (lua_gc) (lua_State *L, int what, ...); -LUA_API int(lua_gc)(lua_State* L, int what, ...); /* ** miscellaneous functions */ -LUA_API int(lua_error)(lua_State* L); +LUA_API int (lua_error) (lua_State *L); + +LUA_API int (lua_next) (lua_State *L, int idx); -LUA_API int(lua_next)(lua_State* L, int idx); +LUA_API void (lua_concat) (lua_State *L, int n); +LUA_API void (lua_len) (lua_State *L, int idx); -LUA_API void(lua_concat)(lua_State* L, int n); -LUA_API void(lua_len)(lua_State* L, int idx); +LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); -LUA_API size_t(lua_stringtonumber)(lua_State* L, const char* s); +LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); -LUA_API lua_Alloc(lua_getallocf)(lua_State* L, void** ud); -LUA_API void(lua_setallocf)(lua_State* L, lua_Alloc f, void* ud); +LUA_API void (lua_toclose) (lua_State *L, int idx); -LUA_API void(lua_toclose)(lua_State* L, int idx); /* ** {============================================================== @@ -315,42 +356,45 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); ** =============================================================== */ -#define lua_getextraspace(L) ((void*)((char*)(L) - LUA_EXTRASPACE)) +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) -#define lua_tonumber(L, i) lua_tonumberx(L, (i), NULL) -#define lua_tointeger(L, i) lua_tointegerx(L, (i), NULL) +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) -#define lua_pop(L, n) lua_settop(L, -(n) - 1) +#define lua_pop(L,n) lua_settop(L, -(n)-1) -#define lua_newtable(L) lua_createtable(L, 0, 0) +#define lua_newtable(L) lua_createtable(L, 0, 0) -#define lua_register(L, n, f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) +#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) -#define lua_pushcfunction(L, f) lua_pushcclosure(L, (f), 0) +#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) -#define lua_isfunction(L, n) (lua_type(L, (n)) == LUA_TFUNCTION) -#define lua_istable(L, n) (lua_type(L, (n)) == LUA_TTABLE) -#define lua_islightuserdata(L, n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) -#define lua_isnil(L, n) (lua_type(L, (n)) == LUA_TNIL) -#define lua_isboolean(L, n) (lua_type(L, (n)) == LUA_TBOOLEAN) -#define lua_isthread(L, n) (lua_type(L, (n)) == LUA_TTHREAD) -#define lua_isnone(L, n) (lua_type(L, (n)) == LUA_TNONE) -#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) +#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) +#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) +#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) +#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) +#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) +#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) +#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) -#define lua_pushliteral(L, s) lua_pushstring(L, "" s) +#define lua_pushliteral(L, s) lua_pushstring(L, "" s) -#define lua_pushglobaltable(L) ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) +#define lua_pushglobaltable(L) \ + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) -#define lua_tostring(L, i) lua_tolstring(L, (i), NULL) +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) -#define lua_insert(L, idx) lua_rotate(L, (idx), 1) -#define lua_remove(L, idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) -#define lua_replace(L, idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) /* }============================================================== */ + /* ** {============================================================== ** compatibility macros @@ -358,17 +402,17 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); */ #if defined(LUA_COMPAT_APIINTCASTS) -#define lua_pushunsigned(L, n) lua_pushinteger(L, (lua_Integer)(n)) -#define lua_tounsignedx(L, i, is) ((lua_Unsigned)lua_tointegerx(L, i, is)) -#define lua_tounsigned(L, i) lua_tounsignedx(L, (i), NULL) +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) #endif -#define lua_newuserdata(L, s) lua_newuserdatauv(L, s, 1) -#define lua_getuservalue(L, idx) lua_getiuservalue(L, idx, 1) -#define lua_setuservalue(L, idx) lua_setiuservalue(L, idx, 1) +#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) +#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) +#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) -#define LUA_NUMTAGS LUA_NUMTYPES +#define LUA_NUMTAGS LUA_NUMTYPES /* }============================================================== */ @@ -378,89 +422,96 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); ** ======================================================================= */ + /* ** Event codes */ -#define LUA_HOOKCALL 0 -#define LUA_HOOKRET 1 -#define LUA_HOOKLINE 2 -#define LUA_HOOKCOUNT 3 +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 #define LUA_HOOKTAILCALL 4 + /* ** Event masks */ -#define LUA_MASKCALL (1 << LUA_HOOKCALL) -#define LUA_MASKRET (1 << LUA_HOOKRET) -#define LUA_MASKLINE (1 << LUA_HOOKLINE) -#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) +#define LUA_MASKCALL (1 << LUA_HOOKCALL) +#define LUA_MASKRET (1 << LUA_HOOKRET) +#define LUA_MASKLINE (1 << LUA_HOOKLINE) +#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) + +typedef struct lua_Debug lua_Debug; /* activation record */ -typedef struct lua_Debug lua_Debug; /* activation record */ /* Functions to be called by the debugger in specific events */ -typedef void (*lua_Hook)(lua_State* L, lua_Debug* ar); +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + -LUA_API int(lua_getstack)(lua_State* L, int level, lua_Debug* ar); -LUA_API int(lua_getinfo)(lua_State* L, const char* what, lua_Debug* ar); -LUA_API const char*(lua_getlocal)(lua_State* L, const lua_Debug* ar, int n); -LUA_API const char*(lua_setlocal)(lua_State* L, const lua_Debug* ar, int n); -LUA_API const char*(lua_getupvalue)(lua_State* L, int funcindex, int n); -LUA_API const char*(lua_setupvalue)(lua_State* L, int funcindex, int n); +LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); +LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); +LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); -LUA_API void*(lua_upvalueid)(lua_State* L, int fidx, int n); -LUA_API void(lua_upvaluejoin)(lua_State* L, int fidx1, int n1, int fidx2, int n2); +LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); +LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, + int fidx2, int n2); -LUA_API void(lua_sethook)(lua_State* L, lua_Hook func, int mask, int count); -LUA_API lua_Hook(lua_gethook)(lua_State* L); -LUA_API int(lua_gethookmask)(lua_State* L); -LUA_API int(lua_gethookcount)(lua_State* L); +LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API lua_Hook (lua_gethook) (lua_State *L); +LUA_API int (lua_gethookmask) (lua_State *L); +LUA_API int (lua_gethookcount) (lua_State *L); -LUA_API int(lua_setcstacklimit)(lua_State* L, unsigned int limit); +LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit); struct lua_Debug { - int event; - const char* name; /* (n) */ - const char* namewhat; /* (n) 'global', 'local', 'field', 'method' */ - const char* what; /* (S) 'Lua', 'C', 'main', 'tail' */ - const char* source; /* (S) */ - size_t srclen; /* (S) */ - int currentline; /* (l) */ - int linedefined; /* (S) */ - int lastlinedefined; /* (S) */ - unsigned char nups; /* (u) number of upvalues */ - unsigned char nparams; /* (u) number of parameters */ - char isvararg; /* (u) */ - char istailcall; /* (t) */ - unsigned short ftransfer; /* (r) index of first value transferred */ - unsigned short ntransfer; /* (r) number of transferred values */ - char short_src[LUA_IDSIZE]; /* (S) */ - /* private part */ - struct CallInfo* i_ci; /* active function */ + int event; + const char *name; /* (n) */ + const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ + const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ + const char *source; /* (S) */ + size_t srclen; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + unsigned short ftransfer; /* (r) index of first value transferred */ + unsigned short ntransfer; /* (r) number of transferred values */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ }; /* }====================================================================== */ + /****************************************************************************** - * Copyright (C) 1994-2020 Lua.org, PUC-Rio. - * - * 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. - ******************************************************************************/ +* Copyright (C) 1994-2020 Lua.org, PUC-Rio. +* +* 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. +******************************************************************************/ + #endif diff --git a/lib/lua-x64/include/lua.hpp b/lib/lua-x64/include/lua.hpp index 964d99d0..ec417f59 100644 --- a/lib/lua-x64/include/lua.hpp +++ b/lib/lua-x64/include/lua.hpp @@ -3,7 +3,7 @@ // <> not supplied automatically because Lua also compiles as C++ extern "C" { -#include "lauxlib.h" #include "lua.h" #include "lualib.h" +#include "lauxlib.h" } diff --git a/lib/lua-x64/include/luaconf.h b/lib/lua-x64/include/luaconf.h index c70e1ae5..3ad294e4 100644 --- a/lib/lua-x64/include/luaconf.h +++ b/lib/lua-x64/include/luaconf.h @@ -4,12 +4,14 @@ ** See Copyright Notice in lua.h */ + #ifndef luaconf_h #define luaconf_h #include #include + /* ** =================================================================== ** General Configuration File for Lua @@ -26,6 +28,7 @@ ** =================================================================== */ + /* ** {==================================================================== ** System Configuration: macros to adapt (if needed) Lua to some @@ -40,35 +43,42 @@ */ /* #define LUA_USE_C89 */ + /* ** By default, Lua on Windows use (some) specific Windows features */ #if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) -#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ #endif + #if defined(LUA_USE_WINDOWS) -#define LUA_DL_DLL /* enable support for DLL */ -#define LUA_USE_C89 /* broadly, Windows is C89 */ +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ #endif + #if defined(LUA_USE_LINUX) #define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ #endif + #if defined(LUA_USE_MACOSX) #define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ #endif + /* @@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. */ -#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) +#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Number types. @@ -80,6 +90,7 @@ */ /* #define LUA_32BITS */ + /* @@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for ** C89 ('long' and 'double'); Windows always has '__int64', so it does @@ -89,6 +100,7 @@ #define LUA_C89_NUMBERS #endif + /* @@ LUA_INT_TYPE defines the type for Lua integers. @@ LUA_FLOAT_TYPE defines the type for Lua floats. @@ -100,48 +112,51 @@ */ /* predefined options for LUA_INT_TYPE */ -#define LUA_INT_INT 1 -#define LUA_INT_LONG 2 -#define LUA_INT_LONGLONG 3 +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 /* predefined options for LUA_FLOAT_TYPE */ -#define LUA_FLOAT_FLOAT 1 -#define LUA_FLOAT_DOUBLE 2 -#define LUA_FLOAT_LONGDOUBLE 3 +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 -#if defined(LUA_32BITS) /* { */ +#if defined(LUA_32BITS) /* { */ /* ** 32-bit integers and 'float' */ -#if LUAI_IS32INT /* use 'int' if big enough */ -#define LUA_INT_TYPE LUA_INT_INT -#else /* otherwise use 'long' */ -#define LUA_INT_TYPE LUA_INT_LONG +#if LUAI_IS32INT /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG #endif -#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT -#elif defined(LUA_C89_NUMBERS) /* }{ */ +#elif defined(LUA_C89_NUMBERS) /* }{ */ /* ** largest types available for C89 ('long' and 'double') */ -#define LUA_INT_TYPE LUA_INT_LONG -#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#endif /* } */ -#endif /* } */ /* ** default configuration for 64-bit Lua ('long long' and 'double') */ #if !defined(LUA_INT_TYPE) -#define LUA_INT_TYPE LUA_INT_LONGLONG +#define LUA_INT_TYPE LUA_INT_LONGLONG #endif #if !defined(LUA_FLOAT_TYPE) -#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE #endif /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Paths. @@ -155,9 +170,10 @@ ** LUA_EXEC_DIR in a Windows path is replaced by the executable's ** directory. */ -#define LUA_PATH_SEP ";" -#define LUA_PATH_MARK "?" -#define LUA_EXEC_DIR "!" +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" + /* @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for @@ -169,51 +185,53 @@ ** non-conventional directories. */ -#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#if defined(_WIN32) /* { */ +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#if defined(_WIN32) /* { */ /* ** In Windows, any exclamation mark ('!') in the path is replaced by the ** path of the directory of the executable file of the current process. */ -#define LUA_LDIR "!\\lua\\" -#define LUA_CDIR "!\\" -#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" #if !defined(LUA_PATH_DEFAULT) -#define LUA_PATH_DEFAULT \ - LUA_LDIR "?.lua;" LUA_LDIR "?\\init.lua;" LUA_CDIR "?.lua;" LUA_CDIR "?\\init.lua;" LUA_SHRDIR "?.lua;" LUA_SHRDIR "?\\init.lua;" \ - ".\\?.lua;" \ - ".\\?\\init.lua" +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ + LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ + ".\\?.lua;" ".\\?\\init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) -#define LUA_CPATH_DEFAULT \ - LUA_CDIR "?.dll;" LUA_CDIR "..\\lib\\lua\\" LUA_VDIR "\\?.dll;" LUA_CDIR "loadall.dll;" \ - ".\\?.dll;" LUA_CDIR "?54.dll;" \ - ".\\?54.dll" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" \ + LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ + LUA_CDIR"loadall.dll;" ".\\?.dll;" \ + LUA_CDIR"?54.dll;" ".\\?54.dll" #endif -#else /* }{ */ +#else /* }{ */ -#define LUA_ROOT "/usr/local/" -#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" -#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" #if !defined(LUA_PATH_DEFAULT) -#define LUA_PATH_DEFAULT \ - LUA_LDIR "?.lua;" LUA_LDIR "?/init.lua;" LUA_CDIR "?.lua;" LUA_CDIR "?/init.lua;" \ - "./?.lua;" \ - "./?/init.lua" +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ + "./?.lua;" "./?/init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) -#define LUA_CPATH_DEFAULT \ - LUA_CDIR "?.so;" LUA_CDIR "loadall.so;" \ - "./?.so;" LUA_CDIR "lib?54.so;" \ - "./lib?54.so" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \ + LUA_CDIR"lib?54.so;" "./lib?54.so" #endif -#endif /* } */ +#endif /* } */ + /* @@ LUA_DIRSEP is the directory separator (for submodules). @@ -223,15 +241,16 @@ #if !defined(LUA_DIRSEP) #if defined(_WIN32) -#define LUA_DIRSEP "\\" +#define LUA_DIRSEP "\\" #else -#define LUA_DIRSEP "/" +#define LUA_DIRSEP "/" #endif #endif /* }================================================================== */ + /* ** {================================================================== ** Marks for exported symbols in the C code @@ -247,25 +266,27 @@ ** the libraries, you may want to use the following definition (define ** LUA_BUILD_AS_DLL to get it). */ -#if defined(LUA_BUILD_AS_DLL) /* { */ +#if defined(LUA_BUILD_AS_DLL) /* { */ -#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ +#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ #define LUA_API __declspec(dllexport) -#else /* }{ */ +#else /* }{ */ #define LUA_API __declspec(dllimport) -#endif /* } */ +#endif /* } */ -#else /* }{ */ +#else /* }{ */ -#define LUA_API extern +#define LUA_API extern + +#endif /* } */ -#endif /* } */ /* ** More often than not the libs go together with the core. */ -#define LUALIB_API LUA_API -#define LUAMOD_API LUA_API +#define LUALIB_API LUA_API +#define LUAMOD_API LUA_API + /* @@ LUAI_FUNC is a mark for all extern functions that are not to be @@ -281,17 +302,19 @@ ** give a warning about it. To avoid these warnings, change to the ** default definition. */ -#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 302) && defined(__ELF__) /* { */ -#define LUAI_FUNC __attribute__((visibility("internal"))) extern -#else /* }{ */ -#define LUAI_FUNC extern -#endif /* } */ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("internal"))) extern +#else /* }{ */ +#define LUAI_FUNC extern +#endif /* } */ -#define LUAI_DDEC(dec) LUAI_FUNC dec -#define LUAI_DDEF /* empty */ +#define LUAI_DDEC(dec) LUAI_FUNC dec +#define LUAI_DDEF /* empty */ /* }================================================================== */ + /* ** {================================================================== ** Compatibility with previous versions @@ -303,7 +326,7 @@ ** You can define it to get all options, or change specific options ** to fit your specific needs. */ -#if defined(LUA_COMPAT_5_3) /* { */ +#if defined(LUA_COMPAT_5_3) /* { */ /* @@ LUA_COMPAT_MATHLIB controls the presence of several deprecated @@ -322,12 +345,14 @@ */ #define LUA_COMPAT_APIINTCASTS + /* @@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod ** using '__lt'. */ #define LUA_COMPAT_LT_LE + /* @@ The following macros supply trivial compatibility for some ** changes in the API. The macros themselves document how to @@ -335,17 +360,19 @@ ** (Once more, these macros were officially removed in 5.3, but they are ** still available here.) */ -#define lua_strlen(L, i) lua_rawlen(L, (i)) +#define lua_strlen(L,i) lua_rawlen(L, (i)) -#define lua_objlen(L, i) lua_rawlen(L, (i)) +#define lua_objlen(L,i) lua_rawlen(L, (i)) -#define lua_equal(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPEQ) -#define lua_lessthan(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPLT) +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) -#endif /* } */ +#endif /* } */ /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Numbers. @@ -368,11 +395,13 @@ @@ lua_str2number converts a decimal numeral to a number. */ + /* The following definitions are good for most cases here */ -#define l_floor(x) (l_mathop(floor)(x)) +#define l_floor(x) (l_mathop(floor)(x)) -#define lua_number2str(s, sz, n) l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) /* @@ lua_numbertointeger converts a float number with an integral value @@ -383,60 +412,67 @@ ** MAXINTEGER may not have one, and therefore its conversion to float ** may have an ill-defined value.) */ -#define lua_numbertointeger(n, p) ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && (n) < -(LUA_NUMBER)(LUA_MININTEGER) && (*(p) = (LUA_INTEGER)(n), 1)) +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + /* now the variable definitions */ -#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float -#define LUA_NUMBER float +#define l_floatatt(n) (FLT_##n) -#define l_floatatt(n) (FLT_##n) +#define LUAI_UACNUMBER double -#define LUAI_UACNUMBER double +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.7g" +#define l_mathop(op) op##f -#define l_mathop(op) op##f +#define lua_str2number(s,p) strtof((s), (p)) -#define lua_str2number(s, p) strtof((s), (p)) -#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ -#define LUA_NUMBER long double +#define LUA_NUMBER long double -#define l_floatatt(n) (LDBL_##n) +#define l_floatatt(n) (LDBL_##n) -#define LUAI_UACNUMBER long double +#define LUAI_UACNUMBER long double -#define LUA_NUMBER_FRMLEN "L" -#define LUA_NUMBER_FMT "%.19Lg" +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" -#define l_mathop(op) op##l +#define l_mathop(op) op##l -#define lua_str2number(s, p) strtold((s), (p)) +#define lua_str2number(s,p) strtold((s), (p)) -#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ -#define LUA_NUMBER double +#define LUA_NUMBER double -#define l_floatatt(n) (DBL_##n) +#define l_floatatt(n) (DBL_##n) -#define LUAI_UACNUMBER double +#define LUAI_UACNUMBER double -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.14g" +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" -#define l_mathop(op) op +#define l_mathop(op) op -#define lua_str2number(s, p) strtod((s), (p)) +#define lua_str2number(s,p) strtod((s), (p)) -#else /* }{ */ +#else /* }{ */ #error "numeric float type not defined" -#endif /* } */ +#endif /* } */ + + /* @@ LUA_INTEGER is the integer type used by Lua. @@ -454,84 +490,89 @@ @@ lua_integer2str converts an integer to a string. */ + /* The following definitions are good for most cases here */ -#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" -#define LUAI_UACINT LUA_INTEGER +#define LUAI_UACINT LUA_INTEGER -#define lua_integer2str(s, sz, n) l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) /* ** use LUAI_UACINT here to avoid problems with promotions (which ** can turn a comparison between unsigneds into a signed comparison) */ -#define LUA_UNSIGNED unsigned LUAI_UACINT +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) -#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) /* now the variable definitions */ -#if LUA_INT_TYPE == LUA_INT_INT /* { int */ +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ -#define LUA_INTEGER int -#define LUA_INTEGER_FRMLEN "" +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" -#define LUA_MAXINTEGER INT_MAX -#define LUA_MININTEGER INT_MIN +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN -#define LUA_MAXUNSIGNED UINT_MAX +#define LUA_MAXUNSIGNED UINT_MAX -#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ -#define LUA_INTEGER long -#define LUA_INTEGER_FRMLEN "l" +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" -#define LUA_MAXINTEGER LONG_MAX -#define LUA_MININTEGER LONG_MIN +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN -#define LUA_MAXUNSIGNED ULONG_MAX +#define LUA_MAXUNSIGNED ULONG_MAX -#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ /* use presence of macro LLONG_MAX as proxy for C99 compliance */ -#if defined(LLONG_MAX) /* { */ +#if defined(LLONG_MAX) /* { */ /* use ISO C99 stuff */ -#define LUA_INTEGER long long -#define LUA_INTEGER_FRMLEN "ll" +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" -#define LUA_MAXINTEGER LLONG_MAX -#define LUA_MININTEGER LLONG_MIN +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN -#define LUA_MAXUNSIGNED ULLONG_MAX +#define LUA_MAXUNSIGNED ULLONG_MAX #elif defined(LUA_USE_WINDOWS) /* }{ */ /* in Windows, can use specific Windows types */ -#define LUA_INTEGER __int64 -#define LUA_INTEGER_FRMLEN "I64" +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" -#define LUA_MAXINTEGER _I64_MAX -#define LUA_MININTEGER _I64_MIN +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN -#define LUA_MAXUNSIGNED _UI64_MAX +#define LUA_MAXUNSIGNED _UI64_MAX -#else /* }{ */ +#else /* }{ */ #error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" -#endif /* } */ +#endif /* } */ -#else /* }{ */ +#else /* }{ */ #error "numeric integer type not defined" -#endif /* } */ +#endif /* } */ /* }================================================================== */ + /* ** {================================================================== ** Dependencies with C99 and other C details @@ -543,11 +584,12 @@ ** (All uses in Lua have only one format item.) */ #if !defined(LUA_USE_C89) -#define l_sprintf(s, sz, f, i) snprintf(s, sz, f, i) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) #else -#define l_sprintf(s, sz, f, i) ((void)(sz), sprintf(s, f, i)) +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) #endif + /* @@ lua_strx2number converts a hexadecimal numeral to a number. ** In C99, 'strtod' does that conversion. Otherwise, you can @@ -555,14 +597,16 @@ ** implementation. */ #if !defined(LUA_USE_C89) -#define lua_strx2number(s, p) lua_str2number(s, p) +#define lua_strx2number(s,p) lua_str2number(s,p) #endif + /* @@ lua_pointer2str converts a pointer to a readable string in a ** non-specified way. */ -#define lua_pointer2str(buff, sz, p) l_sprintf(buff, sz, "%p", p) +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) + /* @@ lua_number2strx converts a float to a hexadecimal numeral. @@ -571,9 +615,11 @@ ** provide its own implementation. */ #if !defined(LUA_USE_C89) -#define lua_number2strx(L, b, sz, f, n) ((void)L, l_sprintf(b, sz, f, (LUAI_UACNUMBER)(n))) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) #endif + /* ** 'strtof' and 'opf' variants for math functions are not valid in ** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the @@ -581,39 +627,43 @@ ** all files that use these macros.) */ #if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) -#undef l_mathop /* variants not available */ +#undef l_mathop /* variants not available */ #undef lua_str2number -#define l_mathop(op) (lua_Number) op /* no variant */ -#define lua_str2number(s, p) ((lua_Number)strtod((s), (p))) +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) #endif + /* @@ LUA_KCONTEXT is the type of the context ('ctx') for continuation ** functions. It must be a numerical type; Lua will use 'intptr_t' if ** available, otherwise it will use 'ptrdiff_t' (the nearest thing to ** 'intptr_t' in C89) */ -#define LUA_KCONTEXT ptrdiff_t +#define LUA_KCONTEXT ptrdiff_t -#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L #include -#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ #undef LUA_KCONTEXT -#define LUA_KCONTEXT intptr_t +#define LUA_KCONTEXT intptr_t #endif #endif + /* @@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). ** Change that if you do not want to use C locales. (Code using this ** macro must include the header 'locale.h'.) */ #if !defined(lua_getlocaledecpoint) -#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) #endif /* }================================================================== */ + /* ** {================================================================== ** Language Variations @@ -629,17 +679,19 @@ /* #define LUA_NOCVTN2S */ /* #define LUA_NOCVTS2N */ + /* @@ LUA_USE_APICHECK turns on several consistency checks on the C API. ** Define it as a help when debugging C code. */ #if defined(LUA_USE_APICHECK) #include -#define luai_apicheck(l, e) assert(e) +#define luai_apicheck(l,e) assert(e) #endif /* }================================================================== */ + /* ** {================================================================== ** Macros that affect the API and must be stable (that is, must be the @@ -656,43 +708,46 @@ ** (It must fit into max(size_t)/32.) */ #if LUAI_IS32INT -#define LUAI_MAXSTACK 1000000 +#define LUAI_MAXSTACK 1000000 #else -#define LUAI_MAXSTACK 15000 +#define LUAI_MAXSTACK 15000 #endif + /* @@ LUA_EXTRASPACE defines the size of a raw memory area associated with ** a Lua state with very fast access. ** CHANGE it if you need a different size. */ -#define LUA_EXTRASPACE (sizeof(void*)) +#define LUA_EXTRASPACE (sizeof(void *)) + /* @@ LUA_IDSIZE gives the maximum size for the description of the source @@ of a function in debug information. ** CHANGE it if you want a different size. */ -#define LUA_IDSIZE 60 +#define LUA_IDSIZE 60 + /* @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. */ -#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) +#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) + /* @@ LUAI_MAXALIGN defines fields that, when used in a union, ensure ** maximum alignment for the other items in that union. */ -#define LUAI_MAXALIGN \ - lua_Number n; \ - double u; \ - void* s; \ - lua_Integer i; \ - long l +#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l /* }================================================================== */ + + + + /* =================================================================== */ /* @@ -700,4 +755,9 @@ ** without modifying the main part of the file. */ + + + + #endif + diff --git a/lib/lua-x64/include/lualib.h b/lib/lua-x64/include/lualib.h index 27a57726..eb08b530 100644 --- a/lib/lua-x64/include/lualib.h +++ b/lib/lua-x64/include/lualib.h @@ -4,48 +4,55 @@ ** See Copyright Notice in lua.h */ + #ifndef lualib_h #define lualib_h #include "lua.h" + /* version suffix for environment variable names */ -#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +LUAMOD_API int (luaopen_base) (lua_State *L); -LUAMOD_API int(luaopen_base)(lua_State* L); +#define LUA_COLIBNAME "coroutine" +LUAMOD_API int (luaopen_coroutine) (lua_State *L); -#define LUA_COLIBNAME "coroutine" -LUAMOD_API int(luaopen_coroutine)(lua_State* L); +#define LUA_TABLIBNAME "table" +LUAMOD_API int (luaopen_table) (lua_State *L); -#define LUA_TABLIBNAME "table" -LUAMOD_API int(luaopen_table)(lua_State* L); +#define LUA_IOLIBNAME "io" +LUAMOD_API int (luaopen_io) (lua_State *L); -#define LUA_IOLIBNAME "io" -LUAMOD_API int(luaopen_io)(lua_State* L); +#define LUA_OSLIBNAME "os" +LUAMOD_API int (luaopen_os) (lua_State *L); -#define LUA_OSLIBNAME "os" -LUAMOD_API int(luaopen_os)(lua_State* L); +#define LUA_STRLIBNAME "string" +LUAMOD_API int (luaopen_string) (lua_State *L); -#define LUA_STRLIBNAME "string" -LUAMOD_API int(luaopen_string)(lua_State* L); +#define LUA_UTF8LIBNAME "utf8" +LUAMOD_API int (luaopen_utf8) (lua_State *L); -#define LUA_UTF8LIBNAME "utf8" -LUAMOD_API int(luaopen_utf8)(lua_State* L); +#define LUA_MATHLIBNAME "math" +LUAMOD_API int (luaopen_math) (lua_State *L); -#define LUA_MATHLIBNAME "math" -LUAMOD_API int(luaopen_math)(lua_State* L); +#define LUA_DBLIBNAME "debug" +LUAMOD_API int (luaopen_debug) (lua_State *L); -#define LUA_DBLIBNAME "debug" -LUAMOD_API int(luaopen_debug)(lua_State* L); +#define LUA_LOADLIBNAME "package" +LUAMOD_API int (luaopen_package) (lua_State *L); -#define LUA_LOADLIBNAME "package" -LUAMOD_API int(luaopen_package)(lua_State* L); /* open all previous libraries */ -LUALIB_API void(luaL_openlibs)(lua_State* L); +LUALIB_API void (luaL_openlibs) (lua_State *L); + + #if !defined(lua_assert) -#define lua_assert(x) ((void)0) +#define lua_assert(x) ((void)0) #endif + #endif diff --git a/lib/lua/include/lauxlib.h b/lib/lua/include/lauxlib.h index ef7c3110..59fef6af 100644 --- a/lib/lua/include/lauxlib.h +++ b/lib/lua/include/lauxlib.h @@ -4,96 +4,117 @@ ** See Copyright Notice in lua.h */ + #ifndef lauxlib_h #define lauxlib_h + #include #include #include "lua.h" + /* global table */ -#define LUA_GNAME "_G" +#define LUA_GNAME "_G" + typedef struct luaL_Buffer luaL_Buffer; + /* extra error code for 'luaL_loadfilex' */ -#define LUA_ERRFILE (LUA_ERRERR + 1) +#define LUA_ERRFILE (LUA_ERRERR+1) + /* key, in the registry, for table of loaded modules */ -#define LUA_LOADED_TABLE "_LOADED" +#define LUA_LOADED_TABLE "_LOADED" + /* key, in the registry, for table of preloaded loaders */ -#define LUA_PRELOAD_TABLE "_PRELOAD" +#define LUA_PRELOAD_TABLE "_PRELOAD" + typedef struct luaL_Reg { - const char* name; - lua_CFunction func; + const char *name; + lua_CFunction func; } luaL_Reg; -#define LUAL_NUMSIZES (sizeof(lua_Integer) * 16 + sizeof(lua_Number)) -LUALIB_API void(luaL_checkversion_)(lua_State* L, lua_Number ver, size_t sz); -#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) -LUALIB_API int(luaL_getmetafield)(lua_State* L, int obj, const char* e); -LUALIB_API int(luaL_callmeta)(lua_State* L, int obj, const char* e); -LUALIB_API const char*(luaL_tolstring)(lua_State* L, int idx, size_t* len); -LUALIB_API int(luaL_argerror)(lua_State* L, int arg, const char* extramsg); -LUALIB_API int(luaL_typeerror)(lua_State* L, int arg, const char* tname); -LUALIB_API const char*(luaL_checklstring)(lua_State* L, int arg, size_t* l); -LUALIB_API const char*(luaL_optlstring)(lua_State* L, int arg, const char* def, size_t* l); -LUALIB_API lua_Number(luaL_checknumber)(lua_State* L, int arg); -LUALIB_API lua_Number(luaL_optnumber)(lua_State* L, int arg, lua_Number def); +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); +LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); +LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); +LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); -LUALIB_API lua_Integer(luaL_checkinteger)(lua_State* L, int arg); -LUALIB_API lua_Integer(luaL_optinteger)(lua_State* L, int arg, lua_Integer def); +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, + lua_Integer def); -LUALIB_API void(luaL_checkstack)(lua_State* L, int sz, const char* msg); -LUALIB_API void(luaL_checktype)(lua_State* L, int arg, int t); -LUALIB_API void(luaL_checkany)(lua_State* L, int arg); +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); +LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int arg); -LUALIB_API int(luaL_newmetatable)(lua_State* L, const char* tname); -LUALIB_API void(luaL_setmetatable)(lua_State* L, const char* tname); -LUALIB_API void*(luaL_testudata)(lua_State* L, int ud, const char* tname); -LUALIB_API void*(luaL_checkudata)(lua_State* L, int ud, const char* tname); +LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); +LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); +LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); -LUALIB_API void(luaL_where)(lua_State* L, int lvl); -LUALIB_API int(luaL_error)(lua_State* L, const char* fmt, ...); +LUALIB_API void (luaL_where) (lua_State *L, int lvl); +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); -LUALIB_API int(luaL_checkoption)(lua_State* L, int arg, const char* def, const char* const lst[]); +LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, + const char *const lst[]); + +LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); +LUALIB_API int (luaL_execresult) (lua_State *L, int stat); -LUALIB_API int(luaL_fileresult)(lua_State* L, int stat, const char* fname); -LUALIB_API int(luaL_execresult)(lua_State* L, int stat); /* predefined references */ -#define LUA_NOREF (-2) -#define LUA_REFNIL (-1) +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) -LUALIB_API int(luaL_ref)(lua_State* L, int t); -LUALIB_API void(luaL_unref)(lua_State* L, int t, int ref); +LUALIB_API int (luaL_ref) (lua_State *L, int t); +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); -LUALIB_API int(luaL_loadfilex)(lua_State* L, const char* filename, const char* mode); +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, + const char *mode); -#define luaL_loadfile(L, f) luaL_loadfilex(L, f, NULL) +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) -LUALIB_API int(luaL_loadbufferx)(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode); -LUALIB_API int(luaL_loadstring)(lua_State* L, const char* s); +LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); -LUALIB_API lua_State*(luaL_newstate)(void); +LUALIB_API lua_State *(luaL_newstate) (void); -LUALIB_API lua_Integer(luaL_len)(lua_State* L, int idx); +LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); -LUALIB_API void luaL_addgsub(luaL_Buffer* b, const char* s, const char* p, const char* r); -LUALIB_API const char*(luaL_gsub)(lua_State* L, const char* s, const char* p, const char* r); +LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, + const char *p, const char *r); +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, + const char *p, const char *r); -LUALIB_API void(luaL_setfuncs)(lua_State* L, const luaL_Reg* l, int nup); +LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); -LUALIB_API int(luaL_getsubtable)(lua_State* L, int idx, const char* fname); +LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); -LUALIB_API void(luaL_traceback)(lua_State* L, lua_State* L1, const char* msg, int level); +LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, + const char *msg, int level); -LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction openf, int glb); +LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, + lua_CFunction openf, int glb); /* ** =============================================================== @@ -101,31 +122,40 @@ LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction ** =============================================================== */ -#define luaL_newlibtable(L, l) lua_createtable(L, 0, sizeof(l) / sizeof((l)[0]) - 1) -#define luaL_newlib(L, l) (luaL_checkversion(L), luaL_newlibtable(L, l), luaL_setfuncs(L, l, 0)) +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) -#define luaL_argcheck(L, cond, arg, extramsg) ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) +#define luaL_argexpected(L,cond,arg,tname) \ + ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) -#define luaL_argexpected(L, cond, arg, tname) ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) -#define luaL_checkstring(L, n) (luaL_checklstring(L, (n), NULL)) -#define luaL_optstring(L, n, d) (luaL_optlstring(L, (n), (d), NULL)) +#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) -#define luaL_typename(L, i) lua_typename(L, lua_type(L, (i))) +#define luaL_dofile(L, fn) \ + (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) -#define luaL_dofile(L, fn) (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) +#define luaL_dostring(L, s) \ + (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) -#define luaL_dostring(L, s) (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) +#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) -#define luaL_getmetatable(L, n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) +#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) -#define luaL_opt(L, f, n, d) (lua_isnoneornil(L, (n)) ? (d) : f(L, (n))) +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) -#define luaL_loadbuffer(L, s, sz, n) luaL_loadbufferx(L, s, sz, n, NULL) /* push the value used to represent failure/error */ -#define luaL_pushfail(L) lua_pushnil(L) +#define luaL_pushfail(L) lua_pushnil(L) + /* ** {====================================================== @@ -134,38 +164,44 @@ LUALIB_API void(luaL_requiref)(lua_State* L, const char* modname, lua_CFunction */ struct luaL_Buffer { - char* b; /* buffer address */ - size_t size; /* buffer size */ - size_t n; /* number of characters in buffer */ - lua_State* L; - union { - LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ - char b[LUAL_BUFFERSIZE]; /* initial buffer */ - } init; + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + union { + LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ + char b[LUAL_BUFFERSIZE]; /* initial buffer */ + } init; }; -#define luaL_bufflen(bf) ((bf)->n) -#define luaL_buffaddr(bf) ((bf)->b) -#define luaL_addchar(B, c) ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), ((B)->b[(B)->n++] = (c))) +#define luaL_bufflen(bf) ((bf)->n) +#define luaL_buffaddr(bf) ((bf)->b) + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) -#define luaL_addsize(B, s) ((B)->n += (s)) +#define luaL_addsize(B,s) ((B)->n += (s)) -#define luaL_buffsub(B, s) ((B)->n -= (s)) +#define luaL_buffsub(B,s) ((B)->n -= (s)) -LUALIB_API void(luaL_buffinit)(lua_State* L, luaL_Buffer* B); -LUALIB_API char*(luaL_prepbuffsize)(luaL_Buffer* B, size_t sz); -LUALIB_API void(luaL_addlstring)(luaL_Buffer* B, const char* s, size_t l); -LUALIB_API void(luaL_addstring)(luaL_Buffer* B, const char* s); -LUALIB_API void(luaL_addvalue)(luaL_Buffer* B); -LUALIB_API void(luaL_pushresult)(luaL_Buffer* B); -LUALIB_API void(luaL_pushresultsize)(luaL_Buffer* B, size_t sz); -LUALIB_API char*(luaL_buffinitsize)(lua_State* L, luaL_Buffer* B, size_t sz); +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); +LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); -#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) /* }====================================================== */ + + /* ** {====================================================== ** File handles for IO library @@ -178,11 +214,12 @@ LUALIB_API char*(luaL_buffinitsize)(lua_State* L, luaL_Buffer* B, size_t sz); ** after that initial structure). */ -#define LUA_FILEHANDLE "FILE*" +#define LUA_FILEHANDLE "FILE*" + typedef struct luaL_Stream { - FILE* f; /* stream (NULL for incompletely created streams) */ - lua_CFunction closef; /* to close stream (NULL for closed streams) */ + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ } luaL_Stream; /* }====================================================== */ @@ -195,21 +232,23 @@ typedef struct luaL_Stream { /* print a string */ #if !defined(lua_writestring) -#define lua_writestring(s, l) fwrite((s), sizeof(char), (l), stdout) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) #endif /* print a newline and flush the output */ #if !defined(lua_writeline) -#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) #endif /* print an error message */ #if !defined(lua_writestringerror) -#define lua_writestringerror(s, p) (fprintf(stderr, (s), (p)), fflush(stderr)) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) #endif /* }================================================================== */ + /* ** {============================================================ ** Compatibility with deprecated conversions @@ -217,16 +256,21 @@ typedef struct luaL_Stream { */ #if defined(LUA_COMPAT_APIINTCASTS) -#define luaL_checkunsigned(L, a) ((lua_Unsigned)luaL_checkinteger(L, a)) -#define luaL_optunsigned(L, a, d) ((lua_Unsigned)luaL_optinteger(L, a, (lua_Integer)(d))) +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) -#define luaL_checkint(L, n) ((int)luaL_checkinteger(L, (n))) -#define luaL_optint(L, n, d) ((int)luaL_optinteger(L, (n), (d))) +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) -#define luaL_checklong(L, n) ((long)luaL_checkinteger(L, (n))) -#define luaL_optlong(L, n, d) ((long)luaL_optinteger(L, (n), (d))) +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #endif /* }============================================================ */ + + #endif + + diff --git a/lib/lua/include/lua.h b/lib/lua/include/lua.h index fa3b074a..c9d64d7f 100644 --- a/lib/lua/include/lua.h +++ b/lib/lua/include/lua.h @@ -5,78 +5,91 @@ ** See Copyright Notice at the end of this file */ + #ifndef lua_h #define lua_h #include #include + #include "luaconf.h" -#define LUA_VERSION_MAJOR "5" -#define LUA_VERSION_MINOR "4" -#define LUA_VERSION_RELEASE "2" -#define LUA_VERSION_NUM 504 -#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "4" +#define LUA_VERSION_RELEASE "2" + +#define LUA_VERSION_NUM 504 +#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" -#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE -#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" -#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" /* mark for precompiled code ('Lua') */ -#define LUA_SIGNATURE "\x1bLua" +#define LUA_SIGNATURE "\x1bLua" /* option for multiple returns in 'lua_pcall' and 'lua_call' */ -#define LUA_MULTRET (-1) +#define LUA_MULTRET (-1) + /* ** Pseudo-indices ** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty ** space after that to help overflow detection) */ -#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) -#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) + /* thread status */ -#define LUA_OK 0 -#define LUA_YIELD 1 -#define LUA_ERRRUN 2 -#define LUA_ERRSYNTAX 3 -#define LUA_ERRMEM 4 -#define LUA_ERRERR 5 +#define LUA_OK 0 +#define LUA_YIELD 1 +#define LUA_ERRRUN 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRERR 5 + typedef struct lua_State lua_State; + /* ** basic types */ -#define LUA_TNONE (-1) +#define LUA_TNONE (-1) + +#define LUA_TNIL 0 +#define LUA_TBOOLEAN 1 +#define LUA_TLIGHTUSERDATA 2 +#define LUA_TNUMBER 3 +#define LUA_TSTRING 4 +#define LUA_TTABLE 5 +#define LUA_TFUNCTION 6 +#define LUA_TUSERDATA 7 +#define LUA_TTHREAD 8 + +#define LUA_NUMTYPES 9 -#define LUA_TNIL 0 -#define LUA_TBOOLEAN 1 -#define LUA_TLIGHTUSERDATA 2 -#define LUA_TNUMBER 3 -#define LUA_TSTRING 4 -#define LUA_TTABLE 5 -#define LUA_TFUNCTION 6 -#define LUA_TUSERDATA 7 -#define LUA_TTHREAD 8 -#define LUA_NUMTYPES 9 /* minimum Lua stack available to a C function */ -#define LUA_MINSTACK 20 +#define LUA_MINSTACK 20 + /* predefined values in the registry */ -#define LUA_RIDX_MAINTHREAD 1 -#define LUA_RIDX_GLOBALS 2 -#define LUA_RIDX_LAST LUA_RIDX_GLOBALS +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + /* type of numbers in Lua */ typedef LUA_NUMBER lua_Number; + /* type for integer functions */ typedef LUA_INTEGER lua_Integer; @@ -86,32 +99,39 @@ typedef LUA_UNSIGNED lua_Unsigned; /* type for continuation-function contexts */ typedef LUA_KCONTEXT lua_KContext; + /* ** Type for C functions registered with Lua */ -typedef int (*lua_CFunction)(lua_State* L); +typedef int (*lua_CFunction) (lua_State *L); /* ** Type for continuation functions */ -typedef int (*lua_KFunction)(lua_State* L, int status, lua_KContext ctx); +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + /* ** Type for functions that read/write blocks when loading/dumping Lua chunks */ -typedef const char* (*lua_Reader)(lua_State* L, void* ud, size_t* sz); +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); -typedef int (*lua_Writer)(lua_State* L, const void* p, size_t sz, void* ud); /* ** Type for memory-allocation functions */ -typedef void* (*lua_Alloc)(void* ud, void* ptr, size_t osize, size_t nsize); +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + /* ** Type for warning functions */ -typedef void (*lua_WarnFunction)(void* ud, const char* msg, int tocont); +typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont); + + + /* ** generic extra include file @@ -120,194 +140,215 @@ typedef void (*lua_WarnFunction)(void* ud, const char* msg, int tocont); #include LUA_USER_H #endif + /* ** RCS ident string */ extern const char lua_ident[]; + /* ** state manipulation */ -LUA_API lua_State*(lua_newstate)(lua_Alloc f, void* ud); -LUA_API void(lua_close)(lua_State* L); -LUA_API lua_State*(lua_newthread)(lua_State* L); -LUA_API int(lua_resetthread)(lua_State* L); +LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); +LUA_API void (lua_close) (lua_State *L); +LUA_API lua_State *(lua_newthread) (lua_State *L); +LUA_API int (lua_resetthread) (lua_State *L); + +LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + -LUA_API lua_CFunction(lua_atpanic)(lua_State* L, lua_CFunction panicf); +LUA_API lua_Number (lua_version) (lua_State *L); -LUA_API lua_Number(lua_version)(lua_State* L); /* ** basic stack manipulation */ -LUA_API int(lua_absindex)(lua_State* L, int idx); -LUA_API int(lua_gettop)(lua_State* L); -LUA_API void(lua_settop)(lua_State* L, int idx); -LUA_API void(lua_pushvalue)(lua_State* L, int idx); -LUA_API void(lua_rotate)(lua_State* L, int idx, int n); -LUA_API void(lua_copy)(lua_State* L, int fromidx, int toidx); -LUA_API int(lua_checkstack)(lua_State* L, int n); +LUA_API int (lua_absindex) (lua_State *L, int idx); +LUA_API int (lua_gettop) (lua_State *L); +LUA_API void (lua_settop) (lua_State *L, int idx); +LUA_API void (lua_pushvalue) (lua_State *L, int idx); +LUA_API void (lua_rotate) (lua_State *L, int idx, int n); +LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); +LUA_API int (lua_checkstack) (lua_State *L, int n); + +LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); -LUA_API void(lua_xmove)(lua_State* from, lua_State* to, int n); /* ** access functions (stack -> C) */ -LUA_API int(lua_isnumber)(lua_State* L, int idx); -LUA_API int(lua_isstring)(lua_State* L, int idx); -LUA_API int(lua_iscfunction)(lua_State* L, int idx); -LUA_API int(lua_isinteger)(lua_State* L, int idx); -LUA_API int(lua_isuserdata)(lua_State* L, int idx); -LUA_API int(lua_type)(lua_State* L, int idx); -LUA_API const char*(lua_typename)(lua_State* L, int tp); - -LUA_API lua_Number(lua_tonumberx)(lua_State* L, int idx, int* isnum); -LUA_API lua_Integer(lua_tointegerx)(lua_State* L, int idx, int* isnum); -LUA_API int(lua_toboolean)(lua_State* L, int idx); -LUA_API const char*(lua_tolstring)(lua_State* L, int idx, size_t* len); -LUA_API lua_Unsigned(lua_rawlen)(lua_State* L, int idx); -LUA_API lua_CFunction(lua_tocfunction)(lua_State* L, int idx); -LUA_API void*(lua_touserdata)(lua_State* L, int idx); -LUA_API lua_State*(lua_tothread)(lua_State* L, int idx); -LUA_API const void*(lua_topointer)(lua_State* L, int idx); +LUA_API int (lua_isnumber) (lua_State *L, int idx); +LUA_API int (lua_isstring) (lua_State *L, int idx); +LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isinteger) (lua_State *L, int idx); +LUA_API int (lua_isuserdata) (lua_State *L, int idx); +LUA_API int (lua_type) (lua_State *L, int idx); +LUA_API const char *(lua_typename) (lua_State *L, int tp); + +LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); +LUA_API int (lua_toboolean) (lua_State *L, int idx); +LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); +LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx); +LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); +LUA_API void *(lua_touserdata) (lua_State *L, int idx); +LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); +LUA_API const void *(lua_topointer) (lua_State *L, int idx); + /* ** Comparison and arithmetic functions */ -#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ -#define LUA_OPSUB 1 -#define LUA_OPMUL 2 -#define LUA_OPMOD 3 -#define LUA_OPPOW 4 -#define LUA_OPDIV 5 -#define LUA_OPIDIV 6 -#define LUA_OPBAND 7 -#define LUA_OPBOR 8 -#define LUA_OPBXOR 9 -#define LUA_OPSHL 10 -#define LUA_OPSHR 11 -#define LUA_OPUNM 12 -#define LUA_OPBNOT 13 - -LUA_API void(lua_arith)(lua_State* L, int op); - -#define LUA_OPEQ 0 -#define LUA_OPLT 1 -#define LUA_OPLE 2 - -LUA_API int(lua_rawequal)(lua_State* L, int idx1, int idx2); -LUA_API int(lua_compare)(lua_State* L, int idx1, int idx2, int op); +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 + +LUA_API void (lua_arith) (lua_State *L, int op); + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); + /* ** push functions (C -> stack) */ -LUA_API void(lua_pushnil)(lua_State* L); -LUA_API void(lua_pushnumber)(lua_State* L, lua_Number n); -LUA_API void(lua_pushinteger)(lua_State* L, lua_Integer n); -LUA_API const char*(lua_pushlstring)(lua_State* L, const char* s, size_t len); -LUA_API const char*(lua_pushstring)(lua_State* L, const char* s); -LUA_API const char*(lua_pushvfstring)(lua_State* L, const char* fmt, va_list argp); -LUA_API const char*(lua_pushfstring)(lua_State* L, const char* fmt, ...); -LUA_API void(lua_pushcclosure)(lua_State* L, lua_CFunction fn, int n); -LUA_API void(lua_pushboolean)(lua_State* L, int b); -LUA_API void(lua_pushlightuserdata)(lua_State* L, void* p); -LUA_API int(lua_pushthread)(lua_State* L); +LUA_API void (lua_pushnil) (lua_State *L); +LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); +LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); +LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); +LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, + va_list argp); +LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); +LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); +LUA_API void (lua_pushboolean) (lua_State *L, int b); +LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); +LUA_API int (lua_pushthread) (lua_State *L); + /* ** get functions (Lua -> stack) */ -LUA_API int(lua_getglobal)(lua_State* L, const char* name); -LUA_API int(lua_gettable)(lua_State* L, int idx); -LUA_API int(lua_getfield)(lua_State* L, int idx, const char* k); -LUA_API int(lua_geti)(lua_State* L, int idx, lua_Integer n); -LUA_API int(lua_rawget)(lua_State* L, int idx); -LUA_API int(lua_rawgeti)(lua_State* L, int idx, lua_Integer n); -LUA_API int(lua_rawgetp)(lua_State* L, int idx, const void* p); - -LUA_API void(lua_createtable)(lua_State* L, int narr, int nrec); -LUA_API void*(lua_newuserdatauv)(lua_State* L, size_t sz, int nuvalue); -LUA_API int(lua_getmetatable)(lua_State* L, int objindex); -LUA_API int(lua_getiuservalue)(lua_State* L, int idx, int n); +LUA_API int (lua_getglobal) (lua_State *L, const char *name); +LUA_API int (lua_gettable) (lua_State *L, int idx); +LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawget) (lua_State *L, int idx); +LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); + +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n); + /* ** set functions (stack -> Lua) */ -LUA_API void(lua_setglobal)(lua_State* L, const char* name); -LUA_API void(lua_settable)(lua_State* L, int idx); -LUA_API void(lua_setfield)(lua_State* L, int idx, const char* k); -LUA_API void(lua_seti)(lua_State* L, int idx, lua_Integer n); -LUA_API void(lua_rawset)(lua_State* L, int idx); -LUA_API void(lua_rawseti)(lua_State* L, int idx, lua_Integer n); -LUA_API void(lua_rawsetp)(lua_State* L, int idx, const void* p); -LUA_API int(lua_setmetatable)(lua_State* L, int objindex); -LUA_API int(lua_setiuservalue)(lua_State* L, int idx, int n); +LUA_API void (lua_setglobal) (lua_State *L, const char *name); +LUA_API void (lua_settable) (lua_State *L, int idx); +LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n); + /* ** 'load' and 'call' functions (load and run Lua code) */ -LUA_API void(lua_callk)(lua_State* L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k); -#define lua_call(L, n, r) lua_callk(L, (n), (r), 0, NULL) +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k); +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k); +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) -LUA_API int(lua_pcallk)(lua_State* L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k); -#define lua_pcall(L, n, r, f) lua_pcallk(L, (n), (r), (f), 0, NULL) +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, const char *mode); -LUA_API int(lua_load)(lua_State* L, lua_Reader reader, void* dt, const char* chunkname, const char* mode); +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); -LUA_API int(lua_dump)(lua_State* L, lua_Writer writer, void* data, int strip); /* ** coroutine functions */ -LUA_API int(lua_yieldk)(lua_State* L, int nresults, lua_KContext ctx, lua_KFunction k); -LUA_API int(lua_resume)(lua_State* L, lua_State* from, int narg, int* nres); -LUA_API int(lua_status)(lua_State* L); -LUA_API int(lua_isyieldable)(lua_State* L); +LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k); +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg, + int *nres); +LUA_API int (lua_status) (lua_State *L); +LUA_API int (lua_isyieldable) (lua_State *L); + +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) -#define lua_yield(L, n) lua_yieldk(L, (n), 0, NULL) /* ** Warning-related functions */ -LUA_API void(lua_setwarnf)(lua_State* L, lua_WarnFunction f, void* ud); -LUA_API void(lua_warning)(lua_State* L, const char* msg, int tocont); +LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud); +LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont); + /* ** garbage-collection function and options */ -#define LUA_GCSTOP 0 -#define LUA_GCRESTART 1 -#define LUA_GCCOLLECT 2 -#define LUA_GCCOUNT 3 -#define LUA_GCCOUNTB 4 -#define LUA_GCSTEP 5 -#define LUA_GCSETPAUSE 6 -#define LUA_GCSETSTEPMUL 7 -#define LUA_GCISRUNNING 9 -#define LUA_GCGEN 10 -#define LUA_GCINC 11 +#define LUA_GCSTOP 0 +#define LUA_GCRESTART 1 +#define LUA_GCCOLLECT 2 +#define LUA_GCCOUNT 3 +#define LUA_GCCOUNTB 4 +#define LUA_GCSTEP 5 +#define LUA_GCSETPAUSE 6 +#define LUA_GCSETSTEPMUL 7 +#define LUA_GCISRUNNING 9 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +LUA_API int (lua_gc) (lua_State *L, int what, ...); -LUA_API int(lua_gc)(lua_State* L, int what, ...); /* ** miscellaneous functions */ -LUA_API int(lua_error)(lua_State* L); +LUA_API int (lua_error) (lua_State *L); + +LUA_API int (lua_next) (lua_State *L, int idx); -LUA_API int(lua_next)(lua_State* L, int idx); +LUA_API void (lua_concat) (lua_State *L, int n); +LUA_API void (lua_len) (lua_State *L, int idx); -LUA_API void(lua_concat)(lua_State* L, int n); -LUA_API void(lua_len)(lua_State* L, int idx); +LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); -LUA_API size_t(lua_stringtonumber)(lua_State* L, const char* s); +LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); -LUA_API lua_Alloc(lua_getallocf)(lua_State* L, void** ud); -LUA_API void(lua_setallocf)(lua_State* L, lua_Alloc f, void* ud); +LUA_API void (lua_toclose) (lua_State *L, int idx); -LUA_API void(lua_toclose)(lua_State* L, int idx); /* ** {============================================================== @@ -315,42 +356,45 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); ** =============================================================== */ -#define lua_getextraspace(L) ((void*)((char*)(L) - LUA_EXTRASPACE)) +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) -#define lua_tonumber(L, i) lua_tonumberx(L, (i), NULL) -#define lua_tointeger(L, i) lua_tointegerx(L, (i), NULL) +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) -#define lua_pop(L, n) lua_settop(L, -(n) - 1) +#define lua_pop(L,n) lua_settop(L, -(n)-1) -#define lua_newtable(L) lua_createtable(L, 0, 0) +#define lua_newtable(L) lua_createtable(L, 0, 0) -#define lua_register(L, n, f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) +#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) -#define lua_pushcfunction(L, f) lua_pushcclosure(L, (f), 0) +#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) -#define lua_isfunction(L, n) (lua_type(L, (n)) == LUA_TFUNCTION) -#define lua_istable(L, n) (lua_type(L, (n)) == LUA_TTABLE) -#define lua_islightuserdata(L, n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) -#define lua_isnil(L, n) (lua_type(L, (n)) == LUA_TNIL) -#define lua_isboolean(L, n) (lua_type(L, (n)) == LUA_TBOOLEAN) -#define lua_isthread(L, n) (lua_type(L, (n)) == LUA_TTHREAD) -#define lua_isnone(L, n) (lua_type(L, (n)) == LUA_TNONE) -#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) +#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) +#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) +#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) +#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) +#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) +#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) +#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) -#define lua_pushliteral(L, s) lua_pushstring(L, "" s) +#define lua_pushliteral(L, s) lua_pushstring(L, "" s) -#define lua_pushglobaltable(L) ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) +#define lua_pushglobaltable(L) \ + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) -#define lua_tostring(L, i) lua_tolstring(L, (i), NULL) +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) -#define lua_insert(L, idx) lua_rotate(L, (idx), 1) -#define lua_remove(L, idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) -#define lua_replace(L, idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) /* }============================================================== */ + /* ** {============================================================== ** compatibility macros @@ -358,17 +402,17 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); */ #if defined(LUA_COMPAT_APIINTCASTS) -#define lua_pushunsigned(L, n) lua_pushinteger(L, (lua_Integer)(n)) -#define lua_tounsignedx(L, i, is) ((lua_Unsigned)lua_tointegerx(L, i, is)) -#define lua_tounsigned(L, i) lua_tounsignedx(L, (i), NULL) +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) #endif -#define lua_newuserdata(L, s) lua_newuserdatauv(L, s, 1) -#define lua_getuservalue(L, idx) lua_getiuservalue(L, idx, 1) -#define lua_setuservalue(L, idx) lua_setiuservalue(L, idx, 1) +#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) +#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) +#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) -#define LUA_NUMTAGS LUA_NUMTYPES +#define LUA_NUMTAGS LUA_NUMTYPES /* }============================================================== */ @@ -378,89 +422,96 @@ LUA_API void(lua_toclose)(lua_State* L, int idx); ** ======================================================================= */ + /* ** Event codes */ -#define LUA_HOOKCALL 0 -#define LUA_HOOKRET 1 -#define LUA_HOOKLINE 2 -#define LUA_HOOKCOUNT 3 +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 #define LUA_HOOKTAILCALL 4 + /* ** Event masks */ -#define LUA_MASKCALL (1 << LUA_HOOKCALL) -#define LUA_MASKRET (1 << LUA_HOOKRET) -#define LUA_MASKLINE (1 << LUA_HOOKLINE) -#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) +#define LUA_MASKCALL (1 << LUA_HOOKCALL) +#define LUA_MASKRET (1 << LUA_HOOKRET) +#define LUA_MASKLINE (1 << LUA_HOOKLINE) +#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) + +typedef struct lua_Debug lua_Debug; /* activation record */ -typedef struct lua_Debug lua_Debug; /* activation record */ /* Functions to be called by the debugger in specific events */ -typedef void (*lua_Hook)(lua_State* L, lua_Debug* ar); +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + -LUA_API int(lua_getstack)(lua_State* L, int level, lua_Debug* ar); -LUA_API int(lua_getinfo)(lua_State* L, const char* what, lua_Debug* ar); -LUA_API const char*(lua_getlocal)(lua_State* L, const lua_Debug* ar, int n); -LUA_API const char*(lua_setlocal)(lua_State* L, const lua_Debug* ar, int n); -LUA_API const char*(lua_getupvalue)(lua_State* L, int funcindex, int n); -LUA_API const char*(lua_setupvalue)(lua_State* L, int funcindex, int n); +LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); +LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); +LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); -LUA_API void*(lua_upvalueid)(lua_State* L, int fidx, int n); -LUA_API void(lua_upvaluejoin)(lua_State* L, int fidx1, int n1, int fidx2, int n2); +LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); +LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, + int fidx2, int n2); -LUA_API void(lua_sethook)(lua_State* L, lua_Hook func, int mask, int count); -LUA_API lua_Hook(lua_gethook)(lua_State* L); -LUA_API int(lua_gethookmask)(lua_State* L); -LUA_API int(lua_gethookcount)(lua_State* L); +LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API lua_Hook (lua_gethook) (lua_State *L); +LUA_API int (lua_gethookmask) (lua_State *L); +LUA_API int (lua_gethookcount) (lua_State *L); -LUA_API int(lua_setcstacklimit)(lua_State* L, unsigned int limit); +LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit); struct lua_Debug { - int event; - const char* name; /* (n) */ - const char* namewhat; /* (n) 'global', 'local', 'field', 'method' */ - const char* what; /* (S) 'Lua', 'C', 'main', 'tail' */ - const char* source; /* (S) */ - size_t srclen; /* (S) */ - int currentline; /* (l) */ - int linedefined; /* (S) */ - int lastlinedefined; /* (S) */ - unsigned char nups; /* (u) number of upvalues */ - unsigned char nparams; /* (u) number of parameters */ - char isvararg; /* (u) */ - char istailcall; /* (t) */ - unsigned short ftransfer; /* (r) index of first value transferred */ - unsigned short ntransfer; /* (r) number of transferred values */ - char short_src[LUA_IDSIZE]; /* (S) */ - /* private part */ - struct CallInfo* i_ci; /* active function */ + int event; + const char *name; /* (n) */ + const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ + const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ + const char *source; /* (S) */ + size_t srclen; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + unsigned short ftransfer; /* (r) index of first value transferred */ + unsigned short ntransfer; /* (r) number of transferred values */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ }; /* }====================================================================== */ + /****************************************************************************** - * Copyright (C) 1994-2020 Lua.org, PUC-Rio. - * - * 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. - ******************************************************************************/ +* Copyright (C) 1994-2020 Lua.org, PUC-Rio. +* +* 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. +******************************************************************************/ + #endif diff --git a/lib/lua/include/lua.hpp b/lib/lua/include/lua.hpp index 964d99d0..ec417f59 100644 --- a/lib/lua/include/lua.hpp +++ b/lib/lua/include/lua.hpp @@ -3,7 +3,7 @@ // <> not supplied automatically because Lua also compiles as C++ extern "C" { -#include "lauxlib.h" #include "lua.h" #include "lualib.h" +#include "lauxlib.h" } diff --git a/lib/lua/include/luaconf.h b/lib/lua/include/luaconf.h index c70e1ae5..3ad294e4 100644 --- a/lib/lua/include/luaconf.h +++ b/lib/lua/include/luaconf.h @@ -4,12 +4,14 @@ ** See Copyright Notice in lua.h */ + #ifndef luaconf_h #define luaconf_h #include #include + /* ** =================================================================== ** General Configuration File for Lua @@ -26,6 +28,7 @@ ** =================================================================== */ + /* ** {==================================================================== ** System Configuration: macros to adapt (if needed) Lua to some @@ -40,35 +43,42 @@ */ /* #define LUA_USE_C89 */ + /* ** By default, Lua on Windows use (some) specific Windows features */ #if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) -#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ #endif + #if defined(LUA_USE_WINDOWS) -#define LUA_DL_DLL /* enable support for DLL */ -#define LUA_USE_C89 /* broadly, Windows is C89 */ +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ #endif + #if defined(LUA_USE_LINUX) #define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ #endif + #if defined(LUA_USE_MACOSX) #define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ #endif + /* @@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. */ -#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) +#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Number types. @@ -80,6 +90,7 @@ */ /* #define LUA_32BITS */ + /* @@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for ** C89 ('long' and 'double'); Windows always has '__int64', so it does @@ -89,6 +100,7 @@ #define LUA_C89_NUMBERS #endif + /* @@ LUA_INT_TYPE defines the type for Lua integers. @@ LUA_FLOAT_TYPE defines the type for Lua floats. @@ -100,48 +112,51 @@ */ /* predefined options for LUA_INT_TYPE */ -#define LUA_INT_INT 1 -#define LUA_INT_LONG 2 -#define LUA_INT_LONGLONG 3 +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 /* predefined options for LUA_FLOAT_TYPE */ -#define LUA_FLOAT_FLOAT 1 -#define LUA_FLOAT_DOUBLE 2 -#define LUA_FLOAT_LONGDOUBLE 3 +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 -#if defined(LUA_32BITS) /* { */ +#if defined(LUA_32BITS) /* { */ /* ** 32-bit integers and 'float' */ -#if LUAI_IS32INT /* use 'int' if big enough */ -#define LUA_INT_TYPE LUA_INT_INT -#else /* otherwise use 'long' */ -#define LUA_INT_TYPE LUA_INT_LONG +#if LUAI_IS32INT /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG #endif -#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT -#elif defined(LUA_C89_NUMBERS) /* }{ */ +#elif defined(LUA_C89_NUMBERS) /* }{ */ /* ** largest types available for C89 ('long' and 'double') */ -#define LUA_INT_TYPE LUA_INT_LONG -#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#endif /* } */ -#endif /* } */ /* ** default configuration for 64-bit Lua ('long long' and 'double') */ #if !defined(LUA_INT_TYPE) -#define LUA_INT_TYPE LUA_INT_LONGLONG +#define LUA_INT_TYPE LUA_INT_LONGLONG #endif #if !defined(LUA_FLOAT_TYPE) -#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE #endif /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Paths. @@ -155,9 +170,10 @@ ** LUA_EXEC_DIR in a Windows path is replaced by the executable's ** directory. */ -#define LUA_PATH_SEP ";" -#define LUA_PATH_MARK "?" -#define LUA_EXEC_DIR "!" +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" + /* @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for @@ -169,51 +185,53 @@ ** non-conventional directories. */ -#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#if defined(_WIN32) /* { */ +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#if defined(_WIN32) /* { */ /* ** In Windows, any exclamation mark ('!') in the path is replaced by the ** path of the directory of the executable file of the current process. */ -#define LUA_LDIR "!\\lua\\" -#define LUA_CDIR "!\\" -#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" #if !defined(LUA_PATH_DEFAULT) -#define LUA_PATH_DEFAULT \ - LUA_LDIR "?.lua;" LUA_LDIR "?\\init.lua;" LUA_CDIR "?.lua;" LUA_CDIR "?\\init.lua;" LUA_SHRDIR "?.lua;" LUA_SHRDIR "?\\init.lua;" \ - ".\\?.lua;" \ - ".\\?\\init.lua" +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ + LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ + ".\\?.lua;" ".\\?\\init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) -#define LUA_CPATH_DEFAULT \ - LUA_CDIR "?.dll;" LUA_CDIR "..\\lib\\lua\\" LUA_VDIR "\\?.dll;" LUA_CDIR "loadall.dll;" \ - ".\\?.dll;" LUA_CDIR "?54.dll;" \ - ".\\?54.dll" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" \ + LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ + LUA_CDIR"loadall.dll;" ".\\?.dll;" \ + LUA_CDIR"?54.dll;" ".\\?54.dll" #endif -#else /* }{ */ +#else /* }{ */ -#define LUA_ROOT "/usr/local/" -#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" -#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" #if !defined(LUA_PATH_DEFAULT) -#define LUA_PATH_DEFAULT \ - LUA_LDIR "?.lua;" LUA_LDIR "?/init.lua;" LUA_CDIR "?.lua;" LUA_CDIR "?/init.lua;" \ - "./?.lua;" \ - "./?/init.lua" +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ + "./?.lua;" "./?/init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) -#define LUA_CPATH_DEFAULT \ - LUA_CDIR "?.so;" LUA_CDIR "loadall.so;" \ - "./?.so;" LUA_CDIR "lib?54.so;" \ - "./lib?54.so" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \ + LUA_CDIR"lib?54.so;" "./lib?54.so" #endif -#endif /* } */ +#endif /* } */ + /* @@ LUA_DIRSEP is the directory separator (for submodules). @@ -223,15 +241,16 @@ #if !defined(LUA_DIRSEP) #if defined(_WIN32) -#define LUA_DIRSEP "\\" +#define LUA_DIRSEP "\\" #else -#define LUA_DIRSEP "/" +#define LUA_DIRSEP "/" #endif #endif /* }================================================================== */ + /* ** {================================================================== ** Marks for exported symbols in the C code @@ -247,25 +266,27 @@ ** the libraries, you may want to use the following definition (define ** LUA_BUILD_AS_DLL to get it). */ -#if defined(LUA_BUILD_AS_DLL) /* { */ +#if defined(LUA_BUILD_AS_DLL) /* { */ -#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ +#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ #define LUA_API __declspec(dllexport) -#else /* }{ */ +#else /* }{ */ #define LUA_API __declspec(dllimport) -#endif /* } */ +#endif /* } */ -#else /* }{ */ +#else /* }{ */ -#define LUA_API extern +#define LUA_API extern + +#endif /* } */ -#endif /* } */ /* ** More often than not the libs go together with the core. */ -#define LUALIB_API LUA_API -#define LUAMOD_API LUA_API +#define LUALIB_API LUA_API +#define LUAMOD_API LUA_API + /* @@ LUAI_FUNC is a mark for all extern functions that are not to be @@ -281,17 +302,19 @@ ** give a warning about it. To avoid these warnings, change to the ** default definition. */ -#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 302) && defined(__ELF__) /* { */ -#define LUAI_FUNC __attribute__((visibility("internal"))) extern -#else /* }{ */ -#define LUAI_FUNC extern -#endif /* } */ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("internal"))) extern +#else /* }{ */ +#define LUAI_FUNC extern +#endif /* } */ -#define LUAI_DDEC(dec) LUAI_FUNC dec -#define LUAI_DDEF /* empty */ +#define LUAI_DDEC(dec) LUAI_FUNC dec +#define LUAI_DDEF /* empty */ /* }================================================================== */ + /* ** {================================================================== ** Compatibility with previous versions @@ -303,7 +326,7 @@ ** You can define it to get all options, or change specific options ** to fit your specific needs. */ -#if defined(LUA_COMPAT_5_3) /* { */ +#if defined(LUA_COMPAT_5_3) /* { */ /* @@ LUA_COMPAT_MATHLIB controls the presence of several deprecated @@ -322,12 +345,14 @@ */ #define LUA_COMPAT_APIINTCASTS + /* @@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod ** using '__lt'. */ #define LUA_COMPAT_LT_LE + /* @@ The following macros supply trivial compatibility for some ** changes in the API. The macros themselves document how to @@ -335,17 +360,19 @@ ** (Once more, these macros were officially removed in 5.3, but they are ** still available here.) */ -#define lua_strlen(L, i) lua_rawlen(L, (i)) +#define lua_strlen(L,i) lua_rawlen(L, (i)) -#define lua_objlen(L, i) lua_rawlen(L, (i)) +#define lua_objlen(L,i) lua_rawlen(L, (i)) -#define lua_equal(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPEQ) -#define lua_lessthan(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPLT) +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) -#endif /* } */ +#endif /* } */ /* }================================================================== */ + + /* ** {================================================================== ** Configuration for Numbers. @@ -368,11 +395,13 @@ @@ lua_str2number converts a decimal numeral to a number. */ + /* The following definitions are good for most cases here */ -#define l_floor(x) (l_mathop(floor)(x)) +#define l_floor(x) (l_mathop(floor)(x)) -#define lua_number2str(s, sz, n) l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) /* @@ lua_numbertointeger converts a float number with an integral value @@ -383,60 +412,67 @@ ** MAXINTEGER may not have one, and therefore its conversion to float ** may have an ill-defined value.) */ -#define lua_numbertointeger(n, p) ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && (n) < -(LUA_NUMBER)(LUA_MININTEGER) && (*(p) = (LUA_INTEGER)(n), 1)) +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + /* now the variable definitions */ -#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float -#define LUA_NUMBER float +#define l_floatatt(n) (FLT_##n) -#define l_floatatt(n) (FLT_##n) +#define LUAI_UACNUMBER double -#define LUAI_UACNUMBER double +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.7g" +#define l_mathop(op) op##f -#define l_mathop(op) op##f +#define lua_str2number(s,p) strtof((s), (p)) -#define lua_str2number(s, p) strtof((s), (p)) -#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ -#define LUA_NUMBER long double +#define LUA_NUMBER long double -#define l_floatatt(n) (LDBL_##n) +#define l_floatatt(n) (LDBL_##n) -#define LUAI_UACNUMBER long double +#define LUAI_UACNUMBER long double -#define LUA_NUMBER_FRMLEN "L" -#define LUA_NUMBER_FMT "%.19Lg" +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" -#define l_mathop(op) op##l +#define l_mathop(op) op##l -#define lua_str2number(s, p) strtold((s), (p)) +#define lua_str2number(s,p) strtold((s), (p)) -#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ -#define LUA_NUMBER double +#define LUA_NUMBER double -#define l_floatatt(n) (DBL_##n) +#define l_floatatt(n) (DBL_##n) -#define LUAI_UACNUMBER double +#define LUAI_UACNUMBER double -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.14g" +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" -#define l_mathop(op) op +#define l_mathop(op) op -#define lua_str2number(s, p) strtod((s), (p)) +#define lua_str2number(s,p) strtod((s), (p)) -#else /* }{ */ +#else /* }{ */ #error "numeric float type not defined" -#endif /* } */ +#endif /* } */ + + /* @@ LUA_INTEGER is the integer type used by Lua. @@ -454,84 +490,89 @@ @@ lua_integer2str converts an integer to a string. */ + /* The following definitions are good for most cases here */ -#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" -#define LUAI_UACINT LUA_INTEGER +#define LUAI_UACINT LUA_INTEGER -#define lua_integer2str(s, sz, n) l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) /* ** use LUAI_UACINT here to avoid problems with promotions (which ** can turn a comparison between unsigneds into a signed comparison) */ -#define LUA_UNSIGNED unsigned LUAI_UACINT +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) -#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) /* now the variable definitions */ -#if LUA_INT_TYPE == LUA_INT_INT /* { int */ +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ -#define LUA_INTEGER int -#define LUA_INTEGER_FRMLEN "" +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" -#define LUA_MAXINTEGER INT_MAX -#define LUA_MININTEGER INT_MIN +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN -#define LUA_MAXUNSIGNED UINT_MAX +#define LUA_MAXUNSIGNED UINT_MAX -#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ -#define LUA_INTEGER long -#define LUA_INTEGER_FRMLEN "l" +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" -#define LUA_MAXINTEGER LONG_MAX -#define LUA_MININTEGER LONG_MIN +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN -#define LUA_MAXUNSIGNED ULONG_MAX +#define LUA_MAXUNSIGNED ULONG_MAX -#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ /* use presence of macro LLONG_MAX as proxy for C99 compliance */ -#if defined(LLONG_MAX) /* { */ +#if defined(LLONG_MAX) /* { */ /* use ISO C99 stuff */ -#define LUA_INTEGER long long -#define LUA_INTEGER_FRMLEN "ll" +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" -#define LUA_MAXINTEGER LLONG_MAX -#define LUA_MININTEGER LLONG_MIN +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN -#define LUA_MAXUNSIGNED ULLONG_MAX +#define LUA_MAXUNSIGNED ULLONG_MAX #elif defined(LUA_USE_WINDOWS) /* }{ */ /* in Windows, can use specific Windows types */ -#define LUA_INTEGER __int64 -#define LUA_INTEGER_FRMLEN "I64" +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" -#define LUA_MAXINTEGER _I64_MAX -#define LUA_MININTEGER _I64_MIN +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN -#define LUA_MAXUNSIGNED _UI64_MAX +#define LUA_MAXUNSIGNED _UI64_MAX -#else /* }{ */ +#else /* }{ */ #error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" -#endif /* } */ +#endif /* } */ -#else /* }{ */ +#else /* }{ */ #error "numeric integer type not defined" -#endif /* } */ +#endif /* } */ /* }================================================================== */ + /* ** {================================================================== ** Dependencies with C99 and other C details @@ -543,11 +584,12 @@ ** (All uses in Lua have only one format item.) */ #if !defined(LUA_USE_C89) -#define l_sprintf(s, sz, f, i) snprintf(s, sz, f, i) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) #else -#define l_sprintf(s, sz, f, i) ((void)(sz), sprintf(s, f, i)) +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) #endif + /* @@ lua_strx2number converts a hexadecimal numeral to a number. ** In C99, 'strtod' does that conversion. Otherwise, you can @@ -555,14 +597,16 @@ ** implementation. */ #if !defined(LUA_USE_C89) -#define lua_strx2number(s, p) lua_str2number(s, p) +#define lua_strx2number(s,p) lua_str2number(s,p) #endif + /* @@ lua_pointer2str converts a pointer to a readable string in a ** non-specified way. */ -#define lua_pointer2str(buff, sz, p) l_sprintf(buff, sz, "%p", p) +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) + /* @@ lua_number2strx converts a float to a hexadecimal numeral. @@ -571,9 +615,11 @@ ** provide its own implementation. */ #if !defined(LUA_USE_C89) -#define lua_number2strx(L, b, sz, f, n) ((void)L, l_sprintf(b, sz, f, (LUAI_UACNUMBER)(n))) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) #endif + /* ** 'strtof' and 'opf' variants for math functions are not valid in ** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the @@ -581,39 +627,43 @@ ** all files that use these macros.) */ #if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) -#undef l_mathop /* variants not available */ +#undef l_mathop /* variants not available */ #undef lua_str2number -#define l_mathop(op) (lua_Number) op /* no variant */ -#define lua_str2number(s, p) ((lua_Number)strtod((s), (p))) +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) #endif + /* @@ LUA_KCONTEXT is the type of the context ('ctx') for continuation ** functions. It must be a numerical type; Lua will use 'intptr_t' if ** available, otherwise it will use 'ptrdiff_t' (the nearest thing to ** 'intptr_t' in C89) */ -#define LUA_KCONTEXT ptrdiff_t +#define LUA_KCONTEXT ptrdiff_t -#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L #include -#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ #undef LUA_KCONTEXT -#define LUA_KCONTEXT intptr_t +#define LUA_KCONTEXT intptr_t #endif #endif + /* @@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). ** Change that if you do not want to use C locales. (Code using this ** macro must include the header 'locale.h'.) */ #if !defined(lua_getlocaledecpoint) -#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) #endif /* }================================================================== */ + /* ** {================================================================== ** Language Variations @@ -629,17 +679,19 @@ /* #define LUA_NOCVTN2S */ /* #define LUA_NOCVTS2N */ + /* @@ LUA_USE_APICHECK turns on several consistency checks on the C API. ** Define it as a help when debugging C code. */ #if defined(LUA_USE_APICHECK) #include -#define luai_apicheck(l, e) assert(e) +#define luai_apicheck(l,e) assert(e) #endif /* }================================================================== */ + /* ** {================================================================== ** Macros that affect the API and must be stable (that is, must be the @@ -656,43 +708,46 @@ ** (It must fit into max(size_t)/32.) */ #if LUAI_IS32INT -#define LUAI_MAXSTACK 1000000 +#define LUAI_MAXSTACK 1000000 #else -#define LUAI_MAXSTACK 15000 +#define LUAI_MAXSTACK 15000 #endif + /* @@ LUA_EXTRASPACE defines the size of a raw memory area associated with ** a Lua state with very fast access. ** CHANGE it if you need a different size. */ -#define LUA_EXTRASPACE (sizeof(void*)) +#define LUA_EXTRASPACE (sizeof(void *)) + /* @@ LUA_IDSIZE gives the maximum size for the description of the source @@ of a function in debug information. ** CHANGE it if you want a different size. */ -#define LUA_IDSIZE 60 +#define LUA_IDSIZE 60 + /* @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. */ -#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) +#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) + /* @@ LUAI_MAXALIGN defines fields that, when used in a union, ensure ** maximum alignment for the other items in that union. */ -#define LUAI_MAXALIGN \ - lua_Number n; \ - double u; \ - void* s; \ - lua_Integer i; \ - long l +#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l /* }================================================================== */ + + + + /* =================================================================== */ /* @@ -700,4 +755,9 @@ ** without modifying the main part of the file. */ + + + + #endif + diff --git a/lib/lua/include/lualib.h b/lib/lua/include/lualib.h index 27a57726..eb08b530 100644 --- a/lib/lua/include/lualib.h +++ b/lib/lua/include/lualib.h @@ -4,48 +4,55 @@ ** See Copyright Notice in lua.h */ + #ifndef lualib_h #define lualib_h #include "lua.h" + /* version suffix for environment variable names */ -#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +LUAMOD_API int (luaopen_base) (lua_State *L); -LUAMOD_API int(luaopen_base)(lua_State* L); +#define LUA_COLIBNAME "coroutine" +LUAMOD_API int (luaopen_coroutine) (lua_State *L); -#define LUA_COLIBNAME "coroutine" -LUAMOD_API int(luaopen_coroutine)(lua_State* L); +#define LUA_TABLIBNAME "table" +LUAMOD_API int (luaopen_table) (lua_State *L); -#define LUA_TABLIBNAME "table" -LUAMOD_API int(luaopen_table)(lua_State* L); +#define LUA_IOLIBNAME "io" +LUAMOD_API int (luaopen_io) (lua_State *L); -#define LUA_IOLIBNAME "io" -LUAMOD_API int(luaopen_io)(lua_State* L); +#define LUA_OSLIBNAME "os" +LUAMOD_API int (luaopen_os) (lua_State *L); -#define LUA_OSLIBNAME "os" -LUAMOD_API int(luaopen_os)(lua_State* L); +#define LUA_STRLIBNAME "string" +LUAMOD_API int (luaopen_string) (lua_State *L); -#define LUA_STRLIBNAME "string" -LUAMOD_API int(luaopen_string)(lua_State* L); +#define LUA_UTF8LIBNAME "utf8" +LUAMOD_API int (luaopen_utf8) (lua_State *L); -#define LUA_UTF8LIBNAME "utf8" -LUAMOD_API int(luaopen_utf8)(lua_State* L); +#define LUA_MATHLIBNAME "math" +LUAMOD_API int (luaopen_math) (lua_State *L); -#define LUA_MATHLIBNAME "math" -LUAMOD_API int(luaopen_math)(lua_State* L); +#define LUA_DBLIBNAME "debug" +LUAMOD_API int (luaopen_debug) (lua_State *L); -#define LUA_DBLIBNAME "debug" -LUAMOD_API int(luaopen_debug)(lua_State* L); +#define LUA_LOADLIBNAME "package" +LUAMOD_API int (luaopen_package) (lua_State *L); -#define LUA_LOADLIBNAME "package" -LUAMOD_API int(luaopen_package)(lua_State* L); /* open all previous libraries */ -LUALIB_API void(luaL_openlibs)(lua_State* L); +LUALIB_API void (luaL_openlibs) (lua_State *L); + + #if !defined(lua_assert) -#define lua_assert(x) ((void)0) +#define lua_assert(x) ((void)0) #endif + #endif diff --git a/lib/md5.c b/lib/md5.c index cff6f11e..f629e92d 100644 --- a/lib/md5.c +++ b/lib/md5.c @@ -10,11 +10,11 @@ freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. + misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. L. Peter Deutsch @@ -27,7 +27,7 @@ This code implements the MD5 Algorithm defined in RFC 1321, whose text is available at - http://www.ietf.org/rfc/rfc1321.txt + http://www.ietf.org/rfc/rfc1321.txt The code is derived from the text of the RFC, including the test suite (section A.5) but excluding the rest of Appendix A. It does not include any code or documentation that is identified in the RFC as being @@ -38,14 +38,14 @@ that follows (in reverse chronological order): 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order - either statically or dynamically; added missing #include - in library. + either statically or dynamically; added missing #include + in library. 2002-03-11 lpd Corrected argument list for main(), and added int return - type, in test program and T value program. + type, in test program and T value program. 2002-02-21 lpd Added missing #include in test program. 2000-07-03 lpd Patched to eliminate warnings about "constant is - unsigned in ANSI C, signed in traditional"; made test program - self-checking. + unsigned in ANSI C, signed in traditional"; made test program + self-checking. 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). 1999-05-03 lpd Original version. @@ -54,86 +54,90 @@ #include "md5.h" #include -#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ +#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ #ifdef ARCH_IS_BIG_ENDIAN -#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) +# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) #else -#define BYTE_ORDER 0 +# define BYTE_ORDER 0 #endif #define T_MASK ((md5_word_t)~0) #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) -#define T3 0x242070db +#define T3 0x242070db #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) -#define T6 0x4787c62a +#define T6 0x4787c62a #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) -#define T9 0x698098d8 +#define T9 0x698098d8 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) -#define T13 0x6b901122 +#define T13 0x6b901122 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) -#define T16 0x49b40821 +#define T16 0x49b40821 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) -#define T19 0x265e5a51 +#define T19 0x265e5a51 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) -#define T22 0x02441453 +#define T22 0x02441453 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) -#define T25 0x21e1cde6 +#define T25 0x21e1cde6 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) -#define T28 0x455a14ed +#define T28 0x455a14ed #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) -#define T31 0x676f02d9 +#define T31 0x676f02d9 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) -#define T35 0x6d9d6122 +#define T35 0x6d9d6122 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) -#define T38 0x4bdecfa9 +#define T38 0x4bdecfa9 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) -#define T41 0x289b7ec6 +#define T41 0x289b7ec6 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) -#define T44 0x04881d05 +#define T44 0x04881d05 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) -#define T47 0x1fa27cf8 +#define T47 0x1fa27cf8 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) -#define T50 0x432aff97 +#define T50 0x432aff97 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) -#define T53 0x655b59c3 +#define T53 0x655b59c3 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) -#define T57 0x6fa87e4f +#define T57 0x6fa87e4f #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) -#define T60 0x4e0811a1 +#define T60 0x4e0811a1 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) -#define T63 0x2ad7d2bb +#define T63 0x2ad7d2bb #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) -static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) + +static void +md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) { - md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3]; + md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; md5_word_t t; #if BYTE_ORDER > 0 - /* Define storage only for big-endian CPUs. */ - md5_word_t X[16]; + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; #else /* Define storage for little-endian or both types of CPUs. */ md5_word_t xbuf[16]; @@ -151,7 +155,7 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) if (*((const md5_byte_t*)&w)) /* dynamic little-endian */ #endif -#if BYTE_ORDER <= 0 /* little-endian */ +#if BYTE_ORDER <= 0 /* little-endian */ { /* * On little-endian machines, we can process properly aligned @@ -173,7 +177,7 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) #if BYTE_ORDER == 0 else /* dynamic big-endian */ #endif -#if BYTE_ORDER >= 0 /* big-endian */ +#if BYTE_ORDER >= 0 /* big-endian */ { /* * On big-endian machines, we must arrange the bytes in the @@ -182,11 +186,11 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) const md5_byte_t* xp = data; int i; -#if BYTE_ORDER == 0 +# if BYTE_ORDER == 0 X = xbuf; /* (dynamic only) */ -#else -#define xbuf X /* (static only) */ -#endif +# else + # define xbuf X /* (static only) */ +# endif for (i = 0; i < 16; ++i, xp += 4) xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); } @@ -199,9 +203,9 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) /* Let [abcd k s i] denote the operation a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ #define F(x, y, z) (((x) & (y)) | (~(x) & (z))) -#define SET(a, b, c, d, k, s, Ti) \ - t = a + F(b, c, d) + X[k] + Ti; \ - a = ROTATE_LEFT(t, s) + b +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 0, 7, T1); SET(d, a, b, c, 1, 12, T2); @@ -225,9 +229,9 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) /* Let [abcd k s i] denote the operation a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ #define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) -#define SET(a, b, c, d, k, s, Ti) \ - t = a + G(b, c, d) + X[k] + Ti; \ - a = ROTATE_LEFT(t, s) + b +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 1, 5, T17); SET(d, a, b, c, 6, 9, T18); @@ -251,9 +255,9 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) /* Let [abcd k s t] denote the operation a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ #define H(x, y, z) ((x) ^ (y) ^ (z)) -#define SET(a, b, c, d, k, s, Ti) \ - t = a + H(b, c, d) + X[k] + Ti; \ - a = ROTATE_LEFT(t, s) + b +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 5, 4, T33); SET(d, a, b, c, 8, 11, T34); @@ -277,9 +281,9 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) /* Let [abcd k s t] denote the operation a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ #define I(x, y, z) ((y) ^ ((x) | ~(z))) -#define SET(a, b, c, d, k, s, Ti) \ - t = a + I(b, c, d) + X[k] + Ti; \ - a = ROTATE_LEFT(t, s) + b +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 0, 6, T49); SET(d, a, b, c, 7, 10, T50); @@ -308,7 +312,8 @@ static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) pms->abcd[3] += d; } -void md5_init(md5_state_t* pms) +void +md5_init(md5_state_t* pms) { pms->count[0] = pms->count[1] = 0; pms->abcd[0] = 0x67452301; @@ -317,7 +322,8 @@ void md5_init(md5_state_t* pms) pms->abcd[3] = 0x10325476; } -void md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes) +void +md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes) { const md5_byte_t* p = data; int left = nbytes; @@ -355,9 +361,15 @@ void md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes) memcpy(pms->buf, p, left); } -void md5_finish(md5_state_t* pms, md5_byte_t digest[16]) +void +md5_finish(md5_state_t* pms, md5_byte_t digest[16]) { - static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + static const md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; md5_byte_t data[8]; int i; diff --git a/lib/md5.h b/lib/md5.h index 4051c051..d10d198d 100644 --- a/lib/md5.h +++ b/lib/md5.h @@ -10,11 +10,11 @@ freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. + misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. L. Peter Deutsch @@ -27,7 +27,7 @@ This code implements the MD5 Algorithm defined in RFC 1321, whose text is available at - http://www.ietf.org/rfc/rfc1321.txt + http://www.ietf.org/rfc/rfc1321.txt The code is derived from the text of the RFC, including the test suite (section A.5) but excluding the rest of Appendix A. It does not include any code or documentation that is identified in the RFC as being @@ -38,17 +38,17 @@ that follows (in reverse chronological order): 2002-04-13 lpd Removed support for non-ANSI compilers; removed - references to Ghostscript; clarified derivation from RFC 1321; - now handles byte order either statically or dynamically. + references to Ghostscript; clarified derivation from RFC 1321; + now handles byte order either statically or dynamically. 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); - added conditionalization for C++ compilation from Martin - Purschke . + added conditionalization for C++ compilation from Martin + Purschke . 1999-05-03 lpd Original version. */ #ifndef md5_INCLUDED -#define md5_INCLUDED +# define md5_INCLUDED /* * This package supports both compile-time and run-time determination of CPU @@ -64,10 +64,11 @@ typedef unsigned char md5_byte_t; /* 8-bit byte */ typedef unsigned int md5_word_t; /* 32-bit word */ /* Define the state of the MD5 Algorithm. */ -typedef struct md5_state_s { - md5_word_t count[2]; /* message length in bits, lsw first */ - md5_word_t abcd[4]; /* digest buffer */ - md5_byte_t buf[64]; /* accumulate block */ +typedef struct md5_state_s +{ + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ } md5_state_t; #ifdef __cplusplus diff --git a/lib/microlru.h b/lib/microlru.h index e418fd41..573e52b6 100644 --- a/lib/microlru.h +++ b/lib/microlru.h @@ -6,111 +6,121 @@ namespace MicroLRU { - template - class Cache { - public: - Cache() : m_size(0) {} - - /** - * \brief Creates a cache with a maximum size - * \param size The cache's maximum size - * \param deleter Deleter function for evicted values - */ - Cache(int size, std::function deleter) - { - m_size = size; - m_deleter = deleter; - } - - /** - * \brief Adds a value to the cache, evicting the least used value if the - * cache is full \param key \param value \remarks The value is swapped if the - * key already exists - */ - void add(K key, V value) - { - if (m_map.size() >= m_size) - { - auto lu_key = least_used_key(); - if (lu_key.has_value()) - { - m_deleter(m_map[lu_key.value()].second); - m_map.erase(lu_key.value()); - } - } - - m_map[key] = std::make_pair(0, value); - } - - /** - * \brief Removes all elements from the cache and calls the deleter - */ - void clear() - { - for (auto const& [_, val] : m_map) - { - m_deleter(val.second); - } - m_map.clear(); - } - - /** - * \brief Gets a value from the cache via a key - * \param key The key - * \return The value associated with the key, or nothing if the key does not - * exist - */ - std::optional get(K key) - { - if (!contains(key)) - { - return std::nullopt; - } - - auto& [usage, value] = m_map[key]; - ++usage; - return std::make_optional(value); - } - - /** - * \brief Checks if the cache contains a key - */ - bool contains(K key) { return m_map.contains(key); } - - /** - * \brief Gets the current size of the cache - */ - size_t size() { return m_map.size(); } - - private: - // Gets the least used key - std::optional least_used_key() - { - if (m_map.size() == 0) - { - return std::nullopt; - } - - K key; - size_t min = SIZE_MAX; - - for (auto& [k, v] : m_map) - { - if (v.first < min) - { - min = v.first; - key = k; - } - } - - return std::make_optional(key); - } - - size_t m_size; - - std::function m_deleter; - - // Map of key to pair of usage count and value - std::unordered_map> m_map; - }; -} // namespace MicroLRU + template + class Cache + { + public: + Cache(): m_size(0) + { + } + + /** + * \brief Creates a cache with a maximum size + * \param size The cache's maximum size + * \param deleter Deleter function for evicted values + */ + Cache(int size, std::function deleter) + { + m_size = size; + m_deleter = deleter; + } + + /** + * \brief Adds a value to the cache, evicting the least used value if the cache is full + * \param key + * \param value + * \remarks The value is swapped if the key already exists + */ + void add(K key, V value) + { + if (m_map.size() >= m_size) + { + auto lu_key = least_used_key(); + if (lu_key.has_value()) + { + m_deleter(m_map[lu_key.value()].second); + m_map.erase(lu_key.value()); + } + } + + m_map[key] = std::make_pair(0, value); + } + + + /** + * \brief Removes all elements from the cache and calls the deleter + */ + void clear() + { + for (auto const& [_, val] : m_map) + { + m_deleter(val.second); + } + m_map.clear(); + } + + /** + * \brief Gets a value from the cache via a key + * \param key The key + * \return The value associated with the key, or nothing if the key does not exist + */ + std::optional get(K key) + { + if (!contains(key)) + { + return std::nullopt; + } + + auto& [usage, value] = m_map[key]; + ++usage; + return std::make_optional(value); + } + + /** + * \brief Checks if the cache contains a key + */ + bool contains(K key) + { + return m_map.contains(key); + } + + /** + * \brief Gets the current size of the cache + */ + size_t size() + { + return m_map.size(); + } + + private: + // Gets the least used key + std::optional least_used_key() + { + if (m_map.size() == 0) + { + return std::nullopt; + } + + K key; + size_t min = SIZE_MAX; + + for (auto& [k, v] : m_map) + { + if (v.first < min) + { + min = v.first; + key = k; + } + } + + return std::make_optional(key); + } + + size_t m_size; + + std::function m_deleter; + + // Map of key to pair of usage count and value + std::unordered_map> m_map; + }; +} diff --git a/lib/spdlog/async.h b/lib/spdlog/async.h index af949c14..e96abd19 100644 --- a/lib/spdlog/async.h +++ b/lib/spdlog/async.h @@ -22,74 +22,79 @@ #include #include -namespace spdlog -{ +namespace spdlog { - namespace details - { - static const size_t default_async_q_size = 8192; - } - - // async logger factory - creates async loggers backed with thread pool. - // if a global thread pool doesn't already exist, create it with default queue - // size of 8192 items and single thread. - template - struct async_factory_impl { - template - static std::shared_ptr create(std::string logger_name, SinkArgs&&... args) - { - auto& registry_inst = details::registry::instance(); - - // create global thread pool if not already exists.. - - auto& mutex = registry_inst.tp_mutex(); - std::lock_guard tp_lock(mutex); - auto tp = registry_inst.get_tp(); - if (tp == nullptr) - { - tp = std::make_shared(details::default_async_q_size, 1U); - registry_inst.set_tp(tp); - } - - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); - registry_inst.initialize_logger(new_logger); - return new_logger; - } - }; - - using async_factory = async_factory_impl; - using async_factory_nonblock = async_factory_impl; - - template - inline std::shared_ptr create_async(std::string logger_name, SinkArgs&&... sink_args) - { - return async_factory::create(std::move(logger_name), std::forward(sink_args)...); - } +namespace details { +static const size_t default_async_q_size = 8192; +} +// async logger factory - creates async loggers backed with thread pool. +// if a global thread pool doesn't already exist, create it with default queue +// size of 8192 items and single thread. +template +struct async_factory_impl { template - inline std::shared_ptr create_async_nb(std::string logger_name, SinkArgs&&... sink_args) - { - return async_factory_nonblock::create(std::move(logger_name), std::forward(sink_args)...); - } + static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { + auto ®istry_inst = details::registry::instance(); - // set global thread pool. - inline void init_thread_pool(size_t q_size, size_t thread_count, std::function on_thread_start, std::function on_thread_stop) - { - auto tp = std::make_shared(q_size, thread_count, on_thread_start, on_thread_stop); - details::registry::instance().set_tp(std::move(tp)); - } + // create global thread pool if not already exists.. - inline void init_thread_pool(size_t q_size, size_t thread_count, std::function on_thread_start) - { - init_thread_pool(q_size, thread_count, on_thread_start, [] {}); - } + auto &mutex = registry_inst.tp_mutex(); + std::lock_guard tp_lock(mutex); + auto tp = registry_inst.get_tp(); + if (tp == nullptr) { + tp = std::make_shared(details::default_async_q_size, 1U); + registry_inst.set_tp(tp); + } - inline void init_thread_pool(size_t q_size, size_t thread_count) - { - init_thread_pool(q_size, thread_count, [] {}, [] {}); + auto sink = std::make_shared(std::forward(args)...); + auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), + std::move(tp), OverflowPolicy); + registry_inst.initialize_logger(new_logger); + return new_logger; } - - // get the global thread pool. - inline std::shared_ptr thread_pool() { return details::registry::instance().get_tp(); } -} // namespace spdlog +}; + +using async_factory = async_factory_impl; +using async_factory_nonblock = async_factory_impl; + +template +inline std::shared_ptr create_async(std::string logger_name, + SinkArgs &&...sink_args) { + return async_factory::create(std::move(logger_name), + std::forward(sink_args)...); +} + +template +inline std::shared_ptr create_async_nb(std::string logger_name, + SinkArgs &&...sink_args) { + return async_factory_nonblock::create(std::move(logger_name), + std::forward(sink_args)...); +} + +// set global thread pool. +inline void init_thread_pool(size_t q_size, + size_t thread_count, + std::function on_thread_start, + std::function on_thread_stop) { + auto tp = std::make_shared(q_size, thread_count, on_thread_start, + on_thread_stop); + details::registry::instance().set_tp(std::move(tp)); +} + +inline void init_thread_pool(size_t q_size, + size_t thread_count, + std::function on_thread_start) { + init_thread_pool(q_size, thread_count, on_thread_start, [] {}); +} + +inline void init_thread_pool(size_t q_size, size_t thread_count) { + init_thread_pool( + q_size, thread_count, [] {}, [] {}); +} + +// get the global thread pool. +inline std::shared_ptr thread_pool() { + return details::registry::instance().get_tp(); +} +} // namespace spdlog diff --git a/lib/spdlog/async_logger-inl.h b/lib/spdlog/async_logger-inl.h index 1b37f00c..499800d8 100644 --- a/lib/spdlog/async_logger-inl.h +++ b/lib/spdlog/async_logger-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -13,17 +13,29 @@ #include #include -SPDLOG_INLINE -spdlog::async_logger::async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) {} +SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, + sinks_init_list sinks_list, + std::weak_ptr tp, + async_overflow_policy overflow_policy) + : async_logger(std::move(logger_name), + sinks_list.begin(), + sinks_list.end(), + std::move(tp), + overflow_policy) {} -SPDLOG_INLINE -spdlog::async_logger::async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} +SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, + sink_ptr single_sink, + std::weak_ptr tp, + async_overflow_policy overflow_policy) + : async_logger( + std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} // send the log message to the thread pool -SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg& msg){SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr -> post_log(shared_from_this(), msg, overflow_policy_); +SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){ + SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){ + pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); } -else -{ +else { throw_spdlog_ex("async log: thread pool doesn't exist anymore"); } } @@ -32,15 +44,13 @@ SPDLOG_LOGGER_CATCH(msg.source) // send flush request to the thread pool SPDLOG_INLINE void spdlog::async_logger::flush_(){SPDLOG_TRY{auto pool_ptr = thread_pool_.lock(); -if (!pool_ptr) -{ +if (!pool_ptr) { throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); } std::future future = pool_ptr->post_flush(shared_from_this(), overflow_policy_); // Wait for the flush operation to complete. -// This might throw exception if the flush message get dropped because of -// overflow. +// This might throw exception if the flush message get dropped because of overflow. future.get(); } SPDLOG_LOGGER_CATCH(source_loc()) @@ -49,34 +59,27 @@ SPDLOG_LOGGER_CATCH(source_loc()) // // backend functions - called from the thread pool to do the actual job // -SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg& msg) -{ - for (auto& sink : sinks_) - { - if (sink->should_log(msg.level)) - { +SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { + for (auto &sink : sinks_) { + if (sink->should_log(msg.level)) { SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } - if (should_flush_(msg)) - { + if (should_flush_(msg)) { backend_flush_(); } } -SPDLOG_INLINE void spdlog::async_logger::backend_flush_() -{ - for (auto& sink : sinks_) - { +SPDLOG_INLINE void spdlog::async_logger::backend_flush_() { + for (auto &sink : sinks_) { SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } -SPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) -{ +SPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(new_name); return cloned; diff --git a/lib/spdlog/async_logger.h b/lib/spdlog/async_logger.h index 03a3ead2..846c4c6f 100644 --- a/lib/spdlog/async_logger.h +++ b/lib/spdlog/async_logger.h @@ -16,50 +16,59 @@ #include -namespace spdlog -{ +namespace spdlog { - // Async overflow policy - block by default. - enum class async_overflow_policy { - block, // Block until message can be enqueued - overrun_oldest, // Discard oldest message in the queue if full when trying to - // add new item. - discard_new // Discard new message if the queue is full when trying to add new - // item. - }; +// Async overflow policy - block by default. +enum class async_overflow_policy { + block, // Block until message can be enqueued + overrun_oldest, // Discard oldest message in the queue if full when trying to + // add new item. + discard_new // Discard new message if the queue is full when trying to add new item. +}; - namespace details - { - class thread_pool; - } +namespace details { +class thread_pool; +} - class SPDLOG_API async_logger final : public std::enable_shared_from_this, public logger { - friend class details::thread_pool; +class SPDLOG_API async_logger final : public std::enable_shared_from_this, + public logger { + friend class details::thread_pool; - public: - template - async_logger(std::string logger_name, It begin, It end, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block) : logger(std::move(logger_name), begin, end), thread_pool_(std::move(tp)), overflow_policy_(overflow_policy) - { - } +public: + template + async_logger(std::string logger_name, + It begin, + It end, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block) + : logger(std::move(logger_name), begin, end), + thread_pool_(std::move(tp)), + overflow_policy_(overflow_policy) {} - async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block); + async_logger(std::string logger_name, + sinks_init_list sinks_list, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); - async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy = async_overflow_policy::block); + async_logger(std::string logger_name, + sink_ptr single_sink, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); - std::shared_ptr clone(std::string new_name) override; + std::shared_ptr clone(std::string new_name) override; - protected: - void sink_it_(const details::log_msg& msg) override; - void flush_() override; - void backend_sink_it_(const details::log_msg& incoming_log_msg); - void backend_flush_(); +protected: + void sink_it_(const details::log_msg &msg) override; + void flush_() override; + void backend_sink_it_(const details::log_msg &incoming_log_msg); + void backend_flush_(); - private: - std::weak_ptr thread_pool_; - async_overflow_policy overflow_policy_; - }; -} // namespace spdlog +private: + std::weak_ptr thread_pool_; + async_overflow_policy overflow_policy_; +}; +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "async_logger-inl.h" + #include "async_logger-inl.h" #endif diff --git a/lib/spdlog/cfg/argv.h b/lib/spdlog/cfg/argv.h index c8b07544..7de2f83e 100644 --- a/lib/spdlog/cfg/argv.h +++ b/lib/spdlog/cfg/argv.h @@ -17,27 +17,24 @@ // turn off all logging except for logger1 and logger2: // example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info" -namespace spdlog -{ - namespace cfg - { - - // search for SPDLOG_LEVEL= in the args and use it to init the levels - inline void load_argv_levels(int argc, const char** argv) - { - const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; - for (int i = 1; i < argc; i++) - { - std::string arg = argv[i]; - if (arg.find(spdlog_level_prefix) == 0) - { - auto levels_string = arg.substr(spdlog_level_prefix.size()); - helpers::load_levels(levels_string); - } - } +namespace spdlog { +namespace cfg { + +// search for SPDLOG_LEVEL= in the args and use it to init the levels +inline void load_argv_levels(int argc, const char **argv) { + const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; + for (int i = 1; i < argc; i++) { + std::string arg = argv[i]; + if (arg.find(spdlog_level_prefix) == 0) { + auto levels_string = arg.substr(spdlog_level_prefix.size()); + helpers::load_levels(levels_string); } + } +} - inline void load_argv_levels(int argc, char** argv) { load_argv_levels(argc, const_cast(argv)); } +inline void load_argv_levels(int argc, char **argv) { + load_argv_levels(argc, const_cast(argv)); +} - } // namespace cfg -} // namespace spdlog +} // namespace cfg +} // namespace spdlog diff --git a/lib/spdlog/cfg/env.h b/lib/spdlog/cfg/env.h index 6b8243b2..6e554145 100644 --- a/lib/spdlog/cfg/env.h +++ b/lib/spdlog/cfg/env.h @@ -8,9 +8,8 @@ // // Init levels and patterns from env variables SPDLOG_LEVEL -// Inspired from Rust's "env_logger" crate -// (https://crates.io/crates/env_logger). Note - fallback to "info" level on -// unrecognized levels +// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger). +// Note - fallback to "info" level on unrecognized levels // // Examples: // @@ -24,18 +23,14 @@ // turn off all logging except for logger1 and logger2: // export SPDLOG_LEVEL="off,logger1=debug,logger2=info" -namespace spdlog -{ - namespace cfg - { - inline void load_env_levels() - { - auto env_val = details::os::getenv("SPDLOG_LEVEL"); - if (!env_val.empty()) - { - helpers::load_levels(env_val); - } - } +namespace spdlog { +namespace cfg { +inline void load_env_levels() { + auto env_val = details::os::getenv("SPDLOG_LEVEL"); + if (!env_val.empty()) { + helpers::load_levels(env_val); + } +} - } // namespace cfg -} // namespace spdlog +} // namespace cfg +} // namespace spdlog diff --git a/lib/spdlog/cfg/helpers-inl.h b/lib/spdlog/cfg/helpers-inl.h index 4cae81d1..93650a2e 100644 --- a/lib/spdlog/cfg/helpers-inl.h +++ b/lib/spdlog/cfg/helpers-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -16,107 +16,92 @@ #include #include -namespace spdlog -{ - namespace cfg - { - namespace helpers - { +namespace spdlog { +namespace cfg { +namespace helpers { - // inplace convert to lowercase - inline std::string& to_lower_(std::string& str) - { - std::transform(str.begin(), str.end(), str.begin(), [](char ch) { return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); }); - return str; - } +// inplace convert to lowercase +inline std::string &to_lower_(std::string &str) { + std::transform(str.begin(), str.end(), str.begin(), [](char ch) { + return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); + }); + return str; +} - // inplace trim spaces - inline std::string& trim_(std::string& str) - { - const char* spaces = " \n\r\t"; - str.erase(str.find_last_not_of(spaces) + 1); - str.erase(0, str.find_first_not_of(spaces)); - return str; - } +// inplace trim spaces +inline std::string &trim_(std::string &str) { + const char *spaces = " \n\r\t"; + str.erase(str.find_last_not_of(spaces) + 1); + str.erase(0, str.find_first_not_of(spaces)); + return str; +} - // return (name,value) trimmed pair from given "name=value" string. - // return empty string on missing parts - // "key=val" => ("key", "val") - // " key = val " => ("key", "val") - // "key=" => ("key", "") - // "val" => ("", "val") +// return (name,value) trimmed pair from given "name=value" string. +// return empty string on missing parts +// "key=val" => ("key", "val") +// " key = val " => ("key", "val") +// "key=" => ("key", "") +// "val" => ("", "val") - inline std::pair extract_kv_(char sep, const std::string& str) - { - auto n = str.find(sep); - std::string k, v; - if (n == std::string::npos) - { - v = str; - } - else - { - k = str.substr(0, n); - v = str.substr(n + 1); - } - return std::make_pair(trim_(k), trim_(v)); - } +inline std::pair extract_kv_(char sep, const std::string &str) { + auto n = str.find(sep); + std::string k, v; + if (n == std::string::npos) { + v = str; + } else { + k = str.substr(0, n); + v = str.substr(n + 1); + } + return std::make_pair(trim_(k), trim_(v)); +} - // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." - // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} - inline std::unordered_map extract_key_vals_(const std::string& str) - { - std::string token; - std::istringstream token_stream(str); - std::unordered_map rv{}; - while (std::getline(token_stream, token, ',')) - { - if (token.empty()) - { - continue; - } - auto kv = extract_kv_('=', token); - rv[kv.first] = kv.second; - } - return rv; - } +// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." +// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} +inline std::unordered_map extract_key_vals_(const std::string &str) { + std::string token; + std::istringstream token_stream(str); + std::unordered_map rv{}; + while (std::getline(token_stream, token, ',')) { + if (token.empty()) { + continue; + } + auto kv = extract_kv_('=', token); + rv[kv.first] = kv.second; + } + return rv; +} - SPDLOG_INLINE void load_levels(const std::string& input) - { - if (input.empty() || input.size() > 512) - { - return; - } +SPDLOG_INLINE void load_levels(const std::string &input) { + if (input.empty() || input.size() > 512) { + return; + } - auto key_vals = extract_key_vals_(input); - std::unordered_map levels; - level::level_enum global_level = level::info; - bool global_level_found = false; + auto key_vals = extract_key_vals_(input); + std::unordered_map levels; + level::level_enum global_level = level::info; + bool global_level_found = false; - for (auto& name_level : key_vals) - { - auto& logger_name = name_level.first; - auto level_name = to_lower_(name_level.second); - auto level = level::from_str(level_name); - // ignore unrecognized level names - if (level == level::off && level_name != "off") - { - continue; - } - if (logger_name.empty()) // no logger name indicate global level - { - global_level_found = true; - global_level = level; - } - else - { - levels[logger_name] = level; - } - } + for (auto &name_level : key_vals) { + auto &logger_name = name_level.first; + auto level_name = to_lower_(name_level.second); + auto level = level::from_str(level_name); + // ignore unrecognized level names + if (level == level::off && level_name != "off") { + continue; + } + if (logger_name.empty()) // no logger name indicate global level + { + global_level_found = true; + global_level = level; + } else { + levels[logger_name] = level; + } + } - details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr); - } + details::registry::instance().set_levels(std::move(levels), + global_level_found ? &global_level : nullptr); +} - } // namespace helpers - } // namespace cfg -} // namespace spdlog +} // namespace helpers +} // namespace cfg +} // namespace spdlog diff --git a/lib/spdlog/cfg/helpers.h b/lib/spdlog/cfg/helpers.h index bd9dd194..c0238189 100644 --- a/lib/spdlog/cfg/helpers.h +++ b/lib/spdlog/cfg/helpers.h @@ -6,28 +6,24 @@ #include #include -namespace spdlog -{ - namespace cfg - { - namespace helpers - { - // - // Init levels from given string - // - // Examples: - // - // set global level to debug: "debug" - // turn off all logging except for logger1: "off,logger1=debug" - // turn off all logging except for logger1 and logger2: - // "off,logger1=debug,logger2=info" - // - SPDLOG_API void load_levels(const std::string& txt); - } // namespace helpers +namespace spdlog { +namespace cfg { +namespace helpers { +// +// Init levels from given string +// +// Examples: +// +// set global level to debug: "debug" +// turn off all logging except for logger1: "off,logger1=debug" +// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" +// +SPDLOG_API void load_levels(const std::string &txt); +} // namespace helpers - } // namespace cfg -} // namespace spdlog +} // namespace cfg +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "helpers-inl.h" -#endif // SPDLOG_HEADER_ONLY + #include "helpers-inl.h" +#endif // SPDLOG_HEADER_ONLY diff --git a/lib/spdlog/common-inl.h b/lib/spdlog/common-inl.h index e7c7ab7c..a8a0453c 100644 --- a/lib/spdlog/common-inl.h +++ b/lib/spdlog/common-inl.h @@ -4,64 +4,65 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog -{ - namespace level - { +namespace spdlog { +namespace level { #if __cplusplus >= 201703L - constexpr +constexpr #endif - static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; + static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; - static const char* short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; +static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; - SPDLOG_INLINE const string_view_t& to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return level_string_views[l]; } +SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { + return level_string_views[l]; +} - SPDLOG_INLINE const char* to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return short_level_names[l]; } +SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { + return short_level_names[l]; +} - SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string& name) SPDLOG_NOEXCEPT - { - auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); - if (it != std::end(level_string_views)) - return static_cast(std::distance(std::begin(level_string_views), it)); +SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT { + auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); + if (it != std::end(level_string_views)) + return static_cast(std::distance(std::begin(level_string_views), it)); - // check also for "warn" and "err" before giving up.. - if (name == "warn") - { - return level::warn; - } - if (name == "err") - { - return level::err; - } - return level::off; - } - } // namespace level + // check also for "warn" and "err" before giving up.. + if (name == "warn") { + return level::warn; + } + if (name == "err") { + return level::err; + } + return level::off; +} +} // namespace level - SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) : msg_(std::move(msg)) {} +SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) + : msg_(std::move(msg)) {} - SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string& msg, int last_errno) - { +SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) { #ifdef SPDLOG_USE_STD_FORMAT - msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); + msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); #else - memory_buf_t outbuf; - fmt::format_system_error(outbuf, last_errno, msg.c_str()); - msg_ = fmt::to_string(outbuf); + memory_buf_t outbuf; + fmt::format_system_error(outbuf, last_errno, msg.c_str()); + msg_ = fmt::to_string(outbuf); #endif - } +} - SPDLOG_INLINE const char* spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); } +SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); } - SPDLOG_INLINE void throw_spdlog_ex(const std::string& msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); } +SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) { + SPDLOG_THROW(spdlog_ex(msg, last_errno)); +} - SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } +SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/common.h b/lib/spdlog/common.h index c01af58a..aca483c2 100644 --- a/lib/spdlog/common.h +++ b/lib/spdlog/common.h @@ -17,210 +17,215 @@ #include #ifdef SPDLOG_USE_STD_FORMAT -#include -#if __cpp_lib_format >= 202207L -#include -#else -#include -#endif + #include + #if __cpp_lib_format >= 202207L + #include + #else + #include + #endif #endif #ifdef SPDLOG_COMPILED_LIB -#undef SPDLOG_HEADER_ONLY -#if defined(SPDLOG_SHARED_LIB) -#if defined(_WIN32) -#ifdef spdlog_EXPORTS -#define SPDLOG_API __declspec(dllexport) -#else // !spdlog_EXPORTS -#define SPDLOG_API __declspec(dllimport) -#endif -#else // !defined(_WIN32) -#define SPDLOG_API __attribute__((visibility("default"))) -#endif -#else // !defined(SPDLOG_SHARED_LIB) -#define SPDLOG_API -#endif -#define SPDLOG_INLINE -#else // !defined(SPDLOG_COMPILED_LIB) -#define SPDLOG_API -#define SPDLOG_HEADER_ONLY -#define SPDLOG_INLINE inline -#endif // #ifdef SPDLOG_COMPILED_LIB + #undef SPDLOG_HEADER_ONLY + #if defined(SPDLOG_SHARED_LIB) + #if defined(_WIN32) + #ifdef spdlog_EXPORTS + #define SPDLOG_API __declspec(dllexport) + #else // !spdlog_EXPORTS + #define SPDLOG_API __declspec(dllimport) + #endif + #else // !defined(_WIN32) + #define SPDLOG_API __attribute__((visibility("default"))) + #endif + #else // !defined(SPDLOG_SHARED_LIB) + #define SPDLOG_API + #endif + #define SPDLOG_INLINE +#else // !defined(SPDLOG_COMPILED_LIB) + #define SPDLOG_API + #define SPDLOG_HEADER_ONLY + #define SPDLOG_INLINE inline +#endif // #ifdef SPDLOG_COMPILED_LIB #include -#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 -#define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) -#define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) -#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -#include -#endif +#if !defined(SPDLOG_USE_STD_FORMAT) && \ + FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 + #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) + #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #include + #endif #else -#define SPDLOG_FMT_RUNTIME(format_string) format_string -#define SPDLOG_FMT_STRING(format_string) format_string + #define SPDLOG_FMT_RUNTIME(format_string) format_string + #define SPDLOG_FMT_STRING(format_string) format_string #endif // visual studio up to 2013 does not support noexcept nor constexpr #if defined(_MSC_VER) && (_MSC_VER < 1900) -#define SPDLOG_NOEXCEPT _NOEXCEPT -#define SPDLOG_CONSTEXPR + #define SPDLOG_NOEXCEPT _NOEXCEPT + #define SPDLOG_CONSTEXPR #else -#define SPDLOG_NOEXCEPT noexcept -#define SPDLOG_CONSTEXPR constexpr + #define SPDLOG_NOEXCEPT noexcept + #define SPDLOG_CONSTEXPR constexpr #endif -// If building with std::format, can just use constexpr, otherwise if building -// with fmt SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to -// avoid situations where a constexpr function in spdlog could end up calling a -// non-constexpr function in fmt depending on the compiler If fmt determines it -// can't use constexpr, we should inline the function instead +// If building with std::format, can just use constexpr, otherwise if building with fmt +// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where +// a constexpr function in spdlog could end up calling a non-constexpr function in fmt +// depending on the compiler +// If fmt determines it can't use constexpr, we should inline the function instead #ifdef SPDLOG_USE_STD_FORMAT -#define SPDLOG_CONSTEXPR_FUNC constexpr -#else // Being built with fmt -#if FMT_USE_CONSTEXPR -#define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR -#else -#define SPDLOG_CONSTEXPR_FUNC inline -#endif + #define SPDLOG_CONSTEXPR_FUNC constexpr +#else // Being built with fmt + #if FMT_USE_CONSTEXPR + #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR + #else + #define SPDLOG_CONSTEXPR_FUNC inline + #endif #endif #if defined(__GNUC__) || defined(__clang__) -#define SPDLOG_DEPRECATED __attribute__((deprecated)) + #define SPDLOG_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) -#define SPDLOG_DEPRECATED __declspec(deprecated) + #define SPDLOG_DEPRECATED __declspec(deprecated) #else -#define SPDLOG_DEPRECATED + #define SPDLOG_DEPRECATED #endif // disable thread local on msvc 2013 #ifndef SPDLOG_NO_TLS -#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) -#define SPDLOG_NO_TLS 1 -#endif + #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) + #define SPDLOG_NO_TLS 1 + #endif #endif #ifndef SPDLOG_FUNCTION -#define SPDLOG_FUNCTION static_cast(__FUNCTION__) + #define SPDLOG_FUNCTION static_cast(__FUNCTION__) #endif #ifdef SPDLOG_NO_EXCEPTIONS -#define SPDLOG_TRY -#define SPDLOG_THROW(ex) \ - do \ - { \ - printf("spdlog fatal error: %s\n", ex.what()); \ - std::abort(); \ - } \ - while (0) -#define SPDLOG_CATCH_STD + #define SPDLOG_TRY + #define SPDLOG_THROW(ex) \ + do { \ + printf("spdlog fatal error: %s\n", ex.what()); \ + std::abort(); \ + } while (0) + #define SPDLOG_CATCH_STD #else -#define SPDLOG_TRY try -#define SPDLOG_THROW(ex) throw(ex) -#define SPDLOG_CATCH_STD \ - catch (const std::exception&) {} + #define SPDLOG_TRY try + #define SPDLOG_THROW(ex) throw(ex) + #define SPDLOG_CATCH_STD \ + catch (const std::exception &) { \ + } #endif -namespace spdlog -{ +namespace spdlog { - class formatter; +class formatter; - namespace sinks - { - class sink; - } +namespace sinks { +class sink; +} #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - using filename_t = std::wstring; -// allow macro expansion to occur in SPDLOG_FILENAME_T -#define SPDLOG_FILENAME_T_INNER(s) L##s -#define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) +using filename_t = std::wstring; + // allow macro expansion to occur in SPDLOG_FILENAME_T + #define SPDLOG_FILENAME_T_INNER(s) L##s + #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) #else - using filename_t = std::string; -#define SPDLOG_FILENAME_T(s) s +using filename_t = std::string; + #define SPDLOG_FILENAME_T(s) s #endif - using log_clock = std::chrono::system_clock; - using sink_ptr = std::shared_ptr; - using sinks_init_list = std::initializer_list; - using err_handler = std::function; +using log_clock = std::chrono::system_clock; +using sink_ptr = std::shared_ptr; +using sinks_init_list = std::initializer_list; +using err_handler = std::function; #ifdef SPDLOG_USE_STD_FORMAT - namespace fmt_lib = std; - - using string_view_t = std::string_view; - using memory_buf_t = std::string; - - template -#if __cpp_lib_format >= 202207L - using format_string_t = std::format_string; -#else - using format_string_t = std::string_view; -#endif - - template - struct is_convertible_to_basic_format_string : std::integral_constant>::value> {}; - -#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - using wstring_view_t = std::wstring_view; - using wmemory_buf_t = std::wstring; - - template -#if __cpp_lib_format >= 202207L - using wformat_string_t = std::wformat_string; -#else - using wformat_string_t = std::wstring_view; -#endif -#endif -#define SPDLOG_BUF_TO_STRING(x) x -#else // use fmt lib instead of std::format - namespace fmt_lib = fmt; - - using string_view_t = fmt::basic_string_view; - using memory_buf_t = fmt::basic_memory_buffer; - - template - using format_string_t = fmt::format_string; - - template - using remove_cvref_t = typename std::remove_cv::type>::type; - - template -#if FMT_VERSION >= 90101 - using fmt_runtime_string = fmt::runtime_format_string; -#else - using fmt_runtime_string = fmt::basic_runtime; -#endif - - // clang doesn't like SFINAE disabled constructor in std::is_convertible<> so - // have to repeat the condition from basic_format_string here, in addition, - // fmt::basic_runtime is only convertible to basic_format_string but - // not basic_string_view - template - struct is_convertible_to_basic_format_string : std::integral_constant>::value || std::is_same, fmt_runtime_string>::value> {}; - -#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - using wstring_view_t = fmt::basic_string_view; - using wmemory_buf_t = fmt::basic_memory_buffer; - - template - using wformat_string_t = fmt::wformat_string; -#endif -#define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) +namespace fmt_lib = std; + +using string_view_t = std::string_view; +using memory_buf_t = std::string; + +template + #if __cpp_lib_format >= 202207L +using format_string_t = std::format_string; + #else +using format_string_t = std::string_view; + #endif + +template +struct is_convertible_to_basic_format_string + : std::integral_constant>::value> {}; + + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) +using wstring_view_t = std::wstring_view; +using wmemory_buf_t = std::wstring; + +template + #if __cpp_lib_format >= 202207L +using wformat_string_t = std::wformat_string; + #else +using wformat_string_t = std::wstring_view; + #endif + #endif + #define SPDLOG_BUF_TO_STRING(x) x +#else // use fmt lib instead of std::format +namespace fmt_lib = fmt; + +using string_view_t = fmt::basic_string_view; +using memory_buf_t = fmt::basic_memory_buffer; + +template +using format_string_t = fmt::format_string; + +template +using remove_cvref_t = typename std::remove_cv::type>::type; + +template + #if FMT_VERSION >= 90101 +using fmt_runtime_string = fmt::runtime_format_string; + #else +using fmt_runtime_string = fmt::basic_runtime; + #endif + +// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the +// condition from basic_format_string here, in addition, fmt::basic_runtime is only +// convertible to basic_format_string but not basic_string_view +template +struct is_convertible_to_basic_format_string + : std::integral_constant>::value || + std::is_same, fmt_runtime_string>::value> { +}; + + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) +using wstring_view_t = fmt::basic_string_view; +using wmemory_buf_t = fmt::basic_memory_buffer; + +template +using wformat_string_t = fmt::wformat_string; + #endif + #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) #endif #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -#ifndef _WIN32 -#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows -#endif // _WIN32 -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT + #ifndef _WIN32 + #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows + #endif // _WIN32 +#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - struct is_convertible_to_any_format_string : std::integral_constant::value || is_convertible_to_basic_format_string::value> {}; +template +struct is_convertible_to_any_format_string + : std::integral_constant::value || + is_convertible_to_basic_format_string::value> {}; #if defined(SPDLOG_NO_ATOMIC_LEVELS) - using level_t = details::null_atomic_int; +using level_t = details::null_atomic_int; #else - using level_t = std::atomic; +using level_t = std::atomic; #endif #define SPDLOG_LEVEL_TRACE 0 @@ -232,13 +237,21 @@ namespace spdlog #define SPDLOG_LEVEL_OFF 6 #if !defined(SPDLOG_ACTIVE_LEVEL) -#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO + #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO #endif - // Log level enum - namespace level - { - enum level_enum : int { trace = SPDLOG_LEVEL_TRACE, debug = SPDLOG_LEVEL_DEBUG, info = SPDLOG_LEVEL_INFO, warn = SPDLOG_LEVEL_WARN, err = SPDLOG_LEVEL_ERROR, critical = SPDLOG_LEVEL_CRITICAL, off = SPDLOG_LEVEL_OFF, n_levels }; +// Log level enum +namespace level { +enum level_enum : int { + trace = SPDLOG_LEVEL_TRACE, + debug = SPDLOG_LEVEL_DEBUG, + info = SPDLOG_LEVEL_INFO, + warn = SPDLOG_LEVEL_WARN, + err = SPDLOG_LEVEL_ERROR, + critical = SPDLOG_LEVEL_CRITICAL, + off = SPDLOG_LEVEL_OFF, + n_levels +}; #define SPDLOG_LEVEL_NAME_TRACE spdlog::string_view_t("trace", 5) #define SPDLOG_LEVEL_NAME_DEBUG spdlog::string_view_t("debug", 5) @@ -249,137 +262,150 @@ namespace spdlog #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3) #if !defined(SPDLOG_LEVEL_NAMES) -#define SPDLOG_LEVEL_NAMES \ - { \ - SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF \ - } + #define SPDLOG_LEVEL_NAMES \ + { \ + SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, \ + SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \ + SPDLOG_LEVEL_NAME_OFF \ + } #endif #if !defined(SPDLOG_SHORT_LEVEL_NAMES) -#define SPDLOG_SHORT_LEVEL_NAMES \ - { \ - "T", "D", "I", "W", "E", "C", "O" \ - } + #define SPDLOG_SHORT_LEVEL_NAMES \ + { "T", "D", "I", "W", "E", "C", "O" } #endif - SPDLOG_API const string_view_t& to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; - SPDLOG_API const char* to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; - SPDLOG_API spdlog::level::level_enum from_str(const std::string& name) SPDLOG_NOEXCEPT; - - } // namespace level - - // - // Color mode used by sinks with color support. - // - enum class color_mode { always, automatic, never }; - - // - // Pattern time - specific time getting to use for pattern_formatter. - // local time by default - // - enum class pattern_time_type { - local, // log localtime - utc // log utc - }; - - // - // Log exception - // - class SPDLOG_API spdlog_ex : public std::exception { - public: - explicit spdlog_ex(std::string msg); - spdlog_ex(const std::string& msg, int last_errno); - const char* what() const SPDLOG_NOEXCEPT override; - - private: - std::string msg_; - }; - - [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string& msg, int last_errno); - [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); - - struct source_loc { - SPDLOG_CONSTEXPR source_loc() = default; - SPDLOG_CONSTEXPR source_loc(const char* filename_in, int line_in, const char* funcname_in) : filename{filename_in}, line{line_in}, funcname{funcname_in} {} - - SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; } - const char* filename{nullptr}; - int line{0}; - const char* funcname{nullptr}; - }; - - struct file_event_handlers { - file_event_handlers() : before_open(nullptr), after_open(nullptr), before_close(nullptr), after_close(nullptr) {} - - std::function before_open; - std::function after_open; - std::function before_close; - std::function after_close; - }; - - namespace details - { - - // to_string_view - - SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t& buf) SPDLOG_NOEXCEPT { return spdlog::string_view_t{buf.data(), buf.size()}; } - - SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT { return str; } +SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; +SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; +SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; + +} // namespace level + +// +// Color mode used by sinks with color support. +// +enum class color_mode { always, automatic, never }; + +// +// Pattern time - specific time getting to use for pattern_formatter. +// local time by default +// +enum class pattern_time_type { + local, // log localtime + utc // log utc +}; + +// +// Log exception +// +class SPDLOG_API spdlog_ex : public std::exception { +public: + explicit spdlog_ex(std::string msg); + spdlog_ex(const std::string &msg, int last_errno); + const char *what() const SPDLOG_NOEXCEPT override; + +private: + std::string msg_; +}; + +[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno); +[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); + +struct source_loc { + SPDLOG_CONSTEXPR source_loc() = default; + SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in) + : filename{filename_in}, + line{line_in}, + funcname{funcname_in} {} + + SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; } + const char *filename{nullptr}; + int line{0}; + const char *funcname{nullptr}; +}; + +struct file_event_handlers { + file_event_handlers() + : before_open(nullptr), + after_open(nullptr), + before_close(nullptr), + after_close(nullptr) {} + + std::function before_open; + std::function after_open; + std::function before_close; + std::function after_close; +}; + +namespace details { + +// to_string_view + +SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) + SPDLOG_NOEXCEPT { + return spdlog::string_view_t{buf.data(), buf.size()}; +} + +SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) + SPDLOG_NOEXCEPT { + return str; +} #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t& buf) SPDLOG_NOEXCEPT { return spdlog::wstring_view_t{buf.data(), buf.size()}; } - - SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT { return str; } +SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) + SPDLOG_NOEXCEPT { + return spdlog::wstring_view_t{buf.data(), buf.size()}; +} + +SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) + SPDLOG_NOEXCEPT { + return str; +} #endif #ifndef SPDLOG_USE_STD_FORMAT - template - inline fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) - { - return fmt; - } +template +inline fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) { + return fmt; +} #elif __cpp_lib_format >= 202207L - template - SPDLOG_CONSTEXPR_FUNC std::basic_string_view to_string_view(std::basic_format_string fmt) SPDLOG_NOEXCEPT - { - return fmt.get(); - } +template +SPDLOG_CONSTEXPR_FUNC std::basic_string_view to_string_view( + std::basic_format_string fmt) SPDLOG_NOEXCEPT { + return fmt.get(); +} #endif // make_unique support for pre c++14 -#if __cplusplus >= 201402L // C++14 and beyond - using std::enable_if_t; - using std::make_unique; +#if __cplusplus >= 201402L // C++14 and beyond +using std::enable_if_t; +using std::make_unique; #else - template - using enable_if_t = typename std::enable_if::type; - - template - std::unique_ptr make_unique(Args&&... args) - { - static_assert(!std::is_array::value, "arrays not supported"); - return std::unique_ptr(new T(std::forward(args)...)); - } +template +using enable_if_t = typename std::enable_if::type; + +template +std::unique_ptr make_unique(Args &&...args) { + static_assert(!std::is_array::value, "arrays not supported"); + return std::unique_ptr(new T(std::forward(args)...)); +} #endif - // to avoid useless casts (see - // https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) - template ::value, int> = 0> - constexpr T conditional_static_cast(U value) - { - return static_cast(value); - } +// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) +template ::value, int> = 0> +constexpr T conditional_static_cast(U value) { + return static_cast(value); +} - template ::value, int> = 0> - constexpr T conditional_static_cast(U value) - { - return value; - } +template ::value, int> = 0> +constexpr T conditional_static_cast(U value) { + return value; +} - } // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "common-inl.h" + #include "common-inl.h" #endif diff --git a/lib/spdlog/details/backtracer-inl.h b/lib/spdlog/details/backtracer-inl.h index 68fb4feb..43d10024 100644 --- a/lib/spdlog/details/backtracer-inl.h +++ b/lib/spdlog/details/backtracer-inl.h @@ -4,71 +4,60 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif -namespace spdlog -{ - namespace details - { - SPDLOG_INLINE backtracer::backtracer(const backtracer& other) - { - std::lock_guard lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = other.messages_; - } - - SPDLOG_INLINE backtracer::backtracer(backtracer&& other) SPDLOG_NOEXCEPT - { - std::lock_guard lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); - } - - SPDLOG_INLINE backtracer& backtracer::operator=(backtracer other) - { - std::lock_guard lock(mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); - return *this; - } - - SPDLOG_INLINE void backtracer::enable(size_t size) - { - std::lock_guard lock{mutex_}; - enabled_.store(true, std::memory_order_relaxed); - messages_ = circular_q{size}; - } - - SPDLOG_INLINE void backtracer::disable() - { - std::lock_guard lock{mutex_}; - enabled_.store(false, std::memory_order_relaxed); - } - - SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); } - - SPDLOG_INLINE void backtracer::push_back(const log_msg& msg) - { - std::lock_guard lock{mutex_}; - messages_.push_back(log_msg_buffer{msg}); - } - - SPDLOG_INLINE bool backtracer::empty() const - { - std::lock_guard lock{mutex_}; - return messages_.empty(); - } - - // pop all items in the q and apply the given fun on each of them. - SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) - { - std::lock_guard lock{mutex_}; - while (!messages_.empty()) - { - auto& front_msg = messages_.front(); - fun(front_msg); - messages_.pop_front(); - } - } - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { +SPDLOG_INLINE backtracer::backtracer(const backtracer &other) { + std::lock_guard lock(other.mutex_); + enabled_ = other.enabled(); + messages_ = other.messages_; +} + +SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT { + std::lock_guard lock(other.mutex_); + enabled_ = other.enabled(); + messages_ = std::move(other.messages_); +} + +SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) { + std::lock_guard lock(mutex_); + enabled_ = other.enabled(); + messages_ = std::move(other.messages_); + return *this; +} + +SPDLOG_INLINE void backtracer::enable(size_t size) { + std::lock_guard lock{mutex_}; + enabled_.store(true, std::memory_order_relaxed); + messages_ = circular_q{size}; +} + +SPDLOG_INLINE void backtracer::disable() { + std::lock_guard lock{mutex_}; + enabled_.store(false, std::memory_order_relaxed); +} + +SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); } + +SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) { + std::lock_guard lock{mutex_}; + messages_.push_back(log_msg_buffer{msg}); +} + +SPDLOG_INLINE bool backtracer::empty() const { + std::lock_guard lock{mutex_}; + return messages_.empty(); +} + +// pop all items in the q and apply the given fun on each of them. +SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) { + std::lock_guard lock{mutex_}; + while (!messages_.empty()) { + auto &front_msg = messages_.front(); + fun(front_msg); + messages_.pop_front(); + } +} +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/backtracer.h b/lib/spdlog/details/backtracer.h index a2b10726..541339cd 100644 --- a/lib/spdlog/details/backtracer.h +++ b/lib/spdlog/details/backtracer.h @@ -13,35 +13,33 @@ // Store log messages in circular buffer. // Useful for storing debug data in case of error/warning happens. -namespace spdlog -{ - namespace details - { - class SPDLOG_API backtracer { - mutable std::mutex mutex_; - std::atomic enabled_{false}; - circular_q messages_; - - public: - backtracer() = default; - backtracer(const backtracer& other); - - backtracer(backtracer&& other) SPDLOG_NOEXCEPT; - backtracer& operator=(backtracer other); - - void enable(size_t size); - void disable(); - bool enabled() const; - void push_back(const log_msg& msg); - bool empty() const; - - // pop all items in the q and apply the given fun on each of them. - void foreach_pop(std::function fun); - }; - - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { +class SPDLOG_API backtracer { + mutable std::mutex mutex_; + std::atomic enabled_{false}; + circular_q messages_; + +public: + backtracer() = default; + backtracer(const backtracer &other); + + backtracer(backtracer &&other) SPDLOG_NOEXCEPT; + backtracer &operator=(backtracer other); + + void enable(size_t size); + void disable(); + bool enabled() const; + void push_back(const log_msg &msg); + bool empty() const; + + // pop all items in the q and apply the given fun on each of them. + void foreach_pop(std::function fun); +}; + +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "backtracer-inl.h" + #include "backtracer-inl.h" #endif diff --git a/lib/spdlog/details/circular_q.h b/lib/spdlog/details/circular_q.h index d460c910..29e9d255 100644 --- a/lib/spdlog/details/circular_q.h +++ b/lib/spdlog/details/circular_q.h @@ -9,122 +9,107 @@ #include "spdlog/common.h" -namespace spdlog -{ - namespace details - { - template - class circular_q { - size_t max_items_ = 0; - typename std::vector::size_type head_ = 0; - typename std::vector::size_type tail_ = 0; - size_t overrun_counter_ = 0; - std::vector v_; - - public: - using value_type = T; - - // empty ctor - create a disabled queue with no elements allocated at all - circular_q() = default; - - explicit circular_q(size_t max_items) : - max_items_(max_items + 1) // one item is reserved as marker for full q - , - v_(max_items_) +namespace spdlog { +namespace details { +template +class circular_q { + size_t max_items_ = 0; + typename std::vector::size_type head_ = 0; + typename std::vector::size_type tail_ = 0; + size_t overrun_counter_ = 0; + std::vector v_; + +public: + using value_type = T; + + // empty ctor - create a disabled queue with no elements allocated at all + circular_q() = default; + + explicit circular_q(size_t max_items) + : max_items_(max_items + 1) // one item is reserved as marker for full q + , + v_(max_items_) {} + + circular_q(const circular_q &) = default; + circular_q &operator=(const circular_q &) = default; + + // move cannot be default, + // since we need to reset head_, tail_, etc to zero in the moved object + circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); } + + circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT { + copy_moveable(std::move(other)); + return *this; + } + + // push back, overrun (oldest) item if no room left + void push_back(T &&item) { + if (max_items_ > 0) { + v_[tail_] = std::move(item); + tail_ = (tail_ + 1) % max_items_; + + if (tail_ == head_) // overrun last item if full { + head_ = (head_ + 1) % max_items_; + ++overrun_counter_; } - - circular_q(const circular_q&) = default; - circular_q& operator=(const circular_q&) = default; - - // move cannot be default, - // since we need to reset head_, tail_, etc to zero in the moved object - circular_q(circular_q&& other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); } - - circular_q& operator=(circular_q&& other) SPDLOG_NOEXCEPT - { - copy_moveable(std::move(other)); - return *this; - } - - // push back, overrun (oldest) item if no room left - void push_back(T&& item) - { - if (max_items_ > 0) - { - v_[tail_] = std::move(item); - tail_ = (tail_ + 1) % max_items_; - - if (tail_ == head_) // overrun last item if full - { - head_ = (head_ + 1) % max_items_; - ++overrun_counter_; - } - } - } - - // Return reference to the front item. - // If there are no elements in the container, the behavior is undefined. - const T& front() const { return v_[head_]; } - - T& front() { return v_[head_]; } - - // Return number of elements actually stored - size_t size() const - { - if (tail_ >= head_) - { - return tail_ - head_; - } - else - { - return max_items_ - (head_ - tail_); - } - } - - // Return const reference to item by index. - // If index is out of range 0…size()-1, the behavior is undefined. - const T& at(size_t i) const - { - assert(i < size()); - return v_[(head_ + i) % max_items_]; - } - - // Pop item from front. - // If there are no elements in the container, the behavior is undefined. - void pop_front() { head_ = (head_ + 1) % max_items_; } - - bool empty() const { return tail_ == head_; } - - bool full() const - { - // head is ahead of the tail by 1 - if (max_items_ > 0) - { - return ((tail_ + 1) % max_items_) == head_; - } - return false; - } - - size_t overrun_counter() const { return overrun_counter_; } - - void reset_overrun_counter() { overrun_counter_ = 0; } - - private: - // copy from other&& and reset it to disabled state - void copy_moveable(circular_q&& other) SPDLOG_NOEXCEPT - { - max_items_ = other.max_items_; - head_ = other.head_; - tail_ = other.tail_; - overrun_counter_ = other.overrun_counter_; - v_ = std::move(other.v_); - - // put &&other in disabled, but valid state - other.max_items_ = 0; - other.head_ = other.tail_ = 0; - other.overrun_counter_ = 0; - } - }; - } // namespace details -} // namespace spdlog + } + } + + // Return reference to the front item. + // If there are no elements in the container, the behavior is undefined. + const T &front() const { return v_[head_]; } + + T &front() { return v_[head_]; } + + // Return number of elements actually stored + size_t size() const { + if (tail_ >= head_) { + return tail_ - head_; + } else { + return max_items_ - (head_ - tail_); + } + } + + // Return const reference to item by index. + // If index is out of range 0…size()-1, the behavior is undefined. + const T &at(size_t i) const { + assert(i < size()); + return v_[(head_ + i) % max_items_]; + } + + // Pop item from front. + // If there are no elements in the container, the behavior is undefined. + void pop_front() { head_ = (head_ + 1) % max_items_; } + + bool empty() const { return tail_ == head_; } + + bool full() const { + // head is ahead of the tail by 1 + if (max_items_ > 0) { + return ((tail_ + 1) % max_items_) == head_; + } + return false; + } + + size_t overrun_counter() const { return overrun_counter_; } + + void reset_overrun_counter() { overrun_counter_ = 0; } + +private: + // copy from other&& and reset it to disabled state + void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT { + max_items_ = other.max_items_; + head_ = other.head_; + tail_ = other.tail_; + overrun_counter_ = other.overrun_counter_; + v_ = std::move(other.v_); + + // put &&other in disabled, but valid state + other.max_items_ = 0; + other.head_ = other.tail_ = 0; + other.overrun_counter_ = 0; + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/console_globals.h b/lib/spdlog/details/console_globals.h index ccb03b7c..9c552106 100644 --- a/lib/spdlog/details/console_globals.h +++ b/lib/spdlog/details/console_globals.h @@ -6,27 +6,23 @@ #include #include -namespace spdlog -{ - namespace details - { +namespace spdlog { +namespace details { - struct console_mutex { - using mutex_t = std::mutex; - static mutex_t& mutex() - { - static mutex_t s_mutex; - return s_mutex; - } - }; +struct console_mutex { + using mutex_t = std::mutex; + static mutex_t &mutex() { + static mutex_t s_mutex; + return s_mutex; + } +}; - struct console_nullmutex { - using mutex_t = null_mutex; - static mutex_t& mutex() - { - static mutex_t s_mutex; - return s_mutex; - } - }; - } // namespace details -} // namespace spdlog +struct console_nullmutex { + using mutex_t = null_mutex; + static mutex_t &mutex() { + static mutex_t s_mutex; + return s_mutex; + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/file_helper-inl.h b/lib/spdlog/details/file_helper-inl.h index 06e8238c..37d1d46f 100644 --- a/lib/spdlog/details/file_helper-inl.h +++ b/lib/spdlog/details/file_helper-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -17,161 +17,136 @@ #include #include -namespace spdlog -{ - namespace details - { - - SPDLOG_INLINE - file_helper::file_helper(const file_event_handlers& event_handlers) : event_handlers_(event_handlers) {} - - SPDLOG_INLINE file_helper::~file_helper() { close(); } - - SPDLOG_INLINE void file_helper::open(const filename_t& fname, bool truncate) - { - close(); - filename_ = fname; - - auto* mode = SPDLOG_FILENAME_T("ab"); - auto* trunc_mode = SPDLOG_FILENAME_T("wb"); - - if (event_handlers_.before_open) - { - event_handlers_.before_open(filename_); - } - for (int tries = 0; tries < open_tries_; ++tries) - { - // create containing folder if not exists already. - os::create_dir(os::dir_name(fname)); - if (truncate) - { - // Truncate by opening-and-closing a tmp file in "wb" mode, always - // opening the actual log-we-write-to in "ab" mode, since that - // interacts more politely with eternal processes that might - // rotate/truncate the file underneath us. - std::FILE* tmp; - if (os::fopen_s(&tmp, fname, trunc_mode)) - { - continue; - } - std::fclose(tmp); - } - if (!os::fopen_s(&fd_, fname, mode)) - { - if (event_handlers_.after_open) - { - event_handlers_.after_open(filename_, fd_); - } - return; - } - - details::os::sleep_for_millis(open_interval_); +namespace spdlog { +namespace details { + +SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) + : event_handlers_(event_handlers) {} + +SPDLOG_INLINE file_helper::~file_helper() { close(); } + +SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) { + close(); + filename_ = fname; + + auto *mode = SPDLOG_FILENAME_T("ab"); + auto *trunc_mode = SPDLOG_FILENAME_T("wb"); + + if (event_handlers_.before_open) { + event_handlers_.before_open(filename_); + } + for (int tries = 0; tries < open_tries_; ++tries) { + // create containing folder if not exists already. + os::create_dir(os::dir_name(fname)); + if (truncate) { + // Truncate by opening-and-closing a tmp file in "wb" mode, always + // opening the actual log-we-write-to in "ab" mode, since that + // interacts more politely with eternal processes that might + // rotate/truncate the file underneath us. + std::FILE *tmp; + if (os::fopen_s(&tmp, fname, trunc_mode)) { + continue; } - - throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); + std::fclose(tmp); } - - SPDLOG_INLINE void file_helper::reopen(bool truncate) - { - if (filename_.empty()) - { - throw_spdlog_ex("Failed re opening file - was not opened before"); + if (!os::fopen_s(&fd_, fname, mode)) { + if (event_handlers_.after_open) { + event_handlers_.after_open(filename_, fd_); } - this->open(filename_, truncate); + return; } - SPDLOG_INLINE void file_helper::flush() - { - if (std::fflush(fd_) != 0) - { - throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); - } + details::os::sleep_for_millis(open_interval_); + } + + throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", + errno); +} + +SPDLOG_INLINE void file_helper::reopen(bool truncate) { + if (filename_.empty()) { + throw_spdlog_ex("Failed re opening file - was not opened before"); + } + this->open(filename_, truncate); +} + +SPDLOG_INLINE void file_helper::flush() { + if (std::fflush(fd_) != 0) { + throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); + } +} + +SPDLOG_INLINE void file_helper::sync() { + if (!os::fsync(fd_)) { + throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); + } +} + +SPDLOG_INLINE void file_helper::close() { + if (fd_ != nullptr) { + if (event_handlers_.before_close) { + event_handlers_.before_close(filename_, fd_); } - SPDLOG_INLINE void file_helper::sync() - { - if (!os::fsync(fd_)) - { - throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); - } - } + std::fclose(fd_); + fd_ = nullptr; - SPDLOG_INLINE void file_helper::close() - { - if (fd_ != nullptr) - { - if (event_handlers_.before_close) - { - event_handlers_.before_close(filename_, fd_); - } - - std::fclose(fd_); - fd_ = nullptr; - - if (event_handlers_.after_close) - { - event_handlers_.after_close(filename_); - } - } + if (event_handlers_.after_close) { + event_handlers_.after_close(filename_); } - - SPDLOG_INLINE void file_helper::write(const memory_buf_t& buf) - { - if (fd_ == nullptr) - return; - size_t msg_size = buf.size(); - auto data = buf.data(); - if (std::fwrite(data, 1, msg_size, fd_) != msg_size) - { - throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); - } - } - - SPDLOG_INLINE size_t file_helper::size() const - { - if (fd_ == nullptr) - { - throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); - } - return os::filesize(fd_); - } - - SPDLOG_INLINE const filename_t& file_helper::filename() const { return filename_; } - - // - // return file path and its extension: - // - // "mylog.txt" => ("mylog", ".txt") - // "mylog" => ("mylog", "") - // "mylog." => ("mylog.", "") - // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") - // - // the starting dot in filenames is ignored (hidden files): - // - // ".mylog" => (".mylog". "") - // "my_folder/.mylog" => ("my_folder/.mylog", "") - // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") - SPDLOG_INLINE std::tuple file_helper::split_by_extension(const filename_t& fname) - { - auto ext_index = fname.rfind('.'); - - // no valid extension found - return whole path and empty string as - // extension - if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) - { - return std::make_tuple(fname, filename_t()); - } - - // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" - auto folder_index = fname.find_last_of(details::os::folder_seps_filename); - if (folder_index != filename_t::npos && folder_index >= ext_index - 1) - { - return std::make_tuple(fname, filename_t()); - } - - // finally - return a valid base and extension tuple - return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); - } - - } // namespace details -} // namespace spdlog + } +} + +SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) { + if (fd_ == nullptr) return; + size_t msg_size = buf.size(); + auto data = buf.data(); + if (std::fwrite(data, 1, msg_size, fd_) != msg_size) { + throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); + } +} + +SPDLOG_INLINE size_t file_helper::size() const { + if (fd_ == nullptr) { + throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); + } + return os::filesize(fd_); +} + +SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; } + +// +// return file path and its extension: +// +// "mylog.txt" => ("mylog", ".txt") +// "mylog" => ("mylog", "") +// "mylog." => ("mylog.", "") +// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") +// +// the starting dot in filenames is ignored (hidden files): +// +// ".mylog" => (".mylog". "") +// "my_folder/.mylog" => ("my_folder/.mylog", "") +// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") +SPDLOG_INLINE std::tuple file_helper::split_by_extension( + const filename_t &fname) { + auto ext_index = fname.rfind('.'); + + // no valid extension found - return whole path and empty string as + // extension + if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) { + return std::make_tuple(fname, filename_t()); + } + + // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" + auto folder_index = fname.find_last_of(details::os::folder_seps_filename); + if (folder_index != filename_t::npos && folder_index >= ext_index - 1) { + return std::make_tuple(fname, filename_t()); + } + + // finally - return a valid base and extension tuple + return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); +} + +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/file_helper.h b/lib/spdlog/details/file_helper.h index d66867b7..f0e5d180 100644 --- a/lib/spdlog/details/file_helper.h +++ b/lib/spdlog/details/file_helper.h @@ -6,58 +6,56 @@ #include #include -namespace spdlog -{ - namespace details - { - - // Helper class for file sinks. - // When failing to open a file, retry several times(5) with a delay interval(10 - // ms). Throw spdlog_ex exception on errors. - - class SPDLOG_API file_helper { - public: - file_helper() = default; - explicit file_helper(const file_event_handlers& event_handlers); - - file_helper(const file_helper&) = delete; - file_helper& operator=(const file_helper&) = delete; - ~file_helper(); - - void open(const filename_t& fname, bool truncate = false); - void reopen(bool truncate); - void flush(); - void sync(); - void close(); - void write(const memory_buf_t& buf); - size_t size() const; - const filename_t& filename() const; - - // - // return file path and its extension: - // - // "mylog.txt" => ("mylog", ".txt") - // "mylog" => ("mylog", "") - // "mylog." => ("mylog.", "") - // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") - // - // the starting dot in filenames is ignored (hidden files): - // - // ".mylog" => (".mylog". "") - // "my_folder/.mylog" => ("my_folder/.mylog", "") - // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") - static std::tuple split_by_extension(const filename_t& fname); - - private: - const int open_tries_ = 5; - const unsigned int open_interval_ = 10; - std::FILE* fd_{nullptr}; - filename_t filename_; - file_event_handlers event_handlers_; - }; - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { + +// Helper class for file sinks. +// When failing to open a file, retry several times(5) with a delay interval(10 ms). +// Throw spdlog_ex exception on errors. + +class SPDLOG_API file_helper { +public: + file_helper() = default; + explicit file_helper(const file_event_handlers &event_handlers); + + file_helper(const file_helper &) = delete; + file_helper &operator=(const file_helper &) = delete; + ~file_helper(); + + void open(const filename_t &fname, bool truncate = false); + void reopen(bool truncate); + void flush(); + void sync(); + void close(); + void write(const memory_buf_t &buf); + size_t size() const; + const filename_t &filename() const; + + // + // return file path and its extension: + // + // "mylog.txt" => ("mylog", ".txt") + // "mylog" => ("mylog", "") + // "mylog." => ("mylog.", "") + // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") + // + // the starting dot in filenames is ignored (hidden files): + // + // ".mylog" => (".mylog". "") + // "my_folder/.mylog" => ("my_folder/.mylog", "") + // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") + static std::tuple split_by_extension(const filename_t &fname); + +private: + const int open_tries_ = 5; + const unsigned int open_interval_ = 10; + std::FILE *fd_{nullptr}; + filename_t filename_; + file_event_handlers event_handlers_; +}; +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "file_helper-inl.h" + #include "file_helper-inl.h" #endif diff --git a/lib/spdlog/details/fmt_helper.h b/lib/spdlog/details/fmt_helper.h index eed0c697..61306003 100644 --- a/lib/spdlog/details/fmt_helper.h +++ b/lib/spdlog/details/fmt_helper.h @@ -9,160 +9,133 @@ #include #ifdef SPDLOG_USE_STD_FORMAT -#include -#include + #include + #include #endif // Some fmt helpers to efficiently format and pad ints and strings -namespace spdlog -{ - namespace details - { - namespace fmt_helper - { +namespace spdlog { +namespace details { +namespace fmt_helper { - inline void append_string_view(spdlog::string_view_t view, memory_buf_t& dest) - { - auto* buf_ptr = view.data(); - dest.append(buf_ptr, buf_ptr + view.size()); - } +inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) { + auto *buf_ptr = view.data(); + dest.append(buf_ptr, buf_ptr + view.size()); +} #ifdef SPDLOG_USE_STD_FORMAT - template - inline void append_int(T n, memory_buf_t& dest) - { - // Buffer should be large enough to hold all digits (digits10 + 1) and a sign - SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits::digits10 + 2; - char buf[BUF_SIZE]; +template +inline void append_int(T n, memory_buf_t &dest) { + // Buffer should be large enough to hold all digits (digits10 + 1) and a sign + SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits::digits10 + 2; + char buf[BUF_SIZE]; - auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); - if (ec == std::errc()) - { - dest.append(buf, ptr); - } - else - { - throw_spdlog_ex("Failed to format int", static_cast(ec)); - } - } + auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); + if (ec == std::errc()) { + dest.append(buf, ptr); + } else { + throw_spdlog_ex("Failed to format int", static_cast(ec)); + } +} #else - template - inline void append_int(T n, memory_buf_t& dest) - { - fmt::format_int i(n); - dest.append(i.data(), i.data() + i.size()); - } +template +inline void append_int(T n, memory_buf_t &dest) { + fmt::format_int i(n); + dest.append(i.data(), i.data() + i.size()); +} #endif - template - SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) - { - // taken from fmt: - // https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 - unsigned int 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; - } - } +template +SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) { + // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 + unsigned int 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; + } +} - template - inline unsigned int count_digits(T n) - { - using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; +template +inline unsigned int count_digits(T n) { + using count_type = + typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; #ifdef SPDLOG_USE_STD_FORMAT - return count_digits_fallback(static_cast(n)); -#else - return static_cast(fmt:: -// fmt 7.0.0 renamed the internal namespace to detail. -// See: https://github.com/fmtlib/fmt/issues/1538 -#if FMT_VERSION < 70000 - internal + return count_digits_fallback(static_cast(n)); #else - detail -#endif - ::count_digits(static_cast(n))); + return static_cast(fmt:: + // fmt 7.0.0 renamed the internal namespace to detail. + // See: https://github.com/fmtlib/fmt/issues/1538 + #if FMT_VERSION < 70000 + internal + #else + detail + #endif + ::count_digits(static_cast(n))); #endif - } +} - inline void pad2(int n, memory_buf_t& dest) - { - if (n >= 0 && n < 100) // 0-99 - { - dest.push_back(static_cast('0' + n / 10)); - dest.push_back(static_cast('0' + n % 10)); - } - else // unlikely, but just in case, let fmt deal with it - { - fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); - } - } +inline void pad2(int n, memory_buf_t &dest) { + if (n >= 0 && n < 100) // 0-99 + { + dest.push_back(static_cast('0' + n / 10)); + dest.push_back(static_cast('0' + n % 10)); + } else // unlikely, but just in case, let fmt deal with it + { + fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); + } +} - template - inline void pad_uint(T n, unsigned int width, memory_buf_t& dest) - { - static_assert(std::is_unsigned::value, "pad_uint must get unsigned T"); - for (auto digits = count_digits(n); digits < width; digits++) - { - dest.push_back('0'); - } - append_int(n, dest); - } +template +inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) { + static_assert(std::is_unsigned::value, "pad_uint must get unsigned T"); + for (auto digits = count_digits(n); digits < width; digits++) { + dest.push_back('0'); + } + append_int(n, dest); +} - template - inline void pad3(T n, memory_buf_t& dest) - { - static_assert(std::is_unsigned::value, "pad3 must get unsigned T"); - if (n < 1000) - { - dest.push_back(static_cast(n / 100 + '0')); - n = n % 100; - dest.push_back(static_cast((n / 10) + '0')); - dest.push_back(static_cast((n % 10) + '0')); - } - else - { - append_int(n, dest); - } - } +template +inline void pad3(T n, memory_buf_t &dest) { + static_assert(std::is_unsigned::value, "pad3 must get unsigned T"); + if (n < 1000) { + dest.push_back(static_cast(n / 100 + '0')); + n = n % 100; + dest.push_back(static_cast((n / 10) + '0')); + dest.push_back(static_cast((n % 10) + '0')); + } else { + append_int(n, dest); + } +} - template - inline void pad6(T n, memory_buf_t& dest) - { - pad_uint(n, 6, dest); - } +template +inline void pad6(T n, memory_buf_t &dest) { + pad_uint(n, 6, dest); +} - template - inline void pad9(T n, memory_buf_t& dest) - { - pad_uint(n, 9, dest); - } +template +inline void pad9(T n, memory_buf_t &dest) { + pad_uint(n, 9, dest); +} - // return fraction of a second of the given time_point. - // e.g. - // fraction(tp) -> will return the millis part of the second - template - inline ToDuration time_fraction(log_clock::time_point tp) - { - using std::chrono::duration_cast; - using std::chrono::seconds; - auto duration = tp.time_since_epoch(); - auto secs = duration_cast(duration); - return duration_cast(duration) - duration_cast(secs); - } +// return fraction of a second of the given time_point. +// e.g. +// fraction(tp) -> will return the millis part of the second +template +inline ToDuration time_fraction(log_clock::time_point tp) { + using std::chrono::duration_cast; + using std::chrono::seconds; + auto duration = tp.time_since_epoch(); + auto secs = duration_cast(duration); + return duration_cast(duration) - duration_cast(secs); +} - } // namespace fmt_helper - } // namespace details -} // namespace spdlog +} // namespace fmt_helper +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/log_msg-inl.h b/lib/spdlog/details/log_msg-inl.h index 7b953c30..aa3a9576 100644 --- a/lib/spdlog/details/log_msg-inl.h +++ b/lib/spdlog/details/log_msg-inl.h @@ -4,32 +4,41 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include -namespace spdlog -{ - namespace details - { - - SPDLOG_INLINE - log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : - logger_name(a_logger_name), level(lvl), time(log_time) +namespace spdlog { +namespace details { + +SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, + spdlog::source_loc loc, + string_view_t a_logger_name, + spdlog::level::level_enum lvl, + spdlog::string_view_t msg) + : logger_name(a_logger_name), + level(lvl), + time(log_time) #ifndef SPDLOG_NO_THREAD_ID - , - thread_id(os::thread_id()) + , + thread_id(os::thread_id()) #endif - , - source(loc), payload(msg) - { - } - - SPDLOG_INLINE - log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} - - SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} - - } // namespace details -} // namespace spdlog + , + source(loc), + payload(msg) { +} + +SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc, + string_view_t a_logger_name, + spdlog::level::level_enum lvl, + spdlog::string_view_t msg) + : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} + +SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, + spdlog::level::level_enum lvl, + spdlog::string_view_t msg) + : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} + +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/log_msg.h b/lib/spdlog/details/log_msg.h index c1ce71b3..87df1e83 100644 --- a/lib/spdlog/details/log_msg.h +++ b/lib/spdlog/details/log_msg.h @@ -6,33 +6,35 @@ #include #include -namespace spdlog -{ - namespace details - { - struct SPDLOG_API log_msg { - log_msg() = default; - log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); - log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); - log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); - log_msg(const log_msg& other) = default; - log_msg& operator=(const log_msg& other) = default; +namespace spdlog { +namespace details { +struct SPDLOG_API log_msg { + log_msg() = default; + log_msg(log_clock::time_point log_time, + source_loc loc, + string_view_t logger_name, + level::level_enum lvl, + string_view_t msg); + log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); + log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); + log_msg(const log_msg &other) = default; + log_msg &operator=(const log_msg &other) = default; - string_view_t logger_name; - level::level_enum level{level::off}; - log_clock::time_point time; - size_t thread_id{0}; + string_view_t logger_name; + level::level_enum level{level::off}; + log_clock::time_point time; + size_t thread_id{0}; - // wrapping the formatted text with color (updated by pattern_formatter). - mutable size_t color_range_start{0}; - mutable size_t color_range_end{0}; + // wrapping the formatted text with color (updated by pattern_formatter). + mutable size_t color_range_start{0}; + mutable size_t color_range_end{0}; - source_loc source; - string_view_t payload; - }; - } // namespace details -} // namespace spdlog + source_loc source; + string_view_t payload; +}; +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "log_msg-inl.h" + #include "log_msg-inl.h" #endif diff --git a/lib/spdlog/details/log_msg_buffer-inl.h b/lib/spdlog/details/log_msg_buffer-inl.h index 2a28a387..2eb24285 100644 --- a/lib/spdlog/details/log_msg_buffer-inl.h +++ b/lib/spdlog/details/log_msg_buffer-inl.h @@ -4,53 +4,51 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif -namespace spdlog -{ - namespace details - { - - SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg& orig_msg) : log_msg{orig_msg} - { - buffer.append(logger_name.begin(), logger_name.end()); - buffer.append(payload.begin(), payload.end()); - update_string_views(); - } - - SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer& other) : log_msg{other} - { - buffer.append(logger_name.begin(), logger_name.end()); - buffer.append(payload.begin(), payload.end()); - update_string_views(); - } - - SPDLOG_INLINE - log_msg_buffer::log_msg_buffer(log_msg_buffer&& other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)} { update_string_views(); } - - SPDLOG_INLINE log_msg_buffer& log_msg_buffer::operator=(const log_msg_buffer& other) - { - log_msg::operator=(other); - buffer.clear(); - buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); - update_string_views(); - return *this; - } - - SPDLOG_INLINE log_msg_buffer& log_msg_buffer::operator=(log_msg_buffer&& other) SPDLOG_NOEXCEPT - { - log_msg::operator=(other); - buffer = std::move(other.buffer); - update_string_views(); - return *this; - } - - SPDLOG_INLINE void log_msg_buffer::update_string_views() - { - logger_name = string_view_t{buffer.data(), logger_name.size()}; - payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; - } - - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { + +SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) + : log_msg{orig_msg} { + buffer.append(logger_name.begin(), logger_name.end()); + buffer.append(payload.begin(), payload.end()); + update_string_views(); +} + +SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) + : log_msg{other} { + buffer.append(logger_name.begin(), logger_name.end()); + buffer.append(payload.begin(), payload.end()); + update_string_views(); +} + +SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT + : log_msg{other}, + buffer{std::move(other.buffer)} { + update_string_views(); +} + +SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) { + log_msg::operator=(other); + buffer.clear(); + buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); + update_string_views(); + return *this; +} + +SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT { + log_msg::operator=(other); + buffer = std::move(other.buffer); + update_string_views(); + return *this; +} + +SPDLOG_INLINE void log_msg_buffer::update_string_views() { + logger_name = string_view_t{buffer.data(), logger_name.size()}; + payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; +} + +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/log_msg_buffer.h b/lib/spdlog/details/log_msg_buffer.h index 2824beaa..1143b3ba 100644 --- a/lib/spdlog/details/log_msg_buffer.h +++ b/lib/spdlog/details/log_msg_buffer.h @@ -5,30 +5,28 @@ #include -namespace spdlog -{ - namespace details - { - - // Extend log_msg with internal buffer to store its payload. - // This is needed since log_msg holds string_views that points to stack data. - - class SPDLOG_API log_msg_buffer : public log_msg { - memory_buf_t buffer; - void update_string_views(); - - public: - log_msg_buffer() = default; - explicit log_msg_buffer(const log_msg& orig_msg); - log_msg_buffer(const log_msg_buffer& other); - log_msg_buffer(log_msg_buffer&& other) SPDLOG_NOEXCEPT; - log_msg_buffer& operator=(const log_msg_buffer& other); - log_msg_buffer& operator=(log_msg_buffer&& other) SPDLOG_NOEXCEPT; - }; - - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { + +// Extend log_msg with internal buffer to store its payload. +// This is needed since log_msg holds string_views that points to stack data. + +class SPDLOG_API log_msg_buffer : public log_msg { + memory_buf_t buffer; + void update_string_views(); + +public: + log_msg_buffer() = default; + explicit log_msg_buffer(const log_msg &orig_msg); + log_msg_buffer(const log_msg_buffer &other); + log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT; + log_msg_buffer &operator=(const log_msg_buffer &other); + log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; +}; + +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "log_msg_buffer-inl.h" + #include "log_msg_buffer-inl.h" #endif diff --git a/lib/spdlog/details/mpmc_blocking_q.h b/lib/spdlog/details/mpmc_blocking_q.h index c5a4434e..5848cca8 100644 --- a/lib/spdlog/details/mpmc_blocking_q.h +++ b/lib/spdlog/details/mpmc_blocking_q.h @@ -16,186 +16,162 @@ #include #include -namespace spdlog -{ - namespace details - { +namespace spdlog { +namespace details { - template - class mpmc_blocking_queue { - public: - using item_type = T; - explicit mpmc_blocking_queue(size_t max_items) : q_(max_items) {} +template +class mpmc_blocking_queue { +public: + using item_type = T; + explicit mpmc_blocking_queue(size_t max_items) + : q_(max_items) {} #ifndef __MINGW32__ - // try to enqueue and block if no room left - void enqueue(T&& item) - { - { - std::unique_lock lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T&& item) - { - { - std::unique_lock lock(queue_mutex_); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - void enqueue_if_have_room(T&& item) - { - bool pushed = false; - { - std::unique_lock lock(queue_mutex_); - if (!q_.full()) - { - q_.push_back(std::move(item)); - pushed = true; - } - } - - if (pushed) - { - push_cv_.notify_one(); - } - else - { - ++discard_counter_; - } - } - - // dequeue with a timeout. - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T& popped_item, std::chrono::milliseconds wait_duration) - { - { - std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { - return false; - } - popped_item = std::move(q_.front()); - q_.pop_front(); - } - pop_cv_.notify_one(); - return true; - } - - // blocking dequeue without a timeout. - void dequeue(T& popped_item) - { - { - std::unique_lock lock(queue_mutex_); - push_cv_.wait(lock, [this] { return !this->q_.empty(); }); - popped_item = std::move(q_.front()); - q_.pop_front(); - } - pop_cv_.notify_one(); - } - -#else - // apparently mingw deadlocks if the mutex is released before cv.notify_one(), - // so release the mutex at the very end each function. - - // try to enqueue and block if no room left - void enqueue(T&& item) - { - std::unique_lock lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T&& item) - { - std::unique_lock lock(queue_mutex_); + // try to enqueue and block if no room left + void enqueue(T &&item) { + { + std::unique_lock lock(queue_mutex_); + pop_cv_.wait(lock, [this] { return !this->q_.full(); }); + q_.push_back(std::move(item)); + } + push_cv_.notify_one(); + } + + // enqueue immediately. overrun oldest message in the queue if no room left. + void enqueue_nowait(T &&item) { + { + std::unique_lock lock(queue_mutex_); + q_.push_back(std::move(item)); + } + push_cv_.notify_one(); + } + + void enqueue_if_have_room(T &&item) { + bool pushed = false; + { + std::unique_lock lock(queue_mutex_); + if (!q_.full()) { q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - void enqueue_if_have_room(T&& item) - { - bool pushed = false; - std::unique_lock lock(queue_mutex_); - if (!q_.full()) - { - q_.push_back(std::move(item)); - pushed = true; - } - - if (pushed) - { - push_cv_.notify_one(); - } - else - { - ++discard_counter_; - } + pushed = true; } - - // dequeue with a timeout. - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T& popped_item, std::chrono::milliseconds wait_duration) - { - std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { - return false; - } - popped_item = std::move(q_.front()); - q_.pop_front(); - pop_cv_.notify_one(); - return true; + } + + if (pushed) { + push_cv_.notify_one(); + } else { + ++discard_counter_; + } + } + + // dequeue with a timeout. + // Return true, if succeeded dequeue item, false otherwise + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { + { + std::unique_lock lock(queue_mutex_); + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { + return false; } + popped_item = std::move(q_.front()); + q_.pop_front(); + } + pop_cv_.notify_one(); + return true; + } + + // blocking dequeue without a timeout. + void dequeue(T &popped_item) { + { + std::unique_lock lock(queue_mutex_); + push_cv_.wait(lock, [this] { return !this->q_.empty(); }); + popped_item = std::move(q_.front()); + q_.pop_front(); + } + pop_cv_.notify_one(); + } - // blocking dequeue without a timeout. - void dequeue(T& popped_item) - { - std::unique_lock lock(queue_mutex_); - push_cv_.wait(lock, [this] { return !this->q_.empty(); }); - popped_item = std::move(q_.front()); - q_.pop_front(); - pop_cv_.notify_one(); - } +#else + // apparently mingw deadlocks if the mutex is released before cv.notify_one(), + // so release the mutex at the very end each function. + + // try to enqueue and block if no room left + void enqueue(T &&item) { + std::unique_lock lock(queue_mutex_); + pop_cv_.wait(lock, [this] { return !this->q_.full(); }); + q_.push_back(std::move(item)); + push_cv_.notify_one(); + } + + // enqueue immediately. overrun oldest message in the queue if no room left. + void enqueue_nowait(T &&item) { + std::unique_lock lock(queue_mutex_); + q_.push_back(std::move(item)); + push_cv_.notify_one(); + } + + void enqueue_if_have_room(T &&item) { + bool pushed = false; + std::unique_lock lock(queue_mutex_); + if (!q_.full()) { + q_.push_back(std::move(item)); + pushed = true; + } + + if (pushed) { + push_cv_.notify_one(); + } else { + ++discard_counter_; + } + } + + // dequeue with a timeout. + // Return true, if succeeded dequeue item, false otherwise + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { + std::unique_lock lock(queue_mutex_); + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { + return false; + } + popped_item = std::move(q_.front()); + q_.pop_front(); + pop_cv_.notify_one(); + return true; + } + + // blocking dequeue without a timeout. + void dequeue(T &popped_item) { + std::unique_lock lock(queue_mutex_); + push_cv_.wait(lock, [this] { return !this->q_.empty(); }); + popped_item = std::move(q_.front()); + q_.pop_front(); + pop_cv_.notify_one(); + } #endif - size_t overrun_counter() - { - std::lock_guard lock(queue_mutex_); - return q_.overrun_counter(); - } - - size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); } - - size_t size() - { - std::lock_guard lock(queue_mutex_); - return q_.size(); - } - - void reset_overrun_counter() - { - std::lock_guard lock(queue_mutex_); - q_.reset_overrun_counter(); - } - - void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); } - - private: - std::mutex queue_mutex_; - std::condition_variable push_cv_; - std::condition_variable pop_cv_; - spdlog::details::circular_q q_; - std::atomic discard_counter_{0}; - }; - } // namespace details -} // namespace spdlog + size_t overrun_counter() { + std::lock_guard lock(queue_mutex_); + return q_.overrun_counter(); + } + + size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); } + + size_t size() { + std::lock_guard lock(queue_mutex_); + return q_.size(); + } + + void reset_overrun_counter() { + std::lock_guard lock(queue_mutex_); + q_.reset_overrun_counter(); + } + + void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); } + +private: + std::mutex queue_mutex_; + std::condition_variable push_cv_; + std::condition_variable pop_cv_; + spdlog::details::circular_q q_; + std::atomic discard_counter_{0}; +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/null_mutex.h b/lib/spdlog/details/null_mutex.h index 8ae349d1..e3b32204 100644 --- a/lib/spdlog/details/null_mutex.h +++ b/lib/spdlog/details/null_mutex.h @@ -7,31 +7,29 @@ #include // null, no cost dummy "mutex" and dummy "atomic" int -namespace spdlog -{ - namespace details - { - struct null_mutex { - void lock() const {} - void unlock() const {} - }; - - struct null_atomic_int { - int value; - null_atomic_int() = default; - - explicit null_atomic_int(int new_value) : value(new_value) {} - - int load(std::memory_order = std::memory_order_relaxed) const { return value; } - - void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } - - int exchange(int new_value, std::memory_order = std::memory_order_relaxed) - { - std::swap(new_value, value); - return new_value; // return value before the call - } - }; - - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { +struct null_mutex { + void lock() const {} + void unlock() const {} +}; + +struct null_atomic_int { + int value; + null_atomic_int() = default; + + explicit null_atomic_int(int new_value) + : value(new_value) {} + + int load(std::memory_order = std::memory_order_relaxed) const { return value; } + + void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } + + int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { + std::swap(new_value, value); + return new_value; // return value before the call + } +}; + +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/os-inl.h b/lib/spdlog/details/os-inl.h index 99bac9d9..e3c80b92 100644 --- a/lib/spdlog/details/os-inl.h +++ b/lib/spdlog/details/os-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -22,619 +22,573 @@ #include #ifdef _WIN32 -#include // for FlushFileBuffers -#include // for _get_osfhandle, _isatty, _fileno -#include // for _get_pid -#include + #include + #include // for FlushFileBuffers + #include // for _get_osfhandle, _isatty, _fileno + #include // for _get_pid -#ifdef __MINGW32__ -#include -#endif + #ifdef __MINGW32__ + #include + #endif -#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) -#include -#include -#endif + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) + #include + #include + #endif -#include // for _mkdir/_wmkdir + #include // for _mkdir/_wmkdir -#else // unix +#else // unix -#include -#include + #include + #include -#ifdef __linux__ -#include //Use gettid() syscall under linux to get thread id + #ifdef __linux__ + #include //Use gettid() syscall under linux to get thread id -#elif defined(_AIX) -#include // for pthread_getthrds_np + #elif defined(_AIX) + #include // for pthread_getthrds_np -#elif defined(__DragonFly__) || defined(__FreeBSD__) -#include // for pthread_getthreadid_np + #elif defined(__DragonFly__) || defined(__FreeBSD__) + #include // for pthread_getthreadid_np -#elif defined(__NetBSD__) -#include // for _lwp_self + #elif defined(__NetBSD__) + #include // for _lwp_self -#elif defined(__sun) -#include // for thr_self -#endif + #elif defined(__sun) + #include // for thr_self + #endif -#endif // unix +#endif // unix #if defined __APPLE__ -#include + #include #endif -#ifndef __has_feature // Clang - feature checking macros. -#define __has_feature(x) 0 // Compatibility with non-clang compilers. +#ifndef __has_feature // Clang - feature checking macros. + #define __has_feature(x) 0 // Compatibility with non-clang compilers. #endif -namespace spdlog -{ - namespace details - { - namespace os - { +namespace spdlog { +namespace details { +namespace os { - SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT - { +SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT { #if defined __linux__ && defined SPDLOG_CLOCK_COARSE - timespec ts; - ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); - return std::chrono::time_point(std::chrono::duration_cast(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); + timespec ts; + ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); + return std::chrono::time_point( + std::chrono::duration_cast( + std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); #else - return log_clock::now(); + return log_clock::now(); #endif - } - SPDLOG_INLINE std::tm localtime(const std::time_t& time_tt) SPDLOG_NOEXCEPT - { +} +SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 - std::tm tm; - ::localtime_s(&tm, &time_tt); + std::tm tm; + ::localtime_s(&tm, &time_tt); #else - std::tm tm; - ::localtime_r(&time_tt, &tm); + std::tm tm; + ::localtime_r(&time_tt, &tm); #endif - return tm; - } + return tm; +} - SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT - { - std::time_t now_t = ::time(nullptr); - return localtime(now_t); - } +SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT { + std::time_t now_t = ::time(nullptr); + return localtime(now_t); +} - SPDLOG_INLINE std::tm gmtime(const std::time_t& time_tt) SPDLOG_NOEXCEPT - { -#ifdef _WIN32 - std::tm tm; - ::gmtime_s(&tm, &time_tt); -#else - std::tm tm; - ::gmtime_r(&time_tt, &tm); -#endif - return tm; - } - - SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT - { - std::time_t now_t = ::time(nullptr); - return gmtime(now_t); - } - - // fopen_s on non windows for writing - SPDLOG_INLINE bool fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode) - { +SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 -#ifdef SPDLOG_WCHAR_FILENAMES - *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); -#else - *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); -#endif -#if defined(SPDLOG_PREVENT_CHILD_FD) - if (*fp != nullptr) - { - auto file_handle = reinterpret_cast(_get_osfhandle(::_fileno(*fp))); - if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) - { - ::fclose(*fp); - *fp = nullptr; - } - } -#endif -#else // unix -#if defined(SPDLOG_PREVENT_CHILD_FD) - const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; - const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); - if (fd == -1) - { - return true; - } - *fp = ::fdopen(fd, mode.c_str()); - if (*fp == nullptr) - { - ::close(fd); - } + std::tm tm; + ::gmtime_s(&tm, &time_tt); #else - *fp = ::fopen((filename.c_str()), mode.c_str()); -#endif + std::tm tm; + ::gmtime_r(&time_tt, &tm); #endif + return tm; +} - return *fp == nullptr; - } +SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT { + std::time_t now_t = ::time(nullptr); + return gmtime(now_t); +} - SPDLOG_INLINE int remove(const filename_t& filename) SPDLOG_NOEXCEPT - { +// fopen_s on non windows for writing +SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) { +#ifdef _WIN32 + #ifdef SPDLOG_WCHAR_FILENAMES + *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); + #else + *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); + #endif + #if defined(SPDLOG_PREVENT_CHILD_FD) + if (*fp != nullptr) { + auto file_handle = reinterpret_cast(_get_osfhandle(::_fileno(*fp))); + if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) { + ::fclose(*fp); + *fp = nullptr; + } + } + #endif +#else // unix + #if defined(SPDLOG_PREVENT_CHILD_FD) + const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; + const int fd = + ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); + if (fd == -1) { + return true; + } + *fp = ::fdopen(fd, mode.c_str()); + if (*fp == nullptr) { + ::close(fd); + } + #else + *fp = ::fopen((filename.c_str()), mode.c_str()); + #endif +#endif + + return *fp == nullptr; +} + +SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return ::_wremove(filename.c_str()); + return ::_wremove(filename.c_str()); #else - return std::remove(filename.c_str()); + return std::remove(filename.c_str()); #endif - } +} - SPDLOG_INLINE int remove_if_exists(const filename_t& filename) SPDLOG_NOEXCEPT { return path_exists(filename) ? remove(filename) : 0; } +SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT { + return path_exists(filename) ? remove(filename) : 0; +} - SPDLOG_INLINE int rename(const filename_t& filename1, const filename_t& filename2) SPDLOG_NOEXCEPT - { +SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return ::_wrename(filename1.c_str(), filename2.c_str()); + return ::_wrename(filename1.c_str(), filename2.c_str()); #else - return std::rename(filename1.c_str(), filename2.c_str()); + return std::rename(filename1.c_str(), filename2.c_str()); #endif - } +} - // Return true if path exists (file or directory) - SPDLOG_INLINE bool path_exists(const filename_t& filename) SPDLOG_NOEXCEPT - { +// Return true if path exists (file or directory) +SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT { #ifdef _WIN32 - struct _stat buffer; -#ifdef SPDLOG_WCHAR_FILENAMES - return (::_wstat(filename.c_str(), &buffer) == 0); -#else - return (::_stat(filename.c_str(), &buffer) == 0); -#endif -#else // common linux/unix all have the stat system call - struct stat buffer; - return (::stat(filename.c_str(), &buffer) == 0); -#endif - } + struct _stat buffer; + #ifdef SPDLOG_WCHAR_FILENAMES + return (::_wstat(filename.c_str(), &buffer) == 0); + #else + return (::_stat(filename.c_str(), &buffer) == 0); + #endif +#else // common linux/unix all have the stat system call + struct stat buffer; + return (::stat(filename.c_str(), &buffer) == 0); +#endif +} #ifdef _MSC_VER -// avoid warning about unreachable statement at the end of filesize() -#pragma warning(push) -#pragma warning(disable : 4702) + // avoid warning about unreachable statement at the end of filesize() + #pragma warning(push) + #pragma warning(disable : 4702) #endif - // Return file size according to open FILE* object - SPDLOG_INLINE size_t filesize(FILE* f) - { - if (f == nullptr) - { - throw_spdlog_ex("Failed getting file size. fd is null"); - } +// Return file size according to open FILE* object +SPDLOG_INLINE size_t filesize(FILE *f) { + if (f == nullptr) { + throw_spdlog_ex("Failed getting file size. fd is null"); + } #if defined(_WIN32) && !defined(__CYGWIN__) - int fd = ::_fileno(f); -#if defined(_WIN64) // 64 bits - __int64 ret = ::_filelengthi64(fd); - if (ret >= 0) - { - return static_cast(ret); - } - -#else // windows 32 bits - long ret = ::_filelength(fd); - if (ret >= 0) - { - return static_cast(ret); - } -#endif - -#else // unix -// OpenBSD and AIX doesn't compile with :: before the fileno(..) -#if defined(__OpenBSD__) || defined(_AIX) - int fd = fileno(f); -#else - int fd = ::fileno(f); -#endif -// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) -#if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64)) - struct stat64 st; - if (::fstat64(fd, &st) == 0) - { - return static_cast(st.st_size); - } -#else // other unix or linux 32 bits or cygwin - struct stat st; - if (::fstat(fd, &st) == 0) - { - return static_cast(st.st_size); - } -#endif -#endif - throw_spdlog_ex("Failed getting file size from fd", errno); - return 0; // will not be reached. - } + int fd = ::_fileno(f); + #if defined(_WIN64) // 64 bits + __int64 ret = ::_filelengthi64(fd); + if (ret >= 0) { + return static_cast(ret); + } + + #else // windows 32 bits + long ret = ::_filelength(fd); + if (ret >= 0) { + return static_cast(ret); + } + #endif + +#else // unix + // OpenBSD and AIX doesn't compile with :: before the fileno(..) + #if defined(__OpenBSD__) || defined(_AIX) + int fd = fileno(f); + #else + int fd = ::fileno(f); + #endif + // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) + #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \ + (defined(__LP64__) || defined(_LP64)) + struct stat64 st; + if (::fstat64(fd, &st) == 0) { + return static_cast(st.st_size); + } + #else // other unix or linux 32 bits or cygwin + struct stat st; + if (::fstat(fd, &st) == 0) { + return static_cast(st.st_size); + } + #endif +#endif + throw_spdlog_ex("Failed getting file size from fd", errno); + return 0; // will not be reached. +} #ifdef _MSC_VER -#pragma warning(pop) + #pragma warning(pop) #endif - // Return utc offset in minutes or throw spdlog_ex on failure - SPDLOG_INLINE int utc_minutes_offset(const std::tm& tm) - { +// Return utc offset in minutes or throw spdlog_ex on failure +SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { #ifdef _WIN32 -#if _WIN32_WINNT < _WIN32_WINNT_WS08 - TIME_ZONE_INFORMATION tzinfo; - auto rv = ::GetTimeZoneInformation(&tzinfo); + #if _WIN32_WINNT < _WIN32_WINNT_WS08 + TIME_ZONE_INFORMATION tzinfo; + auto rv = ::GetTimeZoneInformation(&tzinfo); + #else + DYNAMIC_TIME_ZONE_INFORMATION tzinfo; + auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); + #endif + if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); + + int offset = -tzinfo.Bias; + if (tm.tm_isdst) { + offset -= tzinfo.DaylightBias; + } else { + offset -= tzinfo.StandardBias; + } + return offset; #else - DYNAMIC_TIME_ZONE_INFORMATION tzinfo; - auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); -#endif - if (rv == TIME_ZONE_ID_INVALID) - throw_spdlog_ex("Failed getting timezone info. ", errno); - - int offset = -tzinfo.Bias; - if (tm.tm_isdst) - { - offset -= tzinfo.DaylightBias; - } - else - { - offset -= tzinfo.StandardBias; - } - return offset; -#else - -#if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) - // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris - struct helper { - static long int calculate_gmt_offset(const std::tm& localtm = details::os::localtime(), const std::tm& gmtm = details::os::gmtime()) - { - int local_year = localtm.tm_year + (1900 - 1); - int gmt_year = gmtm.tm_year + (1900 - 1); - long int days = ( - // difference in day of year - localtm.tm_yday - - gmtm.tm_yday - - // + intervening leap days - + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + - ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) - - // + difference in years * 365 */ - + static_cast(local_year - gmt_year) * 365); - - long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); - long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); - long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); - - return secs; - } - }; - - auto offset_seconds = helper::calculate_gmt_offset(tm); -#else - auto offset_seconds = tm.tm_gmtoff; -#endif - - return static_cast(offset_seconds / 60); -#endif - } - - // Return current thread id as size_t - // It exists because the std::this_thread::get_id() is much slower(especially - // under VS 2013) - SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT - { + #if defined(sun) || defined(__sun) || defined(_AIX) || \ + (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ + (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) + // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris + struct helper { + static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), + const std::tm &gmtm = details::os::gmtime()) { + int local_year = localtm.tm_year + (1900 - 1); + int gmt_year = gmtm.tm_year + (1900 - 1); + + long int days = ( + // difference in day of year + localtm.tm_yday - + gmtm.tm_yday + + // + intervening leap days + + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) + + // + difference in years * 365 */ + + static_cast(local_year - gmt_year) * 365); + + long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); + long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); + long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); + + return secs; + } + }; + + auto offset_seconds = helper::calculate_gmt_offset(tm); + #else + auto offset_seconds = tm.tm_gmtoff; + #endif + + return static_cast(offset_seconds / 60); +#endif +} + +// Return current thread id as size_t +// It exists because the std::this_thread::get_id() is much slower(especially +// under VS 2013) +SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT { #ifdef _WIN32 - return static_cast(::GetCurrentThreadId()); + return static_cast(::GetCurrentThreadId()); #elif defined(__linux__) -#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) -#define SYS_gettid __NR_gettid -#endif - return static_cast(::syscall(SYS_gettid)); + #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) + #define SYS_gettid __NR_gettid + #endif + return static_cast(::syscall(SYS_gettid)); #elif defined(_AIX) - struct __pthrdsinfo buf; - int reg_size = 0; - pthread_t pt = pthread_self(); - int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, ®_size); - int tid = (!retval) ? buf.__pi_tid : 0; - return static_cast(tid); + struct __pthrdsinfo buf; + int reg_size = 0; + pthread_t pt = pthread_self(); + int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, ®_size); + int tid = (!retval) ? buf.__pi_tid : 0; + return static_cast(tid); #elif defined(__DragonFly__) || defined(__FreeBSD__) - return static_cast(::pthread_getthreadid_np()); + return static_cast(::pthread_getthreadid_np()); #elif defined(__NetBSD__) - return static_cast(::_lwp_self()); + return static_cast(::_lwp_self()); #elif defined(__OpenBSD__) - return static_cast(::getthrid()); + return static_cast(::getthrid()); #elif defined(__sun) - return static_cast(::thr_self()); + return static_cast(::thr_self()); #elif __APPLE__ - uint64_t tid; -// There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not -// supported on any PPC, including 10.6.8 Rosetta. __POWERPC__ is Apple-specific -// define encompassing ppc and ppc64. -#ifdef MAC_OS_X_VERSION_MAX_ALLOWED - { -#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) - tid = pthread_mach_thread_np(pthread_self()); -#elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 - if (&pthread_threadid_np) - { - pthread_threadid_np(nullptr, &tid); - } - else - { - tid = pthread_mach_thread_np(pthread_self()); - } -#else - pthread_threadid_np(nullptr, &tid); -#endif - } -#else - pthread_threadid_np(nullptr, &tid); -#endif - return static_cast(tid); -#else // Default to standard C++11 (other Unix) - return static_cast(std::hash()(std::this_thread::get_id())); -#endif - } - - // Return current thread id as size_t (from thread local storage) - SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT - { + uint64_t tid; + // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC, + // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64. + #ifdef MAC_OS_X_VERSION_MAX_ALLOWED + { + #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) + tid = pthread_mach_thread_np(pthread_self()); + #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + if (&pthread_threadid_np) { + pthread_threadid_np(nullptr, &tid); + } else { + tid = pthread_mach_thread_np(pthread_self()); + } + #else + pthread_threadid_np(nullptr, &tid); + #endif + } + #else + pthread_threadid_np(nullptr, &tid); + #endif + return static_cast(tid); +#else // Default to standard C++11 (other Unix) + return static_cast(std::hash()(std::this_thread::get_id())); +#endif +} + +// Return current thread id as size_t (from thread local storage) +SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { #if defined(SPDLOG_NO_TLS) - return _thread_id(); -#else // cache thread id in tls - static thread_local const size_t tid = _thread_id(); - return tid; + return _thread_id(); +#else // cache thread id in tls + static thread_local const size_t tid = _thread_id(); + return tid; #endif - } +} - // This is avoid msvc issue in sleep_for that happens if the clock changes. - // See https://github.com/gabime/spdlog/issues/609 - SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT - { +// This is avoid msvc issue in sleep_for that happens if the clock changes. +// See https://github.com/gabime/spdlog/issues/609 +SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT { #if defined(_WIN32) - ::Sleep(milliseconds); + ::Sleep(milliseconds); #else - std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); + std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); #endif - } +} // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - SPDLOG_INLINE std::string filename_to_str(const filename_t& filename) - { - memory_buf_t buf; - wstr_to_utf8buf(filename, buf); - return SPDLOG_BUF_TO_STRING(buf); - } +SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { + memory_buf_t buf; + wstr_to_utf8buf(filename, buf); + return SPDLOG_BUF_TO_STRING(buf); +} #else - SPDLOG_INLINE std::string filename_to_str(const filename_t& filename) { return filename; } +SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; } #endif - SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT - { +SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT { #ifdef _WIN32 - return conditional_static_cast(::GetCurrentProcessId()); + return conditional_static_cast(::GetCurrentProcessId()); #else - return conditional_static_cast(::getpid()); + return conditional_static_cast(::getpid()); #endif - } +} - // Determine if the terminal supports colors - // Based on: https://github.com/agauniyal/rang/ - SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT - { +// Determine if the terminal supports colors +// Based on: https://github.com/agauniyal/rang/ +SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT { #ifdef _WIN32 - return true; + return true; #else - static const bool result = []() - { - const char* env_colorterm_p = std::getenv("COLORTERM"); - if (env_colorterm_p != nullptr) - { - return true; - } + static const bool result = []() { + const char *env_colorterm_p = std::getenv("COLORTERM"); + if (env_colorterm_p != nullptr) { + return true; + } - static constexpr std::array terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; + static constexpr std::array terms = { + {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", + "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; - const char* env_term_p = std::getenv("TERM"); - if (env_term_p == nullptr) - { - return false; - } + const char *env_term_p = std::getenv("TERM"); + if (env_term_p == nullptr) { + return false; + } - return std::any_of(terms.begin(), terms.end(), [&](const char* term) { return std::strstr(env_term_p, term) != nullptr; }); - }(); + return std::any_of(terms.begin(), terms.end(), [&](const char *term) { + return std::strstr(env_term_p, term) != nullptr; + }); + }(); - return result; + return result; #endif - } +} - // Determine if the terminal attached - // Source: https://github.com/agauniyal/rang/ - SPDLOG_INLINE bool in_terminal(FILE* file) SPDLOG_NOEXCEPT - { +// Determine if the terminal attached +// Source: https://github.com/agauniyal/rang/ +SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT { #ifdef _WIN32 - return ::_isatty(_fileno(file)) != 0; + return ::_isatty(_fileno(file)) != 0; #else - return ::isatty(fileno(file)) != 0; + return ::isatty(fileno(file)) != 0; #endif - } +} #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) - SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t& target) - { - if (wstr.size() > static_cast((std::numeric_limits::max)()) / 4 - 1) - { - throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); - } - - int wstr_size = static_cast(wstr.size()); - if (wstr_size == 0) - { - target.resize(0); - return; - } - - int result_size = static_cast(target.capacity()); - if ((wstr_size + 1) * 4 > result_size) - { - result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); - } - - if (result_size > 0) - { - target.resize(result_size); - result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL); - - if (result_size > 0) - { - target.resize(result_size); - return; - } - } - - throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); - } - - SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t& target) - { - if (str.size() > static_cast((std::numeric_limits::max)()) - 1) - { - throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); - } - - int str_size = static_cast(str.size()); - if (str_size == 0) - { - target.resize(0); - return; - } - - // find the size to allocate for the result buffer - int result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0); - - if (result_size > 0) - { - target.resize(result_size); - result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size); - if (result_size > 0) - { - assert(result_size == target.size()); - return; - } - } - - throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); - } -#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || - // defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) - - // return true on success - static SPDLOG_INLINE bool mkdir_(const filename_t& path) - { +SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) { + if (wstr.size() > static_cast((std::numeric_limits::max)()) / 4 - 1) { + throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); + } + + int wstr_size = static_cast(wstr.size()); + if (wstr_size == 0) { + target.resize(0); + return; + } + + int result_size = static_cast(target.capacity()); + if ((wstr_size + 1) * 4 > result_size) { + result_size = + ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); + } + + if (result_size > 0) { + target.resize(result_size); + result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), + result_size, NULL, NULL); + + if (result_size > 0) { + target.resize(result_size); + return; + } + } + + throw_spdlog_ex( + fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); +} + +SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) { + if (str.size() > static_cast((std::numeric_limits::max)()) - 1) { + throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); + } + + int str_size = static_cast(str.size()); + if (str_size == 0) { + target.resize(0); + return; + } + + // find the size to allocate for the result buffer + int result_size = + ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0); + + if (result_size > 0) { + target.resize(result_size); + result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, + target.data(), result_size); + if (result_size > 0) { + assert(result_size == target.size()); + return; + } + } + + throw_spdlog_ex( + fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); +} +#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && + // defined(_WIN32) + +// return true on success +static SPDLOG_INLINE bool mkdir_(const filename_t &path) { #ifdef _WIN32 -#ifdef SPDLOG_WCHAR_FILENAMES - return ::_wmkdir(path.c_str()) == 0; + #ifdef SPDLOG_WCHAR_FILENAMES + return ::_wmkdir(path.c_str()) == 0; + #else + return ::_mkdir(path.c_str()) == 0; + #endif #else - return ::_mkdir(path.c_str()) == 0; -#endif -#else - return ::mkdir(path.c_str(), mode_t(0755)) == 0; -#endif - } - - // create the given directory - and all directories leading to it - // return true on success or if the directory already exists - SPDLOG_INLINE bool create_dir(const filename_t& path) - { - if (path_exists(path)) - { - return true; - } - - if (path.empty()) - { - return false; - } - - size_t search_offset = 0; - do - { - auto token_pos = path.find_first_of(folder_seps_filename, search_offset); - // treat the entire path as a folder if no folder separator not found - if (token_pos == filename_t::npos) - { - token_pos = path.size(); - } - - auto subdir = path.substr(0, token_pos); + return ::mkdir(path.c_str(), mode_t(0755)) == 0; +#endif +} + +// create the given directory - and all directories leading to it +// return true on success or if the directory already exists +SPDLOG_INLINE bool create_dir(const filename_t &path) { + if (path_exists(path)) { + return true; + } + + if (path.empty()) { + return false; + } + + size_t search_offset = 0; + do { + auto token_pos = path.find_first_of(folder_seps_filename, search_offset); + // treat the entire path as a folder if no folder separator not found + if (token_pos == filename_t::npos) { + token_pos = path.size(); + } + + auto subdir = path.substr(0, token_pos); #ifdef _WIN32 - // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\", - // otherwise path_exists(subdir) returns false (issue #3079) - const bool is_drive = subdir.length() == 2 && subdir[1] == ':'; - if (is_drive) - { - subdir += '\\'; - token_pos++; - } -#endif - - if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) - { - return false; // return error if failed creating dir - } - search_offset = token_pos + 1; - } - while (search_offset < path.size()); - - return true; - } - - // Return directory name from given path or empty string - // "abc/file" => "abc" - // "abc/" => "abc" - // "abc" => "" - // "abc///" => "abc//" - SPDLOG_INLINE filename_t dir_name(const filename_t& path) - { - auto pos = path.find_last_of(folder_seps_filename); - return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; - } - - std::string SPDLOG_INLINE getenv(const char* field) - { + // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\", + // otherwise path_exists(subdir) returns false (issue #3079) + const bool is_drive = subdir.length() == 2 && subdir[1] == ':'; + if (is_drive) { + subdir += '\\'; + token_pos++; + } +#endif + + if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { + return false; // return error if failed creating dir + } + search_offset = token_pos + 1; + } while (search_offset < path.size()); + + return true; +} + +// Return directory name from given path or empty string +// "abc/file" => "abc" +// "abc/" => "abc" +// "abc" => "" +// "abc///" => "abc//" +SPDLOG_INLINE filename_t dir_name(const filename_t &path) { + auto pos = path.find_last_of(folder_seps_filename); + return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; +} + +std::string SPDLOG_INLINE getenv(const char *field) { #if defined(_MSC_VER) -#if defined(__cplusplus_winrt) - return std::string{}; // not supported under uwp -#else - size_t len = 0; - char buf[128]; - bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; - return ok ? buf : std::string{}; -#endif -#else // revert to getenv - char* buf = ::getenv(field); - return buf ? buf : std::string{}; -#endif - } - - // Do fsync by FILE handlerpointer - // Return true on success - SPDLOG_INLINE bool fsync(FILE* fp) - { + #if defined(__cplusplus_winrt) + return std::string{}; // not supported under uwp + #else + size_t len = 0; + char buf[128]; + bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; + return ok ? buf : std::string{}; + #endif +#else // revert to getenv + char *buf = ::getenv(field); + return buf ? buf : std::string{}; +#endif +} + +// Do fsync by FILE handlerpointer +// Return true on success +SPDLOG_INLINE bool fsync(FILE *fp) { #ifdef _WIN32 - return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0; + return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0; #else - return ::fsync(fileno(fp)) == 0; + return ::fsync(fileno(fp)) == 0; #endif - } +} - } // namespace os - } // namespace details -} // namespace spdlog +} // namespace os +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/os.h b/lib/spdlog/details/os.h index bda14858..b1069edc 100644 --- a/lib/spdlog/details/os.h +++ b/lib/spdlog/details/os.h @@ -3,124 +3,121 @@ #pragma once -#include // std::time_t +#include // std::time_t #include -namespace spdlog -{ - namespace details - { - namespace os - { +namespace spdlog { +namespace details { +namespace os { - SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT; +SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT; - SPDLOG_API std::tm localtime(const std::time_t& time_tt) SPDLOG_NOEXCEPT; +SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; - SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT; +SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT; - SPDLOG_API std::tm gmtime(const std::time_t& time_tt) SPDLOG_NOEXCEPT; +SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; - SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT; +SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT; // eol definition #if !defined(SPDLOG_EOL) -#ifdef _WIN32 -#define SPDLOG_EOL "\r\n" -#else -#define SPDLOG_EOL "\n" -#endif + #ifdef _WIN32 + #define SPDLOG_EOL "\r\n" + #else + #define SPDLOG_EOL "\n" + #endif #endif - SPDLOG_CONSTEXPR static const char* default_eol = SPDLOG_EOL; +SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL; // folder separator #if !defined(SPDLOG_FOLDER_SEPS) -#ifdef _WIN32 -#define SPDLOG_FOLDER_SEPS "\\/" -#else -#define SPDLOG_FOLDER_SEPS "/" -#endif + #ifdef _WIN32 + #define SPDLOG_FOLDER_SEPS "\\/" + #else + #define SPDLOG_FOLDER_SEPS "/" + #endif #endif - SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; - SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS); +SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; +SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = + SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS); - // fopen_s on non windows for writing - SPDLOG_API bool fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode); +// fopen_s on non windows for writing +SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode); - // Remove filename. return 0 on success - SPDLOG_API int remove(const filename_t& filename) SPDLOG_NOEXCEPT; +// Remove filename. return 0 on success +SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT; - // Remove file if exists. return 0 on success - // Note: Non atomic (might return failure to delete if concurrently deleted by - // other process/thread) - SPDLOG_API int remove_if_exists(const filename_t& filename) SPDLOG_NOEXCEPT; +// Remove file if exists. return 0 on success +// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread) +SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT; - SPDLOG_API int rename(const filename_t& filename1, const filename_t& filename2) SPDLOG_NOEXCEPT; +SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT; - // Return if file exists. - SPDLOG_API bool path_exists(const filename_t& filename) SPDLOG_NOEXCEPT; +// Return if file exists. +SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT; - // Return file size according to open FILE* object - SPDLOG_API size_t filesize(FILE* f); +// Return file size according to open FILE* object +SPDLOG_API size_t filesize(FILE *f); - // Return utc offset in minutes or throw spdlog_ex on failure - SPDLOG_API int utc_minutes_offset(const std::tm& tm = details::os::localtime()); +// Return utc offset in minutes or throw spdlog_ex on failure +SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime()); - // Return current thread id as size_t - // It exists because the std::this_thread::get_id() is much slower(especially - // under VS 2013) - SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT; +// Return current thread id as size_t +// It exists because the std::this_thread::get_id() is much slower(especially +// under VS 2013) +SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT; - // Return current thread id as size_t (from thread local storage) - SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT; +// Return current thread id as size_t (from thread local storage) +SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT; - // This is avoid msvc issue in sleep_for that happens if the clock changes. - // See https://github.com/gabime/spdlog/issues/609 - SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT; +// This is avoid msvc issue in sleep_for that happens if the clock changes. +// See https://github.com/gabime/spdlog/issues/609 +SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT; - SPDLOG_API std::string filename_to_str(const filename_t& filename); +SPDLOG_API std::string filename_to_str(const filename_t &filename); - SPDLOG_API int pid() SPDLOG_NOEXCEPT; +SPDLOG_API int pid() SPDLOG_NOEXCEPT; - // Determine if the terminal supports colors - // Source: https://github.com/agauniyal/rang/ - SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT; +// Determine if the terminal supports colors +// Source: https://github.com/agauniyal/rang/ +SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT; - // Determine if the terminal attached - // Source: https://github.com/agauniyal/rang/ - SPDLOG_API bool in_terminal(FILE* file) SPDLOG_NOEXCEPT; +// Determine if the terminal attached +// Source: https://github.com/agauniyal/rang/ +SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT; #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) - SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t& target); +SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target); - SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t& target); +SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target); #endif - // Return directory name from given path or empty string - // "abc/file" => "abc" - // "abc/" => "abc" - // "abc" => "" - // "abc///" => "abc//" - SPDLOG_API filename_t dir_name(const filename_t& path); +// Return directory name from given path or empty string +// "abc/file" => "abc" +// "abc/" => "abc" +// "abc" => "" +// "abc///" => "abc//" +SPDLOG_API filename_t dir_name(const filename_t &path); - // Create a dir from the given path. - // Return true if succeeded or if this dir already exists. - SPDLOG_API bool create_dir(const filename_t& path); +// Create a dir from the given path. +// Return true if succeeded or if this dir already exists. +SPDLOG_API bool create_dir(const filename_t &path); - // non thread safe, cross platform getenv/getenv_s - // return empty string if field not found - SPDLOG_API std::string getenv(const char* field); +// non thread safe, cross platform getenv/getenv_s +// return empty string if field not found +SPDLOG_API std::string getenv(const char *field); - // Do fsync by FILE objectpointer. - // Return true on success. - SPDLOG_API bool fsync(FILE* fp); +// Do fsync by FILE objectpointer. +// Return true on success. +SPDLOG_API bool fsync(FILE *fp); - } // namespace os - } // namespace details -} // namespace spdlog +} // namespace os +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "os-inl.h" + #include "os-inl.h" #endif diff --git a/lib/spdlog/details/periodic_worker-inl.h b/lib/spdlog/details/periodic_worker-inl.h index 5ce237a3..18f11fbe 100644 --- a/lib/spdlog/details/periodic_worker-inl.h +++ b/lib/spdlog/details/periodic_worker-inl.h @@ -4,27 +4,23 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif -namespace spdlog -{ - namespace details - { +namespace spdlog { +namespace details { - // stop the worker thread and join it - SPDLOG_INLINE periodic_worker::~periodic_worker() +// stop the worker thread and join it +SPDLOG_INLINE periodic_worker::~periodic_worker() { + if (worker_thread_.joinable()) { { - if (worker_thread_.joinable()) - { - { - std::lock_guard lock(mutex_); - active_ = false; - } - cv_.notify_one(); - worker_thread_.join(); - } + std::lock_guard lock(mutex_); + active_ = false; } + cv_.notify_one(); + worker_thread_.join(); + } +} - } // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/periodic_worker.h b/lib/spdlog/details/periodic_worker.h index a7022964..d647b66e 100644 --- a/lib/spdlog/details/periodic_worker.h +++ b/lib/spdlog/details/periodic_worker.h @@ -7,59 +7,52 @@ // // RAII over the owned thread: // creates the thread on construction. -// stops and joins the thread on destruction (if the thread is executing a -// callback, wait for it to finish first). +// stops and joins the thread on destruction (if the thread is executing a callback, wait for it +// to finish first). #include #include #include #include #include -namespace spdlog -{ - namespace details - { +namespace spdlog { +namespace details { - class SPDLOG_API periodic_worker { - public: - template - periodic_worker(const std::function& callback_fun, std::chrono::duration interval) - { - active_ = (interval > std::chrono::duration::zero()); - if (!active_) - { - return; - } +class SPDLOG_API periodic_worker { +public: + template + periodic_worker(const std::function &callback_fun, + std::chrono::duration interval) { + active_ = (interval > std::chrono::duration::zero()); + if (!active_) { + return; + } - worker_thread_ = std::thread( - [this, callback_fun, interval]() - { - for (;;) - { - std::unique_lock lock(this->mutex_); - if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) - { - return; // active_ == false, so exit this thread - } - callback_fun(); - } - }); + worker_thread_ = std::thread([this, callback_fun, interval]() { + for (;;) { + std::unique_lock lock(this->mutex_); + if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { + return; // active_ == false, so exit this thread + } + callback_fun(); } - std::thread& get_thread() { return worker_thread_; } - periodic_worker(const periodic_worker&) = delete; - periodic_worker& operator=(const periodic_worker&) = delete; - // stop the worker thread and join it - ~periodic_worker(); + }); + } + std::thread &get_thread() { return worker_thread_; } + periodic_worker(const periodic_worker &) = delete; + periodic_worker &operator=(const periodic_worker &) = delete; + // stop the worker thread and join it + ~periodic_worker(); - private: - bool active_; - std::thread worker_thread_; - std::mutex mutex_; - std::condition_variable cv_; - }; - } // namespace details -} // namespace spdlog +private: + bool active_; + std::thread worker_thread_; + std::mutex mutex_; + std::condition_variable cv_; +}; +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "periodic_worker-inl.h" + #include "periodic_worker-inl.h" #endif diff --git a/lib/spdlog/details/registry-inl.h b/lib/spdlog/details/registry-inl.h index 3906735f..f447848e 100644 --- a/lib/spdlog/details/registry-inl.h +++ b/lib/spdlog/details/registry-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -13,13 +13,13 @@ #include #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER -// support for the default stdout color logger -#ifdef _WIN32 -#include -#else -#include -#endif -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER + // support for the default stdout color logger + #ifdef _WIN32 + #include + #else + #include + #endif +#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #include #include @@ -27,282 +27,235 @@ #include #include -namespace spdlog -{ - namespace details - { +namespace spdlog { +namespace details { - SPDLOG_INLINE registry::registry() : formatter_(new pattern_formatter()) - { +SPDLOG_INLINE registry::registry() + : formatter_(new pattern_formatter()) { #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER -// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in -// windows). -#ifdef _WIN32 - auto color_sink = std::make_shared(); -#else - auto color_sink = std::make_shared(); -#endif - - const char* default_logger_name = ""; - default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); - loggers_[default_logger_name] = default_logger_; - -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER - } - - SPDLOG_INLINE registry::~registry() = default; - - SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) - { - std::lock_guard lock(logger_map_mutex_); - register_logger_(std::move(new_logger)); - } - - SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) - { - std::lock_guard lock(logger_map_mutex_); - new_logger->set_formatter(formatter_->clone()); - - if (err_handler_) - { - new_logger->set_error_handler(err_handler_); - } - - // set new level according to previously configured level or default level - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); - - new_logger->flush_on(flush_level_); - - if (backtrace_n_messages_ > 0) - { - new_logger->enable_backtrace(backtrace_n_messages_); - } - - if (automatic_registration_) - { - register_logger_(std::move(new_logger)); - } - } - - SPDLOG_INLINE std::shared_ptr registry::get(const std::string& logger_name) - { - std::lock_guard lock(logger_map_mutex_); - auto found = loggers_.find(logger_name); - return found == loggers_.end() ? nullptr : found->second; - } - - SPDLOG_INLINE std::shared_ptr registry::default_logger() - { - std::lock_guard lock(logger_map_mutex_); - return default_logger_; - } - - // Return raw ptr to the default logger. - // To be used directly by the spdlog default api (e.g. spdlog::info) - // This make the default API faster, but cannot be used concurrently with - // set_default_logger(). e.g do not call set_default_logger() from one thread - // while calling spdlog::info() from another. - SPDLOG_INLINE logger* registry::get_default_raw() { return default_logger_.get(); } - - // set default logger. - // default logger is stored in default_logger_ (for faster retrieval) and in the - // loggers_ map. - SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) - { - std::lock_guard lock(logger_map_mutex_); - if (new_default_logger != nullptr) - { - loggers_[new_default_logger->name()] = new_default_logger; - } - default_logger_ = std::move(new_default_logger); - } - - SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) - { - std::lock_guard lock(tp_mutex_); - tp_ = std::move(tp); - } - - SPDLOG_INLINE std::shared_ptr registry::get_tp() - { - std::lock_guard lock(tp_mutex_); - return tp_; - } - - // Set global formatter. Each sink in each logger will get a clone of this - // object - SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) - { - std::lock_guard lock(logger_map_mutex_); - formatter_ = std::move(formatter); - for (auto& l : loggers_) - { - l.second->set_formatter(formatter_->clone()); - } - } - - SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) - { - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = n_messages; - - for (auto& l : loggers_) - { - l.second->enable_backtrace(n_messages); - } - } - - SPDLOG_INLINE void registry::disable_backtrace() - { - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = 0; - for (auto& l : loggers_) - { - l.second->disable_backtrace(); - } - } - - SPDLOG_INLINE void registry::set_level(level::level_enum log_level) - { - std::lock_guard lock(logger_map_mutex_); - for (auto& l : loggers_) - { - l.second->set_level(log_level); - } - global_log_level_ = log_level; - } - - SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) - { - std::lock_guard lock(logger_map_mutex_); - for (auto& l : loggers_) - { - l.second->flush_on(log_level); - } - flush_level_ = log_level; - } - - SPDLOG_INLINE void registry::set_error_handler(err_handler handler) - { - std::lock_guard lock(logger_map_mutex_); - for (auto& l : loggers_) - { - l.second->set_error_handler(handler); - } - err_handler_ = std::move(handler); - } - - SPDLOG_INLINE void registry::apply_all(const std::function)>& fun) - { - std::lock_guard lock(logger_map_mutex_); - for (auto& l : loggers_) - { - fun(l.second); - } - } - - SPDLOG_INLINE void registry::flush_all() - { - std::lock_guard lock(logger_map_mutex_); - for (auto& l : loggers_) - { - l.second->flush(); - } - } - - SPDLOG_INLINE void registry::drop(const std::string& logger_name) - { - std::lock_guard lock(logger_map_mutex_); - auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; - loggers_.erase(logger_name); - if (is_default_logger) - { - default_logger_.reset(); - } - } - - SPDLOG_INLINE void registry::drop_all() - { - std::lock_guard lock(logger_map_mutex_); - loggers_.clear(); - default_logger_.reset(); - } - - // clean all resources and threads started by the registry - SPDLOG_INLINE void registry::shutdown() - { - { - std::lock_guard lock(flusher_mutex_); - periodic_flusher_.reset(); - } - - drop_all(); - - { - std::lock_guard lock(tp_mutex_); - tp_.reset(); - } - } - - SPDLOG_INLINE std::recursive_mutex& registry::tp_mutex() { return tp_mutex_; } - - SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) - { - std::lock_guard lock(logger_map_mutex_); - automatic_registration_ = automatic_registration; - } - - SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum* global_level) - { - std::lock_guard lock(logger_map_mutex_); - log_levels_ = std::move(levels); - auto global_level_requested = global_level != nullptr; - global_log_level_ = global_level_requested ? *global_level : global_log_level_; - - for (auto& logger : loggers_) - { - auto logger_entry = log_levels_.find(logger.first); - if (logger_entry != log_levels_.end()) - { - logger.second->set_level(logger_entry->second); - } - else if (global_level_requested) - { - logger.second->set_level(*global_level); - } - } - } - - SPDLOG_INLINE registry& registry::instance() - { - static registry s_instance; - return s_instance; - } - - SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) - { - std::lock_guard lock(logger_map_mutex_); - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); - } + // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). + #ifdef _WIN32 + auto color_sink = std::make_shared(); + #else + auto color_sink = std::make_shared(); + #endif + + const char *default_logger_name = ""; + default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); + loggers_[default_logger_name] = default_logger_; + +#endif // SPDLOG_DISABLE_DEFAULT_LOGGER +} + +SPDLOG_INLINE registry::~registry() = default; + +SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) { + std::lock_guard lock(logger_map_mutex_); + register_logger_(std::move(new_logger)); +} + +SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) { + std::lock_guard lock(logger_map_mutex_); + new_logger->set_formatter(formatter_->clone()); + + if (err_handler_) { + new_logger->set_error_handler(err_handler_); + } + + // set new level according to previously configured level or default level + auto it = log_levels_.find(new_logger->name()); + auto new_level = it != log_levels_.end() ? it->second : global_log_level_; + new_logger->set_level(new_level); + + new_logger->flush_on(flush_level_); + + if (backtrace_n_messages_ > 0) { + new_logger->enable_backtrace(backtrace_n_messages_); + } + + if (automatic_registration_) { + register_logger_(std::move(new_logger)); + } +} + +SPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) { + std::lock_guard lock(logger_map_mutex_); + auto found = loggers_.find(logger_name); + return found == loggers_.end() ? nullptr : found->second; +} + +SPDLOG_INLINE std::shared_ptr registry::default_logger() { + std::lock_guard lock(logger_map_mutex_); + return default_logger_; +} + +// Return raw ptr to the default logger. +// To be used directly by the spdlog default api (e.g. spdlog::info) +// This make the default API faster, but cannot be used concurrently with set_default_logger(). +// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. +SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); } + +// set default logger. +// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. +SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) { + std::lock_guard lock(logger_map_mutex_); + if (new_default_logger != nullptr) { + loggers_[new_default_logger->name()] = new_default_logger; + } + default_logger_ = std::move(new_default_logger); +} + +SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) { + std::lock_guard lock(tp_mutex_); + tp_ = std::move(tp); +} + +SPDLOG_INLINE std::shared_ptr registry::get_tp() { + std::lock_guard lock(tp_mutex_); + return tp_; +} + +// Set global formatter. Each sink in each logger will get a clone of this object +SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) { + std::lock_guard lock(logger_map_mutex_); + formatter_ = std::move(formatter); + for (auto &l : loggers_) { + l.second->set_formatter(formatter_->clone()); + } +} + +SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) { + std::lock_guard lock(logger_map_mutex_); + backtrace_n_messages_ = n_messages; + + for (auto &l : loggers_) { + l.second->enable_backtrace(n_messages); + } +} + +SPDLOG_INLINE void registry::disable_backtrace() { + std::lock_guard lock(logger_map_mutex_); + backtrace_n_messages_ = 0; + for (auto &l : loggers_) { + l.second->disable_backtrace(); + } +} + +SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) { + l.second->set_level(log_level); + } + global_log_level_ = log_level; +} + +SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) { + l.second->flush_on(log_level); + } + flush_level_ = log_level; +} + +SPDLOG_INLINE void registry::set_error_handler(err_handler handler) { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) { + l.second->set_error_handler(handler); + } + err_handler_ = std::move(handler); +} + +SPDLOG_INLINE void registry::apply_all( + const std::function)> &fun) { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) { + fun(l.second); + } +} + +SPDLOG_INLINE void registry::flush_all() { + std::lock_guard lock(logger_map_mutex_); + for (auto &l : loggers_) { + l.second->flush(); + } +} + +SPDLOG_INLINE void registry::drop(const std::string &logger_name) { + std::lock_guard lock(logger_map_mutex_); + auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; + loggers_.erase(logger_name); + if (is_default_logger) { + default_logger_.reset(); + } +} + +SPDLOG_INLINE void registry::drop_all() { + std::lock_guard lock(logger_map_mutex_); + loggers_.clear(); + default_logger_.reset(); +} + +// clean all resources and threads started by the registry +SPDLOG_INLINE void registry::shutdown() { + { + std::lock_guard lock(flusher_mutex_); + periodic_flusher_.reset(); + } - SPDLOG_INLINE void registry::throw_if_exists_(const std::string& logger_name) - { - if (loggers_.find(logger_name) != loggers_.end()) - { - throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); - } - } + drop_all(); - SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) - { - auto logger_name = new_logger->name(); - throw_if_exists_(logger_name); - loggers_[logger_name] = std::move(new_logger); + { + std::lock_guard lock(tp_mutex_); + tp_.reset(); + } +} + +SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } + +SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) { + std::lock_guard lock(logger_map_mutex_); + automatic_registration_ = automatic_registration; +} + +SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { + std::lock_guard lock(logger_map_mutex_); + log_levels_ = std::move(levels); + auto global_level_requested = global_level != nullptr; + global_log_level_ = global_level_requested ? *global_level : global_log_level_; + + for (auto &logger : loggers_) { + auto logger_entry = log_levels_.find(logger.first); + if (logger_entry != log_levels_.end()) { + logger.second->set_level(logger_entry->second); + } else if (global_level_requested) { + logger.second->set_level(*global_level); } - - } // namespace details -} // namespace spdlog + } +} + +SPDLOG_INLINE registry ®istry::instance() { + static registry s_instance; + return s_instance; +} + +SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) { + std::lock_guard lock(logger_map_mutex_); + auto it = log_levels_.find(new_logger->name()); + auto new_level = it != log_levels_.end() ? it->second : global_log_level_; + new_logger->set_level(new_level); +} + +SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) { + if (loggers_.find(logger_name) != loggers_.end()) { + throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); + } +} + +SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) { + auto logger_name = new_logger->name(); + throw_if_exists_(logger_name); + loggers_[logger_name] = std::move(new_logger); +} + +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/registry.h b/lib/spdlog/details/registry.h index 0e9780e1..8afcbd6f 100644 --- a/lib/spdlog/details/registry.h +++ b/lib/spdlog/details/registry.h @@ -4,9 +4,9 @@ #pragma once // Loggers registry of unique name->logger pointer -// An attempt to create a logger with an already existing name will result with -// spdlog_ex exception. If user requests a non existing logger, nullptr will be -// returned This class is thread safe +// An attempt to create a logger with an already existing name will result with spdlog_ex exception. +// If user requests a non existing logger, nullptr will be returned +// This class is thread safe #include #include @@ -18,118 +18,112 @@ #include #include -namespace spdlog -{ - class logger; +namespace spdlog { +class logger; - namespace details - { - class thread_pool; +namespace details { +class thread_pool; - class SPDLOG_API registry { - public: - using log_levels = std::unordered_map; - registry(const registry&) = delete; - registry& operator=(const registry&) = delete; +class SPDLOG_API registry { +public: + using log_levels = std::unordered_map; + registry(const registry &) = delete; + registry &operator=(const registry &) = delete; - void register_logger(std::shared_ptr new_logger); - void initialize_logger(std::shared_ptr new_logger); - std::shared_ptr get(const std::string& logger_name); - std::shared_ptr default_logger(); + void register_logger(std::shared_ptr new_logger); + void initialize_logger(std::shared_ptr new_logger); + std::shared_ptr get(const std::string &logger_name); + std::shared_ptr default_logger(); - // Return raw ptr to the default logger. - // To be used directly by the spdlog default api (e.g. spdlog::info) - // This make the default API faster, but cannot be used concurrently with - // set_default_logger(). e.g do not call set_default_logger() from one thread - // while calling spdlog::info() from another. - logger* get_default_raw(); + // Return raw ptr to the default logger. + // To be used directly by the spdlog default api (e.g. spdlog::info) + // This make the default API faster, but cannot be used concurrently with set_default_logger(). + // e.g do not call set_default_logger() from one thread while calling spdlog::info() from + // another. + logger *get_default_raw(); - // set default logger and add it to the registry if not registered already. - // default logger is stored in default_logger_ (for faster retrieval) and in - // the loggers_ map. Note: Make sure to unregister it when no longer needed or - // before calling again with a new logger. - void set_default_logger(std::shared_ptr new_default_logger); + // set default logger and add it to the registry if not registered already. + // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. + // Note: Make sure to unregister it when no longer needed or before calling again with a new + // logger. + void set_default_logger(std::shared_ptr new_default_logger); - void set_tp(std::shared_ptr tp); + void set_tp(std::shared_ptr tp); - std::shared_ptr get_tp(); + std::shared_ptr get_tp(); - // Set global formatter. Each sink in each logger will get a clone of this - // object - void set_formatter(std::unique_ptr formatter); + // Set global formatter. Each sink in each logger will get a clone of this object + void set_formatter(std::unique_ptr formatter); - void enable_backtrace(size_t n_messages); + void enable_backtrace(size_t n_messages); - void disable_backtrace(); + void disable_backtrace(); - void set_level(level::level_enum log_level); + void set_level(level::level_enum log_level); - void flush_on(level::level_enum log_level); + void flush_on(level::level_enum log_level); - template - void flush_every(std::chrono::duration interval) - { - std::lock_guard lock(flusher_mutex_); - auto clbk = [this]() { this->flush_all(); }; - periodic_flusher_ = details::make_unique(clbk, interval); - } + template + void flush_every(std::chrono::duration interval) { + std::lock_guard lock(flusher_mutex_); + auto clbk = [this]() { this->flush_all(); }; + periodic_flusher_ = details::make_unique(clbk, interval); + } - std::unique_ptr& get_flusher() - { - std::lock_guard lock(flusher_mutex_); - return periodic_flusher_; - } + std::unique_ptr &get_flusher() { + std::lock_guard lock(flusher_mutex_); + return periodic_flusher_; + } - void set_error_handler(err_handler handler); + void set_error_handler(err_handler handler); - void apply_all(const std::function)>& fun); + void apply_all(const std::function)> &fun); - void flush_all(); + void flush_all(); - void drop(const std::string& logger_name); + void drop(const std::string &logger_name); - void drop_all(); + void drop_all(); - // clean all resources and threads started by the registry - void shutdown(); + // clean all resources and threads started by the registry + void shutdown(); - std::recursive_mutex& tp_mutex(); + std::recursive_mutex &tp_mutex(); - void set_automatic_registration(bool automatic_registration); + void set_automatic_registration(bool automatic_registration); - // set levels for all existing/future loggers. global_level can be null if - // should not set. - void set_levels(log_levels levels, level::level_enum* global_level); + // set levels for all existing/future loggers. global_level can be null if should not set. + void set_levels(log_levels levels, level::level_enum *global_level); - static registry& instance(); + static registry &instance(); - void apply_logger_env_levels(std::shared_ptr new_logger); + void apply_logger_env_levels(std::shared_ptr new_logger); - private: - registry(); - ~registry(); +private: + registry(); + ~registry(); - void throw_if_exists_(const std::string& logger_name); - void register_logger_(std::shared_ptr new_logger); - bool set_level_from_cfg_(logger* logger); - std::mutex logger_map_mutex_, flusher_mutex_; - std::recursive_mutex tp_mutex_; - std::unordered_map> loggers_; - log_levels log_levels_; - std::unique_ptr formatter_; - spdlog::level::level_enum global_log_level_ = level::info; - level::level_enum flush_level_ = level::off; - err_handler err_handler_; - std::shared_ptr tp_; - std::unique_ptr periodic_flusher_; - std::shared_ptr default_logger_; - bool automatic_registration_ = true; - size_t backtrace_n_messages_ = 0; - }; + void throw_if_exists_(const std::string &logger_name); + void register_logger_(std::shared_ptr new_logger); + bool set_level_from_cfg_(logger *logger); + std::mutex logger_map_mutex_, flusher_mutex_; + std::recursive_mutex tp_mutex_; + std::unordered_map> loggers_; + log_levels log_levels_; + std::unique_ptr formatter_; + spdlog::level::level_enum global_log_level_ = level::info; + level::level_enum flush_level_ = level::off; + err_handler err_handler_; + std::shared_ptr tp_; + std::unique_ptr periodic_flusher_; + std::shared_ptr default_logger_; + bool automatic_registration_ = true; + size_t backtrace_n_messages_ = 0; +}; - } // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "registry-inl.h" + #include "registry-inl.h" #endif diff --git a/lib/spdlog/details/synchronous_factory.h b/lib/spdlog/details/synchronous_factory.h index 0af4f2fb..4bd5a51c 100644 --- a/lib/spdlog/details/synchronous_factory.h +++ b/lib/spdlog/details/synchronous_factory.h @@ -5,20 +5,18 @@ #include "registry.h" -namespace spdlog -{ +namespace spdlog { - // Default logger factory- creates synchronous loggers - class logger; +// Default logger factory- creates synchronous loggers +class logger; - struct synchronous_factory { - template - static std::shared_ptr create(std::string logger_name, SinkArgs&&... args) - { - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); - details::registry::instance().initialize_logger(new_logger); - return new_logger; - } - }; -} // namespace spdlog +struct synchronous_factory { + template + static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { + auto sink = std::make_shared(std::forward(args)...); + auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); + details::registry::instance().initialize_logger(new_logger); + return new_logger; + } +}; +} // namespace spdlog diff --git a/lib/spdlog/details/tcp_client-windows.h b/lib/spdlog/details/tcp_client-windows.h index d1b97bf7..bf8f7b87 100644 --- a/lib/spdlog/details/tcp_client-windows.h +++ b/lib/spdlog/details/tcp_client-windows.h @@ -19,132 +19,117 @@ #pragma comment(lib, "Mswsock.lib") #pragma comment(lib, "AdvApi32.lib") -namespace spdlog -{ - namespace details - { - class tcp_client { - SOCKET socket_ = INVALID_SOCKET; - - static void init_winsock_() - { - WSADATA wsaData; - auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData); - if (rv != 0) - { - throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); - } - } - - static void throw_winsock_error_(const std::string& msg, int last_error) - { - char buf[512]; - ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); - - throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf)); +namespace spdlog { +namespace details { +class tcp_client { + SOCKET socket_ = INVALID_SOCKET; + + static void init_winsock_() { + WSADATA wsaData; + auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData); + if (rv != 0) { + throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); + } + } + + static void throw_winsock_error_(const std::string &msg, int last_error) { + char buf[512]; + ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, + last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, + (sizeof(buf) / sizeof(char)), NULL); + + throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf)); + } + +public: + tcp_client() { init_winsock_(); } + + ~tcp_client() { + close(); + ::WSACleanup(); + } + + bool is_connected() const { return socket_ != INVALID_SOCKET; } + + void close() { + ::closesocket(socket_); + socket_ = INVALID_SOCKET; + } + + SOCKET fd() const { return socket_; } + + // try to connect or throw on failure + void connect(const std::string &host, int port) { + if (is_connected()) { + close(); + } + struct addrinfo hints {}; + ZeroMemory(&hints, sizeof(hints)); + + hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value + hints.ai_protocol = 0; + + auto port_str = std::to_string(port); + struct addrinfo *addrinfo_result; + auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); + int last_error = 0; + if (rv != 0) { + last_error = ::WSAGetLastError(); + WSACleanup(); + throw_winsock_error_("getaddrinfo failed", last_error); + } + + // Try each address until we successfully connect(2). + + for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { + socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + if (socket_ == INVALID_SOCKET) { + last_error = ::WSAGetLastError(); + WSACleanup(); + continue; } - - public: - tcp_client() { init_winsock_(); } - - ~tcp_client() - { + if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) { + break; + } else { + last_error = ::WSAGetLastError(); close(); - ::WSACleanup(); } - - bool is_connected() const { return socket_ != INVALID_SOCKET; } - - void close() - { - ::closesocket(socket_); - socket_ = INVALID_SOCKET; - } - - SOCKET fd() const { return socket_; } - - // try to connect or throw on failure - void connect(const std::string& host, int port) - { - if (is_connected()) - { - close(); - } - struct addrinfo hints {}; - ZeroMemory(&hints, sizeof(hints)); - - hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on - hints.ai_socktype = SOCK_STREAM; // TCP - hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value - hints.ai_protocol = 0; - - auto port_str = std::to_string(port); - struct addrinfo* addrinfo_result; - auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); - int last_error = 0; - if (rv != 0) - { - last_error = ::WSAGetLastError(); - WSACleanup(); - throw_winsock_error_("getaddrinfo failed", last_error); - } - - // Try each address until we successfully connect(2). - - for (auto* rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) - { - socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); - if (socket_ == INVALID_SOCKET) - { - last_error = ::WSAGetLastError(); - WSACleanup(); - continue; - } - if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) - { - break; - } - else - { - last_error = ::WSAGetLastError(); - close(); - } - } - ::freeaddrinfo(addrinfo_result); - if (socket_ == INVALID_SOCKET) - { - WSACleanup(); - throw_winsock_error_("connect failed", last_error); - } - - // set TCP_NODELAY - int enable_flag = 1; - ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), sizeof(enable_flag)); + } + ::freeaddrinfo(addrinfo_result); + if (socket_ == INVALID_SOCKET) { + WSACleanup(); + throw_winsock_error_("connect failed", last_error); + } + + // set TCP_NODELAY + int enable_flag = 1; + ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), + sizeof(enable_flag)); + } + + // Send exactly n_bytes of the given data. + // On error close the connection and throw. + void send(const char *data, size_t n_bytes) { + size_t bytes_sent = 0; + while (bytes_sent < n_bytes) { + const int send_flags = 0; + auto write_result = + ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags); + if (write_result == SOCKET_ERROR) { + int last_error = ::WSAGetLastError(); + close(); + throw_winsock_error_("send failed", last_error); } - // Send exactly n_bytes of the given data. - // On error close the connection and throw. - void send(const char* data, size_t n_bytes) + if (write_result == 0) // (probably should not happen but in any case..) { - size_t bytes_sent = 0; - while (bytes_sent < n_bytes) - { - const int send_flags = 0; - auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags); - if (write_result == SOCKET_ERROR) - { - int last_error = ::WSAGetLastError(); - close(); - throw_winsock_error_("send failed", last_error); - } - - if (write_result == 0) // (probably should not happen but in any case..) - { - break; - } - bytes_sent += static_cast(write_result); - } + break; } - }; - } // namespace details -} // namespace spdlog + bytes_sent += static_cast(write_result); + } + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/tcp_client.h b/lib/spdlog/details/tcp_client.h index 068b2e39..9d3c40d5 100644 --- a/lib/spdlog/details/tcp_client.h +++ b/lib/spdlog/details/tcp_client.h @@ -4,7 +4,7 @@ #pragma once #ifdef _WIN32 -#error include tcp_client-windows.h instead + #error include tcp_client-windows.h instead #endif // tcp client helper @@ -20,118 +20,108 @@ #include -namespace spdlog -{ - namespace details - { - class tcp_client { - int socket_ = -1; - - public: - bool is_connected() const { return socket_ != -1; } - - void close() - { - if (is_connected()) - { - ::close(socket_); - socket_ = -1; - } - } - - int fd() const { return socket_; } - - ~tcp_client() { close(); } - - // try to connect or throw on failure - void connect(const std::string& host, int port) - { - close(); - struct addrinfo hints {}; - memset(&hints, 0, sizeof(struct addrinfo)); - hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on - hints.ai_socktype = SOCK_STREAM; // TCP - hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value - hints.ai_protocol = 0; - - auto port_str = std::to_string(port); - struct addrinfo* addrinfo_result; - auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); - if (rv != 0) - { - throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv))); - } - - // Try each address until we successfully connect(2). - int last_errno = 0; - for (auto* rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) - { +namespace spdlog { +namespace details { +class tcp_client { + int socket_ = -1; + +public: + bool is_connected() const { return socket_ != -1; } + + void close() { + if (is_connected()) { + ::close(socket_); + socket_ = -1; + } + } + + int fd() const { return socket_; } + + ~tcp_client() { close(); } + + // try to connect or throw on failure + void connect(const std::string &host, int port) { + close(); + struct addrinfo hints {}; + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value + hints.ai_protocol = 0; + + auto port_str = std::to_string(port); + struct addrinfo *addrinfo_result; + auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); + if (rv != 0) { + throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv))); + } + + // Try each address until we successfully connect(2). + int last_errno = 0; + for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { #if defined(SOCK_CLOEXEC) - const int flags = SOCK_CLOEXEC; + const int flags = SOCK_CLOEXEC; #else - const int flags = 0; + const int flags = 0; #endif - socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol); - if (socket_ == -1) - { - last_errno = errno; - continue; - } - rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen); - if (rv == 0) - { - break; - } - last_errno = errno; - ::close(socket_); - socket_ = -1; - } - ::freeaddrinfo(addrinfo_result); - if (socket_ == -1) - { - throw_spdlog_ex("::connect failed", last_errno); - } - - // set TCP_NODELAY - int enable_flag = 1; - ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), sizeof(enable_flag)); - - // prevent sigpipe on systems where MSG_NOSIGNAL is not available + socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol); + if (socket_ == -1) { + last_errno = errno; + continue; + } + rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen); + if (rv == 0) { + break; + } + last_errno = errno; + ::close(socket_); + socket_ = -1; + } + ::freeaddrinfo(addrinfo_result); + if (socket_ == -1) { + throw_spdlog_ex("::connect failed", last_errno); + } + + // set TCP_NODELAY + int enable_flag = 1; + ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag), + sizeof(enable_flag)); + + // prevent sigpipe on systems where MSG_NOSIGNAL is not available #if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) - ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&enable_flag), sizeof(enable_flag)); + ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&enable_flag), + sizeof(enable_flag)); #endif #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) -#error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" + #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" #endif - } + } - // Send exactly n_bytes of the given data. - // On error close the connection and throw. - void send(const char* data, size_t n_bytes) - { - size_t bytes_sent = 0; - while (bytes_sent < n_bytes) - { + // Send exactly n_bytes of the given data. + // On error close the connection and throw. + void send(const char *data, size_t n_bytes) { + size_t bytes_sent = 0; + while (bytes_sent < n_bytes) { #if defined(MSG_NOSIGNAL) - const int send_flags = MSG_NOSIGNAL; + const int send_flags = MSG_NOSIGNAL; #else - const int send_flags = 0; + const int send_flags = 0; #endif - auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags); - if (write_result < 0) - { - close(); - throw_spdlog_ex("write(2) failed", errno); - } - - if (write_result == 0) // (probably should not happen but in any case..) - { - break; - } - bytes_sent += static_cast(write_result); - } + auto write_result = + ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags); + if (write_result < 0) { + close(); + throw_spdlog_ex("write(2) failed", errno); + } + + if (write_result == 0) // (probably should not happen but in any case..) + { + break; } - }; - } // namespace details -} // namespace spdlog + bytes_sent += static_cast(write_result); + } + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/thread_pool-inl.h b/lib/spdlog/details/thread_pool-inl.h index 861851e4..ccc1dc97 100644 --- a/lib/spdlog/details/thread_pool-inl.h +++ b/lib/spdlog/details/thread_pool-inl.h @@ -4,141 +4,129 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog -{ - namespace details - { - - SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop) : q_(q_max_items) - { - if (threads_n == 0 || threads_n > 1000) - { - throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " - "range is 1-1000)"); - } - for (size_t i = 0; i < threads_n; i++) - { - threads_.emplace_back( - [this, on_thread_start, on_thread_stop] - { - on_thread_start(); - this->thread_pool::worker_loop_(); - on_thread_stop(); - }); - } +namespace spdlog { +namespace details { + +SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, + size_t threads_n, + std::function on_thread_start, + std::function on_thread_stop) + : q_(q_max_items) { + if (threads_n == 0 || threads_n > 1000) { + throw_spdlog_ex( + "spdlog::thread_pool(): invalid threads_n param (valid " + "range is 1-1000)"); + } + for (size_t i = 0; i < threads_n; i++) { + threads_.emplace_back([this, on_thread_start, on_thread_stop] { + on_thread_start(); + this->thread_pool::worker_loop_(); + on_thread_stop(); + }); + } +} + +SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, + size_t threads_n, + std::function on_thread_start) + : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {} + +SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) + : thread_pool( + q_max_items, threads_n, [] {}, [] {}) {} + +// message all threads to terminate gracefully join them +SPDLOG_INLINE thread_pool::~thread_pool() { + SPDLOG_TRY { + for (size_t i = 0; i < threads_.size(); i++) { + post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); } - SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start) : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {} - - SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) : thread_pool(q_max_items, threads_n, [] {}, [] {}) {} - - // message all threads to terminate gracefully join them - SPDLOG_INLINE thread_pool::~thread_pool() - { - SPDLOG_TRY - { - for (size_t i = 0; i < threads_.size(); i++) - { - post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); - } - - for (auto& t : threads_) - { - t.join(); - } - } - SPDLOG_CATCH_STD + for (auto &t : threads_) { + t.join(); } - - void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr&& worker_ptr, const details::log_msg& msg, async_overflow_policy overflow_policy) - { - async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); - post_async_msg_(std::move(async_m), overflow_policy); + } + SPDLOG_CATCH_STD +} + +void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, + const details::log_msg &msg, + async_overflow_policy overflow_policy) { + async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); + post_async_msg_(std::move(async_m), overflow_policy); +} + +std::future SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, + async_overflow_policy overflow_policy) { + std::promise promise; + std::future future = promise.get_future(); + post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush, std::move(promise)), + overflow_policy); + return future; +} + +size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); } + +void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } + +size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); } + +void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } + +size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); } + +void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, + async_overflow_policy overflow_policy) { + if (overflow_policy == async_overflow_policy::block) { + q_.enqueue(std::move(new_msg)); + } else if (overflow_policy == async_overflow_policy::overrun_oldest) { + q_.enqueue_nowait(std::move(new_msg)); + } else { + assert(overflow_policy == async_overflow_policy::discard_new); + q_.enqueue_if_have_room(std::move(new_msg)); + } +} + +void SPDLOG_INLINE thread_pool::worker_loop_() { + while (process_next_msg_()) { + } +} + +// process next message in the queue +// return true if this thread should still be active (while no terminate msg +// was received) +bool SPDLOG_INLINE thread_pool::process_next_msg_() { + async_msg incoming_async_msg; + q_.dequeue(incoming_async_msg); + + switch (incoming_async_msg.msg_type) { + case async_msg_type::log: { + incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); + return true; } - - std::future SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr&& worker_ptr, async_overflow_policy overflow_policy) - { - std::promise promise; - std::future future = promise.get_future(); - post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush, std::move(promise)), overflow_policy); - return future; + case async_msg_type::flush: { + incoming_async_msg.worker_ptr->backend_flush_(); + incoming_async_msg.flush_promise.set_value(); + return true; } - size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); } - - void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } - - size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); } - - void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } - - size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); } - - void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg&& new_msg, async_overflow_policy overflow_policy) - { - if (overflow_policy == async_overflow_policy::block) - { - q_.enqueue(std::move(new_msg)); - } - else if (overflow_policy == async_overflow_policy::overrun_oldest) - { - q_.enqueue_nowait(std::move(new_msg)); - } - else - { - assert(overflow_policy == async_overflow_policy::discard_new); - q_.enqueue_if_have_room(std::move(new_msg)); - } + case async_msg_type::terminate: { + return false; } - void SPDLOG_INLINE thread_pool::worker_loop_() - { - while (process_next_msg_()) - { - } + default: { + assert(false); } + } - // process next message in the queue - // return true if this thread should still be active (while no terminate msg - // was received) - bool SPDLOG_INLINE thread_pool::process_next_msg_() - { - async_msg incoming_async_msg; - q_.dequeue(incoming_async_msg); - - switch (incoming_async_msg.msg_type) - { - case async_msg_type::log: - { - incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); - return true; - } - case async_msg_type::flush: - { - incoming_async_msg.worker_ptr->backend_flush_(); - incoming_async_msg.flush_promise.set_value(); - return true; - } - - case async_msg_type::terminate: - { - return false; - } - - default: - { - assert(false); - } - } - - return true; - } + return true; +} - } // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/thread_pool.h b/lib/spdlog/details/thread_pool.h index 74d744ea..0d56a091 100644 --- a/lib/spdlog/details/thread_pool.h +++ b/lib/spdlog/details/thread_pool.h @@ -14,96 +14,115 @@ #include #include -namespace spdlog -{ - class async_logger; +namespace spdlog { +class async_logger; - namespace details - { +namespace details { - using async_logger_ptr = std::shared_ptr; +using async_logger_ptr = std::shared_ptr; - enum class async_msg_type { log, flush, terminate }; +enum class async_msg_type { log, flush, terminate }; - // Async msg to move to/from the queue - // Movable only. should never be copied - struct async_msg : log_msg_buffer { - async_msg_type msg_type{async_msg_type::log}; - async_logger_ptr worker_ptr; - std::promise flush_promise; +// Async msg to move to/from the queue +// Movable only. should never be copied +struct async_msg : log_msg_buffer { + async_msg_type msg_type{async_msg_type::log}; + async_logger_ptr worker_ptr; + std::promise flush_promise; - async_msg() = default; - ~async_msg() = default; + async_msg() = default; + ~async_msg() = default; - // should only be moved in or out of the queue.. - async_msg(const async_msg&) = delete; + // should only be moved in or out of the queue.. + async_msg(const async_msg &) = delete; // support for vs2013 move #if defined(_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg&& other) : log_msg_buffer(std::move(other)), msg_type(other.msg_type), worker_ptr(std::move(other.worker_ptr)) {} - - async_msg& operator=(async_msg&& other) - { - *static_cast(this) = std::move(other); - msg_type = other.msg_type; - worker_ptr = std::move(other.worker_ptr); - return *this; - } -#else // (_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg&&) = default; - async_msg& operator=(async_msg&&) = default; + async_msg(async_msg &&other) + : log_msg_buffer(std::move(other)), + msg_type(other.msg_type), + worker_ptr(std::move(other.worker_ptr)) {} + + async_msg &operator=(async_msg &&other) { + *static_cast(this) = std::move(other); + msg_type = other.msg_type; + worker_ptr = std::move(other.worker_ptr); + return *this; + } +#else // (_MSC_VER) && _MSC_VER <= 1800 + async_msg(async_msg &&) = default; + async_msg &operator=(async_msg &&) = default; #endif - // construct from log_msg with given type - async_msg(async_logger_ptr&& worker, async_msg_type the_type, const details::log_msg& m) : log_msg_buffer{m}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{} {} - - async_msg(async_logger_ptr&& worker, async_msg_type the_type) : log_msg_buffer{}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{} {} - - async_msg(async_logger_ptr&& worker, async_msg_type the_type, std::promise&& promise) : log_msg_buffer{}, msg_type{the_type}, worker_ptr{std::move(worker)}, flush_promise{std::move(promise)} {} - - explicit async_msg(async_msg_type the_type) : async_msg{nullptr, the_type} {} - }; - - class SPDLOG_API thread_pool { - public: - using item_type = async_msg; - using q_type = details::mpmc_blocking_queue; - - thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop); - thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start); - thread_pool(size_t q_max_items, size_t threads_n); - - // message all threads to terminate gracefully and join them - ~thread_pool(); - - thread_pool(const thread_pool&) = delete; - thread_pool& operator=(thread_pool&&) = delete; - - void post_log(async_logger_ptr&& worker_ptr, const details::log_msg& msg, async_overflow_policy overflow_policy); - std::future post_flush(async_logger_ptr&& worker_ptr, async_overflow_policy overflow_policy); - size_t overrun_counter(); - void reset_overrun_counter(); - size_t discard_counter(); - void reset_discard_counter(); - size_t queue_size(); - - private: - q_type q_; - - std::vector threads_; - - void post_async_msg_(async_msg&& new_msg, async_overflow_policy overflow_policy); - void worker_loop_(); - - // process next message in the queue - // return true if this thread should still be active (while no terminate msg - // was received) - bool process_next_msg_(); - }; - - } // namespace details -} // namespace spdlog + // construct from log_msg with given type + async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m) + : log_msg_buffer{m}, + msg_type{the_type}, + worker_ptr{std::move(worker)}, + flush_promise{} {} + + async_msg(async_logger_ptr &&worker, async_msg_type the_type) + : log_msg_buffer{}, + msg_type{the_type}, + worker_ptr{std::move(worker)}, + flush_promise{} {} + + async_msg(async_logger_ptr &&worker, async_msg_type the_type, std::promise &&promise) + : log_msg_buffer{}, + msg_type{the_type}, + worker_ptr{std::move(worker)}, + flush_promise{std::move(promise)} {} + + explicit async_msg(async_msg_type the_type) + : async_msg{nullptr, the_type} {} +}; + +class SPDLOG_API thread_pool { +public: + using item_type = async_msg; + using q_type = details::mpmc_blocking_queue; + + thread_pool(size_t q_max_items, + size_t threads_n, + std::function on_thread_start, + std::function on_thread_stop); + thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start); + thread_pool(size_t q_max_items, size_t threads_n); + + // message all threads to terminate gracefully and join them + ~thread_pool(); + + thread_pool(const thread_pool &) = delete; + thread_pool &operator=(thread_pool &&) = delete; + + void post_log(async_logger_ptr &&worker_ptr, + const details::log_msg &msg, + async_overflow_policy overflow_policy); + std::future post_flush(async_logger_ptr &&worker_ptr, + async_overflow_policy overflow_policy); + size_t overrun_counter(); + void reset_overrun_counter(); + size_t discard_counter(); + void reset_discard_counter(); + size_t queue_size(); + +private: + q_type q_; + + std::vector threads_; + + void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy); + void worker_loop_(); + + // process next message in the queue + // return true if this thread should still be active (while no terminate msg + // was received) + bool process_next_msg_(); +}; + +} // namespace details +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "thread_pool-inl.h" + #include "thread_pool-inl.h" #endif diff --git a/lib/spdlog/details/udp_client-windows.h b/lib/spdlog/details/udp_client-windows.h index 99103972..8b7c2232 100644 --- a/lib/spdlog/details/udp_client-windows.h +++ b/lib/spdlog/details/udp_client-windows.h @@ -16,92 +16,83 @@ #include #if defined(_MSC_VER) -#pragma comment(lib, "Ws2_32.lib") -#pragma comment(lib, "Mswsock.lib") -#pragma comment(lib, "AdvApi32.lib") + #pragma comment(lib, "Ws2_32.lib") + #pragma comment(lib, "Mswsock.lib") + #pragma comment(lib, "AdvApi32.lib") #endif -namespace spdlog -{ - namespace details - { - class udp_client { - static constexpr int TX_BUFFER_SIZE = 1024 * 10; - SOCKET socket_ = INVALID_SOCKET; - sockaddr_in addr_ = {}; - - static void init_winsock_() - { - WSADATA wsaData; - auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData); - if (rv != 0) - { - throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); - } - } - - static void throw_winsock_error_(const std::string& msg, int last_error) - { - char buf[512]; - ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); - - throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf)); - } - - void cleanup_() - { - if (socket_ != INVALID_SOCKET) - { - ::closesocket(socket_); - } - socket_ = INVALID_SOCKET; - ::WSACleanup(); - } - - public: - udp_client(const std::string& host, uint16_t port) - { - init_winsock_(); - - addr_.sin_family = PF_INET; - addr_.sin_port = htons(port); - addr_.sin_addr.s_addr = INADDR_ANY; - if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) - { - int last_error = ::WSAGetLastError(); - ::WSACleanup(); - throw_winsock_error_("error: Invalid address!", last_error); - } - - socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); - if (socket_ == INVALID_SOCKET) - { - int last_error = ::WSAGetLastError(); - ::WSACleanup(); - throw_winsock_error_("error: Create Socket failed", last_error); - } - - int option_value = TX_BUFFER_SIZE; - if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) - { - int last_error = ::WSAGetLastError(); - cleanup_(); - throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error); - } - } - - ~udp_client() { cleanup_(); } - - SOCKET fd() const { return socket_; } - - void send(const char* data, size_t n_bytes) - { - socklen_t tolen = sizeof(struct sockaddr); - if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr*)&addr_, tolen) == -1) - { - throw_spdlog_ex("sendto(2) failed", errno); - } - } - }; - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { +class udp_client { + static constexpr int TX_BUFFER_SIZE = 1024 * 10; + SOCKET socket_ = INVALID_SOCKET; + sockaddr_in addr_ = {}; + + static void init_winsock_() { + WSADATA wsaData; + auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData); + if (rv != 0) { + throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); + } + } + + static void throw_winsock_error_(const std::string &msg, int last_error) { + char buf[512]; + ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, + last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, + (sizeof(buf) / sizeof(char)), NULL); + + throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf)); + } + + void cleanup_() { + if (socket_ != INVALID_SOCKET) { + ::closesocket(socket_); + } + socket_ = INVALID_SOCKET; + ::WSACleanup(); + } + +public: + udp_client(const std::string &host, uint16_t port) { + init_winsock_(); + + addr_.sin_family = PF_INET; + addr_.sin_port = htons(port); + addr_.sin_addr.s_addr = INADDR_ANY; + if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) { + int last_error = ::WSAGetLastError(); + ::WSACleanup(); + throw_winsock_error_("error: Invalid address!", last_error); + } + + socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); + if (socket_ == INVALID_SOCKET) { + int last_error = ::WSAGetLastError(); + ::WSACleanup(); + throw_winsock_error_("error: Create Socket failed", last_error); + } + + int option_value = TX_BUFFER_SIZE; + if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, + reinterpret_cast(&option_value), sizeof(option_value)) < 0) { + int last_error = ::WSAGetLastError(); + cleanup_(); + throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error); + } + } + + ~udp_client() { cleanup_(); } + + SOCKET fd() const { return socket_; } + + void send(const char *data, size_t n_bytes) { + socklen_t tolen = sizeof(struct sockaddr); + if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr *)&addr_, + tolen) == -1) { + throw_spdlog_ex("sendto(2) failed", errno); + } + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/udp_client.h b/lib/spdlog/details/udp_client.h index bab37f18..95826f5d 100644 --- a/lib/spdlog/details/udp_client.h +++ b/lib/spdlog/details/udp_client.h @@ -7,7 +7,7 @@ // Will throw on construction if the socket creation failed. #ifdef _WIN32 -#error "include udp_client-windows.h instead" + #error "include udp_client-windows.h instead" #endif #include @@ -22,68 +22,60 @@ #include -namespace spdlog -{ - namespace details - { - - class udp_client { - static constexpr int TX_BUFFER_SIZE = 1024 * 10; - int socket_ = -1; - struct sockaddr_in sockAddr_; - - void cleanup_() - { - if (socket_ != -1) - { - ::close(socket_); - socket_ = -1; - } - } - - public: - udp_client(const std::string& host, uint16_t port) - { - socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); - if (socket_ < 0) - { - throw_spdlog_ex("error: Create Socket Failed!"); - } - - int option_value = TX_BUFFER_SIZE; - if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) - { - cleanup_(); - throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!"); - } - - sockAddr_.sin_family = AF_INET; - sockAddr_.sin_port = htons(port); - - if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) - { - cleanup_(); - throw_spdlog_ex("error: Invalid address!"); - } - - ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero)); - } - - ~udp_client() { cleanup_(); } - - int fd() const { return socket_; } - - // Send exactly n_bytes of the given data. - // On error close the connection and throw. - void send(const char* data, size_t n_bytes) - { - ssize_t toslen = 0; - socklen_t tolen = sizeof(struct sockaddr); - if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr*)&sockAddr_, tolen)) == -1) - { - throw_spdlog_ex("sendto(2) failed", errno); - } - } - }; - } // namespace details -} // namespace spdlog +namespace spdlog { +namespace details { + +class udp_client { + static constexpr int TX_BUFFER_SIZE = 1024 * 10; + int socket_ = -1; + struct sockaddr_in sockAddr_; + + void cleanup_() { + if (socket_ != -1) { + ::close(socket_); + socket_ = -1; + } + } + +public: + udp_client(const std::string &host, uint16_t port) { + socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); + if (socket_ < 0) { + throw_spdlog_ex("error: Create Socket Failed!"); + } + + int option_value = TX_BUFFER_SIZE; + if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, + reinterpret_cast(&option_value), sizeof(option_value)) < 0) { + cleanup_(); + throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!"); + } + + sockAddr_.sin_family = AF_INET; + sockAddr_.sin_port = htons(port); + + if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) { + cleanup_(); + throw_spdlog_ex("error: Invalid address!"); + } + + ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero)); + } + + ~udp_client() { cleanup_(); } + + int fd() const { return socket_; } + + // Send exactly n_bytes of the given data. + // On error close the connection and throw. + void send(const char *data, size_t n_bytes) { + ssize_t toslen = 0; + socklen_t tolen = sizeof(struct sockaddr); + if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == + -1) { + throw_spdlog_ex("sendto(2) failed", errno); + } + } +}; +} // namespace details +} // namespace spdlog diff --git a/lib/spdlog/details/windows_include.h b/lib/spdlog/details/windows_include.h index 6a2f14f9..bbab59b1 100644 --- a/lib/spdlog/details/windows_include.h +++ b/lib/spdlog/details/windows_include.h @@ -1,11 +1,11 @@ #pragma once #ifndef NOMINMAX -#define NOMINMAX // prevent windows redefining min/max + #define NOMINMAX // prevent windows redefining min/max #endif #ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN #endif #include diff --git a/lib/spdlog/fmt/bin_to_hex.h b/lib/spdlog/fmt/bin_to_hex.h index f69abaeb..c2998d57 100644 --- a/lib/spdlog/fmt/bin_to_hex.h +++ b/lib/spdlog/fmt/bin_to_hex.h @@ -9,13 +9,13 @@ #include #if defined(__has_include) -#if __has_include() -#include -#endif + #if __has_include() + #include + #endif #endif #if __cpp_lib_span >= 202002L -#include + #include #endif // @@ -33,88 +33,88 @@ // std::vector v(200, 0x0b); // logger->info("Some buffer {}", spdlog::to_hex(v)); // char buf[128]; -// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), -// std::end(buf))); logger->info("Some buffer {:X}", -// spdlog::to_hex(std::begin(buf), std::end(buf), 16)); - -namespace spdlog -{ - namespace details - { - - template - class dump_info { - public: - dump_info(It range_begin, It range_end, size_t size_per_line) : begin_(range_begin), end_(range_end), size_per_line_(size_per_line) {} - - // do not use begin() and end() to avoid collision with fmt/ranges - It get_begin() const { return begin_; } - It get_end() const { return end_; } - size_t size_per_line() const { return size_per_line_; } - - private: - It begin_, end_; - size_t size_per_line_; - }; - } // namespace details - - // create a dump_info that wraps the given container - template - inline details::dump_info to_hex(const Container& container, size_t size_per_line = 32) - { - static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); - using Iter = typename Container::const_iterator; - return details::dump_info(std::begin(container), std::end(container), size_per_line); - } +// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf))); +// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16)); + +namespace spdlog { +namespace details { + +template +class dump_info { +public: + dump_info(It range_begin, It range_end, size_t size_per_line) + : begin_(range_begin), + end_(range_end), + size_per_line_(size_per_line) {} + + // do not use begin() and end() to avoid collision with fmt/ranges + It get_begin() const { return begin_; } + It get_end() const { return end_; } + size_t size_per_line() const { return size_per_line_; } + +private: + It begin_, end_; + size_t size_per_line_; +}; +} // namespace details + +// create a dump_info that wraps the given container +template +inline details::dump_info to_hex(const Container &container, + size_t size_per_line = 32) { + static_assert(sizeof(typename Container::value_type) == 1, + "sizeof(Container::value_type) != 1"); + using Iter = typename Container::const_iterator; + return details::dump_info(std::begin(container), std::end(container), size_per_line); +} #if __cpp_lib_span >= 202002L - template - inline details::dump_info::iterator> to_hex(const std::span& container, size_t size_per_line = 32) - { - using Container = std::span; - static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); - using Iter = typename Container::iterator; - return details::dump_info(std::begin(container), std::end(container), size_per_line); - } +template +inline details::dump_info::iterator> to_hex( + const std::span &container, size_t size_per_line = 32) { + using Container = std::span; + static_assert(sizeof(typename Container::value_type) == 1, + "sizeof(Container::value_type) != 1"); + using Iter = typename Container::iterator; + return details::dump_info(std::begin(container), std::end(container), size_per_line); +} #endif - // create dump_info from ranges - template - inline details::dump_info to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) - { - return details::dump_info(range_begin, range_end, size_per_line); - } +// create dump_info from ranges +template +inline details::dump_info to_hex(const It range_begin, + const It range_end, + size_t size_per_line = 32) { + return details::dump_info(range_begin, range_end, size_per_line); +} -} // namespace spdlog +} // namespace spdlog namespace #ifdef SPDLOG_USE_STD_FORMAT -std + std #else -fmt + fmt #endif { - template - struct formatter, char> { - const char delimiter = ' '; - bool put_newlines = true; - bool put_delimiters = true; - bool use_uppercase = false; - bool put_positions = true; // position on start of each line - bool show_ascii = false; - - // parse the format string flags - template - SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(); - while (it != ctx.end() && *it != '}') - { - switch (*it) - { +template +struct formatter, char> { + const char delimiter = ' '; + bool put_newlines = true; + bool put_delimiters = true; + bool use_uppercase = false; + bool put_positions = true; // position on start of each line + bool show_ascii = false; + + // parse the format string flags + template + SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { + auto it = ctx.begin(); + while (it != ctx.end() && *it != '}') { + switch (*it) { case 'X': use_uppercase = true; break; @@ -129,107 +129,96 @@ fmt show_ascii = false; break; case 'a': - if (put_newlines) - { + if (put_newlines) { show_ascii = true; } break; - } - - ++it; } - return it; + + ++it; } + return it; + } - // format the given bytes range as hex - template - auto format(const spdlog::details::dump_info& the_range, FormatContext& ctx) const -> decltype(ctx.out()) - { - SPDLOG_CONSTEXPR const char* hex_upper = "0123456789ABCDEF"; - SPDLOG_CONSTEXPR const char* hex_lower = "0123456789abcdef"; - const char* hex_chars = use_uppercase ? hex_upper : hex_lower; + // format the given bytes range as hex + template + auto format(const spdlog::details::dump_info &the_range, FormatContext &ctx) const + -> decltype(ctx.out()) { + SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; + SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; + const char *hex_chars = use_uppercase ? hex_upper : hex_lower; #if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000 - auto inserter = ctx.begin(); + auto inserter = ctx.begin(); #else - auto inserter = ctx.out(); + auto inserter = ctx.out(); #endif - int size_per_line = static_cast(the_range.size_per_line()); - auto start_of_line = the_range.get_begin(); - for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) - { - auto ch = static_cast(*i); + int size_per_line = static_cast(the_range.size_per_line()); + auto start_of_line = the_range.get_begin(); + for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) { + auto ch = static_cast(*i); - if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line)) - { - if (show_ascii && i != the_range.get_begin()) - { - *inserter++ = delimiter; - *inserter++ = delimiter; - for (auto j = start_of_line; j < i; j++) - { - auto pc = static_cast(*j); - *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; - } + if (put_newlines && + (i == the_range.get_begin() || i - start_of_line >= size_per_line)) { + if (show_ascii && i != the_range.get_begin()) { + *inserter++ = delimiter; + *inserter++ = delimiter; + for (auto j = start_of_line; j < i; j++) { + auto pc = static_cast(*j); + *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; } - - put_newline(inserter, static_cast(i - the_range.get_begin())); - - // put first byte without delimiter in front of it - *inserter++ = hex_chars[(ch >> 4) & 0x0f]; - *inserter++ = hex_chars[ch & 0x0f]; - start_of_line = i; - continue; } - if (put_delimiters && i != the_range.get_begin()) - { - *inserter++ = delimiter; - } + put_newline(inserter, static_cast(i - the_range.get_begin())); + // put first byte without delimiter in front of it *inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[ch & 0x0f]; + start_of_line = i; + continue; } - if (show_ascii) // add ascii to last line - { - if (the_range.get_end() - the_range.get_begin() > size_per_line) - { - auto blank_num = size_per_line - (the_range.get_end() - start_of_line); - while (blank_num-- > 0) - { - *inserter++ = delimiter; + + if (put_delimiters && i != the_range.get_begin()) { + *inserter++ = delimiter; + } + + *inserter++ = hex_chars[(ch >> 4) & 0x0f]; + *inserter++ = hex_chars[ch & 0x0f]; + } + if (show_ascii) // add ascii to last line + { + if (the_range.get_end() - the_range.get_begin() > size_per_line) { + auto blank_num = size_per_line - (the_range.get_end() - start_of_line); + while (blank_num-- > 0) { + *inserter++ = delimiter; + *inserter++ = delimiter; + if (put_delimiters) { *inserter++ = delimiter; - if (put_delimiters) - { - *inserter++ = delimiter; - } } } - *inserter++ = delimiter; - *inserter++ = delimiter; - for (auto j = start_of_line; j != the_range.get_end(); j++) - { - auto pc = static_cast(*j); - *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; - } } - return inserter; + *inserter++ = delimiter; + *inserter++ = delimiter; + for (auto j = start_of_line; j != the_range.get_end(); j++) { + auto pc = static_cast(*j); + *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; + } } + return inserter; + } - // put newline(and position header) - template - void put_newline(It inserter, std::size_t pos) const - { + // put newline(and position header) + template + void put_newline(It inserter, std::size_t pos) const { #ifdef _WIN32 - *inserter++ = '\r'; + *inserter++ = '\r'; #endif - *inserter++ = '\n'; + *inserter++ = '\n'; - if (put_positions) - { - spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); - } + if (put_positions) { + spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); } - }; -} // namespace std + } +}; +} // namespace std diff --git a/lib/spdlog/fmt/bundled/args.h b/lib/spdlog/fmt/bundled/args.h index 1a728244..ad1654bb 100644 --- a/lib/spdlog/fmt/bundled/args.h +++ b/lib/spdlog/fmt/bundled/args.h @@ -8,72 +8,58 @@ #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ -#include // std::reference_wrapper -#include // std::unique_ptr +#include // std::reference_wrapper +#include // std::unique_ptr #include #include "core.h" FMT_BEGIN_NAMESPACE -namespace detail -{ - - template - struct is_reference_wrapper : std::false_type {}; - template - struct is_reference_wrapper> : std::true_type {}; - - template - auto unwrap(const T& v) -> const T& - { - return v; - } - template - auto unwrap(const std::reference_wrapper& v) -> const T& - { - return static_cast(v); - } - - class dynamic_arg_list { - // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for - // templates it doesn't complain about inability to deduce single translation - // unit for placing vtable. So storage_node_base is made a fake template. - template - struct node { - virtual ~node() = default; - std::unique_ptr> next; - }; - - template - struct typed_node : node<> { - T value; - - template - FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) - { - } - - template - FMT_CONSTEXPR typed_node(const basic_string_view& arg) : value(arg.data(), arg.size()) - { - } - }; - - std::unique_ptr> head_; - - public: - template - auto push(const Arg& arg) -> const T& - { - auto new_node = std::unique_ptr>(new typed_node(arg)); - auto& value = new_node->value; - new_node->next = std::move(head_); - head_ = std::move(new_node); - return value; - } - }; -} // namespace detail +namespace detail { + +template struct is_reference_wrapper : std::false_type {}; +template +struct is_reference_wrapper> : std::true_type {}; + +template auto unwrap(const T& v) -> const T& { return v; } +template +auto unwrap(const std::reference_wrapper& v) -> const T& { + return static_cast(v); +} + +class dynamic_arg_list { + // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for + // templates it doesn't complain about inability to deduce single translation + // unit for placing vtable. So storage_node_base is made a fake template. + template struct node { + virtual ~node() = default; + std::unique_ptr> next; + }; + + template struct typed_node : node<> { + T value; + + template + FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} + + template + FMT_CONSTEXPR typed_node(const basic_string_view& arg) + : value(arg.data(), arg.size()) {} + }; + + std::unique_ptr> head_; + + public: + template auto push(const Arg& arg) -> const T& { + auto new_node = std::unique_ptr>(new typed_node(arg)); + auto& value = new_node->value; + new_node->next = std::move(head_); + head_ = std::move(new_node); + return value; + } +}; +} // namespace detail /** \rst @@ -92,147 +78,158 @@ class dynamic_format_arg_store : public basic_format_args #endif { -private: - using char_type = typename Context::char_type; - - template - struct need_copy { - static constexpr detail::type mapped_type = detail::mapped_type_constant::value; - - enum { value = !(detail::is_reference_wrapper::value || std::is_same>::value || std::is_same>::value || (mapped_type != detail::type::cstring_type && mapped_type != detail::type::string_type && mapped_type != detail::type::custom_type)) }; + private: + using char_type = typename Context::char_type; + + template struct need_copy { + static constexpr detail::type mapped_type = + detail::mapped_type_constant::value; + + enum { + value = !(detail::is_reference_wrapper::value || + std::is_same>::value || + std::is_same>::value || + (mapped_type != detail::type::cstring_type && + mapped_type != detail::type::string_type && + mapped_type != detail::type::custom_type)) }; - - template - using stored_type = conditional_t>::value && !detail::is_reference_wrapper::value, std::basic_string, T>; - - // Storage of basic_format_arg must be contiguous. - std::vector> data_; - std::vector> named_info_; - - // Storage of arguments not fitting into basic_format_arg must grow - // without relocation because items in data_ refer to it. - detail::dynamic_arg_list dynamic_args_; - - friend class basic_format_args; - - auto get_types() const -> unsigned long long { return detail::is_unpacked_bit | data_.size() | (named_info_.empty() ? 0ULL : static_cast(detail::has_named_args_bit)); } - - auto data() const -> const basic_format_arg* { return named_info_.empty() ? data_.data() : data_.data() + 1; } - - template - void emplace_arg(const T& arg) - { - data_.emplace_back(detail::make_arg(arg)); - } - - template - void emplace_arg(const detail::named_arg& arg) - { - if (named_info_.empty()) - { - constexpr const detail::named_arg_info* zero_ptr{nullptr}; - data_.insert(data_.begin(), {zero_ptr, 0}); - } - data_.emplace_back(detail::make_arg(detail::unwrap(arg.value))); - auto pop_one = [](std::vector>* data) { data->pop_back(); }; - std::unique_ptr>, decltype(pop_one)> guard{&data_, pop_one}; - named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); - data_[0].value_.named_args = {named_info_.data(), named_info_.size()}; - guard.release(); - } - -public: - constexpr dynamic_format_arg_store() = default; - - /** - \rst - Adds an argument into the dynamic store for later passing to a formatting - function. - - Note that custom types and string types (but not string views) are copied - into the store dynamically allocating memory if necessary. - - **Example**:: - - fmt::dynamic_format_arg_store store; - store.push_back(42); - store.push_back("abc"); - store.push_back(1.5f); - std::string result = fmt::vformat("{} and {} and {}", store); - \endrst - */ - template - void push_back(const T& arg) - { - if (detail::const_check(need_copy::value)) - emplace_arg(dynamic_args_.push>(arg)); - else - emplace_arg(detail::unwrap(arg)); - } - - /** - \rst - Adds a reference to the argument into the dynamic store for later passing to - a formatting function. - - **Example**:: - - fmt::dynamic_format_arg_store store; - char band[] = "Rolling Stones"; - store.push_back(std::cref(band)); - band[9] = 'c'; // Changing str affects the output. - std::string result = fmt::vformat("{}", store); - // result == "Rolling Scones" - \endrst - */ - template - void push_back(std::reference_wrapper arg) - { - static_assert(need_copy::value, "objects of built-in types and string views are always copied"); - emplace_arg(arg.get()); - } - - /** - Adds named argument into the dynamic store for later passing to a formatting - function. ``std::reference_wrapper`` is supported to avoid copying of the - argument. The name is always copied into the store. - */ - template - void push_back(const detail::named_arg& arg) - { - const char_type* arg_name = dynamic_args_.push>(arg.name).c_str(); - if (detail::const_check(need_copy::value)) - { - emplace_arg(fmt::arg(arg_name, dynamic_args_.push>(arg.value))); - } - else - { - emplace_arg(fmt::arg(arg_name, arg.value)); - } + }; + + template + using stored_type = conditional_t< + std::is_convertible>::value && + !detail::is_reference_wrapper::value, + std::basic_string, T>; + + // Storage of basic_format_arg must be contiguous. + std::vector> data_; + std::vector> named_info_; + + // Storage of arguments not fitting into basic_format_arg must grow + // without relocation because items in data_ refer to it. + detail::dynamic_arg_list dynamic_args_; + + friend class basic_format_args; + + auto get_types() const -> unsigned long long { + return detail::is_unpacked_bit | data_.size() | + (named_info_.empty() + ? 0ULL + : static_cast(detail::has_named_args_bit)); + } + + auto data() const -> const basic_format_arg* { + return named_info_.empty() ? data_.data() : data_.data() + 1; + } + + template void emplace_arg(const T& arg) { + data_.emplace_back(detail::make_arg(arg)); + } + + template + void emplace_arg(const detail::named_arg& arg) { + if (named_info_.empty()) { + constexpr const detail::named_arg_info* zero_ptr{nullptr}; + data_.insert(data_.begin(), {zero_ptr, 0}); } - - /** Erase all elements from the store */ - void clear() - { - data_.clear(); - named_info_.clear(); - dynamic_args_ = detail::dynamic_arg_list(); - } - - /** - \rst - Reserves space to store at least *new_cap* arguments including - *new_cap_named* named arguments. - \endrst - */ - void reserve(size_t new_cap, size_t new_cap_named) - { - FMT_ASSERT(new_cap >= new_cap_named, "Set of arguments includes set of named arguments"); - data_.reserve(new_cap); - named_info_.reserve(new_cap_named); + data_.emplace_back(detail::make_arg(detail::unwrap(arg.value))); + auto pop_one = [](std::vector>* data) { + data->pop_back(); + }; + std::unique_ptr>, decltype(pop_one)> + guard{&data_, pop_one}; + named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); + data_[0].value_.named_args = {named_info_.data(), named_info_.size()}; + guard.release(); + } + + public: + constexpr dynamic_format_arg_store() = default; + + /** + \rst + Adds an argument into the dynamic store for later passing to a formatting + function. + + Note that custom types and string types (but not string views) are copied + into the store dynamically allocating memory if necessary. + + **Example**:: + + fmt::dynamic_format_arg_store store; + store.push_back(42); + store.push_back("abc"); + store.push_back(1.5f); + std::string result = fmt::vformat("{} and {} and {}", store); + \endrst + */ + template void push_back(const T& arg) { + if (detail::const_check(need_copy::value)) + emplace_arg(dynamic_args_.push>(arg)); + else + emplace_arg(detail::unwrap(arg)); + } + + /** + \rst + Adds a reference to the argument into the dynamic store for later passing to + a formatting function. + + **Example**:: + + fmt::dynamic_format_arg_store store; + char band[] = "Rolling Stones"; + store.push_back(std::cref(band)); + band[9] = 'c'; // Changing str affects the output. + std::string result = fmt::vformat("{}", store); + // result == "Rolling Scones" + \endrst + */ + template void push_back(std::reference_wrapper arg) { + static_assert( + need_copy::value, + "objects of built-in types and string views are always copied"); + emplace_arg(arg.get()); + } + + /** + Adds named argument into the dynamic store for later passing to a formatting + function. ``std::reference_wrapper`` is supported to avoid copying of the + argument. The name is always copied into the store. + */ + template + void push_back(const detail::named_arg& arg) { + const char_type* arg_name = + dynamic_args_.push>(arg.name).c_str(); + if (detail::const_check(need_copy::value)) { + emplace_arg( + fmt::arg(arg_name, dynamic_args_.push>(arg.value))); + } else { + emplace_arg(fmt::arg(arg_name, arg.value)); } + } + + /** Erase all elements from the store */ + void clear() { + data_.clear(); + named_info_.clear(); + dynamic_args_ = detail::dynamic_arg_list(); + } + + /** + \rst + Reserves space to store at least *new_cap* arguments including + *new_cap_named* named arguments. + \endrst + */ + void reserve(size_t new_cap, size_t new_cap_named) { + FMT_ASSERT(new_cap >= new_cap_named, + "Set of arguments includes set of named arguments"); + data_.reserve(new_cap); + named_info_.reserve(new_cap_named); + } }; FMT_END_NAMESPACE -#endif // FMT_ARGS_H_ +#endif // FMT_ARGS_H_ diff --git a/lib/spdlog/fmt/bundled/chrono.h b/lib/spdlog/fmt/bundled/chrono.h index 9b43b3e0..9d54574e 100644 --- a/lib/spdlog/fmt/bundled/chrono.h +++ b/lib/spdlog/fmt/bundled/chrono.h @@ -10,52 +10,53 @@ #include #include -#include // std::isfinite -#include // std::memcpy +#include // std::isfinite +#include // std::memcpy #include #include #include #include #include -#include "ostream.h" // formatbuf +#include "ostream.h" // formatbuf FMT_BEGIN_NAMESPACE // Check if std::chrono::local_t is available. #ifndef FMT_USE_LOCAL_TIME -#ifdef __cpp_lib_chrono -#define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) -#else -#define FMT_USE_LOCAL_TIME 0 -#endif +# ifdef __cpp_lib_chrono +# define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_LOCAL_TIME 0 +# endif #endif // Check if std::chrono::utc_timestamp is available. #ifndef FMT_USE_UTC_TIME -#ifdef __cpp_lib_chrono -#define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) -#else -#define FMT_USE_UTC_TIME 0 -#endif +# ifdef __cpp_lib_chrono +# define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_UTC_TIME 0 +# endif #endif // Enable tzset. #ifndef FMT_USE_TZSET // UWP doesn't provide _tzset. -#if FMT_HAS_INCLUDE("winapifamily.h") -#include -#endif -#if defined(_WIN32) && (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) -#define FMT_USE_TZSET 1 -#else -#define FMT_USE_TZSET 0 -#endif +# if FMT_HAS_INCLUDE("winapifamily.h") +# include +# endif +# if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \ + (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) +# define FMT_USE_TZSET 1 +# else +# define FMT_USE_TZSET 0 +# endif #endif // Enable safe chrono durations, unless explicitly disabled. #ifndef FMT_SAFE_DURATION_CAST -#define FMT_SAFE_DURATION_CAST 1 +# define FMT_SAFE_DURATION_CAST 1 #endif #if FMT_SAFE_DURATION_CAST @@ -65,81 +66,82 @@ FMT_BEGIN_NAMESPACE // See https://github.com/pauldreik/safe_duration_cast // // Copyright Paul Dreik 2019 -namespace safe_duration_cast -{ - - template ::value && std::numeric_limits::is_signed == std::numeric_limits::is_signed)> - FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To - { - ec = 0; - using F = std::numeric_limits; - using T = std::numeric_limits; - static_assert(F::is_integer, "From must be integral"); - static_assert(T::is_integer, "To must be integral"); - - // A and B are both signed, or both unsigned. - if (detail::const_check(F::digits <= T::digits)) - { - // From fits in To without any problem. - } - else - { - // From does not always fit in To, resort to a dynamic check. - if (from < (T::min)() || from > (T::max)()) - { - // outside range. - ec = 1; - return {}; - } - } - return static_cast(from); +namespace safe_duration_cast { + +template ::value && + std::numeric_limits::is_signed == + std::numeric_limits::is_signed)> +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; + static_assert(F::is_integer, "From must be integral"); + static_assert(T::is_integer, "To must be integral"); + + // A and B are both signed, or both unsigned. + if (detail::const_check(F::digits <= T::digits)) { + // From fits in To without any problem. + } else { + // From does not always fit in To, resort to a dynamic check. + if (from < (T::min)() || from > (T::max)()) { + // outside range. + ec = 1; + return {}; } + } + return static_cast(from); +} - /** - * converts From to To, without loss. If the dynamic value of from - * can't be converted to To without loss, ec is set. - */ - template ::value && std::numeric_limits::is_signed != std::numeric_limits::is_signed)> - FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To - { - ec = 0; - using F = std::numeric_limits; - using T = std::numeric_limits; - static_assert(F::is_integer, "From must be integral"); - static_assert(T::is_integer, "To must be integral"); - - if (detail::const_check(F::is_signed && !T::is_signed)) - { - // From may be negative, not allowed! - if (fmt::detail::is_negative(from)) - { - ec = 1; - return {}; - } - // From is positive. Can it always fit in To? - if (detail::const_check(F::digits > T::digits) && from > static_cast(detail::max_value())) - { - ec = 1; - return {}; - } - } - - if (detail::const_check(!F::is_signed && T::is_signed && F::digits >= T::digits) && from > static_cast(detail::max_value())) - { - ec = 1; - return {}; - } - return static_cast(from); // Lossless conversion. +/** + * converts From to To, without loss. If the dynamic value of from + * can't be converted to To without loss, ec is set. + */ +template ::value && + std::numeric_limits::is_signed != + std::numeric_limits::is_signed)> +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; + static_assert(F::is_integer, "From must be integral"); + static_assert(T::is_integer, "To must be integral"); + + if (detail::const_check(F::is_signed && !T::is_signed)) { + // From may be negative, not allowed! + if (fmt::detail::is_negative(from)) { + ec = 1; + return {}; } + // From is positive. Can it always fit in To? + if (detail::const_check(F::digits > T::digits) && + from > static_cast(detail::max_value())) { + ec = 1; + return {}; + } + } + + if (detail::const_check(!F::is_signed && T::is_signed && + F::digits >= T::digits) && + from > static_cast(detail::max_value())) { + ec = 1; + return {}; + } + return static_cast(from); // Lossless conversion. +} - template ::value)> - FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To - { - ec = 0; - return from; - } // function +template ::value)> +FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) + -> To { + ec = 0; + return from; +} // function - // clang-format off +// clang-format off /** * converts From to To if possible, otherwise ec is set. * @@ -152,318 +154,330 @@ namespace safe_duration_cast * subnormal | best effort * -Inf | -Inf */ - // clang-format on - template ::value)> - FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To - { - ec = 0; - using T = std::numeric_limits; - static_assert(std::is_floating_point::value, "From must be floating"); - static_assert(std::is_floating_point::value, "To must be floating"); - - // catch the only happy case - if (std::isfinite(from)) - { - if (from >= T::lowest() && from <= (T::max)()) - { - return static_cast(from); - } - // not within range. - ec = 1; - return {}; - } - - // nan and inf will be preserved - return static_cast(from); - } // function - - template ::value)> - FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To - { - ec = 0; - static_assert(std::is_floating_point::value, "From must be floating"); - return from; +// clang-format on +template ::value)> +FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { + ec = 0; + using T = std::numeric_limits; + static_assert(std::is_floating_point::value, "From must be floating"); + static_assert(std::is_floating_point::value, "To must be floating"); + + // catch the only happy case + if (std::isfinite(from)) { + if (from >= T::lowest() && from <= (T::max)()) { + return static_cast(from); } + // not within range. + ec = 1; + return {}; + } + + // nan and inf will be preserved + return static_cast(from); +} // function + +template ::value)> +FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { + ec = 0; + static_assert(std::is_floating_point::value, "From must be floating"); + return from; +} - /** - * safe duration cast between integral durations - */ - template ::value), FMT_ENABLE_IF(std::is_integral::value)> - auto safe_duration_cast(std::chrono::duration from, int& ec) -> To - { - using From = std::chrono::duration; - ec = 0; - // the basic idea is that we need to convert from count() in the from type - // to count() in the To type, by multiplying it with this: - struct Factor : std::ratio_divide {}; - - static_assert(Factor::num > 0, "num must be positive"); - static_assert(Factor::den > 0, "den must be positive"); - - // the conversion is like this: multiply from.count() with Factor::num - // /Factor::den and convert it to To::rep, all this without - // overflow/underflow. let's start by finding a suitable type that can hold - // both To, From and Factor::num - using IntermediateRep = typename std::common_type::type; - - // safe conversion to IntermediateRep - IntermediateRep count = lossless_integral_conversion(from.count(), ec); - if (ec) - return {}; - // multiply with Factor::num without overflow or underflow - if (detail::const_check(Factor::num != 1)) - { - const auto max1 = detail::max_value() / Factor::num; - if (count > max1) - { - ec = 1; - return {}; - } - const auto min1 = (std::numeric_limits::min)() / Factor::num; - if (detail::const_check(!std::is_unsigned::value) && count < min1) - { - ec = 1; - return {}; - } - count *= Factor::num; - } - - if (detail::const_check(Factor::den != 1)) - count /= Factor::den; - auto tocount = lossless_integral_conversion(count, ec); - return ec ? To() : To(tocount); +/** + * safe duration cast between integral durations + */ +template ::value), + FMT_ENABLE_IF(std::is_integral::value)> +auto safe_duration_cast(std::chrono::duration from, + int& ec) -> To { + using From = std::chrono::duration; + ec = 0; + // the basic idea is that we need to convert from count() in the from type + // to count() in the To type, by multiplying it with this: + struct Factor + : std::ratio_divide {}; + + static_assert(Factor::num > 0, "num must be positive"); + static_assert(Factor::den > 0, "den must be positive"); + + // the conversion is like this: multiply from.count() with Factor::num + // /Factor::den and convert it to To::rep, all this without + // overflow/underflow. let's start by finding a suitable type that can hold + // both To, From and Factor::num + using IntermediateRep = + typename std::common_type::type; + + // safe conversion to IntermediateRep + IntermediateRep count = + lossless_integral_conversion(from.count(), ec); + if (ec) return {}; + // multiply with Factor::num without overflow or underflow + if (detail::const_check(Factor::num != 1)) { + const auto max1 = detail::max_value() / Factor::num; + if (count > max1) { + ec = 1; + return {}; } + const auto min1 = + (std::numeric_limits::min)() / Factor::num; + if (detail::const_check(!std::is_unsigned::value) && + count < min1) { + ec = 1; + return {}; + } + count *= Factor::num; + } - /** - * safe duration_cast between floating point durations - */ - template ::value), FMT_ENABLE_IF(std::is_floating_point::value)> - auto safe_duration_cast(std::chrono::duration from, int& ec) -> To - { - using From = std::chrono::duration; - ec = 0; - if (std::isnan(from.count())) - { - // nan in, gives nan out. easy. - return To{std::numeric_limits::quiet_NaN()}; - } - // maybe we should also check if from is denormal, and decide what to do about - // it. - - // +-inf should be preserved. - if (std::isinf(from.count())) - { - return To{from.count()}; - } - - // the basic idea is that we need to convert from count() in the from type - // to count() in the To type, by multiplying it with this: - struct Factor : std::ratio_divide {}; - - static_assert(Factor::num > 0, "num must be positive"); - static_assert(Factor::den > 0, "den must be positive"); - - // the conversion is like this: multiply from.count() with Factor::num - // /Factor::den and convert it to To::rep, all this without - // overflow/underflow. let's start by finding a suitable type that can hold - // both To, From and Factor::num - using IntermediateRep = typename std::common_type::type; - - // force conversion of From::rep -> IntermediateRep to be safe, - // even if it will never happen be narrowing in this context. - IntermediateRep count = safe_float_conversion(from.count(), ec); - if (ec) - { - return {}; - } - - // multiply with Factor::num without overflow or underflow - if (detail::const_check(Factor::num != 1)) - { - constexpr auto max1 = detail::max_value() / static_cast(Factor::num); - if (count > max1) - { - ec = 1; - return {}; - } - constexpr auto min1 = std::numeric_limits::lowest() / static_cast(Factor::num); - if (count < min1) - { - ec = 1; - return {}; - } - count *= static_cast(Factor::num); - } - - // this can't go wrong, right? den>0 is checked earlier. - if (detail::const_check(Factor::den != 1)) - { - using common_t = typename std::common_type::type; - count /= static_cast(Factor::den); - } - - // convert to the to type, safely - using ToRep = typename To::rep; + if (detail::const_check(Factor::den != 1)) count /= Factor::den; + auto tocount = lossless_integral_conversion(count, ec); + return ec ? To() : To(tocount); +} - const ToRep tocount = safe_float_conversion(count, ec); - if (ec) - { - return {}; - } - return To{tocount}; +/** + * safe duration_cast between floating point durations + */ +template ::value), + FMT_ENABLE_IF(std::is_floating_point::value)> +auto safe_duration_cast(std::chrono::duration from, + int& ec) -> To { + using From = std::chrono::duration; + ec = 0; + if (std::isnan(from.count())) { + // nan in, gives nan out. easy. + return To{std::numeric_limits::quiet_NaN()}; + } + // maybe we should also check if from is denormal, and decide what to do about + // it. + + // +-inf should be preserved. + if (std::isinf(from.count())) { + return To{from.count()}; + } + + // the basic idea is that we need to convert from count() in the from type + // to count() in the To type, by multiplying it with this: + struct Factor + : std::ratio_divide {}; + + static_assert(Factor::num > 0, "num must be positive"); + static_assert(Factor::den > 0, "den must be positive"); + + // the conversion is like this: multiply from.count() with Factor::num + // /Factor::den and convert it to To::rep, all this without + // overflow/underflow. let's start by finding a suitable type that can hold + // both To, From and Factor::num + using IntermediateRep = + typename std::common_type::type; + + // force conversion of From::rep -> IntermediateRep to be safe, + // even if it will never happen be narrowing in this context. + IntermediateRep count = + safe_float_conversion(from.count(), ec); + if (ec) { + return {}; + } + + // multiply with Factor::num without overflow or underflow + if (detail::const_check(Factor::num != 1)) { + constexpr auto max1 = detail::max_value() / + static_cast(Factor::num); + if (count > max1) { + ec = 1; + return {}; + } + constexpr auto min1 = std::numeric_limits::lowest() / + static_cast(Factor::num); + if (count < min1) { + ec = 1; + return {}; } -} // namespace safe_duration_cast + count *= static_cast(Factor::num); + } + + // this can't go wrong, right? den>0 is checked earlier. + if (detail::const_check(Factor::den != 1)) { + using common_t = typename std::common_type::type; + count /= static_cast(Factor::den); + } + + // convert to the to type, safely + using ToRep = typename To::rep; + + const ToRep tocount = safe_float_conversion(count, ec); + if (ec) { + return {}; + } + return To{tocount}; +} +} // namespace safe_duration_cast #endif // Prevents expansion of a preceding token as a function-style macro. // Usage: f FMT_NOMACRO() #define FMT_NOMACRO -namespace detail -{ - template - struct null {}; - inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } - inline auto localtime_s(...) -> null<> { return null<>(); } - inline auto gmtime_r(...) -> null<> { return null<>(); } - inline auto gmtime_s(...) -> null<> { return null<>(); } - - inline auto get_classic_locale() -> const std::locale& - { - static const auto& locale = std::locale::classic(); - return locale; - } +namespace detail { +template struct null {}; +inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } +inline auto localtime_s(...) -> null<> { return null<>(); } +inline auto gmtime_r(...) -> null<> { return null<>(); } +inline auto gmtime_s(...) -> null<> { return null<>(); } - template - struct codecvt_result { - static constexpr const size_t max_size = 32; - CodeUnit buf[max_size]; - CodeUnit* end; - }; +inline auto get_classic_locale() -> const std::locale& { + static const auto& locale = std::locale::classic(); + return locale; +} + +template struct codecvt_result { + static constexpr const size_t max_size = 32; + CodeUnit buf[max_size]; + CodeUnit* end; +}; - template - void write_codecvt(codecvt_result& out, string_view in_buf, const std::locale& loc) - { +template +void write_codecvt(codecvt_result& out, string_view in_buf, + const std::locale& loc) { #if FMT_CLANG_VERSION -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated" - auto& f = std::use_facet>(loc); -#pragma clang diagnostic pop +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated" + auto& f = std::use_facet>(loc); +# pragma clang diagnostic pop #else - auto& f = std::use_facet>(loc); + auto& f = std::use_facet>(loc); #endif - auto mb = std::mbstate_t(); - const char* from_next = nullptr; - auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, std::begin(out.buf), std::end(out.buf), out.end); - if (result != std::codecvt_base::ok) - FMT_THROW(format_error("failed to format time")); - } + auto mb = std::mbstate_t(); + const char* from_next = nullptr; + auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, + std::begin(out.buf), std::end(out.buf), out.end); + if (result != std::codecvt_base::ok) + FMT_THROW(format_error("failed to format time")); +} - template - auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt - { - if (detail::is_utf8() && loc != get_classic_locale()) - { - // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and - // gcc-4. -#if FMT_MSC_VERSION != 0 || (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) - // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 - // and newer. - using code_unit = wchar_t; +template +auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) + -> OutputIt { + if (detail::is_utf8() && loc != get_classic_locale()) { + // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and + // gcc-4. +#if FMT_MSC_VERSION != 0 || \ + (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) + // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 + // and newer. + using code_unit = wchar_t; #else - using code_unit = char32_t; + using code_unit = char32_t; #endif - using unit_t = codecvt_result; - unit_t unit; - write_codecvt(unit, in, loc); - // In UTF-8 is used one to four one-byte code units. - auto u = to_utf8>(); - if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) - FMT_THROW(format_error("failed to format time")); - return copy_str(u.c_str(), u.c_str() + u.size(), out); - } - return copy_str(in.data(), in.data() + in.size(), out); - } + using unit_t = codecvt_result; + unit_t unit; + write_codecvt(unit, in, loc); + // In UTF-8 is used one to four one-byte code units. + auto u = + to_utf8>(); + if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) + FMT_THROW(format_error("failed to format time")); + return copy_str(u.c_str(), u.c_str() + u.size(), out); + } + return copy_str(in.data(), in.data() + in.size(), out); +} - template ::value)> - auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt - { - codecvt_result unit; - write_codecvt(unit, sv, loc); - return copy_str(unit.buf, unit.end, out); - } +template ::value)> +auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) + -> OutputIt { + codecvt_result unit; + write_codecvt(unit, sv, loc); + return copy_str(unit.buf, unit.end, out); +} - template ::value)> - auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt - { - return write_encoded_tm_str(out, sv, loc); - } +template ::value)> +auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) + -> OutputIt { + return write_encoded_tm_str(out, sv, loc); +} - template - inline void do_write(buffer& buf, const std::tm& time, const std::locale& loc, char format, char modifier) - { - auto&& format_buf = formatbuf>(buf); - auto&& os = std::basic_ostream(&format_buf); - os.imbue(loc); - const auto& facet = std::use_facet>(loc); - auto end = facet.put(os, os, Char(' '), &time, format, modifier); - if (end.failed()) - FMT_THROW(format_error("failed to format time")); - } +template +inline void do_write(buffer& buf, const std::tm& time, + const std::locale& loc, char format, char modifier) { + auto&& format_buf = formatbuf>(buf); + auto&& os = std::basic_ostream(&format_buf); + os.imbue(loc); + const auto& facet = std::use_facet>(loc); + auto end = facet.put(os, os, Char(' '), &time, format, modifier); + if (end.failed()) FMT_THROW(format_error("failed to format time")); +} - template ::value)> - auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt - { - auto&& buf = get_buffer(out); - do_write(buf, time, loc, format, modifier); - return get_iterator(buf, out); - } +template ::value)> +auto write(OutputIt out, const std::tm& time, const std::locale& loc, + char format, char modifier = 0) -> OutputIt { + auto&& buf = get_buffer(out); + do_write(buf, time, loc, format, modifier); + return get_iterator(buf, out); +} - template ::value)> - auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt - { - auto&& buf = basic_memory_buffer(); - do_write(buf, time, loc, format, modifier); - return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); - } +template ::value)> +auto write(OutputIt out, const std::tm& time, const std::locale& loc, + char format, char modifier = 0) -> OutputIt { + auto&& buf = basic_memory_buffer(); + do_write(buf, time, loc, format, modifier); + return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); +} - template - struct is_same_arithmetic_type : public std::integral_constant::value && std::is_integral::value) || (std::is_floating_point::value && std::is_floating_point::value)> {}; +template +struct is_same_arithmetic_type + : public std::integral_constant::value && + std::is_integral::value) || + (std::is_floating_point::value && + std::is_floating_point::value)> { +}; - template ::value)> - auto fmt_duration_cast(std::chrono::duration from) -> To - { +template < + typename To, typename FromRep, typename FromPeriod, + FMT_ENABLE_IF(is_same_arithmetic_type::value)> +auto fmt_duration_cast(std::chrono::duration from) -> To { #if FMT_SAFE_DURATION_CAST - // Throwing version of safe_duration_cast is only available for - // integer to integer or float to float casts. - int ec; - To to = safe_duration_cast::safe_duration_cast(from, ec); - if (ec) - FMT_THROW(format_error("cannot format duration")); - return to; + // Throwing version of safe_duration_cast is only available for + // integer to integer or float to float casts. + int ec; + To to = safe_duration_cast::safe_duration_cast(from, ec); + if (ec) FMT_THROW(format_error("cannot format duration")); + return to; #else - // Standard duration cast, may overflow. - return std::chrono::duration_cast(from); + // Standard duration cast, may overflow. + return std::chrono::duration_cast(from); #endif - } +} - template ::value)> - auto fmt_duration_cast(std::chrono::duration from) -> To - { - // Mixed integer <-> float cast is not supported by safe_duration_cast. - return std::chrono::duration_cast(from); - } +template < + typename To, typename FromRep, typename FromPeriod, + FMT_ENABLE_IF(!is_same_arithmetic_type::value)> +auto fmt_duration_cast(std::chrono::duration from) -> To { + // Mixed integer <-> float cast is not supported by safe_duration_cast. + return std::chrono::duration_cast(from); +} - template - auto to_time_t(std::chrono::time_point time_point) -> std::time_t - { - // Cannot use std::chrono::system_clock::to_time_t since this would first - // require a cast to std::chrono::system_clock::time_point, which could - // overflow. - return fmt_duration_cast>(time_point.time_since_epoch()).count(); - } -} // namespace detail +template +auto to_time_t( + std::chrono::time_point time_point) + -> std::time_t { + // Cannot use std::chrono::system_clock::to_time_t since this would first + // require a cast to std::chrono::system_clock::time_point, which could + // overflow. + return fmt_duration_cast>( + time_point.time_since_epoch()) + .count(); +} +} // namespace detail FMT_BEGIN_EXPORT @@ -472,53 +486,47 @@ FMT_BEGIN_EXPORT expressed in local time. Unlike ``std::localtime``, this function is thread-safe on most platforms. */ -inline auto localtime(std::time_t time) -> std::tm -{ - struct dispatcher { - std::time_t time_; - std::tm tm_; - - dispatcher(std::time_t t) : time_(t) {} - - auto run() -> bool - { - using namespace fmt::detail; - return handle(localtime_r(&time_, &tm_)); - } +inline auto localtime(std::time_t time) -> std::tm { + struct dispatcher { + std::time_t time_; + std::tm tm_; - auto handle(std::tm* tm) -> bool { return tm != nullptr; } + dispatcher(std::time_t t) : time_(t) {} - auto handle(detail::null<>) -> bool - { - using namespace fmt::detail; - return fallback(localtime_s(&tm_, &time_)); - } + auto run() -> bool { + using namespace fmt::detail; + return handle(localtime_r(&time_, &tm_)); + } + + auto handle(std::tm* tm) -> bool { return tm != nullptr; } + + auto handle(detail::null<>) -> bool { + using namespace fmt::detail; + return fallback(localtime_s(&tm_, &time_)); + } - auto fallback(int res) -> bool { return res == 0; } + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - auto fallback(detail::null<>) -> bool - { - using namespace fmt::detail; - std::tm* tm = std::localtime(&time_); - if (tm) - tm_ = *tm; - return tm != nullptr; - } + auto fallback(detail::null<>) -> bool { + using namespace fmt::detail; + std::tm* tm = std::localtime(&time_); + if (tm) tm_ = *tm; + return tm != nullptr; + } #endif - }; - dispatcher lt(time); - // Too big time values may be unsupported. - if (!lt.run()) - FMT_THROW(format_error("time_t value out of range")); - return lt.tm_; + }; + dispatcher lt(time); + // Too big time values may be unsupported. + if (!lt.run()) FMT_THROW(format_error("time_t value out of range")); + return lt.tm_; } #if FMT_USE_LOCAL_TIME template -inline auto localtime(std::chrono::local_time time) -> std::tm -{ - return localtime(detail::to_time_t(std::chrono::current_zone()->to_sys(time))); +inline auto localtime(std::chrono::local_time time) -> std::tm { + return localtime( + detail::to_time_t(std::chrono::current_zone()->to_sys(time))); } #endif @@ -527,1852 +535,1706 @@ inline auto localtime(std::chrono::local_time time) -> std::tm expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this function is thread-safe on most platforms. */ -inline auto gmtime(std::time_t time) -> std::tm -{ - struct dispatcher { - std::time_t time_; - std::tm tm_; - - dispatcher(std::time_t t) : time_(t) {} - - auto run() -> bool - { - using namespace fmt::detail; - return handle(gmtime_r(&time_, &tm_)); - } +inline auto gmtime(std::time_t time) -> std::tm { + struct dispatcher { + std::time_t time_; + std::tm tm_; - auto handle(std::tm* tm) -> bool { return tm != nullptr; } + dispatcher(std::time_t t) : time_(t) {} - auto handle(detail::null<>) -> bool - { - using namespace fmt::detail; - return fallback(gmtime_s(&tm_, &time_)); - } + auto run() -> bool { + using namespace fmt::detail; + return handle(gmtime_r(&time_, &tm_)); + } + + auto handle(std::tm* tm) -> bool { return tm != nullptr; } - auto fallback(int res) -> bool { return res == 0; } + auto handle(detail::null<>) -> bool { + using namespace fmt::detail; + return fallback(gmtime_s(&tm_, &time_)); + } + + auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION - auto fallback(detail::null<>) -> bool - { - std::tm* tm = std::gmtime(&time_); - if (tm) - tm_ = *tm; - return tm != nullptr; - } + auto fallback(detail::null<>) -> bool { + std::tm* tm = std::gmtime(&time_); + if (tm) tm_ = *tm; + return tm != nullptr; + } #endif - }; - auto gt = dispatcher(time); - // Too big time values may be unsupported. - if (!gt.run()) - FMT_THROW(format_error("time_t value out of range")); - return gt.tm_; + }; + auto gt = dispatcher(time); + // Too big time values may be unsupported. + if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); + return gt.tm_; } template -inline auto gmtime(std::chrono::time_point time_point) -> std::tm -{ - return gmtime(detail::to_time_t(time_point)); +inline auto gmtime( + std::chrono::time_point time_point) + -> std::tm { + return gmtime(detail::to_time_t(time_point)); } -namespace detail -{ - - // Writes two-digit numbers a, b and c separated by sep to buf. - // The method by Pavel Novikov based on - // https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. - inline void write_digit2_separated(char* buf, unsigned a, unsigned b, unsigned c, char sep) - { - unsigned long long digits = a | (b << 24) | (static_cast(c) << 48); - // Convert each value to BCD. - // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. - // The difference is - // y - x = a * 6 - // a can be found from x: - // a = floor(x / 10) - // then - // y = x + a * 6 = x + floor(x / 10) * 6 - // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). - digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; - // Put low nibbles to high bytes and high nibbles to low bytes. - digits = ((digits & 0x00f00000f00000f0) >> 4) | ((digits & 0x000f00000f00000f) << 8); - auto usep = static_cast(sep); - // Add ASCII '0' to each digit byte and insert separators. - digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); - - constexpr const size_t len = 8; - if (const_check(is_big_endian())) - { - char tmp[len]; - std::memcpy(tmp, &digits, len); - std::reverse_copy(tmp, tmp + len, buf); - } - else - { - std::memcpy(buf, &digits, len); - } - } +namespace detail { + +// Writes two-digit numbers a, b and c separated by sep to buf. +// The method by Pavel Novikov based on +// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. +inline void write_digit2_separated(char* buf, unsigned a, unsigned b, + unsigned c, char sep) { + unsigned long long digits = + a | (b << 24) | (static_cast(c) << 48); + // Convert each value to BCD. + // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. + // The difference is + // y - x = a * 6 + // a can be found from x: + // a = floor(x / 10) + // then + // y = x + a * 6 = x + floor(x / 10) * 6 + // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). + digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; + // Put low nibbles to high bytes and high nibbles to low bytes. + digits = ((digits & 0x00f00000f00000f0) >> 4) | + ((digits & 0x000f00000f00000f) << 8); + auto usep = static_cast(sep); + // Add ASCII '0' to each digit byte and insert separators. + digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); + + constexpr const size_t len = 8; + if (const_check(is_big_endian())) { + char tmp[len]; + std::memcpy(tmp, &digits, len); + std::reverse_copy(tmp, tmp + len, buf); + } else { + std::memcpy(buf, &digits, len); + } +} - template - FMT_CONSTEXPR inline auto get_units() -> const char* - { - if (std::is_same::value) - return "as"; - if (std::is_same::value) - return "fs"; - if (std::is_same::value) - return "ps"; - if (std::is_same::value) - return "ns"; - if (std::is_same::value) - return "µs"; - if (std::is_same::value) - return "ms"; - if (std::is_same::value) - return "cs"; - if (std::is_same::value) - return "ds"; - if (std::is_same>::value) - return "s"; - if (std::is_same::value) - return "das"; - if (std::is_same::value) - return "hs"; - if (std::is_same::value) - return "ks"; - if (std::is_same::value) - return "Ms"; - if (std::is_same::value) - return "Gs"; - if (std::is_same::value) - return "Ts"; - if (std::is_same::value) - return "Ps"; - if (std::is_same::value) - return "Es"; - if (std::is_same>::value) - return "min"; - if (std::is_same>::value) - return "h"; - if (std::is_same>::value) - return "d"; - return nullptr; - } +template +FMT_CONSTEXPR inline auto get_units() -> const char* { + if (std::is_same::value) return "as"; + if (std::is_same::value) return "fs"; + if (std::is_same::value) return "ps"; + if (std::is_same::value) return "ns"; + if (std::is_same::value) return "µs"; + if (std::is_same::value) return "ms"; + if (std::is_same::value) return "cs"; + if (std::is_same::value) return "ds"; + if (std::is_same>::value) return "s"; + if (std::is_same::value) return "das"; + if (std::is_same::value) return "hs"; + if (std::is_same::value) return "ks"; + if (std::is_same::value) return "Ms"; + if (std::is_same::value) return "Gs"; + if (std::is_same::value) return "Ts"; + if (std::is_same::value) return "Ps"; + if (std::is_same::value) return "Es"; + if (std::is_same>::value) return "min"; + if (std::is_same>::value) return "h"; + if (std::is_same>::value) return "d"; + return nullptr; +} - enum class numeric_system { - standard, - // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale. - alternative - }; - - // Glibc extensions for formatting numeric values. - enum class pad_type { - unspecified, - // Do not pad a numeric result string. - none, - // Pad a numeric result string with zeros even if the conversion specifier - // character uses space-padding by default. - zero, - // Pad a numeric result string with spaces. - space, - }; - - template - auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt - { - if (pad == pad_type::none) - return out; - return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); - } +enum class numeric_system { + standard, + // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale. + alternative +}; - template - auto write_padding(OutputIt out, pad_type pad) -> OutputIt - { - if (pad != pad_type::none) - *out++ = pad == pad_type::space ? ' ' : '0'; - return out; - } +// Glibc extensions for formatting numeric values. +enum class pad_type { + unspecified, + // Do not pad a numeric result string. + none, + // Pad a numeric result string with zeros even if the conversion specifier + // character uses space-padding by default. + zero, + // Pad a numeric result string with spaces. + space, +}; - // Parses a put_time-like format string and invokes handler actions. - template - FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, Handler&& handler) -> const Char* - { - if (begin == end || *begin == '}') - return begin; - if (*begin != '%') - FMT_THROW(format_error("invalid format")); - auto ptr = begin; - pad_type pad = pad_type::unspecified; - while (ptr != end) - { - auto c = *ptr; - if (c == '}') - break; - if (c != '%') - { - ++ptr; - continue; - } - if (begin != ptr) - handler.on_text(begin, ptr); - ++ptr; // consume '%' - if (ptr == end) - FMT_THROW(format_error("invalid format")); - c = *ptr; - switch (c) - { - case '_': - pad = pad_type::space; - ++ptr; - break; - case '-': - pad = pad_type::none; - ++ptr; - break; - case '0': - pad = pad_type::zero; - ++ptr; - break; - } - if (ptr == end) - FMT_THROW(format_error("invalid format")); - c = *ptr++; - switch (c) - { - case '%': - handler.on_text(ptr - 1, ptr); - break; - case 'n': - { - const Char newline[] = {'\n'}; - handler.on_text(newline, newline + 1); - break; - } - case 't': - { - const Char tab[] = {'\t'}; - handler.on_text(tab, tab + 1); - break; - } - // Year: - case 'Y': - handler.on_year(numeric_system::standard); - break; - case 'y': - handler.on_short_year(numeric_system::standard); - break; - case 'C': - handler.on_century(numeric_system::standard); - break; - case 'G': - handler.on_iso_week_based_year(); - break; - case 'g': - handler.on_iso_week_based_short_year(); - break; - // Day of the week: - case 'a': - handler.on_abbr_weekday(); - break; - case 'A': - handler.on_full_weekday(); - break; - case 'w': - handler.on_dec0_weekday(numeric_system::standard); - break; - case 'u': - handler.on_dec1_weekday(numeric_system::standard); - break; - // Month: - case 'b': - case 'h': - handler.on_abbr_month(); - break; - case 'B': - handler.on_full_month(); - break; - case 'm': - handler.on_dec_month(numeric_system::standard); - break; - // Day of the year/month: - case 'U': - handler.on_dec0_week_of_year(numeric_system::standard); - break; - case 'W': - handler.on_dec1_week_of_year(numeric_system::standard); - break; - case 'V': - handler.on_iso_week_of_year(numeric_system::standard); - break; - case 'j': - handler.on_day_of_year(); - break; - case 'd': - handler.on_day_of_month(numeric_system::standard); - break; - case 'e': - handler.on_day_of_month_space(numeric_system::standard); - break; - // Hour, minute, second: - case 'H': - handler.on_24_hour(numeric_system::standard, pad); - break; - case 'I': - handler.on_12_hour(numeric_system::standard, pad); - break; - case 'M': - handler.on_minute(numeric_system::standard, pad); - break; - case 'S': - handler.on_second(numeric_system::standard, pad); - break; - // Other: - case 'c': - handler.on_datetime(numeric_system::standard); - break; - case 'x': - handler.on_loc_date(numeric_system::standard); - break; - case 'X': - handler.on_loc_time(numeric_system::standard); - break; - case 'D': - handler.on_us_date(); - break; - case 'F': - handler.on_iso_date(); - break; - case 'r': - handler.on_12_hour_time(); - break; - case 'R': - handler.on_24_hour_time(); - break; - case 'T': - handler.on_iso_time(); - break; - case 'p': - handler.on_am_pm(); - break; - case 'Q': - handler.on_duration_value(); - break; - case 'q': - handler.on_duration_unit(); - break; - case 'z': - handler.on_utc_offset(numeric_system::standard); - break; - case 'Z': - handler.on_tz_name(); - break; - // Alternative representation: - case 'E': - { - if (ptr == end) - FMT_THROW(format_error("invalid format")); - c = *ptr++; - switch (c) - { - case 'Y': - handler.on_year(numeric_system::alternative); - break; - case 'y': - handler.on_offset_year(); - break; - case 'C': - handler.on_century(numeric_system::alternative); - break; - case 'c': - handler.on_datetime(numeric_system::alternative); - break; - case 'x': - handler.on_loc_date(numeric_system::alternative); - break; - case 'X': - handler.on_loc_time(numeric_system::alternative); - break; - case 'z': - handler.on_utc_offset(numeric_system::alternative); - break; - default: - FMT_THROW(format_error("invalid format")); - } - break; - } - case 'O': - if (ptr == end) - FMT_THROW(format_error("invalid format")); - c = *ptr++; - switch (c) - { - case 'y': - handler.on_short_year(numeric_system::alternative); - break; - case 'm': - handler.on_dec_month(numeric_system::alternative); - break; - case 'U': - handler.on_dec0_week_of_year(numeric_system::alternative); - break; - case 'W': - handler.on_dec1_week_of_year(numeric_system::alternative); - break; - case 'V': - handler.on_iso_week_of_year(numeric_system::alternative); - break; - case 'd': - handler.on_day_of_month(numeric_system::alternative); - break; - case 'e': - handler.on_day_of_month_space(numeric_system::alternative); - break; - case 'w': - handler.on_dec0_weekday(numeric_system::alternative); - break; - case 'u': - handler.on_dec1_weekday(numeric_system::alternative); - break; - case 'H': - handler.on_24_hour(numeric_system::alternative, pad); - break; - case 'I': - handler.on_12_hour(numeric_system::alternative, pad); - break; - case 'M': - handler.on_minute(numeric_system::alternative, pad); - break; - case 'S': - handler.on_second(numeric_system::alternative, pad); - break; - case 'z': - handler.on_utc_offset(numeric_system::alternative); - break; - default: - FMT_THROW(format_error("invalid format")); - } - break; - default: - FMT_THROW(format_error("invalid format")); - } - begin = ptr; - } - if (begin != ptr) - handler.on_text(begin, ptr); - return ptr; - } +template +auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { + if (pad == pad_type::none) return out; + return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); +} - template - struct null_chrono_spec_handler { - FMT_CONSTEXPR void unsupported() { static_cast(this)->unsupported(); } - FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_offset_year() { unsupported(); } - FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } - FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } - FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } - FMT_CONSTEXPR void on_full_weekday() { unsupported(); } - FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_abbr_month() { unsupported(); } - FMT_CONSTEXPR void on_full_month() { unsupported(); } - FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_day_of_year() { unsupported(); } - FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_us_date() { unsupported(); } - FMT_CONSTEXPR void on_iso_date() { unsupported(); } - FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } - FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } - FMT_CONSTEXPR void on_iso_time() { unsupported(); } - FMT_CONSTEXPR void on_am_pm() { unsupported(); } - FMT_CONSTEXPR void on_duration_value() { unsupported(); } - FMT_CONSTEXPR void on_duration_unit() { unsupported(); } - FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } - FMT_CONSTEXPR void on_tz_name() { unsupported(); } - }; - - struct tm_format_checker : null_chrono_spec_handler { - FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); } - - template - FMT_CONSTEXPR void on_text(const Char*, const Char*) - { - } - FMT_CONSTEXPR void on_year(numeric_system) {} - FMT_CONSTEXPR void on_short_year(numeric_system) {} - FMT_CONSTEXPR void on_offset_year() {} - FMT_CONSTEXPR void on_century(numeric_system) {} - FMT_CONSTEXPR void on_iso_week_based_year() {} - FMT_CONSTEXPR void on_iso_week_based_short_year() {} - FMT_CONSTEXPR void on_abbr_weekday() {} - FMT_CONSTEXPR void on_full_weekday() {} - FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} - FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} - FMT_CONSTEXPR void on_abbr_month() {} - FMT_CONSTEXPR void on_full_month() {} - FMT_CONSTEXPR void on_dec_month(numeric_system) {} - FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} - FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} - FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} - FMT_CONSTEXPR void on_day_of_year() {} - FMT_CONSTEXPR void on_day_of_month(numeric_system) {} - FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} - FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_datetime(numeric_system) {} - FMT_CONSTEXPR void on_loc_date(numeric_system) {} - FMT_CONSTEXPR void on_loc_time(numeric_system) {} - FMT_CONSTEXPR void on_us_date() {} - FMT_CONSTEXPR void on_iso_date() {} - FMT_CONSTEXPR void on_12_hour_time() {} - FMT_CONSTEXPR void on_24_hour_time() {} - FMT_CONSTEXPR void on_iso_time() {} - FMT_CONSTEXPR void on_am_pm() {} - FMT_CONSTEXPR void on_utc_offset(numeric_system) {} - FMT_CONSTEXPR void on_tz_name() {} - }; - - inline auto tm_wday_full_name(int wday) -> const char* - { - static constexpr const char* full_name_list[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; - return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; - } - inline auto tm_wday_short_name(int wday) -> const char* - { - static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; - return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; - } +template +auto write_padding(OutputIt out, pad_type pad) -> OutputIt { + if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0'; + return out; +} - inline auto tm_mon_full_name(int mon) -> const char* - { - static constexpr const char* full_name_list[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; - return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; +// Parses a put_time-like format string and invokes handler actions. +template +FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + if (begin == end || *begin == '}') return begin; + if (*begin != '%') FMT_THROW(format_error("invalid format")); + auto ptr = begin; + pad_type pad = pad_type::unspecified; + while (ptr != end) { + auto c = *ptr; + if (c == '}') break; + if (c != '%') { + ++ptr; + continue; } - inline auto tm_mon_short_name(int mon) -> const char* - { - static constexpr const char* short_name_list[] = { - "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", - }; - return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; + if (begin != ptr) handler.on_text(begin, ptr); + ++ptr; // consume '%' + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr; + switch (c) { + case '_': + pad = pad_type::space; + ++ptr; + break; + case '-': + pad = pad_type::none; + ++ptr; + break; + case '0': + pad = pad_type::zero; + ++ptr; + break; } - - template - struct has_member_data_tm_gmtoff : std::false_type {}; - template - struct has_member_data_tm_gmtoff> : std::true_type {}; - - template - struct has_member_data_tm_zone : std::false_type {}; - template - struct has_member_data_tm_zone> : std::true_type {}; - -#if FMT_USE_TZSET - inline void tzset_once() - { - static bool init = []() -> bool - { - _tzset(); - return true; - }(); - ignore_unused(init); + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case '%': + handler.on_text(ptr - 1, ptr); + break; + case 'n': { + const Char newline[] = {'\n'}; + handler.on_text(newline, newline + 1); + break; } -#endif - - // Converts value to Int and checks that it's in the range [0, upper). - template ::value)> - inline auto to_nonnegative_int(T value, Int upper) -> Int - { - if (!std::is_unsigned::value && (value < 0 || to_unsigned(value) > to_unsigned(upper))) - { - FMT_THROW(fmt::format_error("chrono value is out of range")); - } - return static_cast(value); + case 't': { + const Char tab[] = {'\t'}; + handler.on_text(tab, tab + 1); + break; } - template ::value)> - inline auto to_nonnegative_int(T value, Int upper) -> Int - { - if (value < 0 || value > static_cast(upper)) - FMT_THROW(format_error("invalid value")); - return static_cast(value); + // Year: + case 'Y': + handler.on_year(numeric_system::standard); + break; + case 'y': + handler.on_short_year(numeric_system::standard); + break; + case 'C': + handler.on_century(numeric_system::standard); + break; + case 'G': + handler.on_iso_week_based_year(); + break; + case 'g': + handler.on_iso_week_based_short_year(); + break; + // Day of the week: + case 'a': + handler.on_abbr_weekday(); + break; + case 'A': + handler.on_full_weekday(); + break; + case 'w': + handler.on_dec0_weekday(numeric_system::standard); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::standard); + break; + // Month: + case 'b': + case 'h': + handler.on_abbr_month(); + break; + case 'B': + handler.on_full_month(); + break; + case 'm': + handler.on_dec_month(numeric_system::standard); + break; + // Day of the year/month: + case 'U': + handler.on_dec0_week_of_year(numeric_system::standard); + break; + case 'W': + handler.on_dec1_week_of_year(numeric_system::standard); + break; + case 'V': + handler.on_iso_week_of_year(numeric_system::standard); + break; + case 'j': + handler.on_day_of_year(); + break; + case 'd': + handler.on_day_of_month(numeric_system::standard); + break; + case 'e': + handler.on_day_of_month_space(numeric_system::standard); + break; + // Hour, minute, second: + case 'H': + handler.on_24_hour(numeric_system::standard, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::standard, pad); + break; + case 'M': + handler.on_minute(numeric_system::standard, pad); + break; + case 'S': + handler.on_second(numeric_system::standard, pad); + break; + // Other: + case 'c': + handler.on_datetime(numeric_system::standard); + break; + case 'x': + handler.on_loc_date(numeric_system::standard); + break; + case 'X': + handler.on_loc_time(numeric_system::standard); + break; + case 'D': + handler.on_us_date(); + break; + case 'F': + handler.on_iso_date(); + break; + case 'r': + handler.on_12_hour_time(); + break; + case 'R': + handler.on_24_hour_time(); + break; + case 'T': + handler.on_iso_time(); + break; + case 'p': + handler.on_am_pm(); + break; + case 'Q': + handler.on_duration_value(); + break; + case 'q': + handler.on_duration_unit(); + break; + case 'z': + handler.on_utc_offset(numeric_system::standard); + break; + case 'Z': + handler.on_tz_name(); + break; + // Alternative representation: + case 'E': { + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'Y': + handler.on_year(numeric_system::alternative); + break; + case 'y': + handler.on_offset_year(); + break; + case 'C': + handler.on_century(numeric_system::alternative); + break; + case 'c': + handler.on_datetime(numeric_system::alternative); + break; + case 'x': + handler.on_loc_date(numeric_system::alternative); + break; + case 'X': + handler.on_loc_time(numeric_system::alternative); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); + } + break; } - - constexpr auto pow10(std::uint32_t n) -> long long { return n == 0 ? 1 : 10 * pow10(n - 1); } - - // Counts the number of fractional digits in the range [0, 18] according to the - // C++20 spec. If more than 18 fractional digits are required then returns 6 for - // microseconds precision. - template () / 10)> - struct count_fractional_digits { - static constexpr int value = Num % Den == 0 ? N : count_fractional_digits::value; - }; - - // Base case that doesn't instantiate any more templates - // in order to avoid overflow. - template - struct count_fractional_digits { - static constexpr int value = (Num % Den == 0) ? N : 6; - }; - - // Format subseconds which are given as an integer type with an appropriate - // number of digits. - template - void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) - { - constexpr auto num_fractional_digits = count_fractional_digits::value; - - using subsecond_precision = std::chrono::duration::type, std::ratio<1, detail::pow10(num_fractional_digits)>>; - - const auto fractional = d - fmt_duration_cast(d); - const auto subseconds = std::chrono::treat_as_floating_point::value ? fractional.count() : fmt_duration_cast(fractional).count(); - auto n = static_cast>(subseconds); - const int num_digits = detail::count_digits(n); - - int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); - if (precision < 0) - { - FMT_ASSERT(!std::is_floating_point::value, ""); - if (std::ratio_less::value) - { - *out++ = '.'; - out = std::fill_n(out, leading_zeroes, '0'); - out = format_decimal(out, n, num_digits).end; - } - } - else - { - *out++ = '.'; - leading_zeroes = (std::min)(leading_zeroes, precision); - out = std::fill_n(out, leading_zeroes, '0'); - int remaining = precision - leading_zeroes; - if (remaining != 0 && remaining < num_digits) - { - n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); - out = format_decimal(out, n, remaining).end; - return; - } - out = format_decimal(out, n, num_digits).end; - remaining -= num_digits; - out = std::fill_n(out, remaining, '0'); - } - } - - // Format subseconds which are given as a floating point type with an - // appropriate number of digits. We cannot pass the Duration here, as we - // explicitly need to pass the Rep value in the chrono_formatter. - template - void write_floating_seconds(memory_buffer& buf, Duration duration, int num_fractional_digits = -1) - { - using rep = typename Duration::rep; - FMT_ASSERT(std::is_floating_point::value, ""); - - auto val = duration.count(); - - if (num_fractional_digits < 0) - { - // For `std::round` with fallback to `round`: - // On some toolchains `std::round` is not available (e.g. GCC 6). - using namespace std; - num_fractional_digits = count_fractional_digits::value; - if (num_fractional_digits < 6 && static_cast(round(val)) != val) - num_fractional_digits = 6; - } - - fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), std::fmod(val * static_cast(Duration::period::num) / static_cast(Duration::period::den), static_cast(60)), num_fractional_digits); + case 'O': + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'y': + handler.on_short_year(numeric_system::alternative); + break; + case 'm': + handler.on_dec_month(numeric_system::alternative); + break; + case 'U': + handler.on_dec0_week_of_year(numeric_system::alternative); + break; + case 'W': + handler.on_dec1_week_of_year(numeric_system::alternative); + break; + case 'V': + handler.on_iso_week_of_year(numeric_system::alternative); + break; + case 'd': + handler.on_day_of_month(numeric_system::alternative); + break; + case 'e': + handler.on_day_of_month_space(numeric_system::alternative); + break; + case 'w': + handler.on_dec0_weekday(numeric_system::alternative); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::alternative); + break; + case 'H': + handler.on_24_hour(numeric_system::alternative, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::alternative, pad); + break; + case 'M': + handler.on_minute(numeric_system::alternative, pad); + break; + case 'S': + handler.on_second(numeric_system::alternative, pad); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); + } + break; + default: + FMT_THROW(format_error("invalid format")); } + begin = ptr; + } + if (begin != ptr) handler.on_text(begin, ptr); + return ptr; +} - template - class tm_writer { - private: - static constexpr int days_per_week = 7; - - const std::locale& loc_; - const bool is_classic_; - OutputIt out_; - const Duration* subsecs_; - const std::tm& tm_; - - auto tm_sec() const noexcept -> int - { - FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); - return tm_.tm_sec; - } - auto tm_min() const noexcept -> int - { - FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); - return tm_.tm_min; - } - auto tm_hour() const noexcept -> int - { - FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); - return tm_.tm_hour; - } - auto tm_mday() const noexcept -> int - { - FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); - return tm_.tm_mday; - } - auto tm_mon() const noexcept -> int - { - FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); - return tm_.tm_mon; - } - auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } - auto tm_wday() const noexcept -> int - { - FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); - return tm_.tm_wday; - } - auto tm_yday() const noexcept -> int - { - FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); - return tm_.tm_yday; - } +template struct null_chrono_spec_handler { + FMT_CONSTEXPR void unsupported() { + static_cast(this)->unsupported(); + } + FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_offset_year() { unsupported(); } + FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } + FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } + FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } + FMT_CONSTEXPR void on_full_weekday() { unsupported(); } + FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_abbr_month() { unsupported(); } + FMT_CONSTEXPR void on_full_month() { unsupported(); } + FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_year() { unsupported(); } + FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_us_date() { unsupported(); } + FMT_CONSTEXPR void on_iso_date() { unsupported(); } + FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } + FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } + FMT_CONSTEXPR void on_iso_time() { unsupported(); } + FMT_CONSTEXPR void on_am_pm() { unsupported(); } + FMT_CONSTEXPR void on_duration_value() { unsupported(); } + FMT_CONSTEXPR void on_duration_unit() { unsupported(); } + FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_tz_name() { unsupported(); } +}; - auto tm_hour12() const noexcept -> int - { - const auto h = tm_hour(); - const auto z = h < 12 ? h : h - 12; - return z == 0 ? 12 : z; - } +struct tm_format_checker : null_chrono_spec_handler { + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); } + + template + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + FMT_CONSTEXPR void on_year(numeric_system) {} + FMT_CONSTEXPR void on_short_year(numeric_system) {} + FMT_CONSTEXPR void on_offset_year() {} + FMT_CONSTEXPR void on_century(numeric_system) {} + FMT_CONSTEXPR void on_iso_week_based_year() {} + FMT_CONSTEXPR void on_iso_week_based_short_year() {} + FMT_CONSTEXPR void on_abbr_weekday() {} + FMT_CONSTEXPR void on_full_weekday() {} + FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} + FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} + FMT_CONSTEXPR void on_abbr_month() {} + FMT_CONSTEXPR void on_full_month() {} + FMT_CONSTEXPR void on_dec_month(numeric_system) {} + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_day_of_year() {} + FMT_CONSTEXPR void on_day_of_month(numeric_system) {} + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} + FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_datetime(numeric_system) {} + FMT_CONSTEXPR void on_loc_date(numeric_system) {} + FMT_CONSTEXPR void on_loc_time(numeric_system) {} + FMT_CONSTEXPR void on_us_date() {} + FMT_CONSTEXPR void on_iso_date() {} + FMT_CONSTEXPR void on_12_hour_time() {} + FMT_CONSTEXPR void on_24_hour_time() {} + FMT_CONSTEXPR void on_iso_time() {} + FMT_CONSTEXPR void on_am_pm() {} + FMT_CONSTEXPR void on_utc_offset(numeric_system) {} + FMT_CONSTEXPR void on_tz_name() {} +}; - // POSIX and the C Standard are unclear or inconsistent about what %C and %y - // do if the year is negative or exceeds 9999. Use the convention that %C - // concatenated with %y yields the same output as %Y, and that %Y contains at - // least 4 characters, with more only if necessary. - auto split_year_lower(long long year) const noexcept -> int - { - auto l = year % 100; - if (l < 0) - l = -l; // l in [0, 99] - return static_cast(l); - } +inline auto tm_wday_full_name(int wday) -> const char* { + static constexpr const char* full_name_list[] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday"}; + return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; +} +inline auto tm_wday_short_name(int wday) -> const char* { + static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat"}; + return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; +} - // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. - auto iso_year_weeks(long long curr_year) const noexcept -> int - { - const auto prev_year = curr_year - 1; - const auto curr_p = (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % days_per_week; - const auto prev_p = (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % days_per_week; - return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); - } - auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / days_per_week; } - auto tm_iso_week_year() const noexcept -> long long - { - const auto year = tm_year(); - const auto w = iso_week_num(tm_yday(), tm_wday()); - if (w < 1) - return year - 1; - if (w > iso_year_weeks(year)) - return year + 1; - return year; - } - auto tm_iso_week_of_year() const noexcept -> int - { - const auto year = tm_year(); - const auto w = iso_week_num(tm_yday(), tm_wday()); - if (w < 1) - return iso_year_weeks(year - 1); - if (w > iso_year_weeks(year)) - return 1; - return w; - } +inline auto tm_mon_full_name(int mon) -> const char* { + static constexpr const char* full_name_list[] = { + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December"}; + return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; +} +inline auto tm_mon_short_name(int mon) -> const char* { + static constexpr const char* short_name_list[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", + }; + return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; +} - void write1(int value) { *out_++ = static_cast('0' + to_unsigned(value) % 10); } - void write2(int value) - { - const char* d = digits2(to_unsigned(value) % 100); - *out_++ = *d++; - *out_++ = *d; - } - void write2(int value, pad_type pad) - { - unsigned int v = to_unsigned(value) % 100; - if (v >= 10) - { - const char* d = digits2(v); - *out_++ = *d++; - *out_++ = *d; - } - else - { - out_ = detail::write_padding(out_, pad); - *out_++ = static_cast('0' + v); - } - } +template +struct has_member_data_tm_gmtoff : std::false_type {}; +template +struct has_member_data_tm_gmtoff> + : std::true_type {}; - void write_year_extended(long long year) - { - // At least 4 characters. - int width = 4; - if (year < 0) - { - *out_++ = '-'; - year = 0 - year; - --width; - } - uint32_or_64_or_128_t n = to_unsigned(year); - const int num_digits = count_digits(n); - if (width > num_digits) - out_ = std::fill_n(out_, width - num_digits, '0'); - out_ = format_decimal(out_, n, num_digits).end; - } - void write_year(long long year) - { - if (year >= 0 && year < 10000) - { - write2(static_cast(year / 100)); - write2(static_cast(year % 100)); - } - else - { - write_year_extended(year); - } - } +template +struct has_member_data_tm_zone : std::false_type {}; +template +struct has_member_data_tm_zone> + : std::true_type {}; - void write_utc_offset(long offset, numeric_system ns) - { - if (offset < 0) - { - *out_++ = '-'; - offset = -offset; - } - else - { - *out_++ = '+'; - } - offset /= 60; - write2(static_cast(offset / 60)); - if (ns != numeric_system::standard) - *out_++ = ':'; - write2(static_cast(offset % 60)); - } - template ::value)> - void format_utc_offset_impl(const T& tm, numeric_system ns) - { - write_utc_offset(tm.tm_gmtoff, ns); - } - template ::value)> - void format_utc_offset_impl(const T& tm, numeric_system ns) - { -#if defined(_WIN32) && defined(_UCRT) #if FMT_USE_TZSET - tzset_once(); -#endif - long offset = 0; - _get_timezone(&offset); - if (tm.tm_isdst) - { - long dstbias = 0; - _get_dstbias(&dstbias); - offset += dstbias; - } - write_utc_offset(-offset, ns); -#else - if (ns == numeric_system::standard) - return format_localized('z'); - - // Extract timezone offset from timezone conversion functions. - std::tm gtm = tm; - std::time_t gt = std::mktime(>m); - std::tm ltm = gmtime(gt); - std::time_t lt = std::mktime(<m); - long offset = gt - lt; - write_utc_offset(offset, ns); +inline void tzset_once() { + static bool init = []() -> bool { + _tzset(); + return true; + }(); + ignore_unused(init); +} #endif - } - - template ::value)> - void format_tz_name_impl(const T& tm) - { - if (is_classic_) - out_ = write_tm_str(out_, tm.tm_zone, loc_); - else - format_localized('Z'); - } - template ::value)> - void format_tz_name_impl(const T&) - { - format_localized('Z'); - } - void format_localized(char format, char modifier = 0) { out_ = write(out_, tm_, loc_, format, modifier); } - - public: - tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, const Duration* subsecs = nullptr) : loc_(loc), is_classic_(loc_ == get_classic_locale()), out_(out), subsecs_(subsecs), tm_(tm) {} - - auto out() const -> OutputIt { return out_; } - - FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { out_ = copy_str(begin, end, out_); } - - void on_abbr_weekday() - { - if (is_classic_) - out_ = write(out_, tm_wday_short_name(tm_wday())); - else - format_localized('a'); - } - void on_full_weekday() - { - if (is_classic_) - out_ = write(out_, tm_wday_full_name(tm_wday())); - else - format_localized('A'); - } - void on_dec0_weekday(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write1(tm_wday()); - format_localized('w', 'O'); - } - void on_dec1_weekday(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - { - auto wday = tm_wday(); - write1(wday == 0 ? days_per_week : wday); - } - else - { - format_localized('u', 'O'); - } - } - - void on_abbr_month() - { - if (is_classic_) - out_ = write(out_, tm_mon_short_name(tm_mon())); - else - format_localized('b'); - } - void on_full_month() - { - if (is_classic_) - out_ = write(out_, tm_mon_full_name(tm_mon())); - else - format_localized('B'); - } - - void on_datetime(numeric_system ns) - { - if (is_classic_) - { - on_abbr_weekday(); - *out_++ = ' '; - on_abbr_month(); - *out_++ = ' '; - on_day_of_month_space(numeric_system::standard); - *out_++ = ' '; - on_iso_time(); - *out_++ = ' '; - on_year(numeric_system::standard); - } - else - { - format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); - } - } - void on_loc_date(numeric_system ns) - { - if (is_classic_) - on_us_date(); - else - format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); - } - void on_loc_time(numeric_system ns) - { - if (is_classic_) - on_iso_time(); - else - format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); - } - void on_us_date() - { - char buf[8]; - write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); - out_ = copy_str(std::begin(buf), std::end(buf), out_); - } - void on_iso_date() - { - auto year = tm_year(); - char buf[10]; - size_t offset = 0; - if (year >= 0 && year < 10000) - { - copy2(buf, digits2(static_cast(year / 100))); - } - else - { - offset = 4; - write_year_extended(year); - year = 0; - } - write_digit2_separated(buf + 2, static_cast(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); - out_ = copy_str(std::begin(buf) + offset, std::end(buf), out_); - } - - void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } - void on_tz_name() { format_tz_name_impl(tm_); } - - void on_year(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write_year(tm_year()); - format_localized('Y', 'E'); - } - void on_short_year(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(split_year_lower(tm_year())); - format_localized('y', 'O'); - } - void on_offset_year() - { - if (is_classic_) - return write2(split_year_lower(tm_year())); - format_localized('y', 'E'); - } - - void on_century(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - { - auto year = tm_year(); - auto upper = year / 100; - if (year >= -99 && year < 0) - { - // Zero upper on negative year. - *out_++ = '-'; - *out_++ = '0'; - } - else if (upper >= 0 && upper < 100) - { - write2(static_cast(upper)); - } - else - { - out_ = write(out_, upper); - } - } - else - { - format_localized('C', 'E'); - } - } - - void on_dec_month(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_mon() + 1); - format_localized('m', 'O'); - } - - void on_dec0_week_of_year(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); - format_localized('U', 'O'); - } - void on_dec1_week_of_year(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - { - auto wday = tm_wday(); - write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / days_per_week); - } - else - { - format_localized('W', 'O'); - } - } - void on_iso_week_of_year(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_iso_week_of_year()); - format_localized('V', 'O'); - } - - void on_iso_week_based_year() { write_year(tm_iso_week_year()); } - void on_iso_week_based_short_year() { write2(split_year_lower(tm_iso_week_year())); } - - void on_day_of_year() - { - auto yday = tm_yday() + 1; - write1(yday / 100); - write2(yday % 100); - } - void on_day_of_month(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_mday()); - format_localized('d', 'O'); - } - void on_day_of_month_space(numeric_system ns) - { - if (is_classic_ || ns == numeric_system::standard) - { - auto mday = to_unsigned(tm_mday()) % 100; - const char* d2 = digits2(mday); - *out_++ = mday < 10 ? ' ' : d2[0]; - *out_++ = d2[1]; - } - else - { - format_localized('e', 'O'); - } - } - - void on_24_hour(numeric_system ns, pad_type pad) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_hour(), pad); - format_localized('H', 'O'); - } - void on_12_hour(numeric_system ns, pad_type pad) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_hour12(), pad); - format_localized('I', 'O'); - } - void on_minute(numeric_system ns, pad_type pad) - { - if (is_classic_ || ns == numeric_system::standard) - return write2(tm_min(), pad); - format_localized('M', 'O'); - } - - void on_second(numeric_system ns, pad_type pad) - { - if (is_classic_ || ns == numeric_system::standard) - { - write2(tm_sec(), pad); - if (subsecs_) - { - if (std::is_floating_point::value) - { - auto buf = memory_buffer(); - write_floating_seconds(buf, *subsecs_); - if (buf.size() > 1) - { - // Remove the leading "0", write something like ".123". - out_ = std::copy(buf.begin() + 1, buf.end(), out_); - } - } - else - { - write_fractional_seconds(out_, *subsecs_); - } - } - } - else - { - // Currently no formatting of subseconds when a locale is set. - format_localized('S', 'O'); - } - } - - void on_12_hour_time() - { - if (is_classic_) - { - char buf[8]; - write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); - out_ = copy_str(std::begin(buf), std::end(buf), out_); - *out_++ = ' '; - on_am_pm(); - } - else - { - format_localized('r'); - } - } - void on_24_hour_time() - { - write2(tm_hour()); - *out_++ = ':'; - write2(tm_min()); - } - void on_iso_time() - { - on_24_hour_time(); - *out_++ = ':'; - on_second(numeric_system::standard, pad_type::unspecified); - } +// Converts value to Int and checks that it's in the range [0, upper). +template ::value)> +inline auto to_nonnegative_int(T value, Int upper) -> Int { + if (!std::is_unsigned::value && + (value < 0 || to_unsigned(value) > to_unsigned(upper))) { + FMT_THROW(fmt::format_error("chrono value is out of range")); + } + return static_cast(value); +} +template ::value)> +inline auto to_nonnegative_int(T value, Int upper) -> Int { + if (value < 0 || value > static_cast(upper)) + FMT_THROW(format_error("invalid value")); + return static_cast(value); +} - void on_am_pm() - { - if (is_classic_) - { - *out_++ = tm_hour() < 12 ? 'A' : 'P'; - *out_++ = 'M'; - } - else - { - format_localized('p'); - } - } +constexpr auto pow10(std::uint32_t n) -> long long { + return n == 0 ? 1 : 10 * pow10(n - 1); +} - // These apply to chrono durations but not tm. - void on_duration_value() {} - void on_duration_unit() {} - }; +// Counts the number of fractional digits in the range [0, 18] according to the +// C++20 spec. If more than 18 fractional digits are required then returns 6 for +// microseconds precision. +template () / 10)> +struct count_fractional_digits { + static constexpr int value = + Num % Den == 0 ? N : count_fractional_digits::value; +}; - struct chrono_format_checker : null_chrono_spec_handler { - bool has_precision_integral = false; +// Base case that doesn't instantiate any more templates +// in order to avoid overflow. +template +struct count_fractional_digits { + static constexpr int value = (Num % Den == 0) ? N : 6; +}; - FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); } +// Format subseconds which are given as an integer type with an appropriate +// number of digits. +template +void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { + constexpr auto num_fractional_digits = + count_fractional_digits::value; + + using subsecond_precision = std::chrono::duration< + typename std::common_type::type, + std::ratio<1, detail::pow10(num_fractional_digits)>>; + + const auto fractional = d - fmt_duration_cast(d); + const auto subseconds = + std::chrono::treat_as_floating_point< + typename subsecond_precision::rep>::value + ? fractional.count() + : fmt_duration_cast(fractional).count(); + auto n = static_cast>(subseconds); + const int num_digits = detail::count_digits(n); + + int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); + if (precision < 0) { + FMT_ASSERT(!std::is_floating_point::value, ""); + if (std::ratio_less::value) { + *out++ = '.'; + out = std::fill_n(out, leading_zeroes, '0'); + out = format_decimal(out, n, num_digits).end; + } + } else { + *out++ = '.'; + leading_zeroes = (std::min)(leading_zeroes, precision); + out = std::fill_n(out, leading_zeroes, '0'); + int remaining = precision - leading_zeroes; + if (remaining != 0 && remaining < num_digits) { + n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); + out = format_decimal(out, n, remaining).end; + return; + } + out = format_decimal(out, n, num_digits).end; + remaining -= num_digits; + out = std::fill_n(out, remaining, '0'); + } +} - template - FMT_CONSTEXPR void on_text(const Char*, const Char*) - { - } - FMT_CONSTEXPR void on_day_of_year() {} - FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} - FMT_CONSTEXPR void on_12_hour_time() {} - FMT_CONSTEXPR void on_24_hour_time() {} - FMT_CONSTEXPR void on_iso_time() {} - FMT_CONSTEXPR void on_am_pm() {} - FMT_CONSTEXPR void on_duration_value() const - { - if (has_precision_integral) - { - FMT_THROW(format_error("precision not allowed for this argument type")); - } - } - FMT_CONSTEXPR void on_duration_unit() {} - }; +// Format subseconds which are given as a floating point type with an +// appropriate number of digits. We cannot pass the Duration here, as we +// explicitly need to pass the Rep value in the chrono_formatter. +template +void write_floating_seconds(memory_buffer& buf, Duration duration, + int num_fractional_digits = -1) { + using rep = typename Duration::rep; + FMT_ASSERT(std::is_floating_point::value, ""); + + auto val = duration.count(); + + if (num_fractional_digits < 0) { + // For `std::round` with fallback to `round`: + // On some toolchains `std::round` is not available (e.g. GCC 6). + using namespace std; + num_fractional_digits = + count_fractional_digits::value; + if (num_fractional_digits < 6 && static_cast(round(val)) != val) + num_fractional_digits = 6; + } + + fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), + std::fmod(val * static_cast(Duration::period::num) / + static_cast(Duration::period::den), + static_cast(60)), + num_fractional_digits); +} - template ::value&& has_isfinite::value)> - inline auto isfinite(T) -> bool - { - return true; +template +class tm_writer { + private: + static constexpr int days_per_week = 7; + + const std::locale& loc_; + const bool is_classic_; + OutputIt out_; + const Duration* subsecs_; + const std::tm& tm_; + + auto tm_sec() const noexcept -> int { + FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); + return tm_.tm_sec; + } + auto tm_min() const noexcept -> int { + FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); + return tm_.tm_min; + } + auto tm_hour() const noexcept -> int { + FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); + return tm_.tm_hour; + } + auto tm_mday() const noexcept -> int { + FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); + return tm_.tm_mday; + } + auto tm_mon() const noexcept -> int { + FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); + return tm_.tm_mon; + } + auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } + auto tm_wday() const noexcept -> int { + FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); + return tm_.tm_wday; + } + auto tm_yday() const noexcept -> int { + FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); + return tm_.tm_yday; + } + + auto tm_hour12() const noexcept -> int { + const auto h = tm_hour(); + const auto z = h < 12 ? h : h - 12; + return z == 0 ? 12 : z; + } + + // POSIX and the C Standard are unclear or inconsistent about what %C and %y + // do if the year is negative or exceeds 9999. Use the convention that %C + // concatenated with %y yields the same output as %Y, and that %Y contains at + // least 4 characters, with more only if necessary. + auto split_year_lower(long long year) const noexcept -> int { + auto l = year % 100; + if (l < 0) l = -l; // l in [0, 99] + return static_cast(l); + } + + // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. + auto iso_year_weeks(long long curr_year) const noexcept -> int { + const auto prev_year = curr_year - 1; + const auto curr_p = + (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % + days_per_week; + const auto prev_p = + (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % + days_per_week; + return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); + } + auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { + return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / + days_per_week; + } + auto tm_iso_week_year() const noexcept -> long long { + const auto year = tm_year(); + const auto w = iso_week_num(tm_yday(), tm_wday()); + if (w < 1) return year - 1; + if (w > iso_year_weeks(year)) return year + 1; + return year; + } + auto tm_iso_week_of_year() const noexcept -> int { + const auto year = tm_year(); + const auto w = iso_week_num(tm_yday(), tm_wday()); + if (w < 1) return iso_year_weeks(year - 1); + if (w > iso_year_weeks(year)) return 1; + return w; + } + + void write1(int value) { + *out_++ = static_cast('0' + to_unsigned(value) % 10); + } + void write2(int value) { + const char* d = digits2(to_unsigned(value) % 100); + *out_++ = *d++; + *out_++ = *d; + } + void write2(int value, pad_type pad) { + unsigned int v = to_unsigned(value) % 100; + if (v >= 10) { + const char* d = digits2(v); + *out_++ = *d++; + *out_++ = *d; + } else { + out_ = detail::write_padding(out_, pad); + *out_++ = static_cast('0' + v); } - - template ::value)> - inline auto mod(T x, int y) -> T - { - return x % static_cast(y); + } + + void write_year_extended(long long year) { + // At least 4 characters. + int width = 4; + if (year < 0) { + *out_++ = '-'; + year = 0 - year; + --width; } - template ::value)> - inline auto mod(T x, int y) -> T - { - return std::fmod(x, static_cast(y)); + uint32_or_64_or_128_t n = to_unsigned(year); + const int num_digits = count_digits(n); + if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0'); + out_ = format_decimal(out_, n, num_digits).end; + } + void write_year(long long year) { + if (year >= 0 && year < 10000) { + write2(static_cast(year / 100)); + write2(static_cast(year % 100)); + } else { + write_year_extended(year); } - - // If T is an integral type, maps T to its unsigned counterpart, otherwise - // leaves it unchanged (unlike std::make_unsigned). - template ::value> - struct make_unsigned_or_unchanged { - using type = T; - }; - - template - struct make_unsigned_or_unchanged { - using type = typename std::make_unsigned::type; - }; - - template ::value)> - inline auto get_milliseconds(std::chrono::duration d) -> std::chrono::duration - { - // this may overflow and/or the result may not fit in the - // target type. -#if FMT_SAFE_DURATION_CAST - using CommonSecondsType = typename std::common_type::type; - const auto d_as_common = fmt_duration_cast(d); - const auto d_as_whole_seconds = fmt_duration_cast(d_as_common); - // this conversion should be nonproblematic - const auto diff = d_as_common - d_as_whole_seconds; - const auto ms = fmt_duration_cast>(diff); - return ms; + } + + void write_utc_offset(long offset, numeric_system ns) { + if (offset < 0) { + *out_++ = '-'; + offset = -offset; + } else { + *out_++ = '+'; + } + offset /= 60; + write2(static_cast(offset / 60)); + if (ns != numeric_system::standard) *out_++ = ':'; + write2(static_cast(offset % 60)); + } + template ::value)> + void format_utc_offset_impl(const T& tm, numeric_system ns) { + write_utc_offset(tm.tm_gmtoff, ns); + } + template ::value)> + void format_utc_offset_impl(const T& tm, numeric_system ns) { +#if defined(_WIN32) && defined(_UCRT) +# if FMT_USE_TZSET + tzset_once(); +# endif + long offset = 0; + _get_timezone(&offset); + if (tm.tm_isdst) { + long dstbias = 0; + _get_dstbias(&dstbias); + offset += dstbias; + } + write_utc_offset(-offset, ns); #else - auto s = fmt_duration_cast(d); - return fmt_duration_cast(d - s); + if (ns == numeric_system::standard) return format_localized('z'); + + // Extract timezone offset from timezone conversion functions. + std::tm gtm = tm; + std::time_t gt = std::mktime(>m); + std::tm ltm = gmtime(gt); + std::time_t lt = std::mktime(<m); + long offset = gt - lt; + write_utc_offset(offset, ns); #endif + } + + template ::value)> + void format_tz_name_impl(const T& tm) { + if (is_classic_) + out_ = write_tm_str(out_, tm.tm_zone, loc_); + else + format_localized('Z'); + } + template ::value)> + void format_tz_name_impl(const T&) { + format_localized('Z'); + } + + void format_localized(char format, char modifier = 0) { + out_ = write(out_, tm_, loc_, format, modifier); + } + + public: + tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, + const Duration* subsecs = nullptr) + : loc_(loc), + is_classic_(loc_ == get_classic_locale()), + out_(out), + subsecs_(subsecs), + tm_(tm) {} + + auto out() const -> OutputIt { return out_; } + + FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { + out_ = copy_str(begin, end, out_); + } + + void on_abbr_weekday() { + if (is_classic_) + out_ = write(out_, tm_wday_short_name(tm_wday())); + else + format_localized('a'); + } + void on_full_weekday() { + if (is_classic_) + out_ = write(out_, tm_wday_full_name(tm_wday())); + else + format_localized('A'); + } + void on_dec0_weekday(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday()); + format_localized('w', 'O'); + } + void on_dec1_weekday(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto wday = tm_wday(); + write1(wday == 0 ? days_per_week : wday); + } else { + format_localized('u', 'O'); } - - template ::value)> - auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt - { - return write(out, val); + } + + void on_abbr_month() { + if (is_classic_) + out_ = write(out_, tm_mon_short_name(tm_mon())); + else + format_localized('b'); + } + void on_full_month() { + if (is_classic_) + out_ = write(out_, tm_mon_full_name(tm_mon())); + else + format_localized('B'); + } + + void on_datetime(numeric_system ns) { + if (is_classic_) { + on_abbr_weekday(); + *out_++ = ' '; + on_abbr_month(); + *out_++ = ' '; + on_day_of_month_space(numeric_system::standard); + *out_++ = ' '; + on_iso_time(); + *out_++ = ' '; + on_year(numeric_system::standard); + } else { + format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); } - - template ::value)> - auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt - { - auto specs = format_specs(); - specs.precision = precision; - specs.type = precision >= 0 ? presentation_type::fixed_lower : presentation_type::general_lower; - return write(out, val, specs); + } + void on_loc_date(numeric_system ns) { + if (is_classic_) + on_us_date(); + else + format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); + } + void on_loc_time(numeric_system ns) { + if (is_classic_) + on_iso_time(); + else + format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); + } + void on_us_date() { + char buf[8]; + write_digit2_separated(buf, to_unsigned(tm_mon() + 1), + to_unsigned(tm_mday()), + to_unsigned(split_year_lower(tm_year())), '/'); + out_ = copy_str(std::begin(buf), std::end(buf), out_); + } + void on_iso_date() { + auto year = tm_year(); + char buf[10]; + size_t offset = 0; + if (year >= 0 && year < 10000) { + copy2(buf, digits2(static_cast(year / 100))); + } else { + offset = 4; + write_year_extended(year); + year = 0; } - - template - auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt - { - return std::copy(unit.begin(), unit.end(), out); + write_digit2_separated(buf + 2, static_cast(year % 100), + to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), + '-'); + out_ = copy_str(std::begin(buf) + offset, std::end(buf), out_); + } + + void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } + void on_tz_name() { format_tz_name_impl(tm_); } + + void on_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write_year(tm_year()); + format_localized('Y', 'E'); + } + void on_short_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(split_year_lower(tm_year())); + format_localized('y', 'O'); + } + void on_offset_year() { + if (is_classic_) return write2(split_year_lower(tm_year())); + format_localized('y', 'E'); + } + + void on_century(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto year = tm_year(); + auto upper = year / 100; + if (year >= -99 && year < 0) { + // Zero upper on negative year. + *out_++ = '-'; + *out_++ = '0'; + } else if (upper >= 0 && upper < 100) { + write2(static_cast(upper)); + } else { + out_ = write(out_, upper); + } + } else { + format_localized('C', 'E'); } - - template - auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt - { - // This works when wchar_t is UTF-32 because units only contain characters - // that have the same representation in UTF-16 and UTF-32. - utf8_to_utf16 u(unit); - return std::copy(u.c_str(), u.c_str() + u.size(), out); + } + + void on_dec_month(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_mon() + 1); + format_localized('m', 'O'); + } + + void on_dec0_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); + format_localized('U', 'O'); + } + void on_dec1_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto wday = tm_wday(); + write2((tm_yday() + days_per_week - + (wday == 0 ? (days_per_week - 1) : (wday - 1))) / + days_per_week); + } else { + format_localized('W', 'O'); } - - template - auto format_duration_unit(OutputIt out) -> OutputIt - { - if (const char* unit = get_units()) - return copy_unit(string_view(unit), out, Char()); - *out++ = '['; - out = write(out, Period::num); - if (const_check(Period::den != 1)) - { - *out++ = '/'; - out = write(out, Period::den); - } - *out++ = ']'; - *out++ = 's'; - return out; + } + void on_iso_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_iso_week_of_year()); + format_localized('V', 'O'); + } + + void on_iso_week_based_year() { write_year(tm_iso_week_year()); } + void on_iso_week_based_short_year() { + write2(split_year_lower(tm_iso_week_year())); + } + + void on_day_of_year() { + auto yday = tm_yday() + 1; + write1(yday / 100); + write2(yday % 100); + } + void on_day_of_month(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday()); + format_localized('d', 'O'); + } + void on_day_of_month_space(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto mday = to_unsigned(tm_mday()) % 100; + const char* d2 = digits2(mday); + *out_++ = mday < 10 ? ' ' : d2[0]; + *out_++ = d2[1]; + } else { + format_localized('e', 'O'); } + } + + void on_24_hour(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_hour(), pad); + format_localized('H', 'O'); + } + void on_12_hour(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_hour12(), pad); + format_localized('I', 'O'); + } + void on_minute(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_min(), pad); + format_localized('M', 'O'); + } + + void on_second(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) { + write2(tm_sec(), pad); + if (subsecs_) { + if (std::is_floating_point::value) { + auto buf = memory_buffer(); + write_floating_seconds(buf, *subsecs_); + if (buf.size() > 1) { + // Remove the leading "0", write something like ".123". + out_ = std::copy(buf.begin() + 1, buf.end(), out_); + } + } else { + write_fractional_seconds(out_, *subsecs_); + } + } + } else { + // Currently no formatting of subseconds when a locale is set. + format_localized('S', 'O'); + } + } + + void on_12_hour_time() { + if (is_classic_) { + char buf[8]; + write_digit2_separated(buf, to_unsigned(tm_hour12()), + to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); + out_ = copy_str(std::begin(buf), std::end(buf), out_); + *out_++ = ' '; + on_am_pm(); + } else { + format_localized('r'); + } + } + void on_24_hour_time() { + write2(tm_hour()); + *out_++ = ':'; + write2(tm_min()); + } + void on_iso_time() { + on_24_hour_time(); + *out_++ = ':'; + on_second(numeric_system::standard, pad_type::unspecified); + } + + void on_am_pm() { + if (is_classic_) { + *out_++ = tm_hour() < 12 ? 'A' : 'P'; + *out_++ = 'M'; + } else { + format_localized('p'); + } + } - class get_locale { - private: - union { - std::locale locale_; - }; - bool has_locale_ = false; - - public: - get_locale(bool localized, locale_ref loc) : has_locale_(localized) - { - if (localized) - ::new (&locale_) std::locale(loc.template get()); - } - ~get_locale() - { - if (has_locale_) - locale_.~locale(); - } - operator const std::locale&() const { return has_locale_ ? locale_ : get_classic_locale(); } - }; - - template - struct chrono_formatter { - FormatContext& context; - OutputIt out; - int precision; - bool localized = false; - // rep is unsigned to avoid overflow. - using rep = conditional_t::value && sizeof(Rep) < sizeof(int), unsigned, typename make_unsigned_or_unchanged::type>; - rep val; - using seconds = std::chrono::duration; - seconds s; - using milliseconds = std::chrono::duration; - bool negative; - - using char_type = typename FormatContext::char_type; - using tm_writer_type = tm_writer; - - chrono_formatter(FormatContext& ctx, OutputIt o, std::chrono::duration d) : context(ctx), out(o), val(static_cast(d.count())), negative(false) - { - if (d.count() < 0) - { - val = 0 - val; - negative = true; - } - - // this may overflow and/or the result may not fit in the - // target type. - // might need checked conversion (rep!=Rep) - s = fmt_duration_cast(std::chrono::duration(val)); - } - - // returns true if nan or inf, writes to out. - auto handle_nan_inf() -> bool - { - if (isfinite(val)) - { - return false; - } - if (isnan(val)) - { - write_nan(); - return true; - } - // must be +-inf - if (val > 0) - { - write_pinf(); - } - else - { - write_ninf(); - } - return true; - } - - auto days() const -> Rep { return static_cast(s.count() / 86400); } - auto hour() const -> Rep { return static_cast(mod((s.count() / 3600), 24)); } - - auto hour12() const -> Rep - { - Rep hour = static_cast(mod((s.count() / 3600), 12)); - return hour <= 0 ? 12 : hour; - } - - auto minute() const -> Rep { return static_cast(mod((s.count() / 60), 60)); } - auto second() const -> Rep { return static_cast(mod(s.count(), 60)); } - - auto time() const -> std::tm - { - auto time = std::tm(); - time.tm_hour = to_nonnegative_int(hour(), 24); - time.tm_min = to_nonnegative_int(minute(), 60); - time.tm_sec = to_nonnegative_int(second(), 60); - return time; - } - - void write_sign() - { - if (negative) - { - *out++ = '-'; - negative = false; - } - } + // These apply to chrono durations but not tm. + void on_duration_value() {} + void on_duration_unit() {} +}; - void write(Rep value, int width, pad_type pad = pad_type::unspecified) - { - write_sign(); - if (isnan(value)) - return write_nan(); - uint32_or_64_or_128_t n = to_unsigned(to_nonnegative_int(value, max_value())); - int num_digits = detail::count_digits(n); - if (width > num_digits) - { - out = detail::write_padding(out, pad, width - num_digits); - } - out = format_decimal(out, n, num_digits).end; - } +struct chrono_format_checker : null_chrono_spec_handler { + bool has_precision_integral = false; + + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); } + + template + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + FMT_CONSTEXPR void on_day_of_year() {} + FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour_time() {} + FMT_CONSTEXPR void on_24_hour_time() {} + FMT_CONSTEXPR void on_iso_time() {} + FMT_CONSTEXPR void on_am_pm() {} + FMT_CONSTEXPR void on_duration_value() const { + if (has_precision_integral) { + FMT_THROW(format_error("precision not allowed for this argument type")); + } + } + FMT_CONSTEXPR void on_duration_unit() {} +}; - void write_nan() { std::copy_n("nan", 3, out); } - void write_pinf() { std::copy_n("inf", 3, out); } - void write_ninf() { std::copy_n("-inf", 4, out); } - - template - void format_tm(const tm& time, Callback cb, Args... args) - { - if (isnan(val)) - return write_nan(); - get_locale loc(localized, context.locale()); - auto w = tm_writer_type(loc, out, time); - (w.*cb)(args...); - out = w.out(); - } +template ::value&& has_isfinite::value)> +inline auto isfinite(T) -> bool { + return true; +} - void on_text(const char_type* begin, const char_type* end) { std::copy(begin, end, out); } - - // These are not implemented because durations don't have date information. - void on_abbr_weekday() {} - void on_full_weekday() {} - void on_dec0_weekday(numeric_system) {} - void on_dec1_weekday(numeric_system) {} - void on_abbr_month() {} - void on_full_month() {} - void on_datetime(numeric_system) {} - void on_loc_date(numeric_system) {} - void on_loc_time(numeric_system) {} - void on_us_date() {} - void on_iso_date() {} - void on_utc_offset(numeric_system) {} - void on_tz_name() {} - void on_year(numeric_system) {} - void on_short_year(numeric_system) {} - void on_offset_year() {} - void on_century(numeric_system) {} - void on_iso_week_based_year() {} - void on_iso_week_based_short_year() {} - void on_dec_month(numeric_system) {} - void on_dec0_week_of_year(numeric_system) {} - void on_dec1_week_of_year(numeric_system) {} - void on_iso_week_of_year(numeric_system) {} - void on_day_of_month(numeric_system) {} - void on_day_of_month_space(numeric_system) {} - - void on_day_of_year() - { - if (handle_nan_inf()) - return; - write(days(), 0); - } +template ::value)> +inline auto mod(T x, int y) -> T { + return x % static_cast(y); +} +template ::value)> +inline auto mod(T x, int y) -> T { + return std::fmod(x, static_cast(y)); +} - void on_24_hour(numeric_system ns, pad_type pad) - { - if (handle_nan_inf()) - return; +// If T is an integral type, maps T to its unsigned counterpart, otherwise +// leaves it unchanged (unlike std::make_unsigned). +template ::value> +struct make_unsigned_or_unchanged { + using type = T; +}; - if (ns == numeric_system::standard) - return write(hour(), 2, pad); - auto time = tm(); - time.tm_hour = to_nonnegative_int(hour(), 24); - format_tm(time, &tm_writer_type::on_24_hour, ns, pad); - } +template struct make_unsigned_or_unchanged { + using type = typename std::make_unsigned::type; +}; - void on_12_hour(numeric_system ns, pad_type pad) - { - if (handle_nan_inf()) - return; +template ::value)> +inline auto get_milliseconds(std::chrono::duration d) + -> std::chrono::duration { + // this may overflow and/or the result may not fit in the + // target type. +#if FMT_SAFE_DURATION_CAST + using CommonSecondsType = + typename std::common_type::type; + const auto d_as_common = fmt_duration_cast(d); + const auto d_as_whole_seconds = + fmt_duration_cast(d_as_common); + // this conversion should be nonproblematic + const auto diff = d_as_common - d_as_whole_seconds; + const auto ms = + fmt_duration_cast>(diff); + return ms; +#else + auto s = fmt_duration_cast(d); + return fmt_duration_cast(d - s); +#endif +} - if (ns == numeric_system::standard) - return write(hour12(), 2, pad); - auto time = tm(); - time.tm_hour = to_nonnegative_int(hour12(), 12); - format_tm(time, &tm_writer_type::on_12_hour, ns, pad); - } +template ::value)> +auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { + return write(out, val); +} - void on_minute(numeric_system ns, pad_type pad) - { - if (handle_nan_inf()) - return; +template ::value)> +auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { + auto specs = format_specs(); + specs.precision = precision; + specs.type = precision >= 0 ? presentation_type::fixed_lower + : presentation_type::general_lower; + return write(out, val, specs); +} - if (ns == numeric_system::standard) - return write(minute(), 2, pad); - auto time = tm(); - time.tm_min = to_nonnegative_int(minute(), 60); - format_tm(time, &tm_writer_type::on_minute, ns, pad); - } +template +auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { + return std::copy(unit.begin(), unit.end(), out); +} - void on_second(numeric_system ns, pad_type pad) - { - if (handle_nan_inf()) - return; - - if (ns == numeric_system::standard) - { - if (std::is_floating_point::value) - { - auto buf = memory_buffer(); - write_floating_seconds(buf, std::chrono::duration(val), precision); - if (negative) - *out++ = '-'; - if (buf.size() < 2 || buf[1] == '.') - { - out = detail::write_padding(out, pad); - } - out = std::copy(buf.begin(), buf.end(), out); - } - else - { - write(second(), 2, pad); - write_fractional_seconds(out, std::chrono::duration(val), precision); - } - return; - } - auto time = tm(); - time.tm_sec = to_nonnegative_int(second(), 60); - format_tm(time, &tm_writer_type::on_second, ns, pad); - } +template +auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { + // This works when wchar_t is UTF-32 because units only contain characters + // that have the same representation in UTF-16 and UTF-32. + utf8_to_utf16 u(unit); + return std::copy(u.c_str(), u.c_str() + u.size(), out); +} - void on_12_hour_time() - { - if (handle_nan_inf()) - return; - format_tm(time(), &tm_writer_type::on_12_hour_time); - } +template +auto format_duration_unit(OutputIt out) -> OutputIt { + if (const char* unit = get_units()) + return copy_unit(string_view(unit), out, Char()); + *out++ = '['; + out = write(out, Period::num); + if (const_check(Period::den != 1)) { + *out++ = '/'; + out = write(out, Period::den); + } + *out++ = ']'; + *out++ = 's'; + return out; +} - void on_24_hour_time() - { - if (handle_nan_inf()) - { - *out++ = ':'; - handle_nan_inf(); - return; - } - - write(hour(), 2); - *out++ = ':'; - write(minute(), 2); - } +class get_locale { + private: + union { + std::locale locale_; + }; + bool has_locale_ = false; + + public: + get_locale(bool localized, locale_ref loc) : has_locale_(localized) { + if (localized) + ::new (&locale_) std::locale(loc.template get()); + } + ~get_locale() { + if (has_locale_) locale_.~locale(); + } + operator const std::locale&() const { + return has_locale_ ? locale_ : get_classic_locale(); + } +}; - void on_iso_time() - { - on_24_hour_time(); - *out++ = ':'; - if (handle_nan_inf()) - return; - on_second(numeric_system::standard, pad_type::unspecified); - } +template +struct chrono_formatter { + FormatContext& context; + OutputIt out; + int precision; + bool localized = false; + // rep is unsigned to avoid overflow. + using rep = + conditional_t::value && sizeof(Rep) < sizeof(int), + unsigned, typename make_unsigned_or_unchanged::type>; + rep val; + using seconds = std::chrono::duration; + seconds s; + using milliseconds = std::chrono::duration; + bool negative; + + using char_type = typename FormatContext::char_type; + using tm_writer_type = tm_writer; + + chrono_formatter(FormatContext& ctx, OutputIt o, + std::chrono::duration d) + : context(ctx), + out(o), + val(static_cast(d.count())), + negative(false) { + if (d.count() < 0) { + val = 0 - val; + negative = true; + } - void on_am_pm() - { - if (handle_nan_inf()) - return; - format_tm(time(), &tm_writer_type::on_am_pm); - } + // this may overflow and/or the result may not fit in the + // target type. + // might need checked conversion (rep!=Rep) + s = fmt_duration_cast(std::chrono::duration(val)); + } - void on_duration_value() - { - if (handle_nan_inf()) - return; - write_sign(); - out = format_duration_value(out, val, precision); - } + // returns true if nan or inf, writes to out. + auto handle_nan_inf() -> bool { + if (isfinite(val)) { + return false; + } + if (isnan(val)) { + write_nan(); + return true; + } + // must be +-inf + if (val > 0) { + write_pinf(); + } else { + write_ninf(); + } + return true; + } + + auto days() const -> Rep { return static_cast(s.count() / 86400); } + auto hour() const -> Rep { + return static_cast(mod((s.count() / 3600), 24)); + } + + auto hour12() const -> Rep { + Rep hour = static_cast(mod((s.count() / 3600), 12)); + return hour <= 0 ? 12 : hour; + } + + auto minute() const -> Rep { + return static_cast(mod((s.count() / 60), 60)); + } + auto second() const -> Rep { return static_cast(mod(s.count(), 60)); } + + auto time() const -> std::tm { + auto time = std::tm(); + time.tm_hour = to_nonnegative_int(hour(), 24); + time.tm_min = to_nonnegative_int(minute(), 60); + time.tm_sec = to_nonnegative_int(second(), 60); + return time; + } + + void write_sign() { + if (negative) { + *out++ = '-'; + negative = false; + } + } + + void write(Rep value, int width, pad_type pad = pad_type::unspecified) { + write_sign(); + if (isnan(value)) return write_nan(); + uint32_or_64_or_128_t n = + to_unsigned(to_nonnegative_int(value, max_value())); + int num_digits = detail::count_digits(n); + if (width > num_digits) { + out = detail::write_padding(out, pad, width - num_digits); + } + out = format_decimal(out, n, num_digits).end; + } + + void write_nan() { std::copy_n("nan", 3, out); } + void write_pinf() { std::copy_n("inf", 3, out); } + void write_ninf() { std::copy_n("-inf", 4, out); } + + template + void format_tm(const tm& time, Callback cb, Args... args) { + if (isnan(val)) return write_nan(); + get_locale loc(localized, context.locale()); + auto w = tm_writer_type(loc, out, time); + (w.*cb)(args...); + out = w.out(); + } + + void on_text(const char_type* begin, const char_type* end) { + std::copy(begin, end, out); + } + + // These are not implemented because durations don't have date information. + void on_abbr_weekday() {} + void on_full_weekday() {} + void on_dec0_weekday(numeric_system) {} + void on_dec1_weekday(numeric_system) {} + void on_abbr_month() {} + void on_full_month() {} + void on_datetime(numeric_system) {} + void on_loc_date(numeric_system) {} + void on_loc_time(numeric_system) {} + void on_us_date() {} + void on_iso_date() {} + void on_utc_offset(numeric_system) {} + void on_tz_name() {} + void on_year(numeric_system) {} + void on_short_year(numeric_system) {} + void on_offset_year() {} + void on_century(numeric_system) {} + void on_iso_week_based_year() {} + void on_iso_week_based_short_year() {} + void on_dec_month(numeric_system) {} + void on_dec0_week_of_year(numeric_system) {} + void on_dec1_week_of_year(numeric_system) {} + void on_iso_week_of_year(numeric_system) {} + void on_day_of_month(numeric_system) {} + void on_day_of_month_space(numeric_system) {} + + void on_day_of_year() { + if (handle_nan_inf()) return; + write(days(), 0); + } + + void on_24_hour(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(hour(), 2, pad); + auto time = tm(); + time.tm_hour = to_nonnegative_int(hour(), 24); + format_tm(time, &tm_writer_type::on_24_hour, ns, pad); + } + + void on_12_hour(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(hour12(), 2, pad); + auto time = tm(); + time.tm_hour = to_nonnegative_int(hour12(), 12); + format_tm(time, &tm_writer_type::on_12_hour, ns, pad); + } + + void on_minute(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(minute(), 2, pad); + auto time = tm(); + time.tm_min = to_nonnegative_int(minute(), 60); + format_tm(time, &tm_writer_type::on_minute, ns, pad); + } + + void on_second(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) { + if (std::is_floating_point::value) { + auto buf = memory_buffer(); + write_floating_seconds(buf, std::chrono::duration(val), + precision); + if (negative) *out++ = '-'; + if (buf.size() < 2 || buf[1] == '.') { + out = detail::write_padding(out, pad); + } + out = std::copy(buf.begin(), buf.end(), out); + } else { + write(second(), 2, pad); + write_fractional_seconds( + out, std::chrono::duration(val), precision); + } + return; + } + auto time = tm(); + time.tm_sec = to_nonnegative_int(second(), 60); + format_tm(time, &tm_writer_type::on_second, ns, pad); + } + + void on_12_hour_time() { + if (handle_nan_inf()) return; + format_tm(time(), &tm_writer_type::on_12_hour_time); + } + + void on_24_hour_time() { + if (handle_nan_inf()) { + *out++ = ':'; + handle_nan_inf(); + return; + } - void on_duration_unit() { out = format_duration_unit(out); } - }; + write(hour(), 2); + *out++ = ':'; + write(minute(), 2); + } + + void on_iso_time() { + on_24_hour_time(); + *out++ = ':'; + if (handle_nan_inf()) return; + on_second(numeric_system::standard, pad_type::unspecified); + } + + void on_am_pm() { + if (handle_nan_inf()) return; + format_tm(time(), &tm_writer_type::on_am_pm); + } + + void on_duration_value() { + if (handle_nan_inf()) return; + write_sign(); + out = format_duration_value(out, val, precision); + } + + void on_duration_unit() { + out = format_duration_unit(out); + } +}; -} // namespace detail +} // namespace detail #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; #else // A fallback version of weekday. class weekday { -private: - unsigned char value; - -public: - weekday() = default; - explicit constexpr weekday(unsigned wd) noexcept : value(static_cast(wd != 7 ? wd : 0)) {} - constexpr auto c_encoding() const noexcept -> unsigned { return value; } + private: + unsigned char value; + + public: + weekday() = default; + explicit constexpr weekday(unsigned wd) noexcept + : value(static_cast(wd != 7 ? wd : 0)) {} + constexpr auto c_encoding() const noexcept -> unsigned { return value; } }; class year_month_day {}; #endif // A rudimentary weekday formatter. -template -struct formatter { -private: - bool localized = false; - -public: - FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) - { - auto begin = ctx.begin(), end = ctx.end(); - if (begin != end && *begin == 'L') - { - ++begin; - localized = true; - } - return begin; - } - - template - auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto time = std::tm(); - time.tm_wday = static_cast(wd.c_encoding()); - detail::get_locale loc(localized, ctx.locale()); - auto w = detail::tm_writer(loc, ctx.out(), time); - w.on_abbr_weekday(); - return w.out(); +template struct formatter { + private: + bool localized = false; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin != end && *begin == 'L') { + ++begin; + localized = true; } + return begin; + } + + template + auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_wday = static_cast(wd.c_encoding()); + detail::get_locale loc(localized, ctx.locale()); + auto w = detail::tm_writer(loc, ctx.out(), time); + w.on_abbr_weekday(); + return w.out(); + } }; template struct formatter, Char> { -private: - format_specs specs_; - detail::arg_ref width_ref_; - detail::arg_ref precision_ref_; - bool localized_ = false; - basic_string_view format_str_; - -public: - FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(), end = ctx.end(); - if (it == end || *it == '}') - return it; - - it = detail::parse_align(it, end, specs_); - if (it == end) - return it; - - it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); - if (it == end) - return it; - - auto checker = detail::chrono_format_checker(); - if (*it == '.') - { - checker.has_precision_integral = !std::is_floating_point::value; - it = detail::parse_precision(it, end, specs_.precision, precision_ref_, ctx); - } - if (it != end && *it == 'L') - { - localized_ = true; - ++it; - } - end = detail::parse_chrono_format(it, end, checker); - format_str_ = {it, detail::to_unsigned(end - it)}; - return end; + private: + format_specs specs_; + detail::arg_ref width_ref_; + detail::arg_ref precision_ref_; + bool localized_ = false; + basic_string_view format_str_; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + if (it == end || *it == '}') return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; + + auto checker = detail::chrono_format_checker(); + if (*it == '.') { + checker.has_precision_integral = !std::is_floating_point::value; + it = detail::parse_precision(it, end, specs_.precision, precision_ref_, + ctx); } - - template - auto format(std::chrono::duration d, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto specs = specs_; - auto precision = specs.precision; - specs.precision = -1; - auto begin = format_str_.begin(), end = format_str_.end(); - // As a possible future optimization, we could avoid extra copying if width - // is not specified. - auto buf = basic_memory_buffer(); - auto out = std::back_inserter(buf); - detail::handle_dynamic_spec(specs.width, width_ref_, ctx); - detail::handle_dynamic_spec(precision, precision_ref_, ctx); - if (begin == end || *begin == '}') - { - out = detail::format_duration_value(out, d.count(), precision); - detail::format_duration_unit(out); - } - else - { - using chrono_formatter = detail::chrono_formatter; - auto f = chrono_formatter(ctx, out, d); - f.precision = precision; - f.localized = localized_; - detail::parse_chrono_format(begin, end, f); - } - return detail::write(ctx.out(), basic_string_view(buf.data(), buf.size()), specs); + if (it != end && *it == 'L') { + localized_ = true; + ++it; + } + end = detail::parse_chrono_format(it, end, checker); + format_str_ = {it, detail::to_unsigned(end - it)}; + return end; + } + + template + auto format(std::chrono::duration d, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto specs = specs_; + auto precision = specs.precision; + specs.precision = -1; + auto begin = format_str_.begin(), end = format_str_.end(); + // As a possible future optimization, we could avoid extra copying if width + // is not specified. + auto buf = basic_memory_buffer(); + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); + detail::handle_dynamic_spec(precision, + precision_ref_, ctx); + if (begin == end || *begin == '}') { + out = detail::format_duration_value(out, d.count(), precision); + detail::format_duration_unit(out); + } else { + using chrono_formatter = + detail::chrono_formatter; + auto f = chrono_formatter(ctx, out, d); + f.precision = precision; + f.localized = localized_; + detail::parse_chrono_format(begin, end, f); } + return detail::write( + ctx.out(), basic_string_view(buf.data(), buf.size()), specs); + } }; template -struct formatter, Char> : formatter { - FMT_CONSTEXPR formatter() { this->format_str_ = detail::string_literal{}; } - - template - auto format(std::chrono::time_point val, FormatContext& ctx) const -> decltype(ctx.out()) - { - using period = typename Duration::period; - if (detail::const_check(period::num != 1 || period::den != 1 || std::is_floating_point::value)) - { - const auto epoch = val.time_since_epoch(); - auto subsecs = detail::fmt_duration_cast(epoch - detail::fmt_duration_cast(epoch)); - - if (subsecs.count() < 0) - { - auto second = detail::fmt_duration_cast(std::chrono::seconds(1)); - if (epoch.count() < ((Duration::min)() + second).count()) - FMT_THROW(format_error("duration is too small")); - subsecs += second; - val -= second; - } - - return formatter::do_format(gmtime(val), ctx, &subsecs); - } - - return formatter::format(gmtime(val), ctx); +struct formatter, + Char> : formatter { + FMT_CONSTEXPR formatter() { + this->format_str_ = detail::string_literal{}; + } + + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + using period = typename Duration::period; + if (detail::const_check( + period::num != 1 || period::den != 1 || + std::is_floating_point::value)) { + const auto epoch = val.time_since_epoch(); + auto subsecs = detail::fmt_duration_cast( + epoch - detail::fmt_duration_cast(epoch)); + + if (subsecs.count() < 0) { + auto second = + detail::fmt_duration_cast(std::chrono::seconds(1)); + if (epoch.count() < ((Duration::min)() + second).count()) + FMT_THROW(format_error("duration is too small")); + subsecs += second; + val -= second; + } + + return formatter::do_format(gmtime(val), ctx, &subsecs); } + + return formatter::format(gmtime(val), ctx); + } }; #if FMT_USE_LOCAL_TIME template -struct formatter, Char> : formatter { - FMT_CONSTEXPR formatter() { this->format_str_ = detail::string_literal{}; } - - template - auto format(std::chrono::local_time val, FormatContext& ctx) const -> decltype(ctx.out()) - { - using period = typename Duration::period; - if (period::num != 1 || period::den != 1 || std::is_floating_point::value) - { - const auto epoch = val.time_since_epoch(); - const auto subsecs = detail::fmt_duration_cast(epoch - detail::fmt_duration_cast(epoch)); - - return formatter::do_format(localtime(val), ctx, &subsecs); - } - - return formatter::format(localtime(val), ctx); +struct formatter, Char> + : formatter { + FMT_CONSTEXPR formatter() { + this->format_str_ = detail::string_literal{}; + } + + template + auto format(std::chrono::local_time val, FormatContext& ctx) const + -> decltype(ctx.out()) { + using period = typename Duration::period; + if (period::num != 1 || period::den != 1 || + std::is_floating_point::value) { + const auto epoch = val.time_since_epoch(); + const auto subsecs = detail::fmt_duration_cast( + epoch - detail::fmt_duration_cast(epoch)); + + return formatter::do_format(localtime(val), ctx, &subsecs); } + + return formatter::format(localtime(val), ctx); + } }; #endif #if FMT_USE_UTC_TIME template -struct formatter, Char> : formatter, Char> { - template - auto format(std::chrono::time_point val, FormatContext& ctx) const -> decltype(ctx.out()) - { - return formatter, Char>::format(std::chrono::utc_clock::to_sys(val), ctx); - } +struct formatter, + Char> + : formatter, + Char> { + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + return formatter< + std::chrono::time_point, + Char>::format(std::chrono::utc_clock::to_sys(val), ctx); + } }; #endif -template -struct formatter { -private: - format_specs specs_; - detail::arg_ref width_ref_; - -protected: - basic_string_view format_str_; - - template - auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) - { - auto specs = specs_; - auto buf = basic_memory_buffer(); - auto out = std::back_inserter(buf); - detail::handle_dynamic_spec(specs.width, width_ref_, ctx); - - auto loc_ref = ctx.locale(); - detail::get_locale loc(static_cast(loc_ref), loc_ref); - auto w = detail::tm_writer(loc, out, tm, subsecs); - detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w); - return detail::write(ctx.out(), basic_string_view(buf.data(), buf.size()), specs); - } - -public: - FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(), end = ctx.end(); - if (it == end || *it == '}') - return it; - - it = detail::parse_align(it, end, specs_); - if (it == end) - return it; - - it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); - if (it == end) - return it; - - end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); - // Replace the default format_str only if the new spec is not empty. - if (end != it) - format_str_ = {it, detail::to_unsigned(end - it)}; - return end; - } - - template - auto format(const std::tm& tm, FormatContext& ctx) const -> decltype(ctx.out()) - { - return do_format(tm, ctx, nullptr); - } +template struct formatter { + private: + format_specs specs_; + detail::arg_ref width_ref_; + + protected: + basic_string_view format_str_; + + template + auto do_format(const std::tm& tm, FormatContext& ctx, + const Duration* subsecs) const -> decltype(ctx.out()) { + auto specs = specs_; + auto buf = basic_memory_buffer(); + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); + + auto loc_ref = ctx.locale(); + detail::get_locale loc(static_cast(loc_ref), loc_ref); + auto w = + detail::tm_writer(loc, out, tm, subsecs); + detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w); + return detail::write( + ctx.out(), basic_string_view(buf.data(), buf.size()), specs); + } + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(), end = ctx.end(); + if (it == end || *it == '}') return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it == end) return it; + + end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); + // Replace the default format_str only if the new spec is not empty. + if (end != it) format_str_ = {it, detail::to_unsigned(end - it)}; + return end; + } + + template + auto format(const std::tm& tm, FormatContext& ctx) const + -> decltype(ctx.out()) { + return do_format(tm, ctx, nullptr); + } }; FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_CHRONO_H_ +#endif // FMT_CHRONO_H_ diff --git a/lib/spdlog/fmt/bundled/color.h b/lib/spdlog/fmt/bundled/color.h index 12ebc366..367849a8 100644 --- a/lib/spdlog/fmt/bundled/color.h +++ b/lib/spdlog/fmt/bundled/color.h @@ -14,452 +14,471 @@ FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT enum class color : uint32_t { - alice_blue = 0xF0F8FF, // rgb(240,248,255) - antique_white = 0xFAEBD7, // rgb(250,235,215) - aqua = 0x00FFFF, // rgb(0,255,255) - aquamarine = 0x7FFFD4, // rgb(127,255,212) - azure = 0xF0FFFF, // rgb(240,255,255) - beige = 0xF5F5DC, // rgb(245,245,220) - bisque = 0xFFE4C4, // rgb(255,228,196) - black = 0x000000, // rgb(0,0,0) - blanched_almond = 0xFFEBCD, // rgb(255,235,205) - blue = 0x0000FF, // rgb(0,0,255) - blue_violet = 0x8A2BE2, // rgb(138,43,226) - brown = 0xA52A2A, // rgb(165,42,42) - burly_wood = 0xDEB887, // rgb(222,184,135) - cadet_blue = 0x5F9EA0, // rgb(95,158,160) - chartreuse = 0x7FFF00, // rgb(127,255,0) - chocolate = 0xD2691E, // rgb(210,105,30) - coral = 0xFF7F50, // rgb(255,127,80) - cornflower_blue = 0x6495ED, // rgb(100,149,237) - cornsilk = 0xFFF8DC, // rgb(255,248,220) - crimson = 0xDC143C, // rgb(220,20,60) - cyan = 0x00FFFF, // rgb(0,255,255) - dark_blue = 0x00008B, // rgb(0,0,139) - dark_cyan = 0x008B8B, // rgb(0,139,139) - dark_golden_rod = 0xB8860B, // rgb(184,134,11) - dark_gray = 0xA9A9A9, // rgb(169,169,169) - dark_green = 0x006400, // rgb(0,100,0) - dark_khaki = 0xBDB76B, // rgb(189,183,107) - dark_magenta = 0x8B008B, // rgb(139,0,139) - dark_olive_green = 0x556B2F, // rgb(85,107,47) - dark_orange = 0xFF8C00, // rgb(255,140,0) - dark_orchid = 0x9932CC, // rgb(153,50,204) - dark_red = 0x8B0000, // rgb(139,0,0) - dark_salmon = 0xE9967A, // rgb(233,150,122) - dark_sea_green = 0x8FBC8F, // rgb(143,188,143) - dark_slate_blue = 0x483D8B, // rgb(72,61,139) - dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) - dark_turquoise = 0x00CED1, // rgb(0,206,209) - dark_violet = 0x9400D3, // rgb(148,0,211) - deep_pink = 0xFF1493, // rgb(255,20,147) - deep_sky_blue = 0x00BFFF, // rgb(0,191,255) - dim_gray = 0x696969, // rgb(105,105,105) - dodger_blue = 0x1E90FF, // rgb(30,144,255) - fire_brick = 0xB22222, // rgb(178,34,34) - floral_white = 0xFFFAF0, // rgb(255,250,240) - forest_green = 0x228B22, // rgb(34,139,34) - fuchsia = 0xFF00FF, // rgb(255,0,255) - gainsboro = 0xDCDCDC, // rgb(220,220,220) - ghost_white = 0xF8F8FF, // rgb(248,248,255) - gold = 0xFFD700, // rgb(255,215,0) - golden_rod = 0xDAA520, // rgb(218,165,32) - gray = 0x808080, // rgb(128,128,128) - green = 0x008000, // rgb(0,128,0) - green_yellow = 0xADFF2F, // rgb(173,255,47) - honey_dew = 0xF0FFF0, // rgb(240,255,240) - hot_pink = 0xFF69B4, // rgb(255,105,180) - indian_red = 0xCD5C5C, // rgb(205,92,92) - indigo = 0x4B0082, // rgb(75,0,130) - ivory = 0xFFFFF0, // rgb(255,255,240) - khaki = 0xF0E68C, // rgb(240,230,140) - lavender = 0xE6E6FA, // rgb(230,230,250) - lavender_blush = 0xFFF0F5, // rgb(255,240,245) - lawn_green = 0x7CFC00, // rgb(124,252,0) - lemon_chiffon = 0xFFFACD, // rgb(255,250,205) - light_blue = 0xADD8E6, // rgb(173,216,230) - light_coral = 0xF08080, // rgb(240,128,128) - light_cyan = 0xE0FFFF, // rgb(224,255,255) - light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) - light_gray = 0xD3D3D3, // rgb(211,211,211) - light_green = 0x90EE90, // rgb(144,238,144) - light_pink = 0xFFB6C1, // rgb(255,182,193) - light_salmon = 0xFFA07A, // rgb(255,160,122) - light_sea_green = 0x20B2AA, // rgb(32,178,170) - light_sky_blue = 0x87CEFA, // rgb(135,206,250) - light_slate_gray = 0x778899, // rgb(119,136,153) - light_steel_blue = 0xB0C4DE, // rgb(176,196,222) - light_yellow = 0xFFFFE0, // rgb(255,255,224) - lime = 0x00FF00, // rgb(0,255,0) - lime_green = 0x32CD32, // rgb(50,205,50) - linen = 0xFAF0E6, // rgb(250,240,230) - magenta = 0xFF00FF, // rgb(255,0,255) - maroon = 0x800000, // rgb(128,0,0) - medium_aquamarine = 0x66CDAA, // rgb(102,205,170) - medium_blue = 0x0000CD, // rgb(0,0,205) - medium_orchid = 0xBA55D3, // rgb(186,85,211) - medium_purple = 0x9370DB, // rgb(147,112,219) - medium_sea_green = 0x3CB371, // rgb(60,179,113) - medium_slate_blue = 0x7B68EE, // rgb(123,104,238) - medium_spring_green = 0x00FA9A, // rgb(0,250,154) - medium_turquoise = 0x48D1CC, // rgb(72,209,204) - medium_violet_red = 0xC71585, // rgb(199,21,133) - midnight_blue = 0x191970, // rgb(25,25,112) - mint_cream = 0xF5FFFA, // rgb(245,255,250) - misty_rose = 0xFFE4E1, // rgb(255,228,225) - moccasin = 0xFFE4B5, // rgb(255,228,181) - navajo_white = 0xFFDEAD, // rgb(255,222,173) - navy = 0x000080, // rgb(0,0,128) - old_lace = 0xFDF5E6, // rgb(253,245,230) - olive = 0x808000, // rgb(128,128,0) - olive_drab = 0x6B8E23, // rgb(107,142,35) - orange = 0xFFA500, // rgb(255,165,0) - orange_red = 0xFF4500, // rgb(255,69,0) - orchid = 0xDA70D6, // rgb(218,112,214) - pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) - pale_green = 0x98FB98, // rgb(152,251,152) - pale_turquoise = 0xAFEEEE, // rgb(175,238,238) - pale_violet_red = 0xDB7093, // rgb(219,112,147) - papaya_whip = 0xFFEFD5, // rgb(255,239,213) - peach_puff = 0xFFDAB9, // rgb(255,218,185) - peru = 0xCD853F, // rgb(205,133,63) - pink = 0xFFC0CB, // rgb(255,192,203) - plum = 0xDDA0DD, // rgb(221,160,221) - powder_blue = 0xB0E0E6, // rgb(176,224,230) - purple = 0x800080, // rgb(128,0,128) - rebecca_purple = 0x663399, // rgb(102,51,153) - red = 0xFF0000, // rgb(255,0,0) - rosy_brown = 0xBC8F8F, // rgb(188,143,143) - royal_blue = 0x4169E1, // rgb(65,105,225) - saddle_brown = 0x8B4513, // rgb(139,69,19) - salmon = 0xFA8072, // rgb(250,128,114) - sandy_brown = 0xF4A460, // rgb(244,164,96) - sea_green = 0x2E8B57, // rgb(46,139,87) - sea_shell = 0xFFF5EE, // rgb(255,245,238) - sienna = 0xA0522D, // rgb(160,82,45) - silver = 0xC0C0C0, // rgb(192,192,192) - sky_blue = 0x87CEEB, // rgb(135,206,235) - slate_blue = 0x6A5ACD, // rgb(106,90,205) - slate_gray = 0x708090, // rgb(112,128,144) - snow = 0xFFFAFA, // rgb(255,250,250) - spring_green = 0x00FF7F, // rgb(0,255,127) - steel_blue = 0x4682B4, // rgb(70,130,180) - tan = 0xD2B48C, // rgb(210,180,140) - teal = 0x008080, // rgb(0,128,128) - thistle = 0xD8BFD8, // rgb(216,191,216) - tomato = 0xFF6347, // rgb(255,99,71) - turquoise = 0x40E0D0, // rgb(64,224,208) - violet = 0xEE82EE, // rgb(238,130,238) - wheat = 0xF5DEB3, // rgb(245,222,179) - white = 0xFFFFFF, // rgb(255,255,255) - white_smoke = 0xF5F5F5, // rgb(245,245,245) - yellow = 0xFFFF00, // rgb(255,255,0) - yellow_green = 0x9ACD32 // rgb(154,205,50) -}; // enum class color - -enum class terminal_color : uint8_t { black = 30, red, green, yellow, blue, magenta, cyan, white, bright_black = 90, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white }; + alice_blue = 0xF0F8FF, // rgb(240,248,255) + antique_white = 0xFAEBD7, // rgb(250,235,215) + aqua = 0x00FFFF, // rgb(0,255,255) + aquamarine = 0x7FFFD4, // rgb(127,255,212) + azure = 0xF0FFFF, // rgb(240,255,255) + beige = 0xF5F5DC, // rgb(245,245,220) + bisque = 0xFFE4C4, // rgb(255,228,196) + black = 0x000000, // rgb(0,0,0) + blanched_almond = 0xFFEBCD, // rgb(255,235,205) + blue = 0x0000FF, // rgb(0,0,255) + blue_violet = 0x8A2BE2, // rgb(138,43,226) + brown = 0xA52A2A, // rgb(165,42,42) + burly_wood = 0xDEB887, // rgb(222,184,135) + cadet_blue = 0x5F9EA0, // rgb(95,158,160) + chartreuse = 0x7FFF00, // rgb(127,255,0) + chocolate = 0xD2691E, // rgb(210,105,30) + coral = 0xFF7F50, // rgb(255,127,80) + cornflower_blue = 0x6495ED, // rgb(100,149,237) + cornsilk = 0xFFF8DC, // rgb(255,248,220) + crimson = 0xDC143C, // rgb(220,20,60) + cyan = 0x00FFFF, // rgb(0,255,255) + dark_blue = 0x00008B, // rgb(0,0,139) + dark_cyan = 0x008B8B, // rgb(0,139,139) + dark_golden_rod = 0xB8860B, // rgb(184,134,11) + dark_gray = 0xA9A9A9, // rgb(169,169,169) + dark_green = 0x006400, // rgb(0,100,0) + dark_khaki = 0xBDB76B, // rgb(189,183,107) + dark_magenta = 0x8B008B, // rgb(139,0,139) + dark_olive_green = 0x556B2F, // rgb(85,107,47) + dark_orange = 0xFF8C00, // rgb(255,140,0) + dark_orchid = 0x9932CC, // rgb(153,50,204) + dark_red = 0x8B0000, // rgb(139,0,0) + dark_salmon = 0xE9967A, // rgb(233,150,122) + dark_sea_green = 0x8FBC8F, // rgb(143,188,143) + dark_slate_blue = 0x483D8B, // rgb(72,61,139) + dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) + dark_turquoise = 0x00CED1, // rgb(0,206,209) + dark_violet = 0x9400D3, // rgb(148,0,211) + deep_pink = 0xFF1493, // rgb(255,20,147) + deep_sky_blue = 0x00BFFF, // rgb(0,191,255) + dim_gray = 0x696969, // rgb(105,105,105) + dodger_blue = 0x1E90FF, // rgb(30,144,255) + fire_brick = 0xB22222, // rgb(178,34,34) + floral_white = 0xFFFAF0, // rgb(255,250,240) + forest_green = 0x228B22, // rgb(34,139,34) + fuchsia = 0xFF00FF, // rgb(255,0,255) + gainsboro = 0xDCDCDC, // rgb(220,220,220) + ghost_white = 0xF8F8FF, // rgb(248,248,255) + gold = 0xFFD700, // rgb(255,215,0) + golden_rod = 0xDAA520, // rgb(218,165,32) + gray = 0x808080, // rgb(128,128,128) + green = 0x008000, // rgb(0,128,0) + green_yellow = 0xADFF2F, // rgb(173,255,47) + honey_dew = 0xF0FFF0, // rgb(240,255,240) + hot_pink = 0xFF69B4, // rgb(255,105,180) + indian_red = 0xCD5C5C, // rgb(205,92,92) + indigo = 0x4B0082, // rgb(75,0,130) + ivory = 0xFFFFF0, // rgb(255,255,240) + khaki = 0xF0E68C, // rgb(240,230,140) + lavender = 0xE6E6FA, // rgb(230,230,250) + lavender_blush = 0xFFF0F5, // rgb(255,240,245) + lawn_green = 0x7CFC00, // rgb(124,252,0) + lemon_chiffon = 0xFFFACD, // rgb(255,250,205) + light_blue = 0xADD8E6, // rgb(173,216,230) + light_coral = 0xF08080, // rgb(240,128,128) + light_cyan = 0xE0FFFF, // rgb(224,255,255) + light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) + light_gray = 0xD3D3D3, // rgb(211,211,211) + light_green = 0x90EE90, // rgb(144,238,144) + light_pink = 0xFFB6C1, // rgb(255,182,193) + light_salmon = 0xFFA07A, // rgb(255,160,122) + light_sea_green = 0x20B2AA, // rgb(32,178,170) + light_sky_blue = 0x87CEFA, // rgb(135,206,250) + light_slate_gray = 0x778899, // rgb(119,136,153) + light_steel_blue = 0xB0C4DE, // rgb(176,196,222) + light_yellow = 0xFFFFE0, // rgb(255,255,224) + lime = 0x00FF00, // rgb(0,255,0) + lime_green = 0x32CD32, // rgb(50,205,50) + linen = 0xFAF0E6, // rgb(250,240,230) + magenta = 0xFF00FF, // rgb(255,0,255) + maroon = 0x800000, // rgb(128,0,0) + medium_aquamarine = 0x66CDAA, // rgb(102,205,170) + medium_blue = 0x0000CD, // rgb(0,0,205) + medium_orchid = 0xBA55D3, // rgb(186,85,211) + medium_purple = 0x9370DB, // rgb(147,112,219) + medium_sea_green = 0x3CB371, // rgb(60,179,113) + medium_slate_blue = 0x7B68EE, // rgb(123,104,238) + medium_spring_green = 0x00FA9A, // rgb(0,250,154) + medium_turquoise = 0x48D1CC, // rgb(72,209,204) + medium_violet_red = 0xC71585, // rgb(199,21,133) + midnight_blue = 0x191970, // rgb(25,25,112) + mint_cream = 0xF5FFFA, // rgb(245,255,250) + misty_rose = 0xFFE4E1, // rgb(255,228,225) + moccasin = 0xFFE4B5, // rgb(255,228,181) + navajo_white = 0xFFDEAD, // rgb(255,222,173) + navy = 0x000080, // rgb(0,0,128) + old_lace = 0xFDF5E6, // rgb(253,245,230) + olive = 0x808000, // rgb(128,128,0) + olive_drab = 0x6B8E23, // rgb(107,142,35) + orange = 0xFFA500, // rgb(255,165,0) + orange_red = 0xFF4500, // rgb(255,69,0) + orchid = 0xDA70D6, // rgb(218,112,214) + pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) + pale_green = 0x98FB98, // rgb(152,251,152) + pale_turquoise = 0xAFEEEE, // rgb(175,238,238) + pale_violet_red = 0xDB7093, // rgb(219,112,147) + papaya_whip = 0xFFEFD5, // rgb(255,239,213) + peach_puff = 0xFFDAB9, // rgb(255,218,185) + peru = 0xCD853F, // rgb(205,133,63) + pink = 0xFFC0CB, // rgb(255,192,203) + plum = 0xDDA0DD, // rgb(221,160,221) + powder_blue = 0xB0E0E6, // rgb(176,224,230) + purple = 0x800080, // rgb(128,0,128) + rebecca_purple = 0x663399, // rgb(102,51,153) + red = 0xFF0000, // rgb(255,0,0) + rosy_brown = 0xBC8F8F, // rgb(188,143,143) + royal_blue = 0x4169E1, // rgb(65,105,225) + saddle_brown = 0x8B4513, // rgb(139,69,19) + salmon = 0xFA8072, // rgb(250,128,114) + sandy_brown = 0xF4A460, // rgb(244,164,96) + sea_green = 0x2E8B57, // rgb(46,139,87) + sea_shell = 0xFFF5EE, // rgb(255,245,238) + sienna = 0xA0522D, // rgb(160,82,45) + silver = 0xC0C0C0, // rgb(192,192,192) + sky_blue = 0x87CEEB, // rgb(135,206,235) + slate_blue = 0x6A5ACD, // rgb(106,90,205) + slate_gray = 0x708090, // rgb(112,128,144) + snow = 0xFFFAFA, // rgb(255,250,250) + spring_green = 0x00FF7F, // rgb(0,255,127) + steel_blue = 0x4682B4, // rgb(70,130,180) + tan = 0xD2B48C, // rgb(210,180,140) + teal = 0x008080, // rgb(0,128,128) + thistle = 0xD8BFD8, // rgb(216,191,216) + tomato = 0xFF6347, // rgb(255,99,71) + turquoise = 0x40E0D0, // rgb(64,224,208) + violet = 0xEE82EE, // rgb(238,130,238) + wheat = 0xF5DEB3, // rgb(245,222,179) + white = 0xFFFFFF, // rgb(255,255,255) + white_smoke = 0xF5F5F5, // rgb(245,245,245) + yellow = 0xFFFF00, // rgb(255,255,0) + yellow_green = 0x9ACD32 // rgb(154,205,50) +}; // enum class color + +enum class terminal_color : uint8_t { + black = 30, + red, + green, + yellow, + blue, + magenta, + cyan, + white, + bright_black = 90, + bright_red, + bright_green, + bright_yellow, + bright_blue, + bright_magenta, + bright_cyan, + bright_white +}; enum class emphasis : uint8_t { - bold = 1, - faint = 1 << 1, - italic = 1 << 2, - underline = 1 << 3, - blink = 1 << 4, - reverse = 1 << 5, - conceal = 1 << 6, - strikethrough = 1 << 7, + bold = 1, + faint = 1 << 1, + italic = 1 << 2, + underline = 1 << 3, + blink = 1 << 4, + reverse = 1 << 5, + conceal = 1 << 6, + strikethrough = 1 << 7, }; // rgb is a struct for red, green and blue colors. // Using the name "rgb" makes some editors show the color in a tooltip. struct rgb { - FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} - FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} - FMT_CONSTEXPR rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} - FMT_CONSTEXPR rgb(color hex) : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF) {} - uint8_t r; - uint8_t g; - uint8_t b; + FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} + FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} + FMT_CONSTEXPR rgb(uint32_t hex) + : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} + FMT_CONSTEXPR rgb(color hex) + : r((uint32_t(hex) >> 16) & 0xFF), + g((uint32_t(hex) >> 8) & 0xFF), + b(uint32_t(hex) & 0xFF) {} + uint8_t r; + uint8_t g; + uint8_t b; }; -namespace detail -{ - - // color is a struct of either a rgb color or a terminal color. - struct color_type { - FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {} - FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = static_cast(rgb_color); } - FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = (static_cast(rgb_color.r) << 16) | (static_cast(rgb_color.g) << 8) | rgb_color.b; } - FMT_CONSTEXPR color_type(terminal_color term_color) noexcept : is_rgb(), value{} { value.term_color = static_cast(term_color); } - bool is_rgb; - union color_union { - uint8_t term_color; - uint32_t rgb_color; - } value; - }; -} // namespace detail +namespace detail { + +// color is a struct of either a rgb color or a terminal color. +struct color_type { + FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {} + FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} { + value.rgb_color = static_cast(rgb_color); + } + FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} { + value.rgb_color = (static_cast(rgb_color.r) << 16) | + (static_cast(rgb_color.g) << 8) | rgb_color.b; + } + FMT_CONSTEXPR color_type(terminal_color term_color) noexcept + : is_rgb(), value{} { + value.term_color = static_cast(term_color); + } + bool is_rgb; + union color_union { + uint8_t term_color; + uint32_t rgb_color; + } value; +}; +} // namespace detail /** A text style consisting of foreground and background colors and emphasis. */ class text_style { -public: - FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : set_foreground_color(), set_background_color(), ems(em) {} - - FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& - { - if (!set_foreground_color) - { - set_foreground_color = rhs.set_foreground_color; - foreground_color = rhs.foreground_color; - } - else if (rhs.set_foreground_color) - { - if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) - FMT_THROW(format_error("can't OR a terminal color")); - foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; - } - - if (!set_background_color) - { - set_background_color = rhs.set_background_color; - background_color = rhs.background_color; - } - else if (rhs.set_background_color) - { - if (!background_color.is_rgb || !rhs.background_color.is_rgb) - FMT_THROW(format_error("can't OR a terminal color")); - background_color.value.rgb_color |= rhs.background_color.value.rgb_color; - } - - ems = static_cast(static_cast(ems) | static_cast(rhs.ems)); - return *this; + public: + FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept + : set_foreground_color(), set_background_color(), ems(em) {} + + FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& { + if (!set_foreground_color) { + set_foreground_color = rhs.set_foreground_color; + foreground_color = rhs.foreground_color; + } else if (rhs.set_foreground_color) { + if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) + FMT_THROW(format_error("can't OR a terminal color")); + foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; } - friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) -> text_style { return lhs |= rhs; } - - FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return set_foreground_color; } - FMT_CONSTEXPR auto has_background() const noexcept -> bool { return set_background_color; } - FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return static_cast(ems) != 0; } - FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type - { - FMT_ASSERT(has_foreground(), "no foreground specified for this style"); - return foreground_color; - } - FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type - { - FMT_ASSERT(has_background(), "no background specified for this style"); - return background_color; - } - FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis - { - FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); - return ems; + if (!set_background_color) { + set_background_color = rhs.set_background_color; + background_color = rhs.background_color; + } else if (rhs.set_background_color) { + if (!background_color.is_rgb || !rhs.background_color.is_rgb) + FMT_THROW(format_error("can't OR a terminal color")); + background_color.value.rgb_color |= rhs.background_color.value.rgb_color; } -private: - FMT_CONSTEXPR text_style(bool is_foreground, detail::color_type text_color) noexcept : set_foreground_color(), set_background_color(), ems() - { - if (is_foreground) - { - foreground_color = text_color; - set_foreground_color = true; - } - else - { - background_color = text_color; - set_background_color = true; - } + ems = static_cast(static_cast(ems) | + static_cast(rhs.ems)); + return *this; + } + + friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) + -> text_style { + return lhs |= rhs; + } + + FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { + return set_foreground_color; + } + FMT_CONSTEXPR auto has_background() const noexcept -> bool { + return set_background_color; + } + FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { + return static_cast(ems) != 0; + } + FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { + FMT_ASSERT(has_foreground(), "no foreground specified for this style"); + return foreground_color; + } + FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { + FMT_ASSERT(has_background(), "no background specified for this style"); + return background_color; + } + FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { + FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); + return ems; + } + + private: + FMT_CONSTEXPR text_style(bool is_foreground, + detail::color_type text_color) noexcept + : set_foreground_color(), set_background_color(), ems() { + if (is_foreground) { + foreground_color = text_color; + set_foreground_color = true; + } else { + background_color = text_color; + set_background_color = true; } + } - friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept -> text_style; + friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept + -> text_style; - friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept -> text_style; + friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept + -> text_style; - detail::color_type foreground_color; - detail::color_type background_color; - bool set_foreground_color; - bool set_background_color; - emphasis ems; + detail::color_type foreground_color; + detail::color_type background_color; + bool set_foreground_color; + bool set_background_color; + emphasis ems; }; /** Creates a text style from the foreground (text) color. */ -FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept -> text_style { return text_style(true, foreground); } +FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept + -> text_style { + return text_style(true, foreground); +} /** Creates a text style from the background color. */ -FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept -> text_style { return text_style(false, background); } - -FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept -> text_style { return text_style(lhs) | rhs; } - -namespace detail -{ - - template - struct ansi_color_escape { - FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, const char* esc) noexcept - { - // If we have a terminal color, we need to output another escape code - // sequence. - if (!text_color.is_rgb) - { - bool is_background = esc == string_view("\x1b[48;2;"); - uint32_t value = text_color.value.term_color; - // Background ASCII codes are the same as the foreground ones but with - // 10 more. - if (is_background) - value += 10u; - - size_t index = 0; - buffer[index++] = static_cast('\x1b'); - buffer[index++] = static_cast('['); - - if (value >= 100u) - { - buffer[index++] = static_cast('1'); - value %= 100u; - } - buffer[index++] = static_cast('0' + value / 10u); - buffer[index++] = static_cast('0' + value % 10u); - - buffer[index++] = static_cast('m'); - buffer[index++] = static_cast('\0'); - return; - } - - for (int i = 0; i < 7; i++) - { - buffer[i] = static_cast(esc[i]); - } - rgb color(text_color.value.rgb_color); - to_esc(color.r, buffer + 7, ';'); - to_esc(color.g, buffer + 11, ';'); - to_esc(color.b, buffer + 15, 'm'); - buffer[19] = static_cast(0); - } - FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept - { - uint8_t em_codes[num_emphases] = {}; - if (has_emphasis(em, emphasis::bold)) - em_codes[0] = 1; - if (has_emphasis(em, emphasis::faint)) - em_codes[1] = 2; - if (has_emphasis(em, emphasis::italic)) - em_codes[2] = 3; - if (has_emphasis(em, emphasis::underline)) - em_codes[3] = 4; - if (has_emphasis(em, emphasis::blink)) - em_codes[4] = 5; - if (has_emphasis(em, emphasis::reverse)) - em_codes[5] = 7; - if (has_emphasis(em, emphasis::conceal)) - em_codes[6] = 8; - if (has_emphasis(em, emphasis::strikethrough)) - em_codes[7] = 9; - - size_t index = 0; - for (size_t i = 0; i < num_emphases; ++i) - { - if (!em_codes[i]) - continue; - buffer[index++] = static_cast('\x1b'); - buffer[index++] = static_cast('['); - buffer[index++] = static_cast('0' + em_codes[i]); - buffer[index++] = static_cast('m'); - } - buffer[index++] = static_cast(0); - } - FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } - - FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } - FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* { return buffer + std::char_traits::length(buffer); } - - private: - static constexpr size_t num_emphases = 8; - Char buffer[7u + 3u * num_emphases + 1u]; - - static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, char delimiter) noexcept - { - out[0] = static_cast('0' + c / 100); - out[1] = static_cast('0' + c / 10 % 10); - out[2] = static_cast('0' + c % 10); - out[3] = static_cast(delimiter); - } - static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept -> bool { return static_cast(em) & static_cast(mask); } - }; - - template - FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept -> ansi_color_escape - { - return ansi_color_escape(foreground, "\x1b[38;2;"); - } +FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept + -> text_style { + return text_style(false, background); +} - template - FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept -> ansi_color_escape - { - return ansi_color_escape(background, "\x1b[48;2;"); - } +FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept + -> text_style { + return text_style(lhs) | rhs; +} - template - FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept -> ansi_color_escape - { - return ansi_color_escape(em); +namespace detail { + +template struct ansi_color_escape { + FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, + const char* esc) noexcept { + // If we have a terminal color, we need to output another escape code + // sequence. + if (!text_color.is_rgb) { + bool is_background = esc == string_view("\x1b[48;2;"); + uint32_t value = text_color.value.term_color; + // Background ASCII codes are the same as the foreground ones but with + // 10 more. + if (is_background) value += 10u; + + size_t index = 0; + buffer[index++] = static_cast('\x1b'); + buffer[index++] = static_cast('['); + + if (value >= 100u) { + buffer[index++] = static_cast('1'); + value %= 100u; + } + buffer[index++] = static_cast('0' + value / 10u); + buffer[index++] = static_cast('0' + value % 10u); + + buffer[index++] = static_cast('m'); + buffer[index++] = static_cast('\0'); + return; } - template - inline void reset_color(buffer& buffer) - { - auto reset_color = string_view("\x1b[0m"); - buffer.append(reset_color.begin(), reset_color.end()); + for (int i = 0; i < 7; i++) { + buffer[i] = static_cast(esc[i]); } - - template - struct styled_arg : detail::view { - const T& value; - text_style style; - styled_arg(const T& v, text_style s) : value(v), style(s) {} - }; - - template - void vformat_to(buffer& buf, const text_style& ts, basic_string_view format_str, basic_format_args>> args) - { - bool has_style = false; - if (ts.has_emphasis()) - { - has_style = true; - auto emphasis = detail::make_emphasis(ts.get_emphasis()); - buf.append(emphasis.begin(), emphasis.end()); - } - if (ts.has_foreground()) - { - has_style = true; - auto foreground = detail::make_foreground_color(ts.get_foreground()); - buf.append(foreground.begin(), foreground.end()); - } - if (ts.has_background()) - { - has_style = true; - auto background = detail::make_background_color(ts.get_background()); - buf.append(background.begin(), background.end()); - } - detail::vformat_to(buf, format_str, args, {}); - if (has_style) - detail::reset_color(buf); + rgb color(text_color.value.rgb_color); + to_esc(color.r, buffer + 7, ';'); + to_esc(color.g, buffer + 11, ';'); + to_esc(color.b, buffer + 15, 'm'); + buffer[19] = static_cast(0); + } + FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept { + uint8_t em_codes[num_emphases] = {}; + if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1; + if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2; + if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3; + if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4; + if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5; + if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7; + if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8; + if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9; + + size_t index = 0; + for (size_t i = 0; i < num_emphases; ++i) { + if (!em_codes[i]) continue; + buffer[index++] = static_cast('\x1b'); + buffer[index++] = static_cast('['); + buffer[index++] = static_cast('0' + em_codes[i]); + buffer[index++] = static_cast('m'); } + buffer[index++] = static_cast(0); + } + FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } + + FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } + FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* { + return buffer + std::char_traits::length(buffer); + } + + private: + static constexpr size_t num_emphases = 8; + Char buffer[7u + 3u * num_emphases + 1u]; + + static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, + char delimiter) noexcept { + out[0] = static_cast('0' + c / 100); + out[1] = static_cast('0' + c / 10 % 10); + out[2] = static_cast('0' + c % 10); + out[3] = static_cast(delimiter); + } + static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept + -> bool { + return static_cast(em) & static_cast(mask); + } +}; -} // namespace detail - -inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, format_args args) -{ - // Legacy wide streams are not supported. - auto buf = memory_buffer(); - detail::vformat_to(buf, ts, fmt, args); - if (detail::is_utf8()) - { - detail::print(f, string_view(buf.begin(), buf.size())); - return; - } - buf.push_back('\0'); - int result = std::fputs(buf.data(), f); - if (result < 0) - FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); +template +FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept + -> ansi_color_escape { + return ansi_color_escape(foreground, "\x1b[38;2;"); +} + +template +FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept + -> ansi_color_escape { + return ansi_color_escape(background, "\x1b[48;2;"); +} + +template +FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept + -> ansi_color_escape { + return ansi_color_escape(em); +} + +template inline void reset_color(buffer& buffer) { + auto reset_color = string_view("\x1b[0m"); + buffer.append(reset_color.begin(), reset_color.end()); +} + +template struct styled_arg : detail::view { + const T& value; + text_style style; + styled_arg(const T& v, text_style s) : value(v), style(s) {} +}; + +template +void vformat_to(buffer& buf, const text_style& ts, + basic_string_view format_str, + basic_format_args>> args) { + bool has_style = false; + if (ts.has_emphasis()) { + has_style = true; + auto emphasis = detail::make_emphasis(ts.get_emphasis()); + buf.append(emphasis.begin(), emphasis.end()); + } + if (ts.has_foreground()) { + has_style = true; + auto foreground = detail::make_foreground_color(ts.get_foreground()); + buf.append(foreground.begin(), foreground.end()); + } + if (ts.has_background()) { + has_style = true; + auto background = detail::make_background_color(ts.get_background()); + buf.append(background.begin(), background.end()); + } + detail::vformat_to(buf, format_str, args, {}); + if (has_style) detail::reset_color(buf); +} + +} // namespace detail + +inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, + format_args args) { + // Legacy wide streams are not supported. + auto buf = memory_buffer(); + detail::vformat_to(buf, ts, fmt, args); + if (detail::is_utf8()) { + detail::print(f, string_view(buf.begin(), buf.size())); + return; + } + buf.push_back('\0'); + int result = std::fputs(buf.data(), f); + if (result < 0) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } /** @@ -473,10 +492,12 @@ inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, format_a "Elapsed time: {0:.2f} seconds", 1.23); \endrst */ -template ::value)> -void print(std::FILE* f, const text_style& ts, const S& format_str, const Args&... args) -{ - vprint(f, ts, format_str, fmt::make_format_args>>(args...)); +template ::value)> +void print(std::FILE* f, const text_style& ts, const S& format_str, + const Args&... args) { + vprint(f, ts, format_str, + fmt::make_format_args>>(args...)); } /** @@ -490,18 +511,20 @@ void print(std::FILE* f, const text_style& ts, const S& format_str, const Args&. "Elapsed time: {0:.2f} seconds", 1.23); \endrst */ -template ::value)> -void print(const text_style& ts, const S& format_str, const Args&... args) -{ - return print(stdout, ts, format_str, args...); +template ::value)> +void print(const text_style& ts, const S& format_str, const Args&... args) { + return print(stdout, ts, format_str, args...); } template > -inline auto vformat(const text_style& ts, const S& format_str, basic_format_args>> args) -> std::basic_string -{ - basic_memory_buffer buf; - detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); - return fmt::to_string(buf); +inline auto vformat( + const text_style& ts, const S& format_str, + basic_format_args>> args) + -> std::basic_string { + basic_memory_buffer buf; + detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); + return fmt::to_string(buf); } /** @@ -517,20 +540,24 @@ inline auto vformat(const text_style& ts, const S& format_str, basic_format_args \endrst */ template > -inline auto format(const text_style& ts, const S& format_str, const Args&... args) -> std::basic_string -{ - return fmt::vformat(ts, detail::to_string_view(format_str), fmt::make_format_args>(args...)); +inline auto format(const text_style& ts, const S& format_str, + const Args&... args) -> std::basic_string { + return fmt::vformat(ts, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } /** Formats a string with the given text_style and writes the output to ``out``. */ -template ::value)> -auto vformat_to(OutputIt out, const text_style& ts, basic_string_view format_str, basic_format_args>> args) -> OutputIt -{ - auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, ts, format_str, args); - return detail::get_iterator(buf, out); +template ::value)> +auto vformat_to(OutputIt out, const text_style& ts, + basic_string_view format_str, + basic_format_args>> args) + -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, ts, format_str, args); + return detail::get_iterator(buf, out); } /** @@ -545,48 +572,51 @@ auto vformat_to(OutputIt out, const text_style& ts, basic_string_view form fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); \endrst */ -template >::value && detail::is_string::value> -inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, Args&&... args) -> typename std::enable_if::type -{ - return vformat_to(out, ts, detail::to_string_view(format_str), fmt::make_format_args>>(args...)); +template < + typename OutputIt, typename S, typename... Args, + bool enable = detail::is_output_iterator>::value && + detail::is_string::value> +inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, + Args&&... args) -> + typename std::enable_if::type { + return vformat_to(out, ts, detail::to_string_view(format_str), + fmt::make_format_args>>(args...)); } template struct formatter, Char> : formatter { - template - auto format(const detail::styled_arg& arg, FormatContext& ctx) const -> decltype(ctx.out()) - { - const auto& ts = arg.style; - const auto& value = arg.value; - auto out = ctx.out(); - - bool has_style = false; - if (ts.has_emphasis()) - { - has_style = true; - auto emphasis = detail::make_emphasis(ts.get_emphasis()); - out = std::copy(emphasis.begin(), emphasis.end(), out); - } - if (ts.has_foreground()) - { - has_style = true; - auto foreground = detail::make_foreground_color(ts.get_foreground()); - out = std::copy(foreground.begin(), foreground.end(), out); - } - if (ts.has_background()) - { - has_style = true; - auto background = detail::make_background_color(ts.get_background()); - out = std::copy(background.begin(), background.end(), out); - } - out = formatter::format(value, ctx); - if (has_style) - { - auto reset_color = string_view("\x1b[0m"); - out = std::copy(reset_color.begin(), reset_color.end(), out); - } - return out; + template + auto format(const detail::styled_arg& arg, FormatContext& ctx) const + -> decltype(ctx.out()) { + const auto& ts = arg.style; + const auto& value = arg.value; + auto out = ctx.out(); + + bool has_style = false; + if (ts.has_emphasis()) { + has_style = true; + auto emphasis = detail::make_emphasis(ts.get_emphasis()); + out = std::copy(emphasis.begin(), emphasis.end(), out); + } + if (ts.has_foreground()) { + has_style = true; + auto foreground = + detail::make_foreground_color(ts.get_foreground()); + out = std::copy(foreground.begin(), foreground.end(), out); + } + if (ts.has_background()) { + has_style = true; + auto background = + detail::make_background_color(ts.get_background()); + out = std::copy(background.begin(), background.end(), out); + } + out = formatter::format(value, ctx); + if (has_style) { + auto reset_color = string_view("\x1b[0m"); + out = std::copy(reset_color.begin(), reset_color.end(), out); } + return out; + } }; /** @@ -602,12 +632,12 @@ struct formatter, Char> : formatter { \endrst */ template -FMT_CONSTEXPR auto styled(const T& value, text_style ts) -> detail::styled_arg> -{ - return detail::styled_arg>{value, ts}; +FMT_CONSTEXPR auto styled(const T& value, text_style ts) + -> detail::styled_arg> { + return detail::styled_arg>{value, ts}; } FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_COLOR_H_ +#endif // FMT_COLOR_H_ diff --git a/lib/spdlog/fmt/bundled/compile.h b/lib/spdlog/fmt/bundled/compile.h index 80ca8536..3b3f166e 100644 --- a/lib/spdlog/fmt/bundled/compile.h +++ b/lib/spdlog/fmt/bundled/compile.h @@ -11,20 +11,19 @@ #include "format.h" FMT_BEGIN_NAMESPACE -namespace detail -{ +namespace detail { - template - FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end, counting_iterator it) -> counting_iterator - { - return it + (end - begin); - } +template +FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end, + counting_iterator it) -> counting_iterator { + return it + (end - begin); +} - // A compile-time string which is compiled into fast formatting code. - class compiled_string {}; +// A compile-time string which is compiled into fast formatting code. +class compiled_string {}; - template - struct is_compiled_string : std::is_base_of {}; +template +struct is_compiled_string : std::is_base_of {}; /** \rst @@ -40,531 +39,497 @@ namespace detail \endrst */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -#define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) +# define FMT_COMPILE(s) \ + FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) #else -#define FMT_COMPILE(s) FMT_STRING(s) +# define FMT_COMPILE(s) FMT_STRING(s) #endif #if FMT_USE_NONTYPE_TEMPLATE_ARGS - template Str> - struct udl_compiled_string : compiled_string { - using char_type = Char; - explicit constexpr operator basic_string_view() const { return {Str.data, N - 1}; } - }; +template Str> +struct udl_compiled_string : compiled_string { + using char_type = Char; + explicit constexpr operator basic_string_view() const { + return {Str.data, N - 1}; + } +}; #endif - template - auto first(const T& value, const Tail&...) -> const T& - { - return value; - } +template +auto first(const T& value, const Tail&...) -> const T& { + return value; +} #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) - template - struct type_list {}; - - // Returns a reference to the argument at index N from [first, rest...]. - template - constexpr const auto& get([[maybe_unused]] const T& first, [[maybe_unused]] const Args&... rest) - { - static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); - if constexpr (N == 0) - return first; - else - return detail::get(rest...); - } - - template - constexpr int get_arg_index_by_name(basic_string_view name, type_list) - { - return get_arg_index_by_name(name); - } - - template - struct get_type_impl; +template struct type_list {}; + +// Returns a reference to the argument at index N from [first, rest...]. +template +constexpr const auto& get([[maybe_unused]] const T& first, + [[maybe_unused]] const Args&... rest) { + static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); + if constexpr (N == 0) + return first; + else + return detail::get(rest...); +} - template - struct get_type_impl> { - using type = remove_cvref_t(std::declval()...))>; - }; +template +constexpr int get_arg_index_by_name(basic_string_view name, + type_list) { + return get_arg_index_by_name(name); +} - template - using get_type = typename get_type_impl::type; +template struct get_type_impl; - template - struct is_compiled_format : std::false_type {}; +template struct get_type_impl> { + using type = + remove_cvref_t(std::declval()...))>; +}; - template - struct text { - basic_string_view data; - using char_type = Char; +template +using get_type = typename get_type_impl::type; - template - constexpr OutputIt format(OutputIt out, const Args&...) const - { - return write(out, data); - } - }; +template struct is_compiled_format : std::false_type {}; - template - struct is_compiled_format> : std::true_type {}; +template struct text { + basic_string_view data; + using char_type = Char; - template - constexpr text make_text(basic_string_view s, size_t pos, size_t size) - { - return {{&s[pos], size}}; - } + template + constexpr OutputIt format(OutputIt out, const Args&...) const { + return write(out, data); + } +}; - template - struct code_unit { - Char value; - using char_type = Char; +template +struct is_compiled_format> : std::true_type {}; - template - constexpr OutputIt format(OutputIt out, const Args&...) const - { - *out++ = value; - return out; - } - }; - - // This ensures that the argument type is convertible to `const T&`. - template - constexpr const T& get_arg_checked(const Args&... args) - { - const auto& arg = detail::get(args...); - if constexpr (detail::is_named_arg>()) - { - return arg.value; - } - else - { - return arg; - } - } +template +constexpr text make_text(basic_string_view s, size_t pos, + size_t size) { + return {{&s[pos], size}}; +} - template - struct is_compiled_format> : std::true_type {}; - - // A replacement field that refers to argument N. - template - struct field { - using char_type = Char; - - template - constexpr OutputIt format(OutputIt out, const Args&... args) const - { - const T& arg = get_arg_checked(args...); - if constexpr (std::is_convertible_v>) - { - auto s = basic_string_view(arg); - return copy_str(s.begin(), s.end(), out); - } - return write(out, arg); - } - }; - - template - struct is_compiled_format> : std::true_type {}; - - // A replacement field that refers to argument with name. - template - struct runtime_named_field { - using char_type = Char; - basic_string_view name; - - template - constexpr static bool try_format_argument(OutputIt& out, - // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 - [[maybe_unused]] basic_string_view arg_name, const T& arg) - { - if constexpr (is_named_arg::type>::value) - { - if (arg_name == arg.name) - { - out = write(out, arg.value); - return true; - } - } - return false; - } +template struct code_unit { + Char value; + using char_type = Char; + + template + constexpr OutputIt format(OutputIt out, const Args&...) const { + *out++ = value; + return out; + } +}; + +// This ensures that the argument type is convertible to `const T&`. +template +constexpr const T& get_arg_checked(const Args&... args) { + const auto& arg = detail::get(args...); + if constexpr (detail::is_named_arg>()) { + return arg.value; + } else { + return arg; + } +} - template - constexpr OutputIt format(OutputIt out, const Args&... args) const - { - bool found = (try_format_argument(out, name, args) || ...); - if (!found) - { - FMT_THROW(format_error("argument with specified name is not found")); - } - return out; - } - }; - - template - struct is_compiled_format> : std::true_type {}; - - // A replacement field that refers to argument N and has format specifiers. - template - struct spec_field { - using char_type = Char; - formatter fmt; - - template - constexpr FMT_INLINE OutputIt format(OutputIt out, const Args&... args) const - { - const auto& vargs = fmt::make_format_args>(args...); - basic_format_context ctx(out, vargs); - return fmt.format(get_arg_checked(args...), ctx); - } - }; - - template - struct is_compiled_format> : std::true_type {}; - - template - struct concat { - L lhs; - R rhs; - using char_type = typename L::char_type; - - template - constexpr OutputIt format(OutputIt out, const Args&... args) const - { - out = lhs.format(out, args...); - return rhs.format(out, args...); - } - }; +template +struct is_compiled_format> : std::true_type {}; - template - struct is_compiled_format> : std::true_type {}; +// A replacement field that refers to argument N. +template struct field { + using char_type = Char; - template - constexpr concat make_concat(L lhs, R rhs) - { - return {lhs, rhs}; + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + const T& arg = get_arg_checked(args...); + if constexpr (std::is_convertible_v>) { + auto s = basic_string_view(arg); + return copy_str(s.begin(), s.end(), out); + } + return write(out, arg); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +// A replacement field that refers to argument with name. +template struct runtime_named_field { + using char_type = Char; + basic_string_view name; + + template + constexpr static bool try_format_argument( + OutputIt& out, + // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 + [[maybe_unused]] basic_string_view arg_name, const T& arg) { + if constexpr (is_named_arg::type>::value) { + if (arg_name == arg.name) { + out = write(out, arg.value); + return true; + } } + return false; + } + + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + bool found = (try_format_argument(out, name, args) || ...); + if (!found) { + FMT_THROW(format_error("argument with specified name is not found")); + } + return out; + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +// A replacement field that refers to argument N and has format specifiers. +template struct spec_field { + using char_type = Char; + formatter fmt; + + template + constexpr FMT_INLINE OutputIt format(OutputIt out, + const Args&... args) const { + const auto& vargs = + fmt::make_format_args>(args...); + basic_format_context ctx(out, vargs); + return fmt.format(get_arg_checked(args...), ctx); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +template struct concat { + L lhs; + R rhs; + using char_type = typename L::char_type; + + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + out = lhs.format(out, args...); + return rhs.format(out, args...); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +template +constexpr concat make_concat(L lhs, R rhs) { + return {lhs, rhs}; +} - struct unknown_format {}; +struct unknown_format {}; - template - constexpr size_t parse_text(basic_string_view str, size_t pos) - { - for (size_t size = str.size(); pos != size; ++pos) - { - if (str[pos] == '{' || str[pos] == '}') - break; - } - return pos; - } +template +constexpr size_t parse_text(basic_string_view str, size_t pos) { + for (size_t size = str.size(); pos != size; ++pos) { + if (str[pos] == '{' || str[pos] == '}') break; + } + return pos; +} - template - constexpr auto compile_format_string(S format_str); - - template - constexpr auto parse_tail(T head, S format_str) - { - if constexpr (POS != basic_string_view(format_str).size()) - { - constexpr auto tail = compile_format_string(format_str); - if constexpr (std::is_same, unknown_format>()) - return tail; - else - return make_concat(head, tail); - } - else - { - return head; - } - } +template +constexpr auto compile_format_string(S format_str); + +template +constexpr auto parse_tail(T head, S format_str) { + if constexpr (POS != + basic_string_view(format_str).size()) { + constexpr auto tail = compile_format_string(format_str); + if constexpr (std::is_same, + unknown_format>()) + return tail; + else + return make_concat(head, tail); + } else { + return head; + } +} - template - struct parse_specs_result { - formatter fmt; - size_t end; - int next_arg_id; - }; - - enum { manual_indexing_id = -1 }; - - template - constexpr parse_specs_result parse_specs(basic_string_view str, size_t pos, int next_arg_id) - { - str.remove_prefix(pos); - auto ctx = compile_parse_context(str, max_value(), nullptr, next_arg_id); - auto f = formatter(); - auto end = f.parse(ctx); - return {f, pos + fmt::detail::to_unsigned(end - str.data()), next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; - } +template struct parse_specs_result { + formatter fmt; + size_t end; + int next_arg_id; +}; + +enum { manual_indexing_id = -1 }; + +template +constexpr parse_specs_result parse_specs(basic_string_view str, + size_t pos, int next_arg_id) { + str.remove_prefix(pos); + auto ctx = + compile_parse_context(str, max_value(), nullptr, next_arg_id); + auto f = formatter(); + auto end = f.parse(ctx); + return {f, pos + fmt::detail::to_unsigned(end - str.data()), + next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; +} - template - struct arg_id_handler { - arg_ref arg_id; +template struct arg_id_handler { + arg_ref arg_id; + + constexpr int on_auto() { + FMT_ASSERT(false, "handler cannot be used with automatic indexing"); + return 0; + } + constexpr int on_index(int id) { + arg_id = arg_ref(id); + return 0; + } + constexpr int on_name(basic_string_view id) { + arg_id = arg_ref(id); + return 0; + } +}; + +template struct parse_arg_id_result { + arg_ref arg_id; + const Char* arg_id_end; +}; + +template +constexpr auto parse_arg_id(const Char* begin, const Char* end) { + auto handler = arg_id_handler{arg_ref{}}; + auto arg_id_end = parse_arg_id(begin, end, handler); + return parse_arg_id_result{handler.arg_id, arg_id_end}; +} - constexpr int on_auto() - { - FMT_ASSERT(false, "handler cannot be used with automatic indexing"); - return 0; - } - constexpr int on_index(int id) - { - arg_id = arg_ref(id); - return 0; - } - constexpr int on_name(basic_string_view id) - { - arg_id = arg_ref(id); - return 0; - } - }; - - template - struct parse_arg_id_result { - arg_ref arg_id; - const Char* arg_id_end; - }; - - template - constexpr auto parse_arg_id(const Char* begin, const Char* end) - { - auto handler = arg_id_handler{arg_ref{}}; - auto arg_id_end = parse_arg_id(begin, end, handler); - return parse_arg_id_result{handler.arg_id, arg_id_end}; +template struct field_type { + using type = remove_cvref_t; +}; + +template +struct field_type::value>> { + using type = remove_cvref_t; +}; + +template +constexpr auto parse_replacement_field_then_tail(S format_str) { + using char_type = typename S::char_type; + constexpr auto str = basic_string_view(format_str); + constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); + if constexpr (c == '}') { + return parse_tail( + field::type, ARG_INDEX>(), + format_str); + } else if constexpr (c != ':') { + FMT_THROW(format_error("expected ':'")); + } else { + constexpr auto result = parse_specs::type>( + str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); + if constexpr (result.end >= str.size() || str[result.end] != '}') { + FMT_THROW(format_error("expected '}'")); + return 0; + } else { + return parse_tail( + spec_field::type, ARG_INDEX>{ + result.fmt}, + format_str); } + } +} - template - struct field_type { - using type = remove_cvref_t; - }; - - template - struct field_type::value>> { - using type = remove_cvref_t; - }; - - template - constexpr auto parse_replacement_field_then_tail(S format_str) - { - using char_type = typename S::char_type; - constexpr auto str = basic_string_view(format_str); - constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); - if constexpr (c == '}') - { - return parse_tail(field::type, ARG_INDEX>(), format_str); - } - else if constexpr (c != ':') - { - FMT_THROW(format_error("expected ':'")); - } - else - { - constexpr auto result = parse_specs::type>(str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); - if constexpr (result.end >= str.size() || str[result.end] != '}') - { - FMT_THROW(format_error("expected '}'")); - return 0; - } - else - { - return parse_tail(spec_field::type, ARG_INDEX>{result.fmt}, format_str); - } +// Compiles a non-empty format string and returns the compiled representation +// or unknown_format() on unrecognized input. +template +constexpr auto compile_format_string(S format_str) { + using char_type = typename S::char_type; + constexpr auto str = basic_string_view(format_str); + if constexpr (str[POS] == '{') { + if constexpr (POS + 1 == str.size()) + FMT_THROW(format_error("unmatched '{' in format string")); + if constexpr (str[POS + 1] == '{') { + return parse_tail(make_text(str, POS, 1), format_str); + } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { + static_assert(ID != manual_indexing_id, + "cannot switch from manual to automatic argument indexing"); + constexpr auto next_id = + ID != manual_indexing_id ? ID + 1 : manual_indexing_id; + return parse_replacement_field_then_tail, Args, + POS + 1, ID, next_id>( + format_str); + } else { + constexpr auto arg_id_result = + parse_arg_id(str.data() + POS + 1, str.data() + str.size()); + constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); + constexpr char_type c = + arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); + static_assert(c == '}' || c == ':', "missing '}' in format string"); + if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) { + static_assert( + ID == manual_indexing_id || ID == 0, + "cannot switch from automatic to manual argument indexing"); + constexpr auto arg_index = arg_id_result.arg_id.val.index; + return parse_replacement_field_then_tail, + Args, arg_id_end_pos, + arg_index, manual_indexing_id>( + format_str); + } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { + constexpr auto arg_index = + get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); + if constexpr (arg_index >= 0) { + constexpr auto next_id = + ID != manual_indexing_id ? ID + 1 : manual_indexing_id; + return parse_replacement_field_then_tail< + decltype(get_type::value), Args, arg_id_end_pos, + arg_index, next_id>(format_str); + } else if constexpr (c == '}') { + return parse_tail( + runtime_named_field{arg_id_result.arg_id.val.name}, + format_str); + } else if constexpr (c == ':') { + return unknown_format(); // no type info for specs parsing } + } } - - // Compiles a non-empty format string and returns the compiled representation - // or unknown_format() on unrecognized input. - template - constexpr auto compile_format_string(S format_str) - { - using char_type = typename S::char_type; - constexpr auto str = basic_string_view(format_str); - if constexpr (str[POS] == '{') - { - if constexpr (POS + 1 == str.size()) - FMT_THROW(format_error("unmatched '{' in format string")); - if constexpr (str[POS + 1] == '{') - { - return parse_tail(make_text(str, POS, 1), format_str); - } - else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') - { - static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); - constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; - return parse_replacement_field_then_tail, Args, POS + 1, ID, next_id>(format_str); - } - else - { - constexpr auto arg_id_result = parse_arg_id(str.data() + POS + 1, str.data() + str.size()); - constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); - constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); - static_assert(c == '}' || c == ':', "missing '}' in format string"); - if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) - { - static_assert(ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing"); - constexpr auto arg_index = arg_id_result.arg_id.val.index; - return parse_replacement_field_then_tail, Args, arg_id_end_pos, arg_index, manual_indexing_id>(format_str); - } - else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) - { - constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); - if constexpr (arg_index >= 0) - { - constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; - return parse_replacement_field_then_tail::value), Args, arg_id_end_pos, arg_index, next_id>(format_str); - } - else if constexpr (c == '}') - { - return parse_tail(runtime_named_field{arg_id_result.arg_id.val.name}, format_str); - } - else if constexpr (c == ':') - { - return unknown_format(); // no type info for specs parsing - } - } - } - } - else if constexpr (str[POS] == '}') - { - if constexpr (POS + 1 == str.size()) - FMT_THROW(format_error("unmatched '}' in format string")); - return parse_tail(make_text(str, POS, 1), format_str); - } - else - { - constexpr auto end = parse_text(str, POS + 1); - if constexpr (end - POS > 1) - { - return parse_tail(make_text(str, POS, end - POS), format_str); - } - else - { - return parse_tail(code_unit{str[POS]}, format_str); - } - } + } else if constexpr (str[POS] == '}') { + if constexpr (POS + 1 == str.size()) + FMT_THROW(format_error("unmatched '}' in format string")); + return parse_tail(make_text(str, POS, 1), format_str); + } else { + constexpr auto end = parse_text(str, POS + 1); + if constexpr (end - POS > 1) { + return parse_tail(make_text(str, POS, end - POS), + format_str); + } else { + return parse_tail(code_unit{str[POS]}, + format_str); } + } +} - template ::value)> - constexpr auto compile(S format_str) - { - constexpr auto str = basic_string_view(format_str); - if constexpr (str.size() == 0) - { - return detail::make_text(str, 0, 0); - } - else - { - constexpr auto result = detail::compile_format_string, 0, 0>(format_str); - return result; - } - } -#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -} // namespace detail +template ::value)> +constexpr auto compile(S format_str) { + constexpr auto str = basic_string_view(format_str); + if constexpr (str.size() == 0) { + return detail::make_text(str, 0, 0); + } else { + constexpr auto result = + detail::compile_format_string, 0, 0>( + format_str); + return result; + } +} +#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +} // namespace detail FMT_BEGIN_EXPORT #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) -template ::value)> -FMT_INLINE std::basic_string format(const CompiledFormat& cf, const Args&... args) -{ - auto s = std::basic_string(); - cf.format(std::back_inserter(s), args...); - return s; +template ::value)> +FMT_INLINE std::basic_string format(const CompiledFormat& cf, + const Args&... args) { + auto s = std::basic_string(); + cf.format(std::back_inserter(s), args...); + return s; } -template ::value)> -constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf, const Args&... args) -{ - return cf.format(out, args...); +template ::value)> +constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf, + const Args&... args) { + return cf.format(out, args...); } -template ::value)> -FMT_INLINE std::basic_string format(const S&, Args&&... args) -{ - if constexpr (std::is_same::value) - { - constexpr auto str = basic_string_view(S()); - if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') - { - const auto& first = detail::first(args...); - if constexpr (detail::is_named_arg>::value) - { - return fmt::to_string(first.value); - } - else - { - return fmt::to_string(first); - } - } - } - constexpr auto compiled = detail::compile(S()); - if constexpr (std::is_same, detail::unknown_format>()) - { - return fmt::format(static_cast>(S()), std::forward(args)...); - } - else - { - return fmt::format(compiled, std::forward(args)...); +template ::value)> +FMT_INLINE std::basic_string format(const S&, + Args&&... args) { + if constexpr (std::is_same::value) { + constexpr auto str = basic_string_view(S()); + if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') { + const auto& first = detail::first(args...); + if constexpr (detail::is_named_arg< + remove_cvref_t>::value) { + return fmt::to_string(first.value); + } else { + return fmt::to_string(first); + } } + } + constexpr auto compiled = detail::compile(S()); + if constexpr (std::is_same, + detail::unknown_format>()) { + return fmt::format( + static_cast>(S()), + std::forward(args)...); + } else { + return fmt::format(compiled, std::forward(args)...); + } } -template ::value)> -FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) -{ - constexpr auto compiled = detail::compile(S()); - if constexpr (std::is_same, detail::unknown_format>()) - { - return fmt::format_to(out, static_cast>(S()), std::forward(args)...); - } - else - { - return fmt::format_to(out, compiled, std::forward(args)...); - } +template ::value)> +FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { + constexpr auto compiled = detail::compile(S()); + if constexpr (std::is_same, + detail::unknown_format>()) { + return fmt::format_to( + out, static_cast>(S()), + std::forward(args)...); + } else { + return fmt::format_to(out, compiled, std::forward(args)...); + } } #endif -template ::value)> -auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args) -> format_to_n_result -{ - using traits = detail::fixed_buffer_traits; - auto buf = detail::iterator_buffer(out, n); - fmt::format_to(std::back_inserter(buf), format_str, std::forward(args)...); - return {buf.out(), buf.count()}; +template ::value)> +auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args) + -> format_to_n_result { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer(out, n); + fmt::format_to(std::back_inserter(buf), format_str, + std::forward(args)...); + return {buf.out(), buf.count()}; } -template ::value)> -FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args) -> size_t -{ - return fmt::format_to(detail::counting_iterator(), format_str, args...).count(); +template ::value)> +FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args) + -> size_t { + return fmt::format_to(detail::counting_iterator(), format_str, args...) + .count(); } -template ::value)> -void print(std::FILE* f, const S& format_str, const Args&... args) -{ - memory_buffer buffer; - fmt::format_to(std::back_inserter(buffer), format_str, args...); - detail::print(f, {buffer.data(), buffer.size()}); +template ::value)> +void print(std::FILE* f, const S& format_str, const Args&... args) { + memory_buffer buffer; + fmt::format_to(std::back_inserter(buffer), format_str, args...); + detail::print(f, {buffer.data(), buffer.size()}); } -template ::value)> -void print(const S& format_str, const Args&... args) -{ - print(stdout, format_str, args...); +template ::value)> +void print(const S& format_str, const Args&... args) { + print(stdout, format_str, args...); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS -inline namespace literals -{ - template - constexpr auto operator""_cf() - { - using char_t = remove_cvref_t; - return detail::udl_compiled_string(); - } -} // namespace literals +inline namespace literals { +template constexpr auto operator""_cf() { + using char_t = remove_cvref_t; + return detail::udl_compiled_string(); +} +} // namespace literals #endif FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_COMPILE_H_ +#endif // FMT_COMPILE_H_ diff --git a/lib/spdlog/fmt/bundled/core.h b/lib/spdlog/fmt/bundled/core.h index bbc3b36f..b51c1406 100644 --- a/lib/spdlog/fmt/bundled/core.h +++ b/lib/spdlog/fmt/bundled/core.h @@ -8,12 +8,12 @@ #ifndef FMT_CORE_H_ #define FMT_CORE_H_ -#include // std::byte -#include // std::FILE -#include // std::strlen +#include // std::byte +#include // std::FILE +#include // std::strlen #include #include -#include // std::addressof +#include // std::addressof #include #include @@ -21,223 +21,246 @@ #define FMT_VERSION 100201 #if defined(__clang__) && !defined(__ibmxl__) -#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #else -#define FMT_CLANG_VERSION 0 +# define FMT_CLANG_VERSION 0 #endif -#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__NVCOMPILER) -#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \ + !defined(__NVCOMPILER) +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #else -#define FMT_GCC_VERSION 0 +# define FMT_GCC_VERSION 0 #endif #ifndef FMT_GCC_PRAGMA // Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884. -#if FMT_GCC_VERSION >= 504 -#define FMT_GCC_PRAGMA(arg) _Pragma(arg) -#else -#define FMT_GCC_PRAGMA(arg) -#endif +# if FMT_GCC_VERSION >= 504 +# define FMT_GCC_PRAGMA(arg) _Pragma(arg) +# else +# define FMT_GCC_PRAGMA(arg) +# endif #endif #ifdef __ICL -#define FMT_ICC_VERSION __ICL +# define FMT_ICC_VERSION __ICL #elif defined(__INTEL_COMPILER) -#define FMT_ICC_VERSION __INTEL_COMPILER +# define FMT_ICC_VERSION __INTEL_COMPILER #else -#define FMT_ICC_VERSION 0 +# define FMT_ICC_VERSION 0 #endif #ifdef _MSC_VER -#define FMT_MSC_VERSION _MSC_VER -#define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) +# define FMT_MSC_VERSION _MSC_VER +# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) #else -#define FMT_MSC_VERSION 0 -#define FMT_MSC_WARNING(...) +# define FMT_MSC_VERSION 0 +# define FMT_MSC_WARNING(...) #endif #ifdef _MSVC_LANG -#define FMT_CPLUSPLUS _MSVC_LANG +# define FMT_CPLUSPLUS _MSVC_LANG #else -#define FMT_CPLUSPLUS __cplusplus +# define FMT_CPLUSPLUS __cplusplus #endif #ifdef __has_feature -#define FMT_HAS_FEATURE(x) __has_feature(x) +# define FMT_HAS_FEATURE(x) __has_feature(x) #else -#define FMT_HAS_FEATURE(x) 0 +# define FMT_HAS_FEATURE(x) 0 #endif #if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900 -#define FMT_HAS_INCLUDE(x) __has_include(x) +# define FMT_HAS_INCLUDE(x) __has_include(x) #else -#define FMT_HAS_INCLUDE(x) 0 +# define FMT_HAS_INCLUDE(x) 0 #endif #ifdef __has_cpp_attribute -#define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) #else -#define FMT_HAS_CPP_ATTRIBUTE(x) 0 +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 #endif -#define FMT_HAS_CPP14_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) +#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) -#define FMT_HAS_CPP17_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) +#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) // Check if relaxed C++14 constexpr is supported. // GCC doesn't allow throw in constexpr until version 6 (bug 67371). #ifndef FMT_USE_CONSTEXPR -#if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L) -#define FMT_USE_CONSTEXPR 1 -#else -#define FMT_USE_CONSTEXPR 0 -#endif +# if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \ + (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && \ + !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L) +# define FMT_USE_CONSTEXPR 1 +# else +# define FMT_USE_CONSTEXPR 0 +# endif #endif #if FMT_USE_CONSTEXPR -#define FMT_CONSTEXPR constexpr +# define FMT_CONSTEXPR constexpr #else -#define FMT_CONSTEXPR +# define FMT_CONSTEXPR #endif -#if (FMT_CPLUSPLUS >= 202002L || (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) && ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) && (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) && defined(__cpp_lib_is_constant_evaluated) -#define FMT_CONSTEXPR20 constexpr +#if (FMT_CPLUSPLUS >= 202002L || \ + (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) && \ + ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) && \ + (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \ + (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) && \ + defined(__cpp_lib_is_constant_evaluated) +# define FMT_CONSTEXPR20 constexpr #else -#define FMT_CONSTEXPR20 +# define FMT_CONSTEXPR20 #endif // Check if constexpr std::char_traits<>::{compare,length} are supported. #if defined(__GLIBCXX__) -#if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE. -#define FMT_CONSTEXPR_CHAR_TRAITS constexpr -#endif -#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && _LIBCPP_VERSION >= 4000 -#define FMT_CONSTEXPR_CHAR_TRAITS constexpr +# if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \ + _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE. +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr +# endif +#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \ + _LIBCPP_VERSION >= 4000 +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr #elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L -#define FMT_CONSTEXPR_CHAR_TRAITS constexpr +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr #endif #ifndef FMT_CONSTEXPR_CHAR_TRAITS -#define FMT_CONSTEXPR_CHAR_TRAITS +# define FMT_CONSTEXPR_CHAR_TRAITS #endif // Check if exceptions are disabled. #ifndef FMT_EXCEPTIONS -#if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) -#define FMT_EXCEPTIONS 0 -#else -#define FMT_EXCEPTIONS 1 -#endif +# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ + (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +# else +# define FMT_EXCEPTIONS 1 +# endif #endif // Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. -#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__) -#define FMT_NORETURN [[noreturn]] +#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \ + !defined(__NVCC__) +# define FMT_NORETURN [[noreturn]] #else -#define FMT_NORETURN +# define FMT_NORETURN #endif #ifndef FMT_NODISCARD -#if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) -#define FMT_NODISCARD [[nodiscard]] -#else -#define FMT_NODISCARD -#endif +# if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) +# define FMT_NODISCARD [[nodiscard]] +# else +# define FMT_NODISCARD +# endif #endif #ifndef FMT_INLINE -#if FMT_GCC_VERSION || FMT_CLANG_VERSION -#define FMT_INLINE inline __attribute__((always_inline)) -#else -#define FMT_INLINE inline -#endif +# if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_INLINE inline __attribute__((always_inline)) +# else +# define FMT_INLINE inline +# endif #endif #ifdef _MSC_VER -#define FMT_UNCHECKED_ITERATOR(It) using _Unchecked_type = It // Mark iterator as checked. +# define FMT_UNCHECKED_ITERATOR(It) \ + using _Unchecked_type = It // Mark iterator as checked. #else -#define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It +# define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It #endif #ifndef FMT_BEGIN_NAMESPACE -#define FMT_BEGIN_NAMESPACE \ - namespace fmt \ - { \ - inline namespace v10 \ - { -#define FMT_END_NAMESPACE \ - } \ +# define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + inline namespace v10 { +# define FMT_END_NAMESPACE \ + } \ } #endif #ifndef FMT_EXPORT -#define FMT_EXPORT -#define FMT_BEGIN_EXPORT -#define FMT_END_EXPORT +# define FMT_EXPORT +# define FMT_BEGIN_EXPORT +# define FMT_END_EXPORT #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION -#define FMT_VISIBILITY(value) __attribute__((visibility(value))) +# define FMT_VISIBILITY(value) __attribute__((visibility(value))) #else -#define FMT_VISIBILITY(value) +# define FMT_VISIBILITY(value) #endif #if !defined(FMT_HEADER_ONLY) && defined(_WIN32) -#if defined(FMT_LIB_EXPORT) -#define FMT_API __declspec(dllexport) -#elif defined(FMT_SHARED) -#define FMT_API __declspec(dllimport) -#endif +# if defined(FMT_LIB_EXPORT) +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif #elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) -#define FMT_API FMT_VISIBILITY("default") +# define FMT_API FMT_VISIBILITY("default") #endif #ifndef FMT_API -#define FMT_API +# define FMT_API #endif // libc++ supports string_view in pre-c++17. -#if FMT_HAS_INCLUDE() && (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) -#include -#define FMT_USE_STRING_VIEW +#if FMT_HAS_INCLUDE() && \ + (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# include +# define FMT_USE_STRING_VIEW #elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L -#include -#define FMT_USE_EXPERIMENTAL_STRING_VIEW +# include +# define FMT_USE_EXPERIMENTAL_STRING_VIEW #endif #ifndef FMT_UNICODE -#define FMT_UNICODE !FMT_MSC_VERSION +# define FMT_UNICODE !FMT_MSC_VERSION #endif #ifndef FMT_CONSTEVAL -#if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && (!defined(__apple_build_version__) || __apple_build_version__ >= 14000029L) && FMT_CPLUSPLUS >= 202002L) || (defined(__cpp_consteval) && (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929)) +# if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \ + (!defined(__apple_build_version__) || \ + __apple_build_version__ >= 14000029L) && \ + FMT_CPLUSPLUS >= 202002L) || \ + (defined(__cpp_consteval) && \ + (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929)) // consteval is broken in MSVC before VS2019 version 16.10 and Apple clang // before 14. -#define FMT_CONSTEVAL consteval -#define FMT_HAS_CONSTEVAL -#else -#define FMT_CONSTEVAL -#endif +# define FMT_CONSTEVAL consteval +# define FMT_HAS_CONSTEVAL +# else +# define FMT_CONSTEVAL +# endif #endif #ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS -#if defined(__cpp_nontype_template_args) && ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || __cpp_nontype_template_args >= 201911L) && !defined(__NVCOMPILER) && !defined(__LCC__) -#define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 -#else -#define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 -#endif +# if defined(__cpp_nontype_template_args) && \ + ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \ + __cpp_nontype_template_args >= 201911L) && \ + !defined(__NVCOMPILER) && !defined(__LCC__) +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +# else +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +# endif #endif // GCC < 5 requires this-> in decltype #ifndef FMT_DECLTYPE_THIS -#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 -#define FMT_DECLTYPE_THIS this-> -#else -#define FMT_DECLTYPE_THIS -#endif +# if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +# define FMT_DECLTYPE_THIS this-> +# else +# define FMT_DECLTYPE_THIS +# endif #endif // Enable minimal optimizations for more compact code in debug mode. FMT_GCC_PRAGMA("GCC push_options") -#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && !defined(__CUDACC__) +#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ + !defined(__CUDACC__) FMT_GCC_PRAGMA("GCC optimize(\"Og\")") #endif @@ -248,152 +271,138 @@ template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; -template -using bool_constant = std::integral_constant; +template using bool_constant = std::integral_constant; template using remove_reference_t = typename std::remove_reference::type; template using remove_const_t = typename std::remove_const::type; template using remove_cvref_t = typename std::remove_cv>::type; -template -struct type_identity { - using type = T; +template struct type_identity { + using type = T; }; -template -using type_identity_t = typename type_identity::type; +template using type_identity_t = typename type_identity::type; template using underlying_t = typename std::underlying_type::type; // Checks whether T is a container with contiguous storage. -template -struct is_contiguous : std::false_type {}; +template struct is_contiguous : std::false_type {}; template struct is_contiguous> : std::true_type {}; struct monostate { - constexpr monostate() {} + constexpr monostate() {} }; // An enable_if helper to be used in template parameters which results in much // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed // to workaround a bug in MSVC 2019 (see #1140 and #1186). #ifdef FMT_DOC -#define FMT_ENABLE_IF(...) +# define FMT_ENABLE_IF(...) #else -#define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 +# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 #endif // This is defined in core.h instead of format.h to avoid injecting in std. // It is a template to avoid undesirable implicit conversions to std::byte. #ifdef __cpp_lib_byte template ::value)> -inline auto format_as(T b) -> unsigned char -{ - return static_cast(b); +inline auto format_as(T b) -> unsigned char { + return static_cast(b); } #endif -namespace detail -{ - // Suppresses "unused variable" warnings with the method described in - // https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. - // (void)var does not work on many Intel compilers. - template - FMT_CONSTEXPR void ignore_unused(const T&...) - { - } +namespace detail { +// Suppresses "unused variable" warnings with the method described in +// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. +// (void)var does not work on many Intel compilers. +template FMT_CONSTEXPR void ignore_unused(const T&...) {} - constexpr FMT_INLINE auto is_constant_evaluated(bool default_value = false) noexcept -> bool - { +constexpr FMT_INLINE auto is_constant_evaluated( + bool default_value = false) noexcept -> bool { // Workaround for incompatibility between libstdc++ consteval-based // std::is_constant_evaluated() implementation and clang-14. // https://github.com/fmtlib/fmt/issues/3247 -#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 12 && (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) - ignore_unused(default_value); - return __builtin_is_constant_evaluated(); +#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \ + _GLIBCXX_RELEASE >= 12 && \ + (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) + ignore_unused(default_value); + return __builtin_is_constant_evaluated(); #elif defined(__cpp_lib_is_constant_evaluated) - ignore_unused(default_value); - return std::is_constant_evaluated(); + ignore_unused(default_value); + return std::is_constant_evaluated(); #else - return default_value; + return default_value; #endif - } +} - // Suppresses "conditional expression is constant" warnings. - template - constexpr FMT_INLINE auto const_check(T value) -> T - { - return value; - } +// Suppresses "conditional expression is constant" warnings. +template constexpr FMT_INLINE auto const_check(T value) -> T { + return value; +} - FMT_NORETURN FMT_API void assert_fail(const char* file, int line, const char* message); +FMT_NORETURN FMT_API void assert_fail(const char* file, int line, + const char* message); #ifndef FMT_ASSERT -#ifdef NDEBUG +# ifdef NDEBUG // FMT_ASSERT is not empty to avoid -Wempty-body. -#define FMT_ASSERT(condition, message) fmt::detail::ignore_unused((condition), (message)) -#else -#define FMT_ASSERT(condition, message) \ - ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ - ? (void)0 \ - : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) -#endif +# define FMT_ASSERT(condition, message) \ + fmt::detail::ignore_unused((condition), (message)) +# else +# define FMT_ASSERT(condition, message) \ + ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ + ? (void)0 \ + : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) +# endif #endif #if defined(FMT_USE_STRING_VIEW) - template - using std_string_view = std::basic_string_view; +template using std_string_view = std::basic_string_view; #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) - template - using std_string_view = std::experimental::basic_string_view; +template +using std_string_view = std::experimental::basic_string_view; #else - template - struct std_string_view {}; +template struct std_string_view {}; #endif #ifdef FMT_USE_INT128 // Do nothing. -#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && !(FMT_CLANG_VERSION && FMT_MSC_VERSION) -#define FMT_USE_INT128 1 - using int128_opt = __int128_t; // An optional native 128-bit integer. - using uint128_opt = __uint128_t; - template - inline auto convert_for_visit(T value) -> T - { - return value; - } +#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ + !(FMT_CLANG_VERSION && FMT_MSC_VERSION) +# define FMT_USE_INT128 1 +using int128_opt = __int128_t; // An optional native 128-bit integer. +using uint128_opt = __uint128_t; +template inline auto convert_for_visit(T value) -> T { + return value; +} #else -#define FMT_USE_INT128 0 +# define FMT_USE_INT128 0 #endif #if !FMT_USE_INT128 - enum class int128_opt {}; - enum class uint128_opt {}; - // Reduce template instantiations. - template - auto convert_for_visit(T) -> monostate - { - return {}; - } -#endif - - // Casts a nonnegative integer to unsigned. - template - FMT_CONSTEXPR auto to_unsigned(Int value) -> typename std::make_unsigned::type - { - FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); - return static_cast::type>(value); - } +enum class int128_opt {}; +enum class uint128_opt {}; +// Reduce template instantiations. +template auto convert_for_visit(T) -> monostate { return {}; } +#endif + +// Casts a nonnegative integer to unsigned. +template +FMT_CONSTEXPR auto to_unsigned(Int value) -> + typename std::make_unsigned::type { + FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); + return static_cast::type>(value); +} - FMT_CONSTEXPR inline auto is_utf8() -> bool - { - FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; +FMT_CONSTEXPR inline auto is_utf8() -> bool { + FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; - // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). - using uchar = unsigned char; - return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && uchar(section[1]) == 0xA7); - } -} // namespace detail + // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). + using uchar = unsigned char; + return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && + uchar(section[1]) == 0xA7); +} +} // namespace detail /** An implementation of ``std::basic_string_view`` for pre-C++17. It provides a @@ -403,214 +412,256 @@ namespace detail recommended). */ FMT_EXPORT -template -class basic_string_view { -private: - const Char* data_; - size_t size_; - -public: - using value_type = Char; - using iterator = const Char*; - - constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} - - /** Constructs a string reference object from a C string and a size. */ - constexpr basic_string_view(const Char* s, size_t count) noexcept : data_(s), size_(count) {} - - /** - \rst - Constructs a string reference object from a C string computing - the size with ``std::char_traits::length``. - \endrst - */ - FMT_CONSTEXPR_CHAR_TRAITS - FMT_INLINE - basic_string_view(const Char* s) : data_(s), size_(detail::const_check(std::is_same::value && !detail::is_constant_evaluated(true)) ? std::strlen(reinterpret_cast(s)) : std::char_traits::length(s)) {} - - /** Constructs a string reference from a ``std::basic_string`` object. */ - template - FMT_CONSTEXPR basic_string_view(const std::basic_string& s) noexcept : data_(s.data()), size_(s.size()) - { - } +template class basic_string_view { + private: + const Char* data_; + size_t size_; + + public: + using value_type = Char; + using iterator = const Char*; + + constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ + constexpr basic_string_view(const Char* s, size_t count) noexcept + : data_(s), size_(count) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + FMT_CONSTEXPR_CHAR_TRAITS + FMT_INLINE + basic_string_view(const Char* s) + : data_(s), + size_(detail::const_check(std::is_same::value && + !detail::is_constant_evaluated(true)) + ? std::strlen(reinterpret_cast(s)) + : std::char_traits::length(s)) {} + + /** Constructs a string reference from a ``std::basic_string`` object. */ + template + FMT_CONSTEXPR basic_string_view( + const std::basic_string& s) noexcept + : data_(s.data()), size_(s.size()) {} + + template >::value)> + FMT_CONSTEXPR basic_string_view(S s) noexcept + : data_(s.data()), size_(s.size()) {} + + /** Returns a pointer to the string data. */ + constexpr auto data() const noexcept -> const Char* { return data_; } + + /** Returns the string size. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + constexpr auto begin() const noexcept -> iterator { return data_; } + constexpr auto end() const noexcept -> iterator { return data_ + size_; } + + constexpr auto operator[](size_t pos) const noexcept -> const Char& { + return data_[pos]; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { + data_ += n; + size_ -= n; + } + + FMT_CONSTEXPR_CHAR_TRAITS auto starts_with( + basic_string_view sv) const noexcept -> bool { + return size_ >= sv.size_ && + std::char_traits::compare(data_, sv.data_, sv.size_) == 0; + } + FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool { + return size_ >= 1 && std::char_traits::eq(*data_, c); + } + FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool { + return starts_with(basic_string_view(s)); + } + + // Lexicographically compare this string reference to other. + FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, + basic_string_view rhs) + -> bool { + return lhs.compare(rhs) == 0; + } + friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) != 0; + } + friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) < 0; + } + friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) <= 0; + } + friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) > 0; + } + friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) >= 0; + } +}; - template >::value)> - FMT_CONSTEXPR basic_string_view(S s) noexcept : data_(s.data()), size_(s.size()) - { - } +FMT_EXPORT +using string_view = basic_string_view; - /** Returns a pointer to the string data. */ - constexpr auto data() const noexcept -> const Char* { return data_; } +/** Specifies if ``T`` is a character type. Can be specialized by users. */ +FMT_EXPORT +template struct is_char : std::false_type {}; +template <> struct is_char : std::true_type {}; - /** Returns the string size. */ - constexpr auto size() const noexcept -> size_t { return size_; } +namespace detail { - constexpr auto begin() const noexcept -> iterator { return data_; } - constexpr auto end() const noexcept -> iterator { return data_ + size_; } +// A base class for compile-time strings. +struct compile_string {}; - constexpr auto operator[](size_t pos) const noexcept -> const Char& { return data_[pos]; } +template +struct is_compile_string : std::is_base_of {}; - FMT_CONSTEXPR void remove_prefix(size_t n) noexcept - { - data_ += n; - size_ -= n; - } +template ::value)> +FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view { + return s; +} +template +inline auto to_string_view(const std::basic_string& s) + -> basic_string_view { + return s; +} +template +constexpr auto to_string_view(basic_string_view s) + -> basic_string_view { + return s; +} +template >::value)> +inline auto to_string_view(std_string_view s) -> basic_string_view { + return s; +} +template ::value)> +constexpr auto to_string_view(const S& s) + -> basic_string_view { + return basic_string_view(s); +} +void to_string_view(...); - FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(basic_string_view sv) const noexcept -> bool { return size_ >= sv.size_ && std::char_traits::compare(data_, sv.data_, sv.size_) == 0; } - FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool { return size_ >= 1 && std::char_traits::eq(*data_, c); } - FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool { return starts_with(basic_string_view(s)); } - - // Lexicographically compare this string reference to other. - FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int - { - size_t str_size = size_ < other.size_ ? size_ : other.size_; - int result = std::char_traits::compare(data_, other.data_, str_size); - if (result == 0) - result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); - return result; - } +// Specifies whether S is a string type convertible to fmt::basic_string_view. +// It should be a constexpr function but MSVC 2017 fails to compile it in +// enable_if and MSVC 2015 fails to compile it as an alias template. +// ADL is intentionally disabled as to_string_view is not an extension point. +template +struct is_string + : std::is_class()))> {}; - FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) == 0; } - friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) != 0; } - friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) < 0; } - friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) <= 0; } - friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) > 0; } - friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) >= 0; } +template struct char_t_impl {}; +template struct char_t_impl::value>> { + using result = decltype(to_string_view(std::declval())); + using type = typename result::value_type; }; -FMT_EXPORT -using string_view = basic_string_view; +enum class type { + none_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + int128_type, + uint128_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + float_type, + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; -/** Specifies if ``T`` is a character type. Can be specialized by users. */ -FMT_EXPORT -template -struct is_char : std::false_type {}; -template <> -struct is_char : std::true_type {}; +// Maps core type T to the corresponding type enum constant. +template +struct type_constant : std::integral_constant {}; + +#define FMT_TYPE_CONSTANT(Type, constant) \ + template \ + struct type_constant \ + : std::integral_constant {} + +FMT_TYPE_CONSTANT(int, int_type); +FMT_TYPE_CONSTANT(unsigned, uint_type); +FMT_TYPE_CONSTANT(long long, long_long_type); +FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); +FMT_TYPE_CONSTANT(int128_opt, int128_type); +FMT_TYPE_CONSTANT(uint128_opt, uint128_type); +FMT_TYPE_CONSTANT(bool, bool_type); +FMT_TYPE_CONSTANT(Char, char_type); +FMT_TYPE_CONSTANT(float, float_type); +FMT_TYPE_CONSTANT(double, double_type); +FMT_TYPE_CONSTANT(long double, long_double_type); +FMT_TYPE_CONSTANT(const Char*, cstring_type); +FMT_TYPE_CONSTANT(basic_string_view, string_type); +FMT_TYPE_CONSTANT(const void*, pointer_type); + +constexpr auto is_integral_type(type t) -> bool { + return t > type::none_type && t <= type::last_integer_type; +} +constexpr auto is_arithmetic_type(type t) -> bool { + return t > type::none_type && t <= type::last_numeric_type; +} -namespace detail -{ +constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } +constexpr auto in(type t, int set) -> bool { + return ((set >> static_cast(t)) & 1) != 0; +} - // A base class for compile-time strings. - struct compile_string {}; +// Bitsets of types. +enum { + sint_set = + set(type::int_type) | set(type::long_long_type) | set(type::int128_type), + uint_set = set(type::uint_type) | set(type::ulong_long_type) | + set(type::uint128_type), + bool_set = set(type::bool_type), + char_set = set(type::char_type), + float_set = set(type::float_type) | set(type::double_type) | + set(type::long_double_type), + string_set = set(type::string_type), + cstring_set = set(type::cstring_type), + pointer_set = set(type::pointer_type) +}; - template - struct is_compile_string : std::is_base_of {}; +// DEPRECATED! +FMT_NORETURN FMT_API void throw_format_error(const char* message); - template ::value)> - FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view - { - return s; - } - template - inline auto to_string_view(const std::basic_string& s) -> basic_string_view - { - return s; - } - template - constexpr auto to_string_view(basic_string_view s) -> basic_string_view - { - return s; - } - template >::value)> - inline auto to_string_view(std_string_view s) -> basic_string_view - { - return s; - } - template ::value)> - constexpr auto to_string_view(const S& s) -> basic_string_view - { - return basic_string_view(s); - } - void to_string_view(...); - - // Specifies whether S is a string type convertible to fmt::basic_string_view. - // It should be a constexpr function but MSVC 2017 fails to compile it in - // enable_if and MSVC 2015 fails to compile it as an alias template. - // ADL is intentionally disabled as to_string_view is not an extension point. - template - struct is_string : std::is_class()))> {}; - - template - struct char_t_impl {}; - template - struct char_t_impl::value>> { - using result = decltype(to_string_view(std::declval())); - using type = typename result::value_type; - }; - - enum class type { - none_type, - // Integer types should go first, - int_type, - uint_type, - long_long_type, - ulong_long_type, - int128_type, - uint128_type, - bool_type, - char_type, - last_integer_type = char_type, - // followed by floating-point types. - float_type, - double_type, - long_double_type, - last_numeric_type = long_double_type, - cstring_type, - string_type, - pointer_type, - custom_type - }; - - // Maps core type T to the corresponding type enum constant. - template - struct type_constant : std::integral_constant {}; - -#define FMT_TYPE_CONSTANT(Type, constant) \ - template \ - struct type_constant : std::integral_constant {} - - FMT_TYPE_CONSTANT(int, int_type); - FMT_TYPE_CONSTANT(unsigned, uint_type); - FMT_TYPE_CONSTANT(long long, long_long_type); - FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); - FMT_TYPE_CONSTANT(int128_opt, int128_type); - FMT_TYPE_CONSTANT(uint128_opt, uint128_type); - FMT_TYPE_CONSTANT(bool, bool_type); - FMT_TYPE_CONSTANT(Char, char_type); - FMT_TYPE_CONSTANT(float, float_type); - FMT_TYPE_CONSTANT(double, double_type); - FMT_TYPE_CONSTANT(long double, long_double_type); - FMT_TYPE_CONSTANT(const Char*, cstring_type); - FMT_TYPE_CONSTANT(basic_string_view, string_type); - FMT_TYPE_CONSTANT(const void*, pointer_type); - - constexpr auto is_integral_type(type t) -> bool { return t > type::none_type && t <= type::last_integer_type; } - constexpr auto is_arithmetic_type(type t) -> bool { return t > type::none_type && t <= type::last_numeric_type; } - - constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } - constexpr auto in(type t, int set) -> bool { return ((set >> static_cast(t)) & 1) != 0; } - - // Bitsets of types. - enum { sint_set = set(type::int_type) | set(type::long_long_type) | set(type::int128_type), uint_set = set(type::uint_type) | set(type::ulong_long_type) | set(type::uint128_type), bool_set = set(type::bool_type), char_set = set(type::char_type), float_set = set(type::float_type) | set(type::double_type) | set(type::long_double_type), string_set = set(type::string_type), cstring_set = set(type::cstring_type), pointer_set = set(type::pointer_type) }; - - // DEPRECATED! - FMT_NORETURN FMT_API void throw_format_error(const char* message); - - struct error_handler { - constexpr error_handler() = default; - - // This function is intentionally not constexpr to give a compile-time error. - FMT_NORETURN void on_error(const char* message) { throw_format_error(message); } - }; -} // namespace detail +struct error_handler { + constexpr error_handler() = default; + + // This function is intentionally not constexpr to give a compile-time error. + FMT_NORETURN void on_error(const char* message) { + throw_format_error(message); + } +}; +} // namespace detail /** Throws ``format_error`` with a given message. */ using detail::throw_format_error; /** String's character type. */ -template -using char_t = typename detail::char_t_impl::type; +template using char_t = typename detail::char_t_impl::type; /** \rst @@ -620,1015 +671,1019 @@ using char_t = typename detail::char_t_impl::type; \endrst */ FMT_EXPORT -template -class basic_format_parse_context { -private: - basic_string_view format_str_; - int next_arg_id_; - - FMT_CONSTEXPR void do_check_arg_id(int id); - -public: - using char_type = Char; - using iterator = const Char*; - - explicit constexpr basic_format_parse_context(basic_string_view format_str, int next_arg_id = 0) : format_str_(format_str), next_arg_id_(next_arg_id) {} - - /** - Returns an iterator to the beginning of the format string range being - parsed. - */ - constexpr auto begin() const noexcept -> iterator { return format_str_.begin(); } - - /** - Returns an iterator past the end of the format string range being parsed. - */ - constexpr auto end() const noexcept -> iterator { return format_str_.end(); } - - /** Advances the begin iterator to ``it``. */ - FMT_CONSTEXPR void advance_to(iterator it) { format_str_.remove_prefix(detail::to_unsigned(it - begin())); } - - /** - Reports an error if using the manual argument indexing; otherwise returns - the next argument index and switches to the automatic indexing. - */ - FMT_CONSTEXPR auto next_arg_id() -> int - { - if (next_arg_id_ < 0) - { - detail::throw_format_error("cannot switch from manual to automatic argument indexing"); - return 0; - } - int id = next_arg_id_++; - do_check_arg_id(id); - return id; - } - - /** - Reports an error if using the automatic argument indexing; otherwise - switches to the manual indexing. - */ - FMT_CONSTEXPR void check_arg_id(int id) - { - if (next_arg_id_ > 0) - { - detail::throw_format_error("cannot switch from automatic to manual argument indexing"); - return; - } - next_arg_id_ = -1; - do_check_arg_id(id); - } - FMT_CONSTEXPR void check_arg_id(basic_string_view) {} - FMT_CONSTEXPR void check_dynamic_spec(int arg_id); +template class basic_format_parse_context { + private: + basic_string_view format_str_; + int next_arg_id_; + + FMT_CONSTEXPR void do_check_arg_id(int id); + + public: + using char_type = Char; + using iterator = const Char*; + + explicit constexpr basic_format_parse_context( + basic_string_view format_str, int next_arg_id = 0) + : format_str_(format_str), next_arg_id_(next_arg_id) {} + + /** + Returns an iterator to the beginning of the format string range being + parsed. + */ + constexpr auto begin() const noexcept -> iterator { + return format_str_.begin(); + } + + /** + Returns an iterator past the end of the format string range being parsed. + */ + constexpr auto end() const noexcept -> iterator { return format_str_.end(); } + + /** Advances the begin iterator to ``it``. */ + FMT_CONSTEXPR void advance_to(iterator it) { + format_str_.remove_prefix(detail::to_unsigned(it - begin())); + } + + /** + Reports an error if using the manual argument indexing; otherwise returns + the next argument index and switches to the automatic indexing. + */ + FMT_CONSTEXPR auto next_arg_id() -> int { + if (next_arg_id_ < 0) { + detail::throw_format_error( + "cannot switch from manual to automatic argument indexing"); + return 0; + } + int id = next_arg_id_++; + do_check_arg_id(id); + return id; + } + + /** + Reports an error if using the automatic argument indexing; otherwise + switches to the manual indexing. + */ + FMT_CONSTEXPR void check_arg_id(int id) { + if (next_arg_id_ > 0) { + detail::throw_format_error( + "cannot switch from automatic to manual argument indexing"); + return; + } + next_arg_id_ = -1; + do_check_arg_id(id); + } + FMT_CONSTEXPR void check_arg_id(basic_string_view) {} + FMT_CONSTEXPR void check_dynamic_spec(int arg_id); }; FMT_EXPORT using format_parse_context = basic_format_parse_context; -namespace detail -{ - // A parse context with extra data used only in compile-time checks. - template - class compile_parse_context : public basic_format_parse_context { - private: - int num_args_; - const type* types_; - using base = basic_format_parse_context; - - public: - explicit FMT_CONSTEXPR compile_parse_context(basic_string_view format_str, int num_args, const type* types, int next_arg_id = 0) : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} - - constexpr auto num_args() const -> int { return num_args_; } - constexpr auto arg_type(int id) const -> type { return types_[id]; } - - FMT_CONSTEXPR auto next_arg_id() -> int - { - int id = base::next_arg_id(); - if (id >= num_args_) - throw_format_error("argument not found"); - return id; - } - - FMT_CONSTEXPR void check_arg_id(int id) - { - base::check_arg_id(id); - if (id >= num_args_) - throw_format_error("argument not found"); - } - using base::check_arg_id; - - FMT_CONSTEXPR void check_dynamic_spec(int arg_id) - { - detail::ignore_unused(arg_id); +namespace detail { +// A parse context with extra data used only in compile-time checks. +template +class compile_parse_context : public basic_format_parse_context { + private: + int num_args_; + const type* types_; + using base = basic_format_parse_context; + + public: + explicit FMT_CONSTEXPR compile_parse_context( + basic_string_view format_str, int num_args, const type* types, + int next_arg_id = 0) + : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} + + constexpr auto num_args() const -> int { return num_args_; } + constexpr auto arg_type(int id) const -> type { return types_[id]; } + + FMT_CONSTEXPR auto next_arg_id() -> int { + int id = base::next_arg_id(); + if (id >= num_args_) throw_format_error("argument not found"); + return id; + } + + FMT_CONSTEXPR void check_arg_id(int id) { + base::check_arg_id(id); + if (id >= num_args_) throw_format_error("argument not found"); + } + using base::check_arg_id; + + FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { + detail::ignore_unused(arg_id); #if !defined(__LCC__) - if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) - throw_format_error("width/precision is not integer"); + if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) + throw_format_error("width/precision is not integer"); #endif - } - }; - - // Extracts a reference to the container from back_insert_iterator. - template - inline auto get_container(std::back_insert_iterator it) -> Container& - { - using base = std::back_insert_iterator; - struct accessor : base { - accessor(base b) : base(b) {} - using base::container; - }; - return *accessor(it).container; - } + } +}; - template - FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) -> OutputIt - { - while (begin != end) - *out++ = static_cast(*begin++); - return out; - } +// Extracts a reference to the container from back_insert_iterator. +template +inline auto get_container(std::back_insert_iterator it) + -> Container& { + using base = std::back_insert_iterator; + struct accessor : base { + accessor(base b) : base(b) {} + using base::container; + }; + return *accessor(it).container; +} - template , U>::value&& is_char::value)> - FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* - { - if (is_constant_evaluated()) - return copy_str(begin, end, out); - auto size = to_unsigned(end - begin); - if (size > 0) - memcpy(out, begin, size * sizeof(U)); - return out + size; - } +template +FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) + -> OutputIt { + while (begin != end) *out++ = static_cast(*begin++); + return out; +} + +template , U>::value&& is_char::value)> +FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* { + if (is_constant_evaluated()) return copy_str(begin, end, out); + auto size = to_unsigned(end - begin); + if (size > 0) memcpy(out, begin, size * sizeof(U)); + return out + size; +} - /** - \rst - A contiguous memory buffer with an optional growing ability. It is an internal - class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. - \endrst - */ - template - class buffer { - private: - T* ptr_; - size_t size_; - size_t capacity_; - - protected: - // Don't initialize ptr_ since it is not accessed to save a few cycles. - FMT_MSC_WARNING(suppress : 26495) - FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {} - - FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept : ptr_(p), size_(sz), capacity_(cap) {} - - FMT_CONSTEXPR20 ~buffer() = default; - buffer(buffer&&) = default; - - /** Sets the buffer data and capacity. */ - FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept - { - ptr_ = buf_data; - capacity_ = buf_capacity; - } - - /** Increases the buffer capacity to hold at least *capacity* elements. */ - // DEPRECATED! - virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0; - - public: - using value_type = T; - using const_reference = const T&; - - buffer(const buffer&) = delete; - void operator=(const buffer&) = delete; - - FMT_INLINE auto begin() noexcept -> T* { return ptr_; } - FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } - - FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } - FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } - - /** Returns the size of this buffer. */ - constexpr auto size() const noexcept -> size_t { return size_; } - - /** Returns the capacity of this buffer. */ - constexpr auto capacity() const noexcept -> size_t { return capacity_; } - - /** Returns a pointer to the buffer data (not null-terminated). */ - FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } - FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } - - /** Clears this buffer. */ - void clear() { size_ = 0; } - - // Tries resizing the buffer to contain *count* elements. If T is a POD type - // the new elements may not be initialized. - FMT_CONSTEXPR20 void try_resize(size_t count) - { - try_reserve(count); - size_ = count <= capacity_ ? count : capacity_; - } - - // Tries increasing the buffer capacity to *new_capacity*. It can increase the - // capacity by a smaller amount than requested but guarantees there is space - // for at least one additional element either by increasing the capacity or by - // flushing the buffer if it is full. - FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) - { - if (new_capacity > capacity_) - grow(new_capacity); - } - - FMT_CONSTEXPR20 void push_back(const T& value) - { - try_reserve(size_ + 1); - ptr_[size_++] = value; - } - - /** Appends data to the end of the buffer. */ - template - void append(const U* begin, const U* end); - - template - FMT_CONSTEXPR auto operator[](Idx index) -> T& - { - return ptr_[index]; - } - template - FMT_CONSTEXPR auto operator[](Idx index) const -> const T& - { - return ptr_[index]; - } - }; - - struct buffer_traits { - explicit buffer_traits(size_t) {} - auto count() const -> size_t { return 0; } - auto limit(size_t size) -> size_t { return size; } - }; - - class fixed_buffer_traits { - private: - size_t count_ = 0; - size_t limit_; - - public: - explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} - auto count() const -> size_t { return count_; } - auto limit(size_t size) -> size_t - { - size_t n = limit_ > count_ ? limit_ - count_ : 0; - count_ += size; - return size < n ? size : n; - } - }; - - // A buffer that writes to an output iterator when flushed. - template - class iterator_buffer final : public Traits, public buffer { - private: - OutputIt out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override - { - if (this->size() == buffer_size) - flush(); - } - - void flush() - { - auto size = this->size(); - this->clear(); - out_ = copy_str(data_, data_ + this->limit(size), out_); - } - - public: - explicit iterator_buffer(OutputIt out, size_t n = buffer_size) : Traits(n), buffer(data_, 0, buffer_size), out_(out) {} - iterator_buffer(iterator_buffer&& other) : Traits(other), buffer(data_, 0, buffer_size), out_(other.out_) {} - ~iterator_buffer() { flush(); } - - auto out() -> OutputIt - { - flush(); - return out_; - } - auto count() const -> size_t { return Traits::count() + this->size(); } - }; - - template - class iterator_buffer final : public fixed_buffer_traits, public buffer { - private: - T* out_; - enum { buffer_size = 256 }; - T data_[buffer_size]; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override - { - if (this->size() == this->capacity()) - flush(); - } - - void flush() - { - size_t n = this->limit(this->size()); - if (this->data() == out_) - { - out_ += n; - this->set(data_, buffer_size); - } - this->clear(); - } - - public: - explicit iterator_buffer(T* out, size_t n = buffer_size) : fixed_buffer_traits(n), buffer(out, 0, n), out_(out) {} - iterator_buffer(iterator_buffer&& other) : fixed_buffer_traits(other), buffer(std::move(other)), out_(other.out_) - { - if (this->data() != out_) - { - this->set(data_, buffer_size); - this->clear(); - } - } - ~iterator_buffer() { flush(); } - - auto out() -> T* - { - flush(); - return out_; - } - auto count() const -> size_t { return fixed_buffer_traits::count() + this->size(); } - }; - - template - class iterator_buffer final : public buffer { - protected: - FMT_CONSTEXPR20 void grow(size_t) override {} - - public: - explicit iterator_buffer(T* out, size_t = 0) : buffer(out, 0, ~size_t()) {} - - auto out() -> T* { return &*this->end(); } - }; - - // A buffer that writes to a container with the contiguous storage. - template - class iterator_buffer, enable_if_t::value, typename Container::value_type>> final : public buffer { - private: - Container& container_; - - protected: - FMT_CONSTEXPR20 void grow(size_t capacity) override - { - container_.resize(capacity); - this->set(&container_[0], capacity); - } - - public: - explicit iterator_buffer(Container& c) : buffer(c.size()), container_(c) {} - explicit iterator_buffer(std::back_insert_iterator out, size_t = 0) : iterator_buffer(get_container(out)) {} - - auto out() -> std::back_insert_iterator { return std::back_inserter(container_); } - }; - - // A buffer that counts the number of code units written discarding the output. - template - class counting_buffer final : public buffer { - private: - enum { buffer_size = 256 }; - T data_[buffer_size]; - size_t count_ = 0; - - protected: - FMT_CONSTEXPR20 void grow(size_t) override - { - if (this->size() != buffer_size) - return; - count_ += this->size(); - this->clear(); - } - - public: - counting_buffer() : buffer(data_, 0, buffer_size) {} - - auto count() -> size_t { return count_ + this->size(); } - }; -} // namespace detail +/** + \rst + A contiguous memory buffer with an optional growing ability. It is an internal + class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. + \endrst + */ +template class buffer { + private: + T* ptr_; + size_t size_; + size_t capacity_; + + protected: + // Don't initialize ptr_ since it is not accessed to save a few cycles. + FMT_MSC_WARNING(suppress : 26495) + FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {} + + FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept + : ptr_(p), size_(sz), capacity_(cap) {} + + FMT_CONSTEXPR20 ~buffer() = default; + buffer(buffer&&) = default; + + /** Sets the buffer data and capacity. */ + FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + /** Increases the buffer capacity to hold at least *capacity* elements. */ + // DEPRECATED! + virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0; + + public: + using value_type = T; + using const_reference = const T&; + + buffer(const buffer&) = delete; + void operator=(const buffer&) = delete; + + FMT_INLINE auto begin() noexcept -> T* { return ptr_; } + FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } + + FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } + FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } + + /** Returns the size of this buffer. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + /** Returns the capacity of this buffer. */ + constexpr auto capacity() const noexcept -> size_t { return capacity_; } + + /** Returns a pointer to the buffer data (not null-terminated). */ + FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } + FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } + + /** Clears this buffer. */ + void clear() { size_ = 0; } + + // Tries resizing the buffer to contain *count* elements. If T is a POD type + // the new elements may not be initialized. + FMT_CONSTEXPR20 void try_resize(size_t count) { + try_reserve(count); + size_ = count <= capacity_ ? count : capacity_; + } + + // Tries increasing the buffer capacity to *new_capacity*. It can increase the + // capacity by a smaller amount than requested but guarantees there is space + // for at least one additional element either by increasing the capacity or by + // flushing the buffer if it is full. + FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) { + if (new_capacity > capacity_) grow(new_capacity); + } + + FMT_CONSTEXPR20 void push_back(const T& value) { + try_reserve(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template void append(const U* begin, const U* end); + + template FMT_CONSTEXPR auto operator[](Idx index) -> T& { + return ptr_[index]; + } + template + FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { + return ptr_[index]; + } +}; + +struct buffer_traits { + explicit buffer_traits(size_t) {} + auto count() const -> size_t { return 0; } + auto limit(size_t size) -> size_t { return size; } +}; + +class fixed_buffer_traits { + private: + size_t count_ = 0; + size_t limit_; + + public: + explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} + auto count() const -> size_t { return count_; } + auto limit(size_t size) -> size_t { + size_t n = limit_ > count_ ? limit_ - count_ : 0; + count_ += size; + return size < n ? size : n; + } +}; + +// A buffer that writes to an output iterator when flushed. +template +class iterator_buffer final : public Traits, public buffer { + private: + OutputIt out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() == buffer_size) flush(); + } + + void flush() { + auto size = this->size(); + this->clear(); + out_ = copy_str(data_, data_ + this->limit(size), out_); + } + + public: + explicit iterator_buffer(OutputIt out, size_t n = buffer_size) + : Traits(n), buffer(data_, 0, buffer_size), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : Traits(other), buffer(data_, 0, buffer_size), out_(other.out_) {} + ~iterator_buffer() { flush(); } + + auto out() -> OutputIt { + flush(); + return out_; + } + auto count() const -> size_t { return Traits::count() + this->size(); } +}; + +template +class iterator_buffer final + : public fixed_buffer_traits, + public buffer { + private: + T* out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() == this->capacity()) flush(); + } + + void flush() { + size_t n = this->limit(this->size()); + if (this->data() == out_) { + out_ += n; + this->set(data_, buffer_size); + } + this->clear(); + } + + public: + explicit iterator_buffer(T* out, size_t n = buffer_size) + : fixed_buffer_traits(n), buffer(out, 0, n), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : fixed_buffer_traits(other), + buffer(std::move(other)), + out_(other.out_) { + if (this->data() != out_) { + this->set(data_, buffer_size); + this->clear(); + } + } + ~iterator_buffer() { flush(); } + + auto out() -> T* { + flush(); + return out_; + } + auto count() const -> size_t { + return fixed_buffer_traits::count() + this->size(); + } +}; + +template class iterator_buffer final : public buffer { + protected: + FMT_CONSTEXPR20 void grow(size_t) override {} + + public: + explicit iterator_buffer(T* out, size_t = 0) : buffer(out, 0, ~size_t()) {} + + auto out() -> T* { return &*this->end(); } +}; + +// A buffer that writes to a container with the contiguous storage. +template +class iterator_buffer, + enable_if_t::value, + typename Container::value_type>> + final : public buffer { + private: + Container& container_; + + protected: + FMT_CONSTEXPR20 void grow(size_t capacity) override { + container_.resize(capacity); + this->set(&container_[0], capacity); + } + + public: + explicit iterator_buffer(Container& c) + : buffer(c.size()), container_(c) {} + explicit iterator_buffer(std::back_insert_iterator out, size_t = 0) + : iterator_buffer(get_container(out)) {} + + auto out() -> std::back_insert_iterator { + return std::back_inserter(container_); + } +}; + +// A buffer that counts the number of code units written discarding the output. +template class counting_buffer final : public buffer { + private: + enum { buffer_size = 256 }; + T data_[buffer_size]; + size_t count_ = 0; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() != buffer_size) return; + count_ += this->size(); + this->clear(); + } + + public: + counting_buffer() : buffer(data_, 0, buffer_size) {} + + auto count() -> size_t { return count_ + this->size(); } +}; +} // namespace detail template -FMT_CONSTEXPR void basic_format_parse_context::do_check_arg_id(int id) -{ - // Argument id is only checked at compile-time during parsing because - // formatting has its own validation. - if (detail::is_constant_evaluated() && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) - { - using context = detail::compile_parse_context; - if (id >= static_cast(this)->num_args()) - detail::throw_format_error("argument not found"); - } +FMT_CONSTEXPR void basic_format_parse_context::do_check_arg_id(int id) { + // Argument id is only checked at compile-time during parsing because + // formatting has its own validation. + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + if (id >= static_cast(this)->num_args()) + detail::throw_format_error("argument not found"); + } } template -FMT_CONSTEXPR void basic_format_parse_context::check_dynamic_spec(int arg_id) -{ - if (detail::is_constant_evaluated() && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) - { - using context = detail::compile_parse_context; - static_cast(this)->check_dynamic_spec(arg_id); - } +FMT_CONSTEXPR void basic_format_parse_context::check_dynamic_spec( + int arg_id) { + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + static_cast(this)->check_dynamic_spec(arg_id); + } } -FMT_EXPORT template -class basic_format_arg; -FMT_EXPORT template -class basic_format_args; -FMT_EXPORT template -class dynamic_format_arg_store; +FMT_EXPORT template class basic_format_arg; +FMT_EXPORT template class basic_format_args; +FMT_EXPORT template class dynamic_format_arg_store; // A formatter for objects of type T. FMT_EXPORT template struct formatter { - // A deleted default constructor indicates a disabled formatter. - formatter() = delete; + // A deleted default constructor indicates a disabled formatter. + formatter() = delete; }; // Specifies if T has an enabled formatter specialization. A type can be // formattable even if it doesn't have a formatter e.g. via a conversion. template -using has_formatter = std::is_constructible>; +using has_formatter = + std::is_constructible>; // An output iterator that appends to a buffer. // It is used to reduce symbol sizes for the common case. class appender : public std::back_insert_iterator> { - using base = std::back_insert_iterator>; + using base = std::back_insert_iterator>; -public: - using std::back_insert_iterator>::back_insert_iterator; - appender(base it) noexcept : base(it) {} - FMT_UNCHECKED_ITERATOR(appender); + public: + using std::back_insert_iterator>::back_insert_iterator; + appender(base it) noexcept : base(it) {} + FMT_UNCHECKED_ITERATOR(appender); - auto operator++() noexcept -> appender& { return *this; } - auto operator++(int) noexcept -> appender { return *this; } + auto operator++() noexcept -> appender& { return *this; } + auto operator++(int) noexcept -> appender { return *this; } }; -namespace detail -{ +namespace detail { - template - constexpr auto has_const_formatter_impl(T*) -> decltype(typename Context::template formatter_type().format(std::declval(), std::declval()), true) - { - return true; - } - template - constexpr auto has_const_formatter_impl(...) -> bool - { - return false; - } - template - constexpr auto has_const_formatter() -> bool - { - return has_const_formatter_impl(static_cast(nullptr)); - } +template +constexpr auto has_const_formatter_impl(T*) + -> decltype(typename Context::template formatter_type().format( + std::declval(), std::declval()), + true) { + return true; +} +template +constexpr auto has_const_formatter_impl(...) -> bool { + return false; +} +template +constexpr auto has_const_formatter() -> bool { + return has_const_formatter_impl(static_cast(nullptr)); +} - template - using buffer_appender = conditional_t::value, appender, std::back_insert_iterator>>; +template +using buffer_appender = conditional_t::value, appender, + std::back_insert_iterator>>; - // Maps an output iterator to a buffer. - template - auto get_buffer(OutputIt out) -> iterator_buffer - { - return iterator_buffer(out); - } - template , Buf>::value)> - auto get_buffer(std::back_insert_iterator out) -> buffer& - { - return get_container(out); - } +// Maps an output iterator to a buffer. +template +auto get_buffer(OutputIt out) -> iterator_buffer { + return iterator_buffer(out); +} +template , Buf>::value)> +auto get_buffer(std::back_insert_iterator out) -> buffer& { + return get_container(out); +} - template - FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) - { - return buf.out(); - } - template - auto get_iterator(buffer&, OutputIt out) -> OutputIt - { - return out; - } +template +FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { + return buf.out(); +} +template +auto get_iterator(buffer&, OutputIt out) -> OutputIt { + return out; +} - struct view {}; - - template - struct named_arg : view { - const Char* name; - const T& value; - named_arg(const Char* n, const T& v) : name(n), value(v) {} - }; - - template - struct named_arg_info { - const Char* name; - int id; - }; - - template - struct arg_data { - // args_[0].named_args points to named_args_ to avoid bloating format_args. - // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. - T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; - named_arg_info named_args_[NUM_NAMED_ARGS]; - - template - arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} - { - } - arg_data(const arg_data& other) = delete; - auto args() const -> const T* { return args_ + 1; } - auto named_args() -> named_arg_info* { return named_args_; } - }; - - template - struct arg_data { - // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. - T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; - - template - FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} - { - } - FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } - FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { return nullptr; } - }; - - template - inline void init_named_args(named_arg_info*, int, int) - { - } +struct view {}; - template - struct is_named_arg : std::false_type {}; - template - struct is_statically_named_arg : std::false_type {}; +template struct named_arg : view { + const Char* name; + const T& value; + named_arg(const Char* n, const T& v) : name(n), value(v) {} +}; - template - struct is_named_arg> : std::true_type {}; +template struct named_arg_info { + const Char* name; + int id; +}; - template ::value)> - void init_named_args(named_arg_info* named_args, int arg_count, int named_arg_count, const T&, const Tail&... args) - { - init_named_args(named_args, arg_count + 1, named_arg_count, args...); - } +template +struct arg_data { + // args_[0].named_args points to named_args_ to avoid bloating format_args. + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; + named_arg_info named_args_[NUM_NAMED_ARGS]; + + template + arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {} + arg_data(const arg_data& other) = delete; + auto args() const -> const T* { return args_ + 1; } + auto named_args() -> named_arg_info* { return named_args_; } +}; - template ::value)> - void init_named_args(named_arg_info* named_args, int arg_count, int named_arg_count, const T& arg, const Tail&... args) - { - named_args[named_arg_count++] = {arg.name, arg_count}; - init_named_args(named_args, arg_count + 1, named_arg_count, args...); - } +template +struct arg_data { + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; + + template + FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} + FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } + FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { + return nullptr; + } +}; - template - FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, const Args&...) - { - } +template +inline void init_named_args(named_arg_info*, int, int) {} - template - constexpr auto count() -> size_t - { - return B ? 1 : 0; - } - template - constexpr auto count() -> size_t - { - return (B1 ? 1 : 0) + count(); - } +template struct is_named_arg : std::false_type {}; +template struct is_statically_named_arg : std::false_type {}; - template - constexpr auto count_named_args() -> size_t - { - return count::value...>(); - } +template +struct is_named_arg> : std::true_type {}; - template - constexpr auto count_statically_named_args() -> size_t - { - return count::value...>(); - } +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T&, const Tail&... args) { + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T& arg, const Tail&... args) { + named_args[named_arg_count++] = {arg.name, arg_count}; + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template +FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, + const Args&...) {} + +template constexpr auto count() -> size_t { return B ? 1 : 0; } +template constexpr auto count() -> size_t { + return (B1 ? 1 : 0) + count(); +} + +template constexpr auto count_named_args() -> size_t { + return count::value...>(); +} + +template +constexpr auto count_statically_named_args() -> size_t { + return count::value...>(); +} + +struct unformattable {}; +struct unformattable_char : unformattable {}; +struct unformattable_pointer : unformattable {}; - struct unformattable {}; - struct unformattable_char : unformattable {}; - struct unformattable_pointer : unformattable {}; - - template - struct string_value { - const Char* data; - size_t size; - }; - - template - struct named_arg_value { - const named_arg_info* data; - size_t size; - }; - - template - struct custom_value { - using parse_context = typename Context::parse_context_type; - void* value; - void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); - }; - - // A formatting argument value. - template - class value { - public: - using char_type = typename Context::char_type; - - union { - monostate no_value; - int int_value; - unsigned uint_value; - long long long_long_value; - unsigned long long ulong_long_value; - int128_opt int128_value; - uint128_opt uint128_value; - bool bool_value; - char_type char_value; - float float_value; - double double_value; - long double long_double_value; - const void* pointer; - string_value string; - custom_value custom; - named_arg_value named_args; - }; - - constexpr FMT_INLINE value() : no_value() {} - constexpr FMT_INLINE value(int val) : int_value(val) {} - constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} - constexpr FMT_INLINE value(long long val) : long_long_value(val) {} - constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} - FMT_INLINE value(int128_opt val) : int128_value(val) {} - FMT_INLINE value(uint128_opt val) : uint128_value(val) {} - constexpr FMT_INLINE value(float val) : float_value(val) {} - constexpr FMT_INLINE value(double val) : double_value(val) {} - FMT_INLINE value(long double val) : long_double_value(val) {} - constexpr FMT_INLINE value(bool val) : bool_value(val) {} - constexpr FMT_INLINE value(char_type val) : char_value(val) {} - FMT_CONSTEXPR FMT_INLINE value(const char_type* val) - { - string.data = val; - if (is_constant_evaluated()) - string.size = {}; - } - FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) - { - string.data = val.data(); - string.size = val.size(); - } - FMT_INLINE value(const void* val) : pointer(val) {} - FMT_INLINE value(const named_arg_info* args, size_t size) : named_args{args, size} {} - - template - FMT_CONSTEXPR20 FMT_INLINE value(T& val) - { - using value_type = remove_const_t; - custom.value = const_cast(std::addressof(val)); - // Get the formatter type through the context to allow different contexts - // have different extension points, e.g. `formatter` for `format` and - // `printf_formatter` for `printf`. - custom.format = format_custom_arg>; - } - value(unformattable); - value(unformattable_char); - value(unformattable_pointer); - - private: - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom_arg(void* arg, typename Context::parse_context_type& parse_ctx, Context& ctx) - { - auto f = Formatter(); - parse_ctx.advance_to(f.parse(parse_ctx)); - using qualified_type = conditional_t(), const T, T>; - // Calling format through a mutable reference is deprecated. - ctx.advance_to(f.format(*static_cast(arg), ctx)); - } - }; - - // 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. - enum { long_short = sizeof(long) == sizeof(int) }; - using long_type = conditional_t; - using ulong_type = conditional_t; - - template - struct format_as_result { - template ::value || std::is_class::value)> - static auto map(U*) -> remove_cvref_t()))>; - static auto map(...) -> void; - - using type = decltype(map(static_cast(nullptr))); - }; - template - using format_as_t = typename format_as_result::type; - - template - struct has_format_as : bool_constant, void>::value> {}; - - // Maps formatting arguments to core types. - // arg_mapper reports errors by returning unformattable instead of using - // static_assert because it's used in the is_formattable trait. - template - struct arg_mapper { - using char_type = typename Context::char_type; - - FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) -> unsigned long long { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } - - template ::value || std::is_same::value)> - FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type - { - return val; - } - template ::value || +template struct string_value { + const Char* data; + size_t size; +}; + +template struct named_arg_value { + const named_arg_info* data; + size_t size; +}; + +template struct custom_value { + using parse_context = typename Context::parse_context_type; + void* value; + void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); +}; + +// A formatting argument value. +template class value { + public: + using char_type = typename Context::char_type; + + union { + monostate no_value; + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + int128_opt int128_value; + uint128_opt uint128_value; + bool bool_value; + char_type char_value; + float float_value; + double double_value; + long double long_double_value; + const void* pointer; + string_value string; + custom_value custom; + named_arg_value named_args; + }; + + constexpr FMT_INLINE value() : no_value() {} + constexpr FMT_INLINE value(int val) : int_value(val) {} + constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} + constexpr FMT_INLINE value(long long val) : long_long_value(val) {} + constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} + FMT_INLINE value(int128_opt val) : int128_value(val) {} + FMT_INLINE value(uint128_opt val) : uint128_value(val) {} + constexpr FMT_INLINE value(float val) : float_value(val) {} + constexpr FMT_INLINE value(double val) : double_value(val) {} + FMT_INLINE value(long double val) : long_double_value(val) {} + constexpr FMT_INLINE value(bool val) : bool_value(val) {} + constexpr FMT_INLINE value(char_type val) : char_value(val) {} + FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { + string.data = val; + if (is_constant_evaluated()) string.size = {}; + } + FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) { + string.data = val.data(); + string.size = val.size(); + } + FMT_INLINE value(const void* val) : pointer(val) {} + FMT_INLINE value(const named_arg_info* args, size_t size) + : named_args{args, size} {} + + template FMT_CONSTEXPR20 FMT_INLINE value(T& val) { + using value_type = remove_const_t; + custom.value = const_cast(std::addressof(val)); + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter` for `format` and + // `printf_formatter` for `printf`. + custom.format = format_custom_arg< + value_type, typename Context::template formatter_type>; + } + value(unformattable); + value(unformattable_char); + value(unformattable_pointer); + + private: + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg(void* arg, + typename Context::parse_context_type& parse_ctx, + Context& ctx) { + auto f = Formatter(); + parse_ctx.advance_to(f.parse(parse_ctx)); + using qualified_type = + conditional_t(), const T, T>; + // Calling format through a mutable reference is deprecated. + ctx.advance_to(f.format(*static_cast(arg), ctx)); + } +}; + +// 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. +enum { long_short = sizeof(long) == sizeof(int) }; +using long_type = conditional_t; +using ulong_type = conditional_t; + +template struct format_as_result { + template ::value || std::is_class::value)> + static auto map(U*) -> remove_cvref_t()))>; + static auto map(...) -> void; + + using type = decltype(map(static_cast(nullptr))); +}; +template using format_as_t = typename format_as_result::type; + +template +struct has_format_as + : bool_constant, void>::value> {}; + +// Maps formatting arguments to core types. +// arg_mapper reports errors by returning unformattable instead of using +// static_assert because it's used in the is_formattable trait. +template struct arg_mapper { + using char_type = typename Context::char_type; + + FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) + -> unsigned long long { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type { + return val; + } + template ::value || #ifdef __cpp_char8_t - std::is_same::value || -#endif - std::is_same::value || std::is_same::value) && - !std::is_same::value, - int> = 0> - FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char - { - return {}; - } - - FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { return val; } - - FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { return val; } - template ::value && !std::is_pointer::value && std::is_same>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> basic_string_view - { - return to_string_view(val); - } - template ::value && !std::is_pointer::value && !std::is_same>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char - { - return {}; - } - - FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { return val; } - FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { return val; } - - // Use SFINAE instead of a const T* parameter to avoid a conflict with the - // array overload. - template ::value || std::is_member_pointer::value || std::is_function::type>::value || (std::is_array::value && !std::is_convertible::value))> - FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer - { - return {}; - } - - template ::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] - { - return values; - } - - // Only map owning types because mapping views can be unsafe. - template , FMT_ENABLE_IF(std::is_arithmetic::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(FMT_DECLTYPE_THIS map(U())) - { - return map(format_as(val)); - } - - template > - struct formattable : bool_constant() || (has_formatter::value && !std::is_const::value)> {}; - - template ::value)> - FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& - { - return val; - } - template ::value)> - FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable - { - return {}; - } - - template , FMT_ENABLE_IF((std::is_class::value || std::is_enum::value || std::is_union::value) && !is_string::value && !is_char::value && !is_named_arg::value && !std::is_arithmetic>::value)> - FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(FMT_DECLTYPE_THIS do_map(val)) - { - return do_map(val); - } - - template ::value)> - FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) - { - return map(named_arg.value); - } - - auto map(...) -> unformattable { return {}; } - }; - - // A type constant after applying arg_mapper. - template - using mapped_type_constant = type_constant().map(std::declval())), typename Context::char_type>; - - enum { packed_arg_bits = 4 }; - // Maximum number of arguments with packed types. - enum { max_packed_args = 62 / packed_arg_bits }; - enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; - enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; - - template - auto copy_str(InputIt begin, InputIt end, appender out) -> appender - { - get_container(out).append(begin, end); - return out; - } - template - auto copy_str(InputIt begin, InputIt end, std::back_insert_iterator out) -> std::back_insert_iterator - { - get_container(out).append(begin, end); - return out; - } + std::is_same::value || +#endif + std::is_same::value || + std::is_same::value) && + !std::is_same::value, + int> = 0> + FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { + return val; + } + + FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { + return val; + } + template ::value && !std::is_pointer::value && + std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) + -> basic_string_view { + return to_string_view(val); + } + template ::value && !std::is_pointer::value && + !std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { + return val; + } + + // Use SFINAE instead of a const T* parameter to avoid a conflict with the + // array overload. + template < + typename T, + FMT_ENABLE_IF( + std::is_pointer::value || std::is_member_pointer::value || + std::is_function::type>::value || + (std::is_array::value && + !std::is_convertible::value))> + FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { + return {}; + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] { + return values; + } + + // Only map owning types because mapping views can be unsafe. + template , + FMT_ENABLE_IF(std::is_arithmetic::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) + -> decltype(FMT_DECLTYPE_THIS map(U())) { + return map(format_as(val)); + } + + template > + struct formattable : bool_constant() || + (has_formatter::value && + !std::is_const::value)> {}; + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& { + return val; + } + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable { + return {}; + } + + template , + FMT_ENABLE_IF((std::is_class::value || std::is_enum::value || + std::is_union::value) && + !is_string::value && !is_char::value && + !is_named_arg::value && + !std::is_arithmetic>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T& val) + -> decltype(FMT_DECLTYPE_THIS do_map(val)) { + return do_map(val); + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) + -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) { + return map(named_arg.value); + } + + auto map(...) -> unformattable { return {}; } +}; - template - FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt - { - return detail::copy_str(rng.begin(), rng.end(), out); - } +// A type constant after applying arg_mapper. +template +using mapped_type_constant = + type_constant().map(std::declval())), + typename Context::char_type>; + +enum { packed_arg_bits = 4 }; +// Maximum number of arguments with packed types. +enum { max_packed_args = 62 / packed_arg_bits }; +enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; +enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; + +template +auto copy_str(InputIt begin, InputIt end, appender out) -> appender { + get_container(out).append(begin, end); + return out; +} +template +auto copy_str(InputIt begin, InputIt end, + std::back_insert_iterator out) + -> std::back_insert_iterator { + get_container(out).append(begin, end); + return out; +} + +template +FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt { + return detail::copy_str(rng.begin(), rng.end(), out); +} #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 - // A workaround for gcc 4.8 to make void_t work in a SFINAE context. - template - struct void_t_impl { - using type = void; - }; - template - using void_t = typename void_t_impl::type; +// A workaround for gcc 4.8 to make void_t work in a SFINAE context. +template struct void_t_impl { + using type = void; +}; +template using void_t = typename void_t_impl::type; #else - template - using void_t = void; +template using void_t = void; #endif - template - struct is_output_iterator : std::false_type {}; +template +struct is_output_iterator : std::false_type {}; - template - struct is_output_iterator::iterator_category, decltype(*std::declval() = std::declval())>> : std::true_type {}; +template +struct is_output_iterator< + It, T, + void_t::iterator_category, + decltype(*std::declval() = std::declval())>> + : std::true_type {}; - template - struct is_back_insert_iterator : std::false_type {}; - template - struct is_back_insert_iterator> : std::true_type {}; +template struct is_back_insert_iterator : std::false_type {}; +template +struct is_back_insert_iterator> + : std::true_type {}; - // A type-erased reference to an std::locale to avoid a heavy include. - class locale_ref { - private: - const void* locale_; // A type-erased pointer to std::locale. +// A type-erased reference to an std::locale to avoid a heavy include. +class locale_ref { + private: + const void* locale_; // A type-erased pointer to std::locale. - public: - constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} - template - explicit locale_ref(const Locale& loc); + public: + constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} + template explicit locale_ref(const Locale& loc); - explicit operator bool() const noexcept { return locale_ != nullptr; } + explicit operator bool() const noexcept { return locale_ != nullptr; } - template - auto get() const -> Locale; - }; + template auto get() const -> Locale; +}; - template - constexpr auto encode_types() -> unsigned long long - { - return 0; - } +template constexpr auto encode_types() -> unsigned long long { + return 0; +} - template - constexpr auto encode_types() -> unsigned long long - { - return static_cast(mapped_type_constant::value) | (encode_types() << packed_arg_bits); - } +template +constexpr auto encode_types() -> unsigned long long { + return static_cast(mapped_type_constant::value) | + (encode_types() << packed_arg_bits); +} #if defined(__cpp_if_constexpr) - // This type is intentionally undefined, only used for errors - template - struct type_is_unformattable_for; +// This type is intentionally undefined, only used for errors +template struct type_is_unformattable_for; #endif - template - FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value - { - using arg_type = remove_cvref_t().map(val))>; +template +FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value { + using arg_type = remove_cvref_t().map(val))>; - constexpr bool formattable_char = !std::is_same::value; - static_assert(formattable_char, "Mixing character types is disallowed."); + constexpr bool formattable_char = + !std::is_same::value; + static_assert(formattable_char, "Mixing character types is disallowed."); - // Formatting of arbitrary pointers is disallowed. If you want to format a - // pointer cast it to `void*` or `const void*`. In particular, this forbids - // formatting of `[const] volatile char*` printed as bool by iostreams. - constexpr bool formattable_pointer = !std::is_same::value; - static_assert(formattable_pointer, "Formatting of non-void pointers is disallowed."); + // Formatting of arbitrary pointers is disallowed. If you want to format a + // pointer cast it to `void*` or `const void*`. In particular, this forbids + // formatting of `[const] volatile char*` printed as bool by iostreams. + constexpr bool formattable_pointer = + !std::is_same::value; + static_assert(formattable_pointer, + "Formatting of non-void pointers is disallowed."); - constexpr bool formattable = !std::is_same::value; + constexpr bool formattable = !std::is_same::value; #if defined(__cpp_if_constexpr) - if constexpr (!formattable) - { - type_is_unformattable_for _; - } -#endif - static_assert(formattable, - "Cannot format an argument. To make type T formattable provide a " - "formatter specialization: https://fmt.dev/latest/api.html#udt"); - return {arg_mapper().map(val)}; - } + if constexpr (!formattable) { + type_is_unformattable_for _; + } +#endif + static_assert( + formattable, + "Cannot format an argument. To make type T formattable provide a " + "formatter specialization: https://fmt.dev/latest/api.html#udt"); + return {arg_mapper().map(val)}; +} - template - FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg - { - auto arg = basic_format_arg(); - arg.type_ = mapped_type_constant::value; - arg.value_ = make_arg(val); - return arg; - } +template +FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg { + auto arg = basic_format_arg(); + arg.type_ = mapped_type_constant::value; + arg.value_ = make_arg(val); + return arg; +} - template - FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg - { - return make_arg(val); - } -} // namespace detail +template +FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg { + return make_arg(val); +} +} // namespace detail FMT_BEGIN_EXPORT // A formatting argument. Context is a template parameter for the compiled API // where output can be unbuffered. -template -class basic_format_arg { -private: - detail::value value_; - detail::type type_; +template class basic_format_arg { + private: + detail::value value_; + detail::type type_; - template - friend FMT_CONSTEXPR auto detail::make_arg(T& value) -> basic_format_arg; + template + friend FMT_CONSTEXPR auto detail::make_arg(T& value) + -> basic_format_arg; - template - friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)); + template + friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, + const basic_format_arg& arg) + -> decltype(vis(0)); - friend class basic_format_args; - friend class dynamic_format_arg_store; + friend class basic_format_args; + friend class dynamic_format_arg_store; - using char_type = typename Context::char_type; + using char_type = typename Context::char_type; - template - friend struct detail::arg_data; + template + friend struct detail::arg_data; - basic_format_arg(const detail::named_arg_info* args, size_t size) : value_(args, size) {} + basic_format_arg(const detail::named_arg_info* args, size_t size) + : value_(args, size) {} -public: - class handle { - public: - explicit handle(detail::custom_value custom) : custom_(custom) {} + public: + class handle { + public: + explicit handle(detail::custom_value custom) : custom_(custom) {} - void format(typename Context::parse_context_type& parse_ctx, Context& ctx) const { custom_.format(custom_.value, parse_ctx, ctx); } + void format(typename Context::parse_context_type& parse_ctx, + Context& ctx) const { + custom_.format(custom_.value, parse_ctx, ctx); + } - private: - detail::custom_value custom_; - }; + private: + detail::custom_value custom_; + }; - constexpr basic_format_arg() : type_(detail::type::none_type) {} + constexpr basic_format_arg() : type_(detail::type::none_type) {} - constexpr explicit operator bool() const noexcept { return type_ != detail::type::none_type; } + constexpr explicit operator bool() const noexcept { + return type_ != detail::type::none_type; + } - auto type() const -> detail::type { return type_; } + auto type() const -> detail::type { return type_; } - auto is_integral() const -> bool { return detail::is_integral_type(type_); } - auto is_arithmetic() const -> bool { return detail::is_arithmetic_type(type_); } + auto is_integral() const -> bool { return detail::is_integral_type(type_); } + auto is_arithmetic() const -> bool { + return detail::is_arithmetic_type(type_); + } - FMT_INLINE auto format_custom(const char_type* parse_begin, typename Context::parse_context_type& parse_ctx, Context& ctx) -> bool - { - if (type_ != detail::type::custom_type) - return false; - parse_ctx.advance_to(parse_begin); - value_.custom.format(value_.custom.value, parse_ctx, ctx); - return true; - } + FMT_INLINE auto format_custom(const char_type* parse_begin, + typename Context::parse_context_type& parse_ctx, + Context& ctx) -> bool { + if (type_ != detail::type::custom_type) return false; + parse_ctx.advance_to(parse_begin); + value_.custom.format(value_.custom.value, parse_ctx, ctx); + return true; + } }; /** @@ -1640,103 +1695,107 @@ class basic_format_arg { */ // DEPRECATED! template -FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) -{ - switch (arg.type_) - { - case detail::type::none_type: - break; - case detail::type::int_type: - return vis(arg.value_.int_value); - case detail::type::uint_type: - return vis(arg.value_.uint_value); - case detail::type::long_long_type: - return vis(arg.value_.long_long_value); - case detail::type::ulong_long_type: - return vis(arg.value_.ulong_long_value); - case detail::type::int128_type: - return vis(detail::convert_for_visit(arg.value_.int128_value)); - case detail::type::uint128_type: - return vis(detail::convert_for_visit(arg.value_.uint128_value)); - case detail::type::bool_type: - return vis(arg.value_.bool_value); - case detail::type::char_type: - return vis(arg.value_.char_value); - case detail::type::float_type: - return vis(arg.value_.float_value); - case detail::type::double_type: - return vis(arg.value_.double_value); - case detail::type::long_double_type: - return vis(arg.value_.long_double_value); - case detail::type::cstring_type: - return vis(arg.value_.string.data); - case detail::type::string_type: - using sv = basic_string_view; - return vis(sv(arg.value_.string.data, arg.value_.string.size)); - case detail::type::pointer_type: - return vis(arg.value_.pointer); - case detail::type::custom_type: - return vis(typename basic_format_arg::handle(arg.value_.custom)); - } - return vis(monostate()); +FMT_CONSTEXPR FMT_INLINE auto visit_format_arg( + Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { + switch (arg.type_) { + case detail::type::none_type: + break; + case detail::type::int_type: + return vis(arg.value_.int_value); + case detail::type::uint_type: + return vis(arg.value_.uint_value); + case detail::type::long_long_type: + return vis(arg.value_.long_long_value); + case detail::type::ulong_long_type: + return vis(arg.value_.ulong_long_value); + case detail::type::int128_type: + return vis(detail::convert_for_visit(arg.value_.int128_value)); + case detail::type::uint128_type: + return vis(detail::convert_for_visit(arg.value_.uint128_value)); + case detail::type::bool_type: + return vis(arg.value_.bool_value); + case detail::type::char_type: + return vis(arg.value_.char_value); + case detail::type::float_type: + return vis(arg.value_.float_value); + case detail::type::double_type: + return vis(arg.value_.double_value); + case detail::type::long_double_type: + return vis(arg.value_.long_double_value); + case detail::type::cstring_type: + return vis(arg.value_.string.data); + case detail::type::string_type: + using sv = basic_string_view; + return vis(sv(arg.value_.string.data, arg.value_.string.size)); + case detail::type::pointer_type: + return vis(arg.value_.pointer); + case detail::type::custom_type: + return vis(typename basic_format_arg::handle(arg.value_.custom)); + } + return vis(monostate()); } // Formatting context. -template -class basic_format_context { -private: - OutputIt out_; - basic_format_args args_; - detail::locale_ref loc_; - -public: - using iterator = OutputIt; - using format_arg = basic_format_arg; - using format_args = basic_format_args; - using parse_context_type = basic_format_parse_context; - template - using formatter_type = formatter; - - /** The character type for the output. */ - using char_type = Char; - - basic_format_context(basic_format_context&&) = default; - basic_format_context(const basic_format_context&) = delete; - void operator=(const basic_format_context&) = delete; - /** - Constructs a ``basic_format_context`` object. References to the arguments - are stored in the object so make sure they have appropriate lifetimes. - */ - constexpr basic_format_context(OutputIt out, format_args ctx_args, detail::locale_ref loc = {}) : out_(out), args_(ctx_args), loc_(loc) {} - - constexpr auto arg(int id) const -> format_arg { return args_.get(id); } - FMT_CONSTEXPR auto arg(basic_string_view name) -> format_arg { return args_.get(name); } - FMT_CONSTEXPR auto arg_id(basic_string_view name) -> int { return args_.get_id(name); } - auto args() const -> const format_args& { return args_; } - - // DEPRECATED! - FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; } - void on_error(const char* message) { error_handler().on_error(message); } - - // Returns an iterator to the beginning of the output range. - FMT_CONSTEXPR auto out() -> iterator { return out_; } - - // Advances the begin iterator to ``it``. - void advance_to(iterator it) - { - if (!detail::is_back_insert_iterator()) - out_ = it; - } - - FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } +template class basic_format_context { + private: + OutputIt out_; + basic_format_args args_; + detail::locale_ref loc_; + + public: + using iterator = OutputIt; + using format_arg = basic_format_arg; + using format_args = basic_format_args; + using parse_context_type = basic_format_parse_context; + template using formatter_type = formatter; + + /** The character type for the output. */ + using char_type = Char; + + basic_format_context(basic_format_context&&) = default; + basic_format_context(const basic_format_context&) = delete; + void operator=(const basic_format_context&) = delete; + /** + Constructs a ``basic_format_context`` object. References to the arguments + are stored in the object so make sure they have appropriate lifetimes. + */ + constexpr basic_format_context(OutputIt out, format_args ctx_args, + detail::locale_ref loc = {}) + : out_(out), args_(ctx_args), loc_(loc) {} + + constexpr auto arg(int id) const -> format_arg { return args_.get(id); } + FMT_CONSTEXPR auto arg(basic_string_view name) -> format_arg { + return args_.get(name); + } + FMT_CONSTEXPR auto arg_id(basic_string_view name) -> int { + return args_.get_id(name); + } + auto args() const -> const format_args& { return args_; } + + // DEPRECATED! + FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; } + void on_error(const char* message) { error_handler().on_error(message); } + + // Returns an iterator to the beginning of the output range. + FMT_CONSTEXPR auto out() -> iterator { return out_; } + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) { + if (!detail::is_back_insert_iterator()) out_ = it; + } + + FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } }; template -using buffer_context = basic_format_context, Char>; +using buffer_context = + basic_format_context, Char>; using format_context = buffer_context; template -using is_formattable = bool_constant>().map(std::declval()))>::value>; +using is_formattable = bool_constant>() + .map(std::declval()))>::value>; /** \rst @@ -1752,30 +1811,38 @@ class format_arg_store : public basic_format_args #endif { -private: - static const size_t num_args = sizeof...(Args); - static constexpr size_t num_named_args = detail::count_named_args(); - static const bool is_packed = num_args <= detail::max_packed_args; - - using value_type = conditional_t, basic_format_arg>; - - detail::arg_data data_; - - friend class basic_format_args; - - static constexpr unsigned long long desc = (is_packed ? detail::encode_types() : detail::is_unpacked_bit | num_args) | (num_named_args != 0 ? static_cast(detail::has_named_args_bit) : 0); - -public: - template - FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args) : + private: + static const size_t num_args = sizeof...(Args); + static constexpr size_t num_named_args = detail::count_named_args(); + static const bool is_packed = num_args <= detail::max_packed_args; + + using value_type = conditional_t, + basic_format_arg>; + + detail::arg_data + data_; + + friend class basic_format_args; + + static constexpr unsigned long long desc = + (is_packed ? detail::encode_types() + : detail::is_unpacked_bit | num_args) | + (num_named_args != 0 + ? static_cast(detail::has_named_args_bit) + : 0); + + public: + template + FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args) + : #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 basic_format_args(*this), #endif - data_{detail::make_arg(args)...} - { - if (detail::const_check(num_named_args != 0)) - detail::init_named_args(data_.named_args(), 0, 0, args...); - } + data_{detail::make_arg(args)...} { + if (detail::const_check(num_named_args != 0)) + detail::init_named_args(data_.named_args(), 0, 0, args...); + } }; /** @@ -1788,9 +1855,9 @@ class format_arg_store */ // Arguments are taken by lvalue references to avoid some lifetime issues. template -constexpr auto make_format_args(T&... args) -> format_arg_store...> -{ - return {args...}; +constexpr auto make_format_args(T&... args) + -> format_arg_store...> { + return {args...}; } /** @@ -1805,10 +1872,9 @@ constexpr auto make_format_args(T&... args) -> format_arg_store -inline auto arg(const Char* name, const T& arg) -> detail::named_arg -{ - static_assert(!detail::is_named_arg(), "nested named arguments"); - return {name, arg}; +inline auto arg(const Char* name, const T& arg) -> detail::named_arg { + static_assert(!detail::is_named_arg(), "nested named arguments"); + return {name, arg}; } FMT_END_EXPORT @@ -1822,114 +1888,115 @@ FMT_END_EXPORT format_args args = make_format_args(); // Error: dangling reference \endrst */ -template -class basic_format_args { -public: - using size_type = int; - using format_arg = basic_format_arg; - -private: - // A descriptor that contains information about formatting arguments. - // If the number of arguments is less or equal to max_packed_args then - // argument types are passed in the descriptor. This reduces binary code size - // per formatting function call. - unsigned long long desc_; - union { - // If is_packed() returns true then argument values are stored in values_; - // otherwise they are stored in args_. This is done to improve cache - // locality and reduce compiled code size since 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 detail::value* values_; - const format_arg* args_; - }; - - constexpr auto is_packed() const -> bool { return (desc_ & detail::is_unpacked_bit) == 0; } - auto has_named_args() const -> bool { return (desc_ & detail::has_named_args_bit) != 0; } - - FMT_CONSTEXPR auto type(int index) const -> detail::type - { - int shift = index * detail::packed_arg_bits; - unsigned int mask = (1 << detail::packed_arg_bits) - 1; - return static_cast((desc_ >> shift) & mask); - } - - constexpr FMT_INLINE basic_format_args(unsigned long long desc, const detail::value* values) : desc_(desc), values_(values) {} - constexpr basic_format_args(unsigned long long desc, const format_arg* args) : desc_(desc), args_(args) {} - -public: - constexpr basic_format_args() : desc_(0), args_(nullptr) {} - - /** - \rst - Constructs a `basic_format_args` object from `~fmt::format_arg_store`. - \endrst - */ - template - constexpr FMT_INLINE basic_format_args(const format_arg_store& store) : basic_format_args(format_arg_store::desc, store.data_.args()) - { - } - - /** - \rst - Constructs a `basic_format_args` object from - `~fmt::dynamic_format_arg_store`. - \endrst - */ - constexpr FMT_INLINE basic_format_args(const dynamic_format_arg_store& store) : basic_format_args(store.get_types(), store.data()) {} - - /** - \rst - Constructs a `basic_format_args` object from a dynamic set of arguments. - \endrst - */ - constexpr basic_format_args(const format_arg* args, int count) : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), args) {} - - /** Returns the argument with the specified id. */ - FMT_CONSTEXPR auto get(int id) const -> format_arg - { - format_arg arg; - if (!is_packed()) - { - if (id < max_size()) - arg = args_[id]; - return arg; - } - if (id >= detail::max_packed_args) - return arg; - arg.type_ = type(id); - if (arg.type_ == detail::type::none_type) - return arg; - arg.value_ = values_[id]; - return arg; - } - - template - auto get(basic_string_view name) const -> format_arg - { - int id = get_id(name); - return id >= 0 ? get(id) : format_arg(); - } - - template - auto get_id(basic_string_view name) const -> int - { - if (!has_named_args()) - return -1; - const auto& named_args = (is_packed() ? values_[-1] : args_[-1].value_).named_args; - for (size_t i = 0; i < named_args.size; ++i) - { - if (named_args.data[i].name == name) - return named_args.data[i].id; - } - return -1; - } - - auto max_size() const -> int - { - unsigned long long max_packed = detail::max_packed_args; - return static_cast(is_packed() ? max_packed : desc_ & ~detail::is_unpacked_bit); - } +template class basic_format_args { + public: + using size_type = int; + using format_arg = basic_format_arg; + + private: + // A descriptor that contains information about formatting arguments. + // If the number of arguments is less or equal to max_packed_args then + // argument types are passed in the descriptor. This reduces binary code size + // per formatting function call. + unsigned long long desc_; + union { + // If is_packed() returns true then argument values are stored in values_; + // otherwise they are stored in args_. This is done to improve cache + // locality and reduce compiled code size since 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 detail::value* values_; + const format_arg* args_; + }; + + constexpr auto is_packed() const -> bool { + return (desc_ & detail::is_unpacked_bit) == 0; + } + auto has_named_args() const -> bool { + return (desc_ & detail::has_named_args_bit) != 0; + } + + FMT_CONSTEXPR auto type(int index) const -> detail::type { + int shift = index * detail::packed_arg_bits; + unsigned int mask = (1 << detail::packed_arg_bits) - 1; + return static_cast((desc_ >> shift) & mask); + } + + constexpr FMT_INLINE basic_format_args(unsigned long long desc, + const detail::value* values) + : desc_(desc), values_(values) {} + constexpr basic_format_args(unsigned long long desc, const format_arg* args) + : desc_(desc), args_(args) {} + + public: + constexpr basic_format_args() : desc_(0), args_(nullptr) {} + + /** + \rst + Constructs a `basic_format_args` object from `~fmt::format_arg_store`. + \endrst + */ + template + constexpr FMT_INLINE basic_format_args( + const format_arg_store& store) + : basic_format_args(format_arg_store::desc, + store.data_.args()) {} + + /** + \rst + Constructs a `basic_format_args` object from + `~fmt::dynamic_format_arg_store`. + \endrst + */ + constexpr FMT_INLINE basic_format_args( + const dynamic_format_arg_store& store) + : basic_format_args(store.get_types(), store.data()) {} + + /** + \rst + Constructs a `basic_format_args` object from a dynamic set of arguments. + \endrst + */ + constexpr basic_format_args(const format_arg* args, int count) + : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), + args) {} + + /** Returns the argument with the specified id. */ + FMT_CONSTEXPR auto get(int id) const -> format_arg { + format_arg arg; + if (!is_packed()) { + if (id < max_size()) arg = args_[id]; + return arg; + } + if (id >= detail::max_packed_args) return arg; + arg.type_ = type(id); + if (arg.type_ == detail::type::none_type) return arg; + arg.value_ = values_[id]; + return arg; + } + + template + auto get(basic_string_view name) const -> format_arg { + int id = get_id(name); + return id >= 0 ? get(id) : format_arg(); + } + + template + auto get_id(basic_string_view name) const -> int { + if (!has_named_args()) return -1; + const auto& named_args = + (is_packed() ? values_[-1] : args_[-1].value_).named_args; + for (size_t i = 0; i < named_args.size; ++i) { + if (named_args.data[i].name == name) return named_args.data[i].id; + } + return -1; + } + + auto max_size() const -> int { + unsigned long long max_packed = detail::max_packed_args; + return static_cast(is_packed() ? max_packed + : desc_ & ~detail::is_unpacked_bit); + } }; /** An alias to ``basic_format_args``. */ @@ -1942,846 +2009,796 @@ FMT_EXPORT using format_args = basic_format_args; // Additionally, if an underlying type is specified, older gcc incorrectly warns // that the type is too small. Both bugs are fixed in gcc 9.3. #if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 -#define FMT_ENUM_UNDERLYING_TYPE(type) +# define FMT_ENUM_UNDERLYING_TYPE(type) #else -#define FMT_ENUM_UNDERLYING_TYPE(type) : type +# define FMT_ENUM_UNDERLYING_TYPE(type) : type #endif -namespace align -{ - enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char) { none, left, right, center, numeric }; +namespace align { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, + numeric}; } using align_t = align::type; -namespace sign -{ - enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char) { none, minus, plus, space }; +namespace sign { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; } using sign_t = sign::type; -namespace detail -{ - - // Workaround an array initialization issue in gcc 4.8. - template - struct fill_t { - private: - enum { max_size = 4 }; - Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; - unsigned char size_ = 1; - - public: - FMT_CONSTEXPR void operator=(basic_string_view s) - { - auto size = s.size(); - FMT_ASSERT(size <= max_size, "invalid fill"); - for (size_t i = 0; i < size; ++i) - data_[i] = s[i]; - size_ = static_cast(size); - } - - constexpr auto size() const -> size_t { return size_; } - constexpr auto data() const -> const Char* { return data_; } - - FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } - FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { return data_[index]; } - }; -} // namespace detail +namespace detail { + +// Workaround an array initialization issue in gcc 4.8. +template struct fill_t { + private: + enum { max_size = 4 }; + Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; + unsigned char size_ = 1; + + public: + FMT_CONSTEXPR void operator=(basic_string_view s) { + auto size = s.size(); + FMT_ASSERT(size <= max_size, "invalid fill"); + for (size_t i = 0; i < size; ++i) data_[i] = s[i]; + size_ = static_cast(size); + } + + constexpr auto size() const -> size_t { return size_; } + constexpr auto data() const -> const Char* { return data_; } + + FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } + FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { + return data_[index]; + } +}; +} // namespace detail enum class presentation_type : unsigned char { - none, - dec, // 'd' - oct, // 'o' - hex_lower, // 'x' - hex_upper, // 'X' - bin_lower, // 'b' - bin_upper, // 'B' - hexfloat_lower, // 'a' - hexfloat_upper, // 'A' - exp_lower, // 'e' - exp_upper, // 'E' - fixed_lower, // 'f' - fixed_upper, // 'F' - general_lower, // 'g' - general_upper, // 'G' - chr, // 'c' - string, // 's' - pointer, // 'p' - debug // '?' + none, + dec, // 'd' + oct, // 'o' + hex_lower, // 'x' + hex_upper, // 'X' + bin_lower, // 'b' + bin_upper, // 'B' + hexfloat_lower, // 'a' + hexfloat_upper, // 'A' + exp_lower, // 'e' + exp_upper, // 'E' + fixed_lower, // 'f' + fixed_upper, // 'F' + general_lower, // 'g' + general_upper, // 'G' + chr, // 'c' + string, // 's' + pointer, // 'p' + debug // '?' }; // Format specifiers for built-in and string types. +template struct format_specs { + int width; + int precision; + presentation_type type; + align_t align : 4; + sign_t sign : 3; + bool alt : 1; // Alternate form ('#'). + bool localized : 1; + detail::fill_t fill; + + constexpr format_specs() + : width(0), + precision(-1), + type(presentation_type::none), + align(align::none), + sign(sign::none), + alt(false), + localized(false) {} +}; + +namespace detail { + +enum class arg_id_kind { none, index, name }; + +// An argument reference. +template struct arg_ref { + FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} + + FMT_CONSTEXPR explicit arg_ref(int index) + : kind(arg_id_kind::index), val(index) {} + FMT_CONSTEXPR explicit arg_ref(basic_string_view name) + : kind(arg_id_kind::name), val(name) {} + + FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { + kind = arg_id_kind::index; + val.index = idx; + return *this; + } + + arg_id_kind kind; + union value { + FMT_CONSTEXPR value(int idx = 0) : index(idx) {} + FMT_CONSTEXPR value(basic_string_view n) : name(n) {} + + int index; + basic_string_view name; + } val; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow reusing the same parsed specifiers with +// different sets of arguments (precompilation of format strings). template -struct format_specs { - int width; - int precision; - presentation_type type; - align_t align : 4; - sign_t sign : 3; - bool alt : 1; // Alternate form ('#'). - bool localized : 1; - detail::fill_t fill; - - constexpr format_specs() : width(0), precision(-1), type(presentation_type::none), align(align::none), sign(sign::none), alt(false), localized(false) {} +struct dynamic_format_specs : format_specs { + arg_ref width_ref; + arg_ref precision_ref; }; -namespace detail -{ +// Converts a character to ASCII. Returns '\0' on conversion failure. +template ::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast(c) : '\0'; +} +template ::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast(c) : '\0'; +} - enum class arg_id_kind { none, index, name }; - - // An argument reference. - template - struct arg_ref { - FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} - - FMT_CONSTEXPR explicit arg_ref(int index) : kind(arg_id_kind::index), val(index) {} - FMT_CONSTEXPR explicit arg_ref(basic_string_view name) : kind(arg_id_kind::name), val(name) {} - - FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& - { - kind = arg_id_kind::index; - val.index = idx; - return *this; - } - - arg_id_kind kind; - union value { - FMT_CONSTEXPR value(int idx = 0) : index(idx) {} - FMT_CONSTEXPR value(basic_string_view n) : name(n) {} - - int index; - basic_string_view name; - } val; - }; - - // Format specifiers with width and precision resolved at formatting rather - // than parsing time to allow reusing the same parsed specifiers with - // different sets of arguments (precompilation of format strings). - template - struct dynamic_format_specs : format_specs { - arg_ref width_ref; - arg_ref precision_ref; - }; - - // Converts a character to ASCII. Returns '\0' on conversion failure. - template ::value)> - constexpr auto to_ascii(Char c) -> char - { - return c <= 0xff ? static_cast(c) : '\0'; - } - template ::value)> - constexpr auto to_ascii(Char c) -> char - { - return c <= 0xff ? static_cast(c) : '\0'; - } +// Returns the number of code units in a code point or 1 on error. +template +FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { + if (const_check(sizeof(Char) != 1)) return 1; + auto c = static_cast(*begin); + return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; +} - // Returns the number of code units in a code point or 1 on error. - template - FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int - { - if (const_check(sizeof(Char) != 1)) - return 1; - auto c = static_cast(*begin); - return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; - } +// Return the result via the out param to workaround gcc bug 77539. +template +FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { + for (out = first; out != last; ++out) { + if (*out == value) return true; + } + return false; +} - // Return the result via the out param to workaround gcc bug 77539. - template - FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool - { - for (out = first; out != last; ++out) - { - if (*out == value) - return true; - } - return false; - } +template <> +inline auto find(const char* first, const char* last, char value, + const char*& out) -> bool { + out = static_cast( + std::memchr(first, value, to_unsigned(last - first))); + return out != nullptr; +} - template <> - inline auto find(const char* first, const char* last, char value, const char*& out) -> bool - { - out = static_cast(std::memchr(first, value, to_unsigned(last - first))); - return out != nullptr; - } +// Parses the range [begin, end) as an unsigned integer. This function assumes +// that the range is non-empty and the first character is a digit. +template +FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, + int error_value) noexcept -> int { + FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); + unsigned value = 0, prev = 0; + auto p = begin; + do { + prev = value; + value = value * 10 + unsigned(*p - '0'); + ++p; + } while (p != end && '0' <= *p && *p <= '9'); + auto num_digits = p - begin; + begin = p; + if (num_digits <= std::numeric_limits::digits10) + return static_cast(value); + // Check for overflow. + const unsigned max = to_unsigned((std::numeric_limits::max)()); + return num_digits == std::numeric_limits::digits10 + 1 && + prev * 10ull + unsigned(p[-1] - '0') <= max + ? static_cast(value) + : error_value; +} - // Parses the range [begin, end) as an unsigned integer. This function assumes - // that the range is non-empty and the first character is a digit. - template - FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, int error_value) noexcept -> int - { - FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); - unsigned value = 0, prev = 0; - auto p = begin; - do - { - prev = value; - value = value * 10 + unsigned(*p - '0'); - ++p; - } - while (p != end && '0' <= *p && *p <= '9'); - auto num_digits = p - begin; - begin = p; - if (num_digits <= std::numeric_limits::digits10) - return static_cast(value); - // Check for overflow. - const unsigned max = to_unsigned((std::numeric_limits::max)()); - return num_digits == std::numeric_limits::digits10 + 1 && prev * 10ull + unsigned(p[-1] - '0') <= max ? static_cast(value) : error_value; - } +FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { + switch (c) { + case '<': + return align::left; + case '>': + return align::right; + case '^': + return align::center; + } + return align::none; +} - FMT_CONSTEXPR inline auto parse_align(char c) -> align_t - { - switch (c) - { - case '<': - return align::left; - case '>': - return align::right; - case '^': - return align::center; - } - return align::none; - } +template constexpr auto is_name_start(Char c) -> bool { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; +} - template - constexpr auto is_name_start(Char c) -> bool - { - return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; - } +template +FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + Char c = *begin; + if (c >= '0' && c <= '9') { + int index = 0; + constexpr int max = (std::numeric_limits::max)(); + if (c != '0') + index = parse_nonnegative_int(begin, end, max); + else + ++begin; + if (begin == end || (*begin != '}' && *begin != ':')) + throw_format_error("invalid format string"); + else + handler.on_index(index); + return begin; + } + if (!is_name_start(c)) { + throw_format_error("invalid format string"); + return begin; + } + auto it = begin; + do { + ++it; + } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); + handler.on_name({begin, to_unsigned(it - begin)}); + return it; +} - template - FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* - { - Char c = *begin; - if (c >= '0' && c <= '9') - { - int index = 0; - constexpr int max = (std::numeric_limits::max)(); - if (c != '0') - index = parse_nonnegative_int(begin, end, max); - else - ++begin; - if (begin == end || (*begin != '}' && *begin != ':')) - throw_format_error("invalid format string"); - else - handler.on_index(index); - return begin; - } - if (!is_name_start(c)) - { - throw_format_error("invalid format string"); - return begin; - } - auto it = begin; - do - { - ++it; - } - while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); - handler.on_name({begin, to_unsigned(it - begin)}); - return it; - } +template +FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + FMT_ASSERT(begin != end, ""); + Char c = *begin; + if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); + handler.on_auto(); + return begin; +} - template - FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* - { - FMT_ASSERT(begin != end, ""); - Char c = *begin; - if (c != '}' && c != ':') - return do_parse_arg_id(begin, end, handler); - handler.on_auto(); - return begin; - } +template struct dynamic_spec_id_handler { + basic_format_parse_context& ctx; + arg_ref& ref; + + FMT_CONSTEXPR void on_auto() { + int id = ctx.next_arg_id(); + ref = arg_ref(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_index(int id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_name(basic_string_view id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + } +}; + +// Parses [integer | "{" [arg_id] "}"]. +template +FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + FMT_ASSERT(begin != end, ""); + if ('0' <= *begin && *begin <= '9') { + int val = parse_nonnegative_int(begin, end, -1); + if (val != -1) + value = val; + else + throw_format_error("number is too big"); + } else if (*begin == '{') { + ++begin; + auto handler = dynamic_spec_id_handler{ctx, ref}; + if (begin != end) begin = parse_arg_id(begin, end, handler); + if (begin != end && *begin == '}') return ++begin; + throw_format_error("invalid format string"); + } + return begin; +} - template - struct dynamic_spec_id_handler { - basic_format_parse_context& ctx; - arg_ref& ref; - - FMT_CONSTEXPR void on_auto() - { - int id = ctx.next_arg_id(); - ref = arg_ref(id); - ctx.check_dynamic_spec(id); - } - FMT_CONSTEXPR void on_index(int id) - { - ref = arg_ref(id); - ctx.check_arg_id(id); - ctx.check_dynamic_spec(id); - } - FMT_CONSTEXPR void on_name(basic_string_view id) - { - ref = arg_ref(id); - ctx.check_arg_id(id); - } - }; - - // Parses [integer | "{" [arg_id] "}"]. - template - FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, int& value, arg_ref& ref, basic_format_parse_context& ctx) -> const Char* - { - FMT_ASSERT(begin != end, ""); - if ('0' <= *begin && *begin <= '9') - { - int val = parse_nonnegative_int(begin, end, -1); - if (val != -1) - value = val; - else - throw_format_error("number is too big"); - } - else if (*begin == '{') - { - ++begin; - auto handler = dynamic_spec_id_handler{ctx, ref}; - if (begin != end) - begin = parse_arg_id(begin, end, handler); - if (begin != end && *begin == '}') - return ++begin; - throw_format_error("invalid format string"); - } +template +FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + ++begin; + if (begin == end || *begin == '}') { + throw_format_error("invalid precision"); + return begin; + } + return parse_dynamic_spec(begin, end, value, ref, ctx); +} + +enum class state { start, align, sign, hash, zero, width, precision, locale }; + +// Parses standard format specifiers. +template +FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( + const Char* begin, const Char* end, dynamic_format_specs& specs, + basic_format_parse_context& ctx, type arg_type) -> const Char* { + auto c = '\0'; + if (end - begin > 1) { + auto next = to_ascii(begin[1]); + c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; + } else { + if (begin == end) return begin; + c = to_ascii(*begin); + } + + struct { + state current_state = state::start; + FMT_CONSTEXPR void operator()(state s, bool valid = true) { + if (current_state >= s || !valid) + throw_format_error("invalid format specifier"); + current_state = s; + } + } enter_state; + + using pres = presentation_type; + constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; + struct { + const Char*& begin; + dynamic_format_specs& specs; + type arg_type; + + FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { + if (!in(arg_type, set)) { + if (arg_type == type::none_type) return begin; + throw_format_error("invalid format specifier"); + } + specs.type = pres_type; + return begin + 1; + } + } parse_presentation_type{begin, specs, arg_type}; + + for (;;) { + switch (c) { + case '<': + case '>': + case '^': + enter_state(state::align); + specs.align = parse_align(c); + ++begin; + break; + case '+': + case '-': + case ' ': + if (arg_type == type::none_type) return begin; + enter_state(state::sign, in(arg_type, sint_set | float_set)); + switch (c) { + case '+': + specs.sign = sign::plus; + break; + case '-': + specs.sign = sign::minus; + break; + case ' ': + specs.sign = sign::space; + break; + } + ++begin; + break; + case '#': + if (arg_type == type::none_type) return begin; + enter_state(state::hash, is_arithmetic_type(arg_type)); + specs.alt = true; + ++begin; + break; + case '0': + enter_state(state::zero); + if (!is_arithmetic_type(arg_type)) { + if (arg_type == type::none_type) return begin; + throw_format_error("format specifier requires numeric argument"); + } + if (specs.align == align::none) { + // Ignore 0 if align is specified for compatibility with std::format. + specs.align = align::numeric; + specs.fill[0] = Char('0'); + } + ++begin; + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '{': + enter_state(state::width); + begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); + break; + case '.': + if (arg_type == type::none_type) return begin; + enter_state(state::precision, + in(arg_type, float_set | string_set | cstring_set)); + begin = parse_precision(begin, end, specs.precision, specs.precision_ref, + ctx); + break; + case 'L': + if (arg_type == type::none_type) return begin; + enter_state(state::locale, is_arithmetic_type(arg_type)); + specs.localized = true; + ++begin; + break; + case 'd': + return parse_presentation_type(pres::dec, integral_set); + case 'o': + return parse_presentation_type(pres::oct, integral_set); + case 'x': + return parse_presentation_type(pres::hex_lower, integral_set); + case 'X': + return parse_presentation_type(pres::hex_upper, integral_set); + case 'b': + return parse_presentation_type(pres::bin_lower, integral_set); + case 'B': + return parse_presentation_type(pres::bin_upper, integral_set); + case 'a': + return parse_presentation_type(pres::hexfloat_lower, float_set); + case 'A': + return parse_presentation_type(pres::hexfloat_upper, float_set); + case 'e': + return parse_presentation_type(pres::exp_lower, float_set); + case 'E': + return parse_presentation_type(pres::exp_upper, float_set); + case 'f': + return parse_presentation_type(pres::fixed_lower, float_set); + case 'F': + return parse_presentation_type(pres::fixed_upper, float_set); + case 'g': + return parse_presentation_type(pres::general_lower, float_set); + case 'G': + return parse_presentation_type(pres::general_upper, float_set); + case 'c': + if (arg_type == type::bool_type) + throw_format_error("invalid format specifier"); + return parse_presentation_type(pres::chr, integral_set); + case 's': + return parse_presentation_type(pres::string, + bool_set | string_set | cstring_set); + case 'p': + return parse_presentation_type(pres::pointer, pointer_set | cstring_set); + case '?': + return parse_presentation_type(pres::debug, + char_set | string_set | cstring_set); + case '}': + return begin; + default: { + if (*begin == '}') return begin; + // Parse fill and alignment. + auto fill_end = begin + code_point_length(begin); + if (end - fill_end <= 0) { + throw_format_error("invalid format specifier"); + return begin; + } + if (*begin == '{') { + throw_format_error("invalid fill character '{'"); return begin; + } + auto align = parse_align(to_ascii(*fill_end)); + enter_state(state::align, align != align::none); + specs.fill = {begin, to_unsigned(fill_end - begin)}; + specs.align = align; + begin = fill_end + 1; } - - template - FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, int& value, arg_ref& ref, basic_format_parse_context& ctx) -> const Char* - { - ++begin; - if (begin == end || *begin == '}') - { - throw_format_error("invalid precision"); - return begin; - } - return parse_dynamic_spec(begin, end, value, ref, ctx); } + if (begin == end) return begin; + c = to_ascii(*begin); + } +} - enum class state { start, align, sign, hash, zero, width, precision, locale }; - - // Parses standard format specifiers. - template - FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(const Char* begin, const Char* end, dynamic_format_specs& specs, basic_format_parse_context& ctx, type arg_type) -> const Char* - { - auto c = '\0'; - if (end - begin > 1) - { - auto next = to_ascii(begin[1]); - c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; - } - else - { - if (begin == end) - return begin; - c = to_ascii(*begin); - } - - struct { - state current_state = state::start; - FMT_CONSTEXPR void operator()(state s, bool valid = true) - { - if (current_state >= s || !valid) - throw_format_error("invalid format specifier"); - current_state = s; - } - } enter_state; - - using pres = presentation_type; - constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; - struct { - const Char*& begin; - dynamic_format_specs& specs; - type arg_type; - - FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* - { - if (!in(arg_type, set)) - { - if (arg_type == type::none_type) - return begin; - throw_format_error("invalid format specifier"); - } - specs.type = pres_type; - return begin + 1; - } - } parse_presentation_type{begin, specs, arg_type}; - - for (;;) - { - switch (c) - { - case '<': - case '>': - case '^': - enter_state(state::align); - specs.align = parse_align(c); - ++begin; - break; - case '+': - case '-': - case ' ': - if (arg_type == type::none_type) - return begin; - enter_state(state::sign, in(arg_type, sint_set | float_set)); - switch (c) - { - case '+': - specs.sign = sign::plus; - break; - case '-': - specs.sign = sign::minus; - break; - case ' ': - specs.sign = sign::space; - break; - } - ++begin; - break; - case '#': - if (arg_type == type::none_type) - return begin; - enter_state(state::hash, is_arithmetic_type(arg_type)); - specs.alt = true; - ++begin; - break; - case '0': - enter_state(state::zero); - if (!is_arithmetic_type(arg_type)) - { - if (arg_type == type::none_type) - return begin; - throw_format_error("format specifier requires numeric argument"); - } - if (specs.align == align::none) - { - // Ignore 0 if align is specified for compatibility with std::format. - specs.align = align::numeric; - specs.fill[0] = Char('0'); - } - ++begin; - break; - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - case '{': - enter_state(state::width); - begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); - break; - case '.': - if (arg_type == type::none_type) - return begin; - enter_state(state::precision, in(arg_type, float_set | string_set | cstring_set)); - begin = parse_precision(begin, end, specs.precision, specs.precision_ref, ctx); - break; - case 'L': - if (arg_type == type::none_type) - return begin; - enter_state(state::locale, is_arithmetic_type(arg_type)); - specs.localized = true; - ++begin; - break; - case 'd': - return parse_presentation_type(pres::dec, integral_set); - case 'o': - return parse_presentation_type(pres::oct, integral_set); - case 'x': - return parse_presentation_type(pres::hex_lower, integral_set); - case 'X': - return parse_presentation_type(pres::hex_upper, integral_set); - case 'b': - return parse_presentation_type(pres::bin_lower, integral_set); - case 'B': - return parse_presentation_type(pres::bin_upper, integral_set); - case 'a': - return parse_presentation_type(pres::hexfloat_lower, float_set); - case 'A': - return parse_presentation_type(pres::hexfloat_upper, float_set); - case 'e': - return parse_presentation_type(pres::exp_lower, float_set); - case 'E': - return parse_presentation_type(pres::exp_upper, float_set); - case 'f': - return parse_presentation_type(pres::fixed_lower, float_set); - case 'F': - return parse_presentation_type(pres::fixed_upper, float_set); - case 'g': - return parse_presentation_type(pres::general_lower, float_set); - case 'G': - return parse_presentation_type(pres::general_upper, float_set); - case 'c': - if (arg_type == type::bool_type) - throw_format_error("invalid format specifier"); - return parse_presentation_type(pres::chr, integral_set); - case 's': - return parse_presentation_type(pres::string, bool_set | string_set | cstring_set); - case 'p': - return parse_presentation_type(pres::pointer, pointer_set | cstring_set); - case '?': - return parse_presentation_type(pres::debug, char_set | string_set | cstring_set); - case '}': - return begin; - default: - { - if (*begin == '}') - return begin; - // Parse fill and alignment. - auto fill_end = begin + code_point_length(begin); - if (end - fill_end <= 0) - { - throw_format_error("invalid format specifier"); - return begin; - } - if (*begin == '{') - { - throw_format_error("invalid fill character '{'"); - return begin; - } - auto align = parse_align(to_ascii(*fill_end)); - enter_state(state::align, align != align::none); - specs.fill = {begin, to_unsigned(fill_end - begin)}; - specs.align = align; - begin = fill_end + 1; - } - } - if (begin == end) - return begin; - c = to_ascii(*begin); - } - } +template +FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + struct id_adapter { + Handler& handler; + int arg_id; + + FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } + FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } + FMT_CONSTEXPR void on_name(basic_string_view id) { + arg_id = handler.on_arg_id(id); + } + }; + + ++begin; + if (begin == end) return handler.on_error("invalid format string"), end; + if (*begin == '}') { + handler.on_replacement_field(handler.on_arg_id(), begin); + } else if (*begin == '{') { + handler.on_text(begin, begin + 1); + } else { + auto adapter = id_adapter{handler, 0}; + begin = parse_arg_id(begin, end, adapter); + Char c = begin != end ? *begin : Char(); + if (c == '}') { + handler.on_replacement_field(adapter.arg_id, begin); + } else if (c == ':') { + begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); + if (begin == end || *begin != '}') + return handler.on_error("unknown format specifier"), end; + } else { + return handler.on_error("missing '}' in format string"), end; + } + } + return begin + 1; +} - template - FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, Handler&& handler) -> const Char* - { - struct id_adapter { - Handler& handler; - int arg_id; - - FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } - FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } - FMT_CONSTEXPR void on_name(basic_string_view id) { arg_id = handler.on_arg_id(id); } - }; - - ++begin; - if (begin == end) - return handler.on_error("invalid format string"), end; - if (*begin == '}') - { - handler.on_replacement_field(handler.on_arg_id(), begin); - } - else if (*begin == '{') - { - handler.on_text(begin, begin + 1); - } - else - { - auto adapter = id_adapter{handler, 0}; - begin = parse_arg_id(begin, end, adapter); - Char c = begin != end ? *begin : Char(); - if (c == '}') - { - handler.on_replacement_field(adapter.arg_id, begin); - } - else if (c == ':') - { - begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); - if (begin == end || *begin != '}') - return handler.on_error("unknown format specifier"), end; - } - else - { - return handler.on_error("missing '}' in format string"), end; - } - } - return begin + 1; - } +template +FMT_CONSTEXPR FMT_INLINE void parse_format_string( + basic_string_view format_str, Handler&& handler) { + auto begin = format_str.data(); + auto end = begin + format_str.size(); + if (end - begin < 32) { + // Use a simple loop instead of memchr for small strings. + const Char* p = begin; + while (p != end) { + auto c = *p++; + if (c == '{') { + handler.on_text(begin, p - 1); + begin = p = parse_replacement_field(p - 1, end, handler); + } else if (c == '}') { + if (p == end || *p != '}') + return handler.on_error("unmatched '}' in format string"); + handler.on_text(begin, p); + begin = ++p; + } + } + handler.on_text(begin, end); + return; + } + struct writer { + FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { + if (from == to) return; + for (;;) { + const Char* p = nullptr; + if (!find(from, to, Char('}'), p)) + return handler_.on_text(from, to); + ++p; + if (p == to || *p != '}') + return handler_.on_error("unmatched '}' in format string"); + handler_.on_text(from, p); + from = p + 1; + } + } + Handler& handler_; + } write = {handler}; + while (begin != end) { + // Doing two passes with memchr (one for '{' and another for '}') is up to + // 2.5x faster than the naive one-pass implementation on big format strings. + const Char* p = begin; + if (*begin != '{' && !find(begin + 1, end, Char('{'), p)) + return write(begin, end); + write(begin, p); + begin = parse_replacement_field(p, end, handler); + } +} - template - FMT_CONSTEXPR FMT_INLINE void parse_format_string(basic_string_view format_str, Handler&& handler) - { - auto begin = format_str.data(); - auto end = begin + format_str.size(); - if (end - begin < 32) - { - // Use a simple loop instead of memchr for small strings. - const Char* p = begin; - while (p != end) - { - auto c = *p++; - if (c == '{') - { - handler.on_text(begin, p - 1); - begin = p = parse_replacement_field(p - 1, end, handler); - } - else if (c == '}') - { - if (p == end || *p != '}') - return handler.on_error("unmatched '}' in format string"); - handler.on_text(begin, p); - begin = ++p; - } - } - handler.on_text(begin, end); - return; - } - struct writer { - FMT_CONSTEXPR void operator()(const Char* from, const Char* to) - { - if (from == to) - return; - for (;;) - { - const Char* p = nullptr; - if (!find(from, to, Char('}'), p)) - return handler_.on_text(from, to); - ++p; - if (p == to || *p != '}') - return handler_.on_error("unmatched '}' in format string"); - handler_.on_text(from, p); - from = p + 1; - } - } - Handler& handler_; - } write = {handler}; - while (begin != end) - { - // Doing two passes with memchr (one for '{' and another for '}') is up to - // 2.5x faster than the naive one-pass implementation on big format strings. - const Char* p = begin; - if (*begin != '{' && !find(begin + 1, end, Char('{'), p)) - return write(begin, end); - write(begin, p); - begin = parse_replacement_field(p, end, handler); - } - } +template ::value> struct strip_named_arg { + using type = T; +}; +template struct strip_named_arg { + using type = remove_cvref_t; +}; - template ::value> - struct strip_named_arg { - using type = T; - }; - template - struct strip_named_arg { - using type = remove_cvref_t; - }; - - template - FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) -> decltype(ctx.begin()) - { - using char_type = typename ParseContext::char_type; - using context = buffer_context; - using mapped_type = conditional_t::value != type::custom_type, decltype(arg_mapper().map(std::declval())), typename strip_named_arg::type>; +template +FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) + -> decltype(ctx.begin()) { + using char_type = typename ParseContext::char_type; + using context = buffer_context; + using mapped_type = conditional_t< + mapped_type_constant::value != type::custom_type, + decltype(arg_mapper().map(std::declval())), + typename strip_named_arg::type>; #if defined(__cpp_if_constexpr) - if constexpr (std::is_default_constructible>::value) - { - return formatter().parse(ctx); - } - else - { - type_is_unformattable_for _; - return ctx.begin(); - } + if constexpr (std::is_default_constructible< + formatter>::value) { + return formatter().parse(ctx); + } else { + type_is_unformattable_for _; + return ctx.begin(); + } #else - return formatter().parse(ctx); + return formatter().parse(ctx); #endif - } +} - // Checks char specs and returns true iff the presentation type is char-like. - template - FMT_CONSTEXPR auto check_char_specs(const format_specs& specs) -> bool - { - if (specs.type != presentation_type::none && specs.type != presentation_type::chr && specs.type != presentation_type::debug) - { - return false; - } - if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) - throw_format_error("invalid format specifier for char"); - return true; - } +// Checks char specs and returns true iff the presentation type is char-like. +template +FMT_CONSTEXPR auto check_char_specs(const format_specs& specs) -> bool { + if (specs.type != presentation_type::none && + specs.type != presentation_type::chr && + specs.type != presentation_type::debug) { + return false; + } + if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) + throw_format_error("invalid format specifier for char"); + return true; +} #if FMT_USE_NONTYPE_TEMPLATE_ARGS - template - constexpr auto get_arg_index_by_name(basic_string_view name) -> int - { - if constexpr (is_statically_named_arg()) - { - if (name == T::name) - return N; - } - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name(name); - (void)name; // Workaround an MSVC bug about "unused" parameter. - return -1; - } +template +constexpr auto get_arg_index_by_name(basic_string_view name) -> int { + if constexpr (is_statically_named_arg()) { + if (name == T::name) return N; + } + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name(name); + (void)name; // Workaround an MSVC bug about "unused" parameter. + return -1; +} #endif - template - FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int - { +template +FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { #if FMT_USE_NONTYPE_TEMPLATE_ARGS - if constexpr (sizeof...(Args) > 0) - return get_arg_index_by_name<0, Args...>(name); + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name<0, Args...>(name); #endif - (void)name; - return -1; - } - - template - class format_string_checker { - private: - using parse_context_type = compile_parse_context; - static constexpr int num_args = sizeof...(Args); - - // Format specifier parsing function. - // In the future basic_format_parse_context will replace compile_parse_context - // here and will use is_constant_evaluated and downcasting to access the data - // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. - using parse_func = const Char* (*)(parse_context_type&); - - type types_[num_args > 0 ? static_cast(num_args) : 1]; - parse_context_type context_; - parse_func parse_funcs_[num_args > 0 ? static_cast(num_args) : 1]; - - public: - explicit FMT_CONSTEXPR format_string_checker(basic_string_view fmt) : types_{mapped_type_constant>::value...}, context_(fmt, num_args, types_), parse_funcs_{&parse_format_specs...} {} - - FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + (void)name; + return -1; +} - FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { return context_.check_arg_id(id), id; } - FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int - { +template class format_string_checker { + private: + using parse_context_type = compile_parse_context; + static constexpr int num_args = sizeof...(Args); + + // Format specifier parsing function. + // In the future basic_format_parse_context will replace compile_parse_context + // here and will use is_constant_evaluated and downcasting to access the data + // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. + using parse_func = const Char* (*)(parse_context_type&); + + type types_[num_args > 0 ? static_cast(num_args) : 1]; + parse_context_type context_; + parse_func parse_funcs_[num_args > 0 ? static_cast(num_args) : 1]; + + public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view fmt) + : types_{mapped_type_constant>::value...}, + context_(fmt, num_args, types_), + parse_funcs_{&parse_format_specs...} {} + + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + + FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return context_.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { #if FMT_USE_NONTYPE_TEMPLATE_ARGS - auto index = get_arg_index_by_name(id); - if (index < 0) - on_error("named argument is not found"); - return index; + auto index = get_arg_index_by_name(id); + if (index < 0) on_error("named argument is not found"); + return index; #else - (void)id; - on_error("compile-time checks for named arguments require C++20 support"); - return 0; -#endif - } - - FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) - { - on_format_specs(id, begin, begin); // Call parse() on empty specs. - } - - FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) -> const Char* - { - context_.advance_to(begin); - // id >= 0 check is a workaround for gcc 10 bug (#2065). - return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; - } - - FMT_CONSTEXPR void on_error(const char* message) { throw_format_error(message); } - }; - - // Reports a compile-time error if S is not a valid format string. - template ::value)> - FMT_INLINE void check_format_string(const S&) - { + (void)id; + on_error("compile-time checks for named arguments require C++20 support"); + return 0; +#endif + } + + FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { + on_format_specs(id, begin, begin); // Call parse() on empty specs. + } + + FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) + -> const Char* { + context_.advance_to(begin); + // id >= 0 check is a workaround for gcc 10 bug (#2065). + return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; + } + + FMT_CONSTEXPR void on_error(const char* message) { + throw_format_error(message); + } +}; + +// Reports a compile-time error if S is not a valid format string. +template ::value)> +FMT_INLINE void check_format_string(const S&) { #ifdef FMT_ENFORCE_COMPILE_STRING - static_assert(is_compile_string::value, - "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " - "FMT_STRING."); + static_assert(is_compile_string::value, + "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " + "FMT_STRING."); #endif - } - template ::value)> - void check_format_string(S format_str) - { - using char_t = typename S::char_type; - FMT_CONSTEXPR auto s = basic_string_view(format_str); - using checker = format_string_checker...>; - FMT_CONSTEXPR bool error = (parse_format_string(s, checker(s)), true); - ignore_unused(error); - } +} +template ::value)> +void check_format_string(S format_str) { + using char_t = typename S::char_type; + FMT_CONSTEXPR auto s = basic_string_view(format_str); + using checker = format_string_checker...>; + FMT_CONSTEXPR bool error = (parse_format_string(s, checker(s)), true); + ignore_unused(error); +} - template - struct vformat_args { - using type = basic_format_args>, Char>>; - }; - template <> - struct vformat_args { - using type = format_args; - }; +template struct vformat_args { + using type = basic_format_args< + basic_format_context>, Char>>; +}; +template <> struct vformat_args { + using type = format_args; +}; - // Use vformat_args and avoid type_identity to keep symbols short. - template - void vformat_to(buffer& buf, basic_string_view fmt, typename vformat_args::type args, locale_ref loc = {}); +// Use vformat_args and avoid type_identity to keep symbols short. +template +void vformat_to(buffer& buf, basic_string_view fmt, + typename vformat_args::type args, locale_ref loc = {}); - FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); +FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); #ifndef _WIN32 - inline void vprint_mojibake(std::FILE*, string_view, format_args) {} +inline void vprint_mojibake(std::FILE*, string_view, format_args) {} #endif -} // namespace detail +} // namespace detail FMT_BEGIN_EXPORT // A formatter specialization for natively supported types. template -struct formatter::value != detail::type::custom_type>> { -private: - detail::dynamic_format_specs specs_; - -public: - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* - { - auto type = detail::type_constant::value; - auto end = detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); - if (type == detail::type::char_type) - detail::check_char_specs(specs_); - return end; - } - - template ::value, FMT_ENABLE_IF(U == detail::type::string_type || U == detail::type::cstring_type || U == detail::type::char_type)> - FMT_CONSTEXPR void set_debug_format(bool set = true) - { - specs_.type = set ? presentation_type::debug : presentation_type::none; - } - - template - FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()); +struct formatter::value != + detail::type::custom_type>> { + private: + detail::dynamic_format_specs specs_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + auto type = detail::type_constant::value; + auto end = + detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); + if (type == detail::type::char_type) detail::check_char_specs(specs_); + return end; + } + + template ::value, + FMT_ENABLE_IF(U == detail::type::string_type || + U == detail::type::cstring_type || + U == detail::type::char_type)> + FMT_CONSTEXPR void set_debug_format(bool set = true) { + specs_.type = set ? presentation_type::debug : presentation_type::none; + } + + template + FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const + -> decltype(ctx.out()); }; -template -struct runtime_format_string { - basic_string_view str; +template struct runtime_format_string { + basic_string_view str; }; /** A compile-time format string. */ -template -class basic_format_string { -private: - basic_string_view str_; - -public: - template >::value)> - FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) - { - static_assert(detail::count<(std::is_base_of>::value && std::is_reference::value)...>() == 0, "passing views as lvalues is disallowed"); +template class basic_format_string { + private: + basic_string_view str_; + + public: + template >::value)> + FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) { + static_assert( + detail::count< + (std::is_base_of>::value && + std::is_reference::value)...>() == 0, + "passing views as lvalues is disallowed"); #ifdef FMT_HAS_CONSTEVAL - if constexpr (detail::count_named_args() == detail::count_statically_named_args()) - { - using checker = detail::format_string_checker...>; - detail::parse_format_string(str_, checker(s)); - } + if constexpr (detail::count_named_args() == + detail::count_statically_named_args()) { + using checker = + detail::format_string_checker...>; + detail::parse_format_string(str_, checker(s)); + } #else - detail::check_format_string(s); + detail::check_format_string(s); #endif - } - basic_format_string(runtime_format_string fmt) : str_(fmt.str) {} + } + basic_format_string(runtime_format_string fmt) : str_(fmt.str) {} - FMT_INLINE operator basic_string_view() const { return str_; } - FMT_INLINE auto get() const -> basic_string_view { return str_; } + FMT_INLINE operator basic_string_view() const { return str_; } + FMT_INLINE auto get() const -> basic_string_view { return str_; } }; #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround broken conversion on older gcc. -template -using format_string = string_view; +template using format_string = string_view; inline auto runtime(string_view s) -> string_view { return s; } #else template @@ -2813,18 +2830,18 @@ FMT_API auto vformat(string_view fmt, format_args args) -> std::string; \endrst */ template -FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) -> std::string -{ - return vformat(fmt, fmt::make_format_args(args...)); +FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) + -> std::string { + return vformat(fmt, fmt::make_format_args(args...)); } /** Formats a string and writes the output to ``out``. */ -template ::value)> -auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt -{ - auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, fmt, args, {}); - return detail::get_iterator(buf, out); +template ::value)> +auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, fmt, args, {}); + return detail::get_iterator(buf, out); } /** @@ -2839,27 +2856,28 @@ auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt fmt::format_to(std::back_inserter(out), "{}", 42); \endrst */ -template ::value)> -FMT_INLINE auto format_to(OutputIt out, format_string fmt, T&&... args) -> OutputIt -{ - return vformat_to(out, fmt, fmt::make_format_args(args...)); +template ::value)> +FMT_INLINE auto format_to(OutputIt out, format_string fmt, T&&... args) + -> OutputIt { + return vformat_to(out, fmt, fmt::make_format_args(args...)); } -template -struct format_to_n_result { - /** Iterator past the end of the output range. */ - OutputIt out; - /** Total (not truncated) output size. */ - size_t size; +template struct format_to_n_result { + /** Iterator past the end of the output range. */ + OutputIt out; + /** Total (not truncated) output size. */ + size_t size; }; -template ::value)> -auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result -{ - using traits = detail::fixed_buffer_traits; - auto buf = detail::iterator_buffer(out, n); - detail::vformat_to(buf, fmt, args, {}); - return {buf.out(), buf.count()}; +template ::value)> +auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) + -> format_to_n_result { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer(out, n); + detail::vformat_to(buf, fmt, args, {}); + return {buf.out(), buf.count()}; } /** @@ -2870,19 +2888,20 @@ auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> `format_to_n` does not append a terminating null character. \endrst */ -template ::value)> -FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, T&&... args) -> format_to_n_result -{ - return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); +template ::value)> +FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, + T&&... args) -> format_to_n_result { + return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); } /** Returns the number of chars in the output of ``format(fmt, args...)``. */ template -FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, T&&... args) -> size_t -{ - auto buf = detail::counting_buffer<>(); - detail::vformat_to(buf, fmt, fmt::make_format_args(args...), {}); - return buf.count(); +FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, + T&&... args) -> size_t { + auto buf = detail::counting_buffer<>(); + detail::vformat_to(buf, fmt, fmt::make_format_args(args...), {}); + return buf.count(); } FMT_API void vprint(string_view fmt, format_args args); @@ -2899,10 +2918,10 @@ FMT_API void vprint(std::FILE* f, string_view fmt, format_args args); \endrst */ template -FMT_INLINE void print(format_string fmt, T&&... args) -{ - const auto& vargs = fmt::make_format_args(args...); - return detail::is_utf8() ? vprint(fmt, vargs) : detail::vprint_mojibake(stdout, fmt, vargs); +FMT_INLINE void print(format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(fmt, vargs) + : detail::vprint_mojibake(stdout, fmt, vargs); } /** @@ -2916,10 +2935,10 @@ FMT_INLINE void print(format_string fmt, T&&... args) \endrst */ template -FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) -{ - const auto& vargs = fmt::make_format_args(args...); - return detail::is_utf8() ? vprint(f, fmt, vargs) : detail::vprint_mojibake(f, fmt, vargs); +FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(f, fmt, vargs) + : detail::vprint_mojibake(f, fmt, vargs); } /** @@ -2927,9 +2946,8 @@ FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) output to the file ``f`` followed by a newline. */ template -FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) -{ - return fmt::print(f, "{}\n", fmt::format(fmt, std::forward(args)...)); +FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) { + return fmt::print(f, "{}\n", fmt::format(fmt, std::forward(args)...)); } /** @@ -2937,9 +2955,8 @@ FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) to ``stdout`` followed by a newline. */ template -FMT_INLINE void println(format_string fmt, T&&... args) -{ - return fmt::println(stdout, fmt, std::forward(args)...); +FMT_INLINE void println(format_string fmt, T&&... args) { + return fmt::println(stdout, fmt, std::forward(args)...); } FMT_END_EXPORT @@ -2947,6 +2964,6 @@ FMT_GCC_PRAGMA("GCC pop_options") FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY -#include "format.h" +# include "format.h" #endif -#endif // FMT_CORE_H_ +#endif // FMT_CORE_H_ diff --git a/lib/spdlog/fmt/bundled/format-inl.h b/lib/spdlog/fmt/bundled/format-inl.h index 8b774e75..efac5d1f 100644 --- a/lib/spdlog/fmt/bundled/format-inl.h +++ b/lib/spdlog/fmt/bundled/format-inl.h @@ -9,950 +9,1670 @@ #define FMT_FORMAT_INL_H_ #include -#include // errno +#include // errno #include #include #include #ifndef FMT_STATIC_THOUSANDS_SEPARATOR -#include +# include #endif #if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR) -#include // _isatty +# include // _isatty #endif #include "format.h" FMT_BEGIN_NAMESPACE -namespace detail -{ - - FMT_FUNC void assert_fail(const char* file, int line, const char* message) - { - // Use unchecked std::fprintf to avoid triggering another assertion when - // writing to stderr fails - std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); - // Chosen instead of std::abort to satisfy Clang in CUDA mode during device - // code pass. - std::terminate(); - } +namespace detail { + +FMT_FUNC void assert_fail(const char* file, int line, const char* message) { + // Use unchecked std::fprintf to avoid triggering another assertion when + // writing to stderr fails + std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); + // Chosen instead of std::abort to satisfy Clang in CUDA mode during device + // code pass. + std::terminate(); +} - FMT_FUNC void throw_format_error(const char* message) { FMT_THROW(format_error(message)); } - - FMT_FUNC void format_error_code(detail::buffer& out, int error_code, string_view message) noexcept - { - // Report error code making sure that the output fits into - // inline_buffer_size to avoid dynamic memory allocation and potential - // bad_alloc. - out.try_resize(0); - static const char SEP[] = ": "; - static const char ERROR_STR[] = "error "; - // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. - size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; - auto abs_value = static_cast>(error_code); - if (detail::is_negative(error_code)) - { - abs_value = 0 - abs_value; - ++error_code_size; - } - error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); - auto it = buffer_appender(out); - if (message.size() <= inline_buffer_size - error_code_size) - fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); - fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); - FMT_ASSERT(out.size() <= inline_buffer_size, ""); - } +FMT_FUNC void throw_format_error(const char* message) { + FMT_THROW(format_error(message)); +} - FMT_FUNC void report_error(format_func func, int error_code, const char* message) noexcept - { - memory_buffer full_message; - func(full_message, error_code, message); - // Don't use fwrite_fully because the latter may throw. - if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) - std::fputc('\n', stderr); - } +FMT_FUNC void format_error_code(detail::buffer& out, int error_code, + string_view message) noexcept { + // Report error code making sure that the output fits into + // inline_buffer_size to avoid dynamic memory allocation and potential + // bad_alloc. + out.try_resize(0); + static const char SEP[] = ": "; + static const char ERROR_STR[] = "error "; + // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. + size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; + auto abs_value = static_cast>(error_code); + if (detail::is_negative(error_code)) { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); + auto it = buffer_appender(out); + if (message.size() <= inline_buffer_size - error_code_size) + fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); + fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); + FMT_ASSERT(out.size() <= inline_buffer_size, ""); +} - // A wrapper around fwrite that throws on error. - inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) - { - size_t written = std::fwrite(ptr, 1, count, stream); - if (written < count) - FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); - } +FMT_FUNC void report_error(format_func func, int error_code, + const char* message) noexcept { + memory_buffer full_message; + func(full_message, error_code, message); + // Don't use fwrite_fully because the latter may throw. + if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) + std::fputc('\n', stderr); +} + +// A wrapper around fwrite that throws on error. +inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) { + size_t written = std::fwrite(ptr, 1, count, stream); + if (written < count) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); +} #ifndef FMT_STATIC_THOUSANDS_SEPARATOR - template - locale_ref::locale_ref(const Locale& loc) : locale_(&loc) - { - static_assert(std::is_same::value, ""); - } +template +locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { + static_assert(std::is_same::value, ""); +} - template - auto locale_ref::get() const -> Locale - { - static_assert(std::is_same::value, ""); - return locale_ ? *static_cast(locale_) : std::locale(); - } +template auto locale_ref::get() const -> Locale { + static_assert(std::is_same::value, ""); + return locale_ ? *static_cast(locale_) : std::locale(); +} - template - FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result - { - auto& facet = std::use_facet>(loc.get()); - auto grouping = facet.grouping(); - auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); - return {std::move(grouping), thousands_sep}; - } - template - FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char - { - return std::use_facet>(loc.get()).decimal_point(); - } +template +FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result { + auto& facet = std::use_facet>(loc.get()); + auto grouping = facet.grouping(); + auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); + return {std::move(grouping), thousands_sep}; +} +template +FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { + return std::use_facet>(loc.get()) + .decimal_point(); +} #else - template - FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result - { - return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR}; - } - template - FMT_FUNC Char decimal_point_impl(locale_ref) - { - return '.'; - } +template +FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result { + return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR}; +} +template FMT_FUNC Char decimal_point_impl(locale_ref) { + return '.'; +} #endif - FMT_FUNC auto write_loc(appender out, loc_value value, const format_specs<>& specs, locale_ref loc) -> bool - { +FMT_FUNC auto write_loc(appender out, loc_value value, + const format_specs<>& specs, locale_ref loc) -> bool { #ifndef FMT_STATIC_THOUSANDS_SEPARATOR - auto locale = loc.get(); - // We cannot use the num_put facet because it may produce output in - // a wrong encoding. - using facet = format_facet; - if (std::has_facet(locale)) - return std::use_facet(locale).put(out, value, specs); - return facet(locale).put(out, value, specs); + auto locale = loc.get(); + // We cannot use the num_put facet because it may produce output in + // a wrong encoding. + using facet = format_facet; + if (std::has_facet(locale)) + return std::use_facet(locale).put(out, value, specs); + return facet(locale).put(out, value, specs); #endif - return false; - } -} // namespace detail + return false; +} +} // namespace detail -template -typename Locale::id format_facet::id; +template typename Locale::id format_facet::id; #ifndef FMT_STATIC_THOUSANDS_SEPARATOR -template -format_facet::format_facet(Locale& loc) -{ - auto& numpunct = std::use_facet>(loc); - grouping_ = numpunct.grouping(); - if (!grouping_.empty()) - separator_ = std::string(1, numpunct.thousands_sep()); +template format_facet::format_facet(Locale& loc) { + auto& numpunct = std::use_facet>(loc); + grouping_ = numpunct.grouping(); + if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep()); } template <> -FMT_API FMT_FUNC auto format_facet::do_put(appender out, loc_value val, const format_specs<>& specs) const -> bool -{ - return val.visit(detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); +FMT_API FMT_FUNC auto format_facet::do_put( + appender out, loc_value val, const format_specs<>& specs) const -> bool { + return val.visit( + detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } #endif -FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error -{ - auto ec = std::error_code(error_code, std::generic_category()); - return std::system_error(ec, vformat(fmt, args)); +FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) + -> std::system_error { + auto ec = std::error_code(error_code, std::generic_category()); + return std::system_error(ec, vformat(fmt, args)); } -namespace detail -{ +namespace detail { - template - inline auto operator==(basic_fp x, basic_fp y) -> bool - { - return x.f == y.f && x.e == y.e; - } +template +inline auto operator==(basic_fp x, basic_fp y) -> bool { + return x.f == y.f && x.e == y.e; +} - // Compilers should be able to optimize this into the ror instruction. - FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t - { - r &= 31; - return (n >> r) | (n << (32 - r)); - } - FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t - { - r &= 63; - return (n >> r) | (n << (64 - r)); - } +// Compilers should be able to optimize this into the ror instruction. +FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t { + r &= 31; + return (n >> r) | (n << (32 - r)); +} +FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t { + r &= 63; + return (n >> r) | (n << (64 - r)); +} + +// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. +namespace dragonbox { +// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a +// 64-bit unsigned integer. +inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { + return umul128_upper64(static_cast(x) << 32, y); +} + +// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a +// 128-bit unsigned integer. +inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept + -> uint128_fallback { + uint64_t high = x * y.high(); + uint128_fallback high_low = umul128(x, y.low()); + return {high + high_low.high(), high_low.low()}; +} - // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. - namespace dragonbox - { - // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a - // 64-bit unsigned integer. - inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { return umul128_upper64(static_cast(x) << 32, y); } - - // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a - // 128-bit unsigned integer. - inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback - { - uint64_t high = x * y.high(); - uint128_fallback high_low = umul128(x, y.low()); - return {high + high_low.high(), high_low.low()}; - } - - // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a - // 64-bit unsigned integer. - inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { return x * y; } - - // Various fast log computations. - inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int - { - FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); - return (e * 631305 - 261663) >> 21; - } - - FMT_INLINE_VARIABLE constexpr struct { - uint32_t divisor; - int shift_amount; - } div_small_pow10_infos[] = {{10, 16}, {100, 16}}; - - // Replaces n by floor(n / pow(10, N)) returning true if and only if n is - // divisible by pow(10, N). - // Precondition: n <= pow(10, N + 1). - template - auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool - { - // The numbers below are chosen such that: - // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, - // 2. nm mod 2^k < m if and only if n is divisible by d, - // where m is magic_number, k is shift_amount - // and d is divisor. - // - // Item 1 is a common technique of replacing division by a constant with - // multiplication, see e.g. "Division by Invariant Integers Using - // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set - // to ceil(2^k/d) for large enough k. - // The idea for item 2 originates from Schubfach. - constexpr auto info = div_small_pow10_infos[N - 1]; - FMT_ASSERT(n <= info.divisor * 10, "n is too large"); - constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; - n *= magic_number; - const uint32_t comparison_mask = (1u << info.shift_amount) - 1; - bool result = (n & comparison_mask) < magic_number; - n >>= info.shift_amount; - return result; - } - - // Computes floor(n / pow(10, N)) for small n and N. - // Precondition: n <= pow(10, N + 1). - template - auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t - { - constexpr auto info = div_small_pow10_infos[N - 1]; - FMT_ASSERT(n <= info.divisor * 10, "n is too large"); - constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; - return (n * magic_number) >> info.shift_amount; - } - - // Computes floor(n / 10^(kappa + 1)) (float) - inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t - { - // 1374389535 = ceil(2^37/100) - return static_cast((static_cast(n) * 1374389535) >> 37); - } - // Computes floor(n / 10^(kappa + 1)) (double) - inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t - { - // 2361183241434822607 = ceil(2^(64+7)/1000) - return umul128_upper64(n, 2361183241434822607ull) >> 7; - } - - // Various subroutines using pow10 cache - template - struct cache_accessor; - - template <> - struct cache_accessor { - using carrier_uint = float_info::carrier_uint; - using cache_entry_type = uint64_t; - - static auto get_cached_power(int k) noexcept -> uint64_t - { - FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); - static constexpr const uint64_t pow10_significands[] = {0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, - 0xafebff0bcb24aaff, 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, - 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, - 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; - return pow10_significands[k - float_info::min_k]; - } - - struct compute_mul_result { - carrier_uint result; - bool is_integer; - }; - struct compute_mul_parity_result { - bool parity; - bool is_integer; - }; - - static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result - { - auto r = umul96_upper64(u, cache); - return {static_cast(r >> 32), static_cast(r) == 0}; - } - - static auto compute_delta(const cache_entry_type& cache, int beta) noexcept -> uint32_t { return static_cast(cache >> (64 - 1 - beta)); } - - static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result - { - FMT_ASSERT(beta >= 1, ""); - FMT_ASSERT(beta < 64, ""); - - auto r = umul96_lower64(two_f, cache); - return {((r >> (64 - beta)) & 1) != 0, static_cast(r >> (32 - beta)) == 0}; - } - - static auto compute_left_endpoint_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast((cache - (cache >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta)); } - - static auto compute_right_endpoint_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast((cache + (cache >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta)); } - - static auto compute_round_up_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (static_cast(cache >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } - }; - - template <> - struct cache_accessor { - using carrier_uint = float_info::carrier_uint; - using cache_entry_type = uint128_fallback; - - static auto get_cached_power(int k) noexcept -> uint128_fallback - { - FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); - - static constexpr const uint128_fallback pow10_significands[] = { +// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a +// 64-bit unsigned integer. +inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { + return x * y; +} + +// Various fast log computations. +inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int { + FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); + return (e * 631305 - 261663) >> 21; +} + +FMT_INLINE_VARIABLE constexpr struct { + uint32_t divisor; + int shift_amount; +} div_small_pow10_infos[] = {{10, 16}, {100, 16}}; + +// Replaces n by floor(n / pow(10, N)) returning true if and only if n is +// divisible by pow(10, N). +// Precondition: n <= pow(10, N + 1). +template +auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool { + // The numbers below are chosen such that: + // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, + // 2. nm mod 2^k < m if and only if n is divisible by d, + // where m is magic_number, k is shift_amount + // and d is divisor. + // + // Item 1 is a common technique of replacing division by a constant with + // multiplication, see e.g. "Division by Invariant Integers Using + // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set + // to ceil(2^k/d) for large enough k. + // The idea for item 2 originates from Schubfach. + constexpr auto info = div_small_pow10_infos[N - 1]; + FMT_ASSERT(n <= info.divisor * 10, "n is too large"); + constexpr uint32_t magic_number = + (1u << info.shift_amount) / info.divisor + 1; + n *= magic_number; + const uint32_t comparison_mask = (1u << info.shift_amount) - 1; + bool result = (n & comparison_mask) < magic_number; + n >>= info.shift_amount; + return result; +} + +// Computes floor(n / pow(10, N)) for small n and N. +// Precondition: n <= pow(10, N + 1). +template auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t { + constexpr auto info = div_small_pow10_infos[N - 1]; + FMT_ASSERT(n <= info.divisor * 10, "n is too large"); + constexpr uint32_t magic_number = + (1u << info.shift_amount) / info.divisor + 1; + return (n * magic_number) >> info.shift_amount; +} + +// Computes floor(n / 10^(kappa + 1)) (float) +inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t { + // 1374389535 = ceil(2^37/100) + return static_cast((static_cast(n) * 1374389535) >> 37); +} +// Computes floor(n / 10^(kappa + 1)) (double) +inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t { + // 2361183241434822607 = ceil(2^(64+7)/1000) + return umul128_upper64(n, 2361183241434822607ull) >> 7; +} + +// Various subroutines using pow10 cache +template struct cache_accessor; + +template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint64_t; + + static auto get_cached_power(int k) noexcept -> uint64_t { + FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + static constexpr const uint64_t pow10_significands[] = { + 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, + 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, + 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, + 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, + 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, + 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, + 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, + 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, + 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, + 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, + 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, + 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, + 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, + 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, + 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, + 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, + 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, + 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, + 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, + 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, + 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, + 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, + 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, + 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, + 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, + 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; + return pow10_significands[k - float_info::min_k]; + } + + struct compute_mul_result { + carrier_uint result; + bool is_integer; + }; + struct compute_mul_parity_result { + bool parity; + bool is_integer; + }; + + static auto compute_mul(carrier_uint u, + const cache_entry_type& cache) noexcept + -> compute_mul_result { + auto r = umul96_upper64(u, cache); + return {static_cast(r >> 32), + static_cast(r) == 0}; + } + + static auto compute_delta(const cache_entry_type& cache, int beta) noexcept + -> uint32_t { + return static_cast(cache >> (64 - 1 - beta)); + } + + static auto compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, + int beta) noexcept + -> compute_mul_parity_result { + FMT_ASSERT(beta >= 1, ""); + FMT_ASSERT(beta < 64, ""); + + auto r = umul96_lower64(two_f, cache); + return {((r >> (64 - beta)) & 1) != 0, + static_cast(r >> (32 - beta)) == 0}; + } + + static auto compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return static_cast( + (cache - (cache >> (num_significand_bits() + 2))) >> + (64 - num_significand_bits() - 1 - beta)); + } + + static auto compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return static_cast( + (cache + (cache >> (num_significand_bits() + 1))) >> + (64 - num_significand_bits() - 1 - beta)); + } + + static auto compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return (static_cast( + cache >> (64 - num_significand_bits() - 2 - beta)) + + 1) / + 2; + } +}; + +template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint128_fallback; + + static auto get_cached_power(int k) noexcept -> uint128_fallback { + FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + + static constexpr const uint128_fallback pow10_significands[] = { #if FMT_USE_FULL_CACHE_DRAGONBOX - {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0x9faacf3df73609b1, 0x77b191618c54e9ad}, {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, {0x9becce62836ac577, 0x4ee367f9430aec33}, {0xc2e801fb244576d5, 0x229c41f793cda740}, {0xf3a20279ed56d48a, 0x6b43527578c11110}, {0x9845418c345644d6, 0x830a13896b78aaaa}, {0xbe5691ef416bd60c, 0x23cc986bc656d554}, {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, - {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, {0x91376c36d99995be, 0x23100809b9c21fa2}, {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, {0xdd95317f31c7fa1d, 0x40405643d711d584}, {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, {0xad1c8eab5ee43b66, 0xda3243650005eed0}, {0xd863b256369d4a40, 0x90bed43e40076a83}, - {0x873e4f75e2224e68, 0x5a7744a6e804a292}, {0xa90de3535aaae202, 0x711515d0a205cb37}, {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, {0x8412d9991ed58091, 0xe858790afe9486c3}, {0xa5178fff668ae0b6, 0x626e974dbe39a873}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, {0xc987434744ac874e, 0xa327ffb266b56221}, {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, - {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, {0xf6019da07f549b2b, 0x7e2a53a146606a49}, {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, {0xc0314325637a1939, 0xfa911155fefb5309}, {0xf03d93eebc589f88, 0x793555ab7eba27cb}, {0x96267c7535b763b5, 0x4bc1558b2f3458df}, {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, {0x92a1958a7675175f, 0x0bfacd89ec191eca}, {0xb749faed14125d36, 0xcef980ec671f667c}, {0xe51c79a85916f484, 0x82b7e12780e7401b}, - {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, {0xaecc49914078536d, 0x58fae9f773886e19}, {0xda7f5bf590966848, 0xaf39a475506a899f}, {0x888f99797a5e012d, 0x6d8406c952429604}, {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, - {0xd0601d8efc57b08b, 0xf13b94daf124da27}, {0x823c12795db6ce57, 0x76c53d08d6b70859}, {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, {0xc21094364dfb5636, 0x985915fc12f542e5}, {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, - {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, {0xbd8430bd08277231, 0x50c6ff782a838354}, {0xece53cec4a314ebd, 0xa4f8bf5635246429}, {0x940f4613ae5ed136, 0x871b7795e136be9a}, {0xb913179899f68584, 0x28e2557b59846e40}, {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, {0xb4bca50b065abe63, 0x0fed077a756b53aa}, {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, - {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, {0x89e42caaf9491b60, 0xf41686c49db57245}, {0xac5d37d5b79b6239, 0x311c2875c522ced6}, {0xd77485cb25823ac7, 0x7d633293366b828c}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, {0xd267caa862a12d66, 0xd072df63c324fd7c}, {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, {0xa46116538d0deb78, 0x52d9be85f074e609}, {0xcd795be870516656, 0x67902e276c921f8c}, {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, - {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, {0xef340a98172aace4, 0x86fb897116c87c35}, {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, {0xbae0a846d2195712, 0x8974836059cca10a}, - {0xe998d258869facd7, 0x2bd1a438703fc94c}, {0x91ff83775423cc06, 0x7b6306a34627ddd0}, {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, {0x8e938662882af53e, 0x547eb47b7282ee9d}, {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, {0xae0b158b4738705e, 0x9624ab50b148d446}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, - {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, {0xd47487cc8470652b, 0x7647c32000696720}, {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, {0xa5fb0a17c777cf09, 0xf468107100525891}, {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, {0x81ac1fe293d599bf, 0xc6f14cd848405531}, {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, {0xfd442e4688bd304a, 0x908f4a166d1da664}, {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, - {0xf7549530e188c128, 0xd12bee59e68ef47d}, {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, {0xebdf661791d60f56, 0x111b495b3464ad22}, {0x936b9fcebb25c995, 0xcab10dd900beec35}, {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, - {0xb3f4e093db73a093, 0x59ed216765690f57}, {0xe0f218b8d25088b8, 0x306869c13ec3532d}, {0x8c974f7383725573, 0x1e414218c73a13fc}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, {0x894bc396ce5da772, 0x6b8bba8c328eb784}, {0xab9eb47c81f5114f, 0x066ea92f3f326565}, {0xd686619ba27255a2, 0xc80a537b0efefebe}, {0x8613fd0145877585, 0xbd06742ce95f5f37}, {0xa798fc4196e952e7, 0x2c48113823b73705}, {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, - {0x82ef85133de648c4, 0x9a984d73dbe722fc}, {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, {0xcc963fee10b7d1b3, 0x318df905079926a9}, {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, {0x9c1661a651213e2d, 0x06bea10ca65c084f}, {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, - {0xbe89523386091465, 0xf6bbb397f1135824}, {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, {0xba121a4650e4ddeb, 0x92f34d62616ce414}, {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, - {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, {0x87625f056c7c4a8b, 0x11471cd764ad4973}, {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, {0xd389b47879823479, 0x4aff1d108d4ec2c4}, {0x843610cb4bf160cb, 0xcedf722a585139bb}, {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, {0xce947a3da6a9273e, 0x733d226229feea33}, {0x811ccc668829b887, 0x0806357d5a3f5260}, {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, - {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, {0xc5029163f384a931, 0x0a9e795e65d4df12}, {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, {0x964e858c91ba2655, 0x3a6a07f8d510f870}, {0xbbe226efb628afea, 0x890489f70a55368c}, {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, - {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, {0xb32df8e9f3546564, 0x47939822dc96abfa}, {0xdff9772470297ebd, 0x59787e2b93bc56f8}, {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, {0xaefae51477a06b03, 0xede622920b6b23f2}, {0xdab99e59958885c4, 0xe95fab368e45ecee}, {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, - {0xd59944a37c0752a2, 0x4be76d3346f04960}, {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, {0x825ecc24c873782f, 0x8ed400668c0c28c9}, {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, - {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, {0xc24452da229b021b, 0xfbe85badce996169}, {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, {0xed246723473e3813, 0x290123e9aab23b69}, {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, - {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, {0x8d590723948a535f, 0x579c487e5a38ad0f}, {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, {0xdcdb1b2798182244, 0xf8e431456cf88e66}, {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, {0xa87fea27a539e9a5, 0x3f2398d747b36225}, {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, {0x83a3eeeef9153e89, 0x1953cf68300424ad}, - {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, {0xcdb02555653131b6, 0x3792f412cb06794e}, {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, {0xc8de047564d20a8b, 0xf245825a5a445276}, {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, {0x9ced737bb6c4183d, 0x55464dd69685606c}, {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, {0xf53304714d9265df, 0xd53dd99f4b3066a9}, {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, {0xbf8fdb78849a5f96, 0xde98520472bdd034}, - {0xef73d256a5c0f77c, 0x963e66858f6d4441}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xbb127c53b17ec159, 0x5560c018580d5d53}, {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, {0x9226712162ab070d, 0xcab3961304ca70e9}, {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, {0xb267ed1940f1c61c, 0x55f038b237591ed4}, {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, - {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, {0xd9c7dced53c72255, 0x96e7bd358c904a22}, {0x881cea14545c7575, 0x7e50d64177da2e55}, {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, {0xcfb11ead453994ba, 0x67de18eda5814af3}, {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, {0xa2425ff75e14fc31, 0xa1258379a94d028e}, {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, - {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, {0x9e74d1b791e07e48, 0x775ea264cf55347e}, {0xc612062576589dda, 0x95364afe032a819e}, {0xf79687aed3eec551, 0x3a83ddbd83f52205}, {0x9abe14cd44753b52, 0xc4926a9672793543}, {0xc16d9a0095928a27, 0x75b7053c0f178294}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, - {0xb877aa3236a4b449, 0x09befeb9fad487c3}, {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, {0xb424dc35095cd80f, 0x538484c19ef38c95}, {0xe12e13424bb40e13, 0x2865a5f206b06fba}, {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, {0xafebff0bcb24aafe, 0xf78f69a51539d749}, {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, {0x89705f4136b4a597, 0x31680a88f8953031}, {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, - {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, {0xd1b71758e219652b, 0xd3c36113404ea4a9}, {0x83126e978d4fdf3b, 0x645a1cac083126ea}, {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, {0xcccccccccccccccc, 0xcccccccccccccccd}, {0x8000000000000000, 0x0000000000000000}, {0xa000000000000000, 0x0000000000000000}, {0xc800000000000000, 0x0000000000000000}, {0xfa00000000000000, 0x0000000000000000}, {0x9c40000000000000, 0x0000000000000000}, - {0xc350000000000000, 0x0000000000000000}, {0xf424000000000000, 0x0000000000000000}, {0x9896800000000000, 0x0000000000000000}, {0xbebc200000000000, 0x0000000000000000}, {0xee6b280000000000, 0x0000000000000000}, {0x9502f90000000000, 0x0000000000000000}, {0xba43b74000000000, 0x0000000000000000}, {0xe8d4a51000000000, 0x0000000000000000}, {0x9184e72a00000000, 0x0000000000000000}, {0xb5e620f480000000, 0x0000000000000000}, {0xe35fa931a0000000, 0x0000000000000000}, - {0x8e1bc9bf04000000, 0x0000000000000000}, {0xb1a2bc2ec5000000, 0x0000000000000000}, {0xde0b6b3a76400000, 0x0000000000000000}, {0x8ac7230489e80000, 0x0000000000000000}, {0xad78ebc5ac620000, 0x0000000000000000}, {0xd8d726b7177a8000, 0x0000000000000000}, {0x878678326eac9000, 0x0000000000000000}, {0xa968163f0a57b400, 0x0000000000000000}, {0xd3c21bcecceda100, 0x0000000000000000}, {0x84595161401484a0, 0x0000000000000000}, {0xa56fa5b99019a5c8, 0x0000000000000000}, - {0xcecb8f27f4200f3a, 0x0000000000000000}, {0x813f3978f8940984, 0x4000000000000000}, {0xa18f07d736b90be5, 0x5000000000000000}, {0xc9f2c9cd04674ede, 0xa400000000000000}, {0xfc6f7c4045812296, 0x4d00000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xc5371912364ce305, 0x6c28000000000000}, {0xf684df56c3e01bc6, 0xc732000000000000}, {0x9a130b963a6c115c, 0x3c7f400000000000}, {0xc097ce7bc90715b3, 0x4b9f100000000000}, {0xf0bdc21abb48db20, 0x1e86d40000000000}, - {0x96769950b50d88f4, 0x1314448000000000}, {0xbc143fa4e250eb31, 0x17d955a000000000}, {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, {0xb7abc627050305ad, 0xf14a3d9e40000000}, {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, {0xe0352f62a19e306e, 0xd50b2037ad200000}, {0x8c213d9da502de45, 0x4526f422cc340000}, {0xaf298d050e4395d6, 0x9670b12b7f410000}, - {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, {0xab0e93b6efee0053, 0x8eea0d047a457a00}, {0xd5d238a4abe98068, 0x72a4904598d6d880}, {0x85a36366eb71f041, 0x47a6da2b7f864750}, {0xa70c3c40a64e6c51, 0x999090b65f67d924}, {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, - {0x9f4f2726179a2245, 0x01d762422c946591}, {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, - {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, {0xacb92ed9397bf996, 0x49c2c37f07965405}, {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, - {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, {0x83c7088e1aab65db, 0x792667c6da79e0fb}, {0xa4b8cab1a1563f52, 0x577001b891185939}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0x80b05e5ac60b6178, 0x544f8158315b05b5}, {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, {0xfb5878494ace3a5f, 0x04ab48a04065c724}, {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, - {0xf5746577930d6500, 0xca8f44ec7ee3647a}, {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, {0xea1575143cf97226, 0xf52d09d71a3293be}, {0x924d692ca61be758, 0x593c2626705f9c57}, {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, - {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, {0x8b865b215899f46c, 0xbd79e0d20082ee75}, {0xae67f1e9aec07187, 0xecd8590680a3aa12}, {0xda01ee641a708de9, 0xe80e6f4820cc9496}, {0x884134fe908658b2, 0x3109058d147fdcde}, {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0xcfe87f7cef46ff16, 0xe612641865679a64}, - {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, {0xa26da3999aef7749, 0xe3be5e330f38f09e}, {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, {0xc646d63501a1511d, 0xb281e1fd541501b9}, {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, {0x9ae757596946075f, 0x3375788de9b06959}, {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, - {0xbd176620a501fbff, 0xb650e5a93bc3d899}, {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, {0x93ba47c980e98cdf, 0xc66f336c36b10138}, {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, {0x9043ea1ac7e41392, 0x87c89837ad68db30}, {0xb454e4a179dd1877, 0x29babe4598c311fc}, {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, {0xdc21a1171d42645d, 0x76707543f4fa1f74}, - {0x899504ae72497eba, 0x6a06494a791c53a9}, {0xabfa45da0edbde69, 0x0487db9d17636893}, {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xa7f26836f282b732, 0x8e6cac7768d7141f}, {0xd1ef0244af2364ff, 0x3207d795430cd927}, {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, {0xcd036837130890a1, 0x36dba887c37a8c10}, {0x802221226be55a64, 0xc2494954da2c978a}, {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, - {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, {0x9c69a97284b578d7, 0xff2a760414536efc}, {0xc38413cf25e2d70d, 0xfef5138519684abb}, {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, {0xba756174393d88df, 0x94f971119aeef9e5}, {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, - {0x91abb422ccb812ee, 0xac62e055c10ab33b}, {0xb616a12b7fe617aa, 0x577b986b314d600a}, {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, {0x8e41ade9fbebc27d, 0x14588f13be847308}, {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, {0x8aec23d680043bee, 0x25de7bb9480d5855}, {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0x87aa9aff79042286, 0x90fb44d2f05d0843}, {0xa99541bf57452b28, 0x353a1607ac744a54}, - {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, {0x847c9b5d7c2e09b7, 0x69956135febada12}, {0xa59bc234db398c25, 0x43fab9837e699096}, {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, {0x9defbf01b061adab, 0x3a0888136afa64a8}, {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, - {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, {0xbc4665b596706114, 0x873d5d9f0dde1fef}, {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, {0x8fa475791a569d10, 0xf96e017d694487bd}, {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, - {0xe070f78d3927556a, 0x85bbe253f47b1418}, {0x8c469ab843b89562, 0x93956d7478ccec8f}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, {0x88fcf317f22241e2, 0x441fece3bdf81f04}, {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, {0x85c7056562757456, 0xf6872d5667844e4a}, {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, {0xd106f86e69d785c7, 0xe13336d701beba53}, {0x82a45b450226b39c, 0xecc0024661173474}, - {0xa34d721642b06084, 0x27f002d7f95d0191}, {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, {0xff290242c83396ce, 0x7e67047175a15272}, {0x9f79a169bd203e41, 0x0f0062c6e984d387}, {0xc75809c42c684dd1, 0x52c07b78a3e60869}, {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, {0xc2abf989935ddbfe, 0x6acff893d00ea436}, {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, {0x98165af37b2153de, 0xc3727a337a8b704b}, {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, - {0xeda2ee1c7064130c, 0x1162def06f79df74}, {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xb10d8e1456105dad, 0x7425a83e872c5f48}, {0xdd50f1996b947518, 0xd12f124e28f7771a}, {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, - {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, {0x8714a775e3e95c78, 0x65acfaec34810a72}, {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, {0xd31045a8341ca07c, 0x1ede48111209a051}, {0x83ea2b892091e44d, 0x934aed0aab460433}, {0xa4e4b66b68b65d60, 0xf81da84d56178540}, {0xce1de40642e3f4b9, 0x36251260ab9d668f}, {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, {0xa1075a24e4421730, 0xb24cf65b8612f820}, {0xc94930ae1d529cfc, 0xdee033f26797b628}, - {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, {0xea53df5fd18d5513, 0x84c86189216dc5ee}, {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, - {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, {0xdf78e4b2bd342cf6, 0x914da9246b255417}, {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, {0xae9672aba3d0c320, 0xa184ac2473b529b2}, {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, {0x8865899617fb1871, 0x7e2fa67c7a658893}, {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, {0xd51ea6fa85785631, 0x552a74227f3ea566}, - {0x8533285c936b35de, 0xd53a88958f872760}, {0xa67ff273b8460356, 0x8a892abaf368f138}, {0xd01fef10a657842c, 0x2d2b7569b0432d86}, {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, {0xcb3f2f7642717713, 0x241c70a936219a74}, {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, {0x9ec95d1463e8a506, 0xf4363804324a40ab}, {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, - {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, {0x976e41088617ca01, 0xd5be0503e085d814}, {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, {0x906a617d450187e2, 0x27fb2b80668b24c6}, {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, {0xe1a63853bbd26451, 0x5e7873f8a0396974}, - {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, {0xac2820d9623bf429, 0x546345fa9fbdcd45}, {0xd732290fbacaf133, 0xa97c177947ad4096}, {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, - {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, {0xa0555e361951c366, 0xd7e105bcc3326220}, {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, {0xfa856334878fc150, 0xb14f98f6f0feb952}, {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, {0xeeea5d5004981478, 0x1858ccfce06cac75}, - {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xbaa718e68396cffd, 0xd30560258f54e6bb}, {0xe950df20247c83fd, 0x47c6b82ef32a206a}, {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, {0xb6472e511c81471d, 0xe0133fe4adf8e953}, {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, {0xb201833b35d63f73, 0x2cd2cc6551e513db}, {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, {0x8b112e86420f6191, 0xfb04afaf27faf783}, {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, - {0xd94ad8b1c7380874, 0x18375281ae7822bd}, {0x87cec76f1c830548, 0x8f2293910d0b15b6}, {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, {0xd433179d9c8cb841, 0x5fa60692a46151ec}, {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, {0xa5c7ea73224deff3, 0x12b9b522906c0801}, {0xcf39e50feae16bef, 0xd768226b34870a01}, {0x81842f29f2cce375, 0xe6a1158300d46641}, {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, - {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, {0xc5a05277621be293, 0xc7098b7305241886}, {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, {0x9a65406d44a5c903, 0x737f74f1dc043329}, {0xc0fe908895cf3b44, 0x505f522e53053ff3}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, {0xbc789925624c5fe0, 0xb67d16413d132073}, {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, - {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, + {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, + {0x9faacf3df73609b1, 0x77b191618c54e9ad}, + {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, + {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, + {0x9becce62836ac577, 0x4ee367f9430aec33}, + {0xc2e801fb244576d5, 0x229c41f793cda740}, + {0xf3a20279ed56d48a, 0x6b43527578c11110}, + {0x9845418c345644d6, 0x830a13896b78aaaa}, + {0xbe5691ef416bd60c, 0x23cc986bc656d554}, + {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, + {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, + {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, + {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, + {0x91376c36d99995be, 0x23100809b9c21fa2}, + {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, + {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, + {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, + {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, + {0xdd95317f31c7fa1d, 0x40405643d711d584}, + {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, + {0xad1c8eab5ee43b66, 0xda3243650005eed0}, + {0xd863b256369d4a40, 0x90bed43e40076a83}, + {0x873e4f75e2224e68, 0x5a7744a6e804a292}, + {0xa90de3535aaae202, 0x711515d0a205cb37}, + {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, + {0x8412d9991ed58091, 0xe858790afe9486c3}, + {0xa5178fff668ae0b6, 0x626e974dbe39a873}, + {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, + {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, + {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, + {0xc987434744ac874e, 0xa327ffb266b56221}, + {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, + {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, + {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, + {0xf6019da07f549b2b, 0x7e2a53a146606a49}, + {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, + {0xc0314325637a1939, 0xfa911155fefb5309}, + {0xf03d93eebc589f88, 0x793555ab7eba27cb}, + {0x96267c7535b763b5, 0x4bc1558b2f3458df}, + {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, + {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, + {0x92a1958a7675175f, 0x0bfacd89ec191eca}, + {0xb749faed14125d36, 0xcef980ec671f667c}, + {0xe51c79a85916f484, 0x82b7e12780e7401b}, + {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, + {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, + {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, + {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, + {0xaecc49914078536d, 0x58fae9f773886e19}, + {0xda7f5bf590966848, 0xaf39a475506a899f}, + {0x888f99797a5e012d, 0x6d8406c952429604}, + {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, + {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, + {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, + {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, + {0xd0601d8efc57b08b, 0xf13b94daf124da27}, + {0x823c12795db6ce57, 0x76c53d08d6b70859}, + {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, + {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, + {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, + {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, + {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, + {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, + {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, + {0xc21094364dfb5636, 0x985915fc12f542e5}, + {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, + {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, + {0xbd8430bd08277231, 0x50c6ff782a838354}, + {0xece53cec4a314ebd, 0xa4f8bf5635246429}, + {0x940f4613ae5ed136, 0x871b7795e136be9a}, + {0xb913179899f68584, 0x28e2557b59846e40}, + {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, + {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, + {0xb4bca50b065abe63, 0x0fed077a756b53aa}, + {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, + {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, + {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, + {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, + {0x89e42caaf9491b60, 0xf41686c49db57245}, + {0xac5d37d5b79b6239, 0x311c2875c522ced6}, + {0xd77485cb25823ac7, 0x7d633293366b828c}, + {0x86a8d39ef77164bc, 0xae5dff9c02033198}, + {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, + {0xd267caa862a12d66, 0xd072df63c324fd7c}, + {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, + {0xa46116538d0deb78, 0x52d9be85f074e609}, + {0xcd795be870516656, 0x67902e276c921f8c}, + {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, + {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, + {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, + {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, + {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, + {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, + {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, + {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, + {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, + {0xef340a98172aace4, 0x86fb897116c87c35}, + {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, + {0xbae0a846d2195712, 0x8974836059cca10a}, + {0xe998d258869facd7, 0x2bd1a438703fc94c}, + {0x91ff83775423cc06, 0x7b6306a34627ddd0}, + {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, + {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, + {0x8e938662882af53e, 0x547eb47b7282ee9d}, + {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, + {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, + {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, + {0xae0b158b4738705e, 0x9624ab50b148d446}, + {0xd98ddaee19068c76, 0x3badd624dd9b0958}, + {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, + {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, + {0xd47487cc8470652b, 0x7647c32000696720}, + {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, + {0xa5fb0a17c777cf09, 0xf468107100525891}, + {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, + {0x81ac1fe293d599bf, 0xc6f14cd848405531}, + {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, + {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, + {0xfd442e4688bd304a, 0x908f4a166d1da664}, + {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, + {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, + {0xf7549530e188c128, 0xd12bee59e68ef47d}, + {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, + {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, + {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, + {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, + {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, + {0xebdf661791d60f56, 0x111b495b3464ad22}, + {0x936b9fcebb25c995, 0xcab10dd900beec35}, + {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, + {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, + {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, + {0xb3f4e093db73a093, 0x59ed216765690f57}, + {0xe0f218b8d25088b8, 0x306869c13ec3532d}, + {0x8c974f7383725573, 0x1e414218c73a13fc}, + {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, + {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, + {0x894bc396ce5da772, 0x6b8bba8c328eb784}, + {0xab9eb47c81f5114f, 0x066ea92f3f326565}, + {0xd686619ba27255a2, 0xc80a537b0efefebe}, + {0x8613fd0145877585, 0xbd06742ce95f5f37}, + {0xa798fc4196e952e7, 0x2c48113823b73705}, + {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, + {0x82ef85133de648c4, 0x9a984d73dbe722fc}, + {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, + {0xcc963fee10b7d1b3, 0x318df905079926a9}, + {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, + {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, + {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, + {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, + {0x9c1661a651213e2d, 0x06bea10ca65c084f}, + {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, + {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, + {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, + {0xbe89523386091465, 0xf6bbb397f1135824}, + {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, + {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, + {0xba121a4650e4ddeb, 0x92f34d62616ce414}, + {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, + {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, + {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, + {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, + {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, + {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, + {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, + {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, + {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, + {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, + {0x87625f056c7c4a8b, 0x11471cd764ad4973}, + {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, + {0xd389b47879823479, 0x4aff1d108d4ec2c4}, + {0x843610cb4bf160cb, 0xcedf722a585139bb}, + {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, + {0xce947a3da6a9273e, 0x733d226229feea33}, + {0x811ccc668829b887, 0x0806357d5a3f5260}, + {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, + {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, + {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, + {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, + {0xc5029163f384a931, 0x0a9e795e65d4df12}, + {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, + {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, + {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, + {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, + {0x964e858c91ba2655, 0x3a6a07f8d510f870}, + {0xbbe226efb628afea, 0x890489f70a55368c}, + {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, + {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, + {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, + {0xe55990879ddcaabd, 0xcc420a6a101d0516}, + {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, + {0xb32df8e9f3546564, 0x47939822dc96abfa}, + {0xdff9772470297ebd, 0x59787e2b93bc56f8}, + {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, + {0xaefae51477a06b03, 0xede622920b6b23f2}, + {0xdab99e59958885c4, 0xe95fab368e45ecee}, + {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, + {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, + {0xd59944a37c0752a2, 0x4be76d3346f04960}, + {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, + {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, + {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, + {0x825ecc24c873782f, 0x8ed400668c0c28c9}, + {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, + {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, + {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, + {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, + {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, + {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, + {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, + {0xc24452da229b021b, 0xfbe85badce996169}, + {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, + {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, + {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, + {0xed246723473e3813, 0x290123e9aab23b69}, + {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, + {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, + {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, + {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, + {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, + {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, + {0x8d590723948a535f, 0x579c487e5a38ad0f}, + {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, + {0xdcdb1b2798182244, 0xf8e431456cf88e66}, + {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, + {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, + {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, + {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, + {0xa87fea27a539e9a5, 0x3f2398d747b36225}, + {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, + {0x83a3eeeef9153e89, 0x1953cf68300424ad}, + {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, + {0xcdb02555653131b6, 0x3792f412cb06794e}, + {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, + {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, + {0xc8de047564d20a8b, 0xf245825a5a445276}, + {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, + {0x9ced737bb6c4183d, 0x55464dd69685606c}, + {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, + {0xf53304714d9265df, 0xd53dd99f4b3066a9}, + {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, + {0xbf8fdb78849a5f96, 0xde98520472bdd034}, + {0xef73d256a5c0f77c, 0x963e66858f6d4441}, + {0x95a8637627989aad, 0xdde7001379a44aa9}, + {0xbb127c53b17ec159, 0x5560c018580d5d53}, + {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, + {0x9226712162ab070d, 0xcab3961304ca70e9}, + {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, + {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, + {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, + {0xb267ed1940f1c61c, 0x55f038b237591ed4}, + {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, + {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, + {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, + {0xd9c7dced53c72255, 0x96e7bd358c904a22}, + {0x881cea14545c7575, 0x7e50d64177da2e55}, + {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, + {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, + {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, + {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, + {0xcfb11ead453994ba, 0x67de18eda5814af3}, + {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, + {0xa2425ff75e14fc31, 0xa1258379a94d028e}, + {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, + {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, + {0x9e74d1b791e07e48, 0x775ea264cf55347e}, + {0xc612062576589dda, 0x95364afe032a819e}, + {0xf79687aed3eec551, 0x3a83ddbd83f52205}, + {0x9abe14cd44753b52, 0xc4926a9672793543}, + {0xc16d9a0095928a27, 0x75b7053c0f178294}, + {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, + {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, + {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, + {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, + {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, + {0xb877aa3236a4b449, 0x09befeb9fad487c3}, + {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, + {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, + {0xb424dc35095cd80f, 0x538484c19ef38c95}, + {0xe12e13424bb40e13, 0x2865a5f206b06fba}, + {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, + {0xafebff0bcb24aafe, 0xf78f69a51539d749}, + {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, + {0x89705f4136b4a597, 0x31680a88f8953031}, + {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, + {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, + {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, + {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, + {0xd1b71758e219652b, 0xd3c36113404ea4a9}, + {0x83126e978d4fdf3b, 0x645a1cac083126ea}, + {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, + {0xcccccccccccccccc, 0xcccccccccccccccd}, + {0x8000000000000000, 0x0000000000000000}, + {0xa000000000000000, 0x0000000000000000}, + {0xc800000000000000, 0x0000000000000000}, + {0xfa00000000000000, 0x0000000000000000}, + {0x9c40000000000000, 0x0000000000000000}, + {0xc350000000000000, 0x0000000000000000}, + {0xf424000000000000, 0x0000000000000000}, + {0x9896800000000000, 0x0000000000000000}, + {0xbebc200000000000, 0x0000000000000000}, + {0xee6b280000000000, 0x0000000000000000}, + {0x9502f90000000000, 0x0000000000000000}, + {0xba43b74000000000, 0x0000000000000000}, + {0xe8d4a51000000000, 0x0000000000000000}, + {0x9184e72a00000000, 0x0000000000000000}, + {0xb5e620f480000000, 0x0000000000000000}, + {0xe35fa931a0000000, 0x0000000000000000}, + {0x8e1bc9bf04000000, 0x0000000000000000}, + {0xb1a2bc2ec5000000, 0x0000000000000000}, + {0xde0b6b3a76400000, 0x0000000000000000}, + {0x8ac7230489e80000, 0x0000000000000000}, + {0xad78ebc5ac620000, 0x0000000000000000}, + {0xd8d726b7177a8000, 0x0000000000000000}, + {0x878678326eac9000, 0x0000000000000000}, + {0xa968163f0a57b400, 0x0000000000000000}, + {0xd3c21bcecceda100, 0x0000000000000000}, + {0x84595161401484a0, 0x0000000000000000}, + {0xa56fa5b99019a5c8, 0x0000000000000000}, + {0xcecb8f27f4200f3a, 0x0000000000000000}, + {0x813f3978f8940984, 0x4000000000000000}, + {0xa18f07d736b90be5, 0x5000000000000000}, + {0xc9f2c9cd04674ede, 0xa400000000000000}, + {0xfc6f7c4045812296, 0x4d00000000000000}, + {0x9dc5ada82b70b59d, 0xf020000000000000}, + {0xc5371912364ce305, 0x6c28000000000000}, + {0xf684df56c3e01bc6, 0xc732000000000000}, + {0x9a130b963a6c115c, 0x3c7f400000000000}, + {0xc097ce7bc90715b3, 0x4b9f100000000000}, + {0xf0bdc21abb48db20, 0x1e86d40000000000}, + {0x96769950b50d88f4, 0x1314448000000000}, + {0xbc143fa4e250eb31, 0x17d955a000000000}, + {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, + {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, + {0xb7abc627050305ad, 0xf14a3d9e40000000}, + {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, + {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, + {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, + {0xe0352f62a19e306e, 0xd50b2037ad200000}, + {0x8c213d9da502de45, 0x4526f422cc340000}, + {0xaf298d050e4395d6, 0x9670b12b7f410000}, + {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, + {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, + {0xab0e93b6efee0053, 0x8eea0d047a457a00}, + {0xd5d238a4abe98068, 0x72a4904598d6d880}, + {0x85a36366eb71f041, 0x47a6da2b7f864750}, + {0xa70c3c40a64e6c51, 0x999090b65f67d924}, + {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, + {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, + {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, + {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, + {0xfee50b7025c36a08, 0x02f236d04753d5b5}, + {0x9f4f2726179a2245, 0x01d762422c946591}, + {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, + {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, + {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, + {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, + {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, + {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, + {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, + {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, + {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, + {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, + {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, + {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, + {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, + {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, + {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, + {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, + {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, + {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, + {0xacb92ed9397bf996, 0x49c2c37f07965405}, + {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, + {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, + {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, + {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, + {0x83c7088e1aab65db, 0x792667c6da79e0fb}, + {0xa4b8cab1a1563f52, 0x577001b891185939}, + {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, + {0x80b05e5ac60b6178, 0x544f8158315b05b5}, + {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, + {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, + {0xfb5878494ace3a5f, 0x04ab48a04065c724}, + {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, + {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, + {0xf5746577930d6500, 0xca8f44ec7ee3647a}, + {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, + {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, + {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, + {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, + {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, + {0xea1575143cf97226, 0xf52d09d71a3293be}, + {0x924d692ca61be758, 0x593c2626705f9c57}, + {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, + {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, + {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, + {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, + {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, + {0x8b865b215899f46c, 0xbd79e0d20082ee75}, + {0xae67f1e9aec07187, 0xecd8590680a3aa12}, + {0xda01ee641a708de9, 0xe80e6f4820cc9496}, + {0x884134fe908658b2, 0x3109058d147fdcde}, + {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, + {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, + {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, + {0xa6539930bf6bff45, 0x84db8346b786151d}, + {0xcfe87f7cef46ff16, 0xe612641865679a64}, + {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, + {0xa26da3999aef7749, 0xe3be5e330f38f09e}, + {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, + {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, + {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, + {0xc646d63501a1511d, 0xb281e1fd541501b9}, + {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, + {0x9ae757596946075f, 0x3375788de9b06959}, + {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, + {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, + {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, + {0xbd176620a501fbff, 0xb650e5a93bc3d899}, + {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, + {0x93ba47c980e98cdf, 0xc66f336c36b10138}, + {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, + {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, + {0x9043ea1ac7e41392, 0x87c89837ad68db30}, + {0xb454e4a179dd1877, 0x29babe4598c311fc}, + {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, + {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, + {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, + {0xdc21a1171d42645d, 0x76707543f4fa1f74}, + {0x899504ae72497eba, 0x6a06494a791c53a9}, + {0xabfa45da0edbde69, 0x0487db9d17636893}, + {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, + {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, + {0xa7f26836f282b732, 0x8e6cac7768d7141f}, + {0xd1ef0244af2364ff, 0x3207d795430cd927}, + {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, + {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, + {0xcd036837130890a1, 0x36dba887c37a8c10}, + {0x802221226be55a64, 0xc2494954da2c978a}, + {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, + {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, + {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, + {0x9c69a97284b578d7, 0xff2a760414536efc}, + {0xc38413cf25e2d70d, 0xfef5138519684abb}, + {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, + {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, + {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, + {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, + {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, + {0xba756174393d88df, 0x94f971119aeef9e5}, + {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, + {0x91abb422ccb812ee, 0xac62e055c10ab33b}, + {0xb616a12b7fe617aa, 0x577b986b314d600a}, + {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, + {0x8e41ade9fbebc27d, 0x14588f13be847308}, + {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, + {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, + {0x8aec23d680043bee, 0x25de7bb9480d5855}, + {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, + {0xd910f7ff28069da4, 0x1b2ba1518094da05}, + {0x87aa9aff79042286, 0x90fb44d2f05d0843}, + {0xa99541bf57452b28, 0x353a1607ac744a54}, + {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, + {0x847c9b5d7c2e09b7, 0x69956135febada12}, + {0xa59bc234db398c25, 0x43fab9837e699096}, + {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, + {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, + {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, + {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, + {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, + {0x9defbf01b061adab, 0x3a0888136afa64a8}, + {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, + {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, + {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, + {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, + {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, + {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, + {0xbc4665b596706114, 0x873d5d9f0dde1fef}, + {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, + {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, + {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, + {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, + {0x8fa475791a569d10, 0xf96e017d694487bd}, + {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, + {0xe070f78d3927556a, 0x85bbe253f47b1418}, + {0x8c469ab843b89562, 0x93956d7478ccec8f}, + {0xaf58416654a6babb, 0x387ac8d1970027b3}, + {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, + {0x88fcf317f22241e2, 0x441fece3bdf81f04}, + {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, + {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, + {0x85c7056562757456, 0xf6872d5667844e4a}, + {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, + {0xd106f86e69d785c7, 0xe13336d701beba53}, + {0x82a45b450226b39c, 0xecc0024661173474}, + {0xa34d721642b06084, 0x27f002d7f95d0191}, + {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, + {0xff290242c83396ce, 0x7e67047175a15272}, + {0x9f79a169bd203e41, 0x0f0062c6e984d387}, + {0xc75809c42c684dd1, 0x52c07b78a3e60869}, + {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, + {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, + {0xc2abf989935ddbfe, 0x6acff893d00ea436}, + {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, + {0x98165af37b2153de, 0xc3727a337a8b704b}, + {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, + {0xeda2ee1c7064130c, 0x1162def06f79df74}, + {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, + {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, + {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, + {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, + {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, + {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, + {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, + {0xb10d8e1456105dad, 0x7425a83e872c5f48}, + {0xdd50f1996b947518, 0xd12f124e28f7771a}, + {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, + {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, + {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, + {0x8714a775e3e95c78, 0x65acfaec34810a72}, + {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, + {0xd31045a8341ca07c, 0x1ede48111209a051}, + {0x83ea2b892091e44d, 0x934aed0aab460433}, + {0xa4e4b66b68b65d60, 0xf81da84d56178540}, + {0xce1de40642e3f4b9, 0x36251260ab9d668f}, + {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, + {0xa1075a24e4421730, 0xb24cf65b8612f820}, + {0xc94930ae1d529cfc, 0xdee033f26797b628}, + {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, + {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, + {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, + {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, + {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, + {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, + {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, + {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, + {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, + {0xea53df5fd18d5513, 0x84c86189216dc5ee}, + {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, + {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, + {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, + {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, + {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, + {0xdf78e4b2bd342cf6, 0x914da9246b255417}, + {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, + {0xae9672aba3d0c320, 0xa184ac2473b529b2}, + {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, + {0x8865899617fb1871, 0x7e2fa67c7a658893}, + {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, + {0xd51ea6fa85785631, 0x552a74227f3ea566}, + {0x8533285c936b35de, 0xd53a88958f872760}, + {0xa67ff273b8460356, 0x8a892abaf368f138}, + {0xd01fef10a657842c, 0x2d2b7569b0432d86}, + {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, + {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, + {0xcb3f2f7642717713, 0x241c70a936219a74}, + {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, + {0x9ec95d1463e8a506, 0xf4363804324a40ab}, + {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, + {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, + {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, + {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, + {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, + {0x976e41088617ca01, 0xd5be0503e085d814}, + {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, + {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, + {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, + {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, + {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, + {0x906a617d450187e2, 0x27fb2b80668b24c6}, + {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, + {0xe1a63853bbd26451, 0x5e7873f8a0396974}, + {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, + {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, + {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, + {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, + {0xac2820d9623bf429, 0x546345fa9fbdcd45}, + {0xd732290fbacaf133, 0xa97c177947ad4096}, + {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, + {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, + {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, + {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, + {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, + {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, + {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, + {0xa0555e361951c366, 0xd7e105bcc3326220}, + {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, + {0xfa856334878fc150, 0xb14f98f6f0feb952}, + {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, + {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, + {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, + {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, + {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, + {0xeeea5d5004981478, 0x1858ccfce06cac75}, + {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, + {0xbaa718e68396cffd, 0xd30560258f54e6bb}, + {0xe950df20247c83fd, 0x47c6b82ef32a206a}, + {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, + {0xb6472e511c81471d, 0xe0133fe4adf8e953}, + {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, + {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, + {0xb201833b35d63f73, 0x2cd2cc6551e513db}, + {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, + {0x8b112e86420f6191, 0xfb04afaf27faf783}, + {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, + {0xd94ad8b1c7380874, 0x18375281ae7822bd}, + {0x87cec76f1c830548, 0x8f2293910d0b15b6}, + {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, + {0xd433179d9c8cb841, 0x5fa60692a46151ec}, + {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, + {0xa5c7ea73224deff3, 0x12b9b522906c0801}, + {0xcf39e50feae16bef, 0xd768226b34870a01}, + {0x81842f29f2cce375, 0xe6a1158300d46641}, + {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, + {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, + {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, + {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, + {0xc5a05277621be293, 0xc7098b7305241886}, + {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, + {0x9a65406d44a5c903, 0x737f74f1dc043329}, + {0xc0fe908895cf3b44, 0x505f522e53053ff3}, + {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, + {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, + {0xbc789925624c5fe0, 0xb67d16413d132073}, + {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, + {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, + {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, + {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, + {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, + {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, + {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, + {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, + {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, + {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else - {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, - {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0xc350000000000000, 0x0000000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, - {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0} + {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, + {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, + {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, + {0x86a8d39ef77164bc, 0xae5dff9c02033198}, + {0xd98ddaee19068c76, 0x3badd624dd9b0958}, + {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, + {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, + {0xe55990879ddcaabd, 0xcc420a6a101d0516}, + {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, + {0x95a8637627989aad, 0xdde7001379a44aa9}, + {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, + {0xc350000000000000, 0x0000000000000000}, + {0x9dc5ada82b70b59d, 0xf020000000000000}, + {0xfee50b7025c36a08, 0x02f236d04753d5b5}, + {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, + {0xa6539930bf6bff45, 0x84db8346b786151d}, + {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, + {0xd910f7ff28069da4, 0x1b2ba1518094da05}, + {0xaf58416654a6babb, 0x387ac8d1970027b3}, + {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, + {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, + {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, + {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, + {0xf13e34aabb430a15, 0x647726b9e7c68ff0} #endif - }; + }; #if FMT_USE_FULL_CACHE_DRAGONBOX - return pow10_significands[k - float_info::min_k]; + return pow10_significands[k - float_info::min_k]; #else - static constexpr const uint64_t powers_of_5_64[] = {0x0000000000000001, 0x0000000000000005, 0x0000000000000019, 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, 0x000000000e8d4a51, 0x0000000048c27395, - 0x000000016bcc41e9, 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; - - static const int compression_ratio = 27; - - // Compute base index. - int cache_index = (k - float_info::min_k) / compression_ratio; - int kb = cache_index * compression_ratio + float_info::min_k; - int offset = k - kb; - - // Get base cache. - uint128_fallback base_cache = pow10_significands[cache_index]; - if (offset == 0) - return base_cache; + static constexpr const uint64_t powers_of_5_64[] = { + 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, + 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, + 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, + 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, + 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, + 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, + 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, + 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, + 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; + + static const int compression_ratio = 27; + + // Compute base index. + int cache_index = (k - float_info::min_k) / compression_ratio; + int kb = cache_index * compression_ratio + float_info::min_k; + int offset = k - kb; + + // Get base cache. + uint128_fallback base_cache = pow10_significands[cache_index]; + if (offset == 0) return base_cache; + + // Compute the required amount of bit-shift. + int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; + FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); + + // Try to recover the real cache. + uint64_t pow5 = powers_of_5_64[offset]; + uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); + uint128_fallback middle_low = umul128(base_cache.low(), pow5); + + recovered_cache += middle_low.high(); + + uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); + uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); + + recovered_cache = + uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, + ((middle_low.low() >> alpha) | middle_to_low)}; + FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); + return {recovered_cache.high(), recovered_cache.low() + 1}; +#endif + } + + struct compute_mul_result { + carrier_uint result; + bool is_integer; + }; + struct compute_mul_parity_result { + bool parity; + bool is_integer; + }; + + static auto compute_mul(carrier_uint u, + const cache_entry_type& cache) noexcept + -> compute_mul_result { + auto r = umul192_upper128(u, cache); + return {r.high(), r.low() == 0}; + } + + static auto compute_delta(cache_entry_type const& cache, int beta) noexcept + -> uint32_t { + return static_cast(cache.high() >> (64 - 1 - beta)); + } + + static auto compute_mul_parity(carrier_uint two_f, + const cache_entry_type& cache, + int beta) noexcept + -> compute_mul_parity_result { + FMT_ASSERT(beta >= 1, ""); + FMT_ASSERT(beta < 64, ""); + + auto r = umul192_lower128(two_f, cache); + return {((r.high() >> (64 - beta)) & 1) != 0, + ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; + } + + static auto compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return (cache.high() - + (cache.high() >> (num_significand_bits() + 2))) >> + (64 - num_significand_bits() - 1 - beta); + } + + static auto compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return (cache.high() + + (cache.high() >> (num_significand_bits() + 1))) >> + (64 - num_significand_bits() - 1 - beta); + } + + static auto compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept -> carrier_uint { + return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) + + 1) / + 2; + } +}; - // Compute the required amount of bit-shift. - int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; - FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); +FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { + return cache_accessor::get_cached_power(k); +} - // Try to recover the real cache. - uint64_t pow5 = powers_of_5_64[offset]; - uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); - uint128_fallback middle_low = umul128(base_cache.low(), pow5); +// Various integer checks +template +auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { + const int case_shorter_interval_left_endpoint_lower_threshold = 2; + const int case_shorter_interval_left_endpoint_upper_threshold = 3; + return exponent >= case_shorter_interval_left_endpoint_lower_threshold && + exponent <= case_shorter_interval_left_endpoint_upper_threshold; +} - recovered_cache += middle_low.high(); +// Remove trailing zeros from n and return the number of zeros removed (float) +FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept { + FMT_ASSERT(n != 0, ""); + // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. + constexpr uint32_t mod_inv_5 = 0xcccccccd; + constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 + + while (true) { + auto q = rotr(n * mod_inv_25, 2); + if (q > max_value() / 100) break; + n = q; + s += 2; + } + auto q = rotr(n * mod_inv_5, 1); + if (q <= max_value() / 10) { + n = q; + s |= 1; + } + return s; +} - uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); - uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); +// Removes trailing zeros and returns the number of zeros removed (double) +FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept { + FMT_ASSERT(n != 0, ""); + + // This magic number is ceil(2^90 / 10^8). + constexpr uint64_t magic_number = 12379400392853802749ull; + auto nm = umul128(n, magic_number); + + // Is n is divisible by 10^8? + if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { + // If yes, work with the quotient... + auto n32 = static_cast(nm.high() >> (90 - 64)); + // ... and use the 32 bit variant of the function + int s = remove_trailing_zeros(n32, 8); + n = n32; + return s; + } + + // If n is not divisible by 10^8, work with n itself. + constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; + constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 + + int s = 0; + while (true) { + auto q = rotr(n * mod_inv_25, 2); + if (q > max_value() / 100) break; + n = q; + s += 2; + } + auto q = rotr(n * mod_inv_5, 1); + if (q <= max_value() / 10) { + n = q; + s |= 1; + } + + return s; +} - recovered_cache = uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, ((middle_low.low() >> alpha) | middle_to_low)}; - FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); - return {recovered_cache.high(), recovered_cache.low() + 1}; -#endif - } - - struct compute_mul_result { - carrier_uint result; - bool is_integer; - }; - struct compute_mul_parity_result { - bool parity; - bool is_integer; - }; - - static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result - { - auto r = umul192_upper128(u, cache); - return {r.high(), r.low() == 0}; - } - - static auto compute_delta(cache_entry_type const& cache, int beta) noexcept -> uint32_t { return static_cast(cache.high() >> (64 - 1 - beta)); } - - static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result - { - FMT_ASSERT(beta >= 1, ""); - FMT_ASSERT(beta < 64, ""); - - auto r = umul192_lower128(two_f, cache); - return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; - } - - static auto compute_left_endpoint_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() - (cache.high() >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta); } - - static auto compute_right_endpoint_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() + (cache.high() >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta); } - - static auto compute_round_up_for_shorter_interval_case(const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } - }; - - FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor::get_cached_power(k); } - - // Various integer checks - template - auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool - { - const int case_shorter_interval_left_endpoint_lower_threshold = 2; - const int case_shorter_interval_left_endpoint_upper_threshold = 3; - return exponent >= case_shorter_interval_left_endpoint_lower_threshold && exponent <= case_shorter_interval_left_endpoint_upper_threshold; - } - - // Remove trailing zeros from n and return the number of zeros removed (float) - FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept - { - FMT_ASSERT(n != 0, ""); - // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. - constexpr uint32_t mod_inv_5 = 0xcccccccd; - constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 - - while (true) - { - auto q = rotr(n * mod_inv_25, 2); - if (q > max_value() / 100) - break; - n = q; - s += 2; - } - auto q = rotr(n * mod_inv_5, 1); - if (q <= max_value() / 10) - { - n = q; - s |= 1; - } - return s; - } - - // Removes trailing zeros and returns the number of zeros removed (double) - FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept - { - FMT_ASSERT(n != 0, ""); - - // This magic number is ceil(2^90 / 10^8). - constexpr uint64_t magic_number = 12379400392853802749ull; - auto nm = umul128(n, magic_number); - - // Is n is divisible by 10^8? - if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) - { - // If yes, work with the quotient... - auto n32 = static_cast(nm.high() >> (90 - 64)); - // ... and use the 32 bit variant of the function - int s = remove_trailing_zeros(n32, 8); - n = n32; - return s; - } - - // If n is not divisible by 10^8, work with n itself. - constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; - constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 - - int s = 0; - while (true) - { - auto q = rotr(n * mod_inv_25, 2); - if (q > max_value() / 100) - break; - n = q; - s += 2; - } - auto q = rotr(n * mod_inv_5, 1); - if (q <= max_value() / 10) - { - n = q; - s |= 1; - } - - return s; - } - - // The main algorithm for shorter interval case - template - FMT_INLINE decimal_fp shorter_interval_case(int exponent) noexcept - { - decimal_fp ret_value; - // Compute k and beta - const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); - const int beta = exponent + floor_log2_pow10(-minus_k); - - // Compute xi and zi - using cache_entry_type = typename cache_accessor::cache_entry_type; - const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); - - auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case(cache, beta); - auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case(cache, beta); - - // If the left endpoint is not an integer, increase it - if (!is_left_endpoint_integer_shorter_interval(exponent)) - ++xi; - - // Try bigger divisor - ret_value.significand = zi / 10; - - // If succeed, remove trailing zeros if necessary and return - if (ret_value.significand * 10 >= xi) - { - ret_value.exponent = minus_k + 1; - ret_value.exponent += remove_trailing_zeros(ret_value.significand); - return ret_value; - } - - // Otherwise, compute the round-up of y - ret_value.significand = cache_accessor::compute_round_up_for_shorter_interval_case(cache, beta); - ret_value.exponent = minus_k; - - // When tie occurs, choose one of them according to the rule - if (exponent >= float_info::shorter_interval_tie_lower_threshold && exponent <= float_info::shorter_interval_tie_upper_threshold) - { - ret_value.significand = ret_value.significand % 2 == 0 ? ret_value.significand : ret_value.significand - 1; - } - else if (ret_value.significand < xi) - { - ++ret_value.significand; - } - return ret_value; - } - - template - auto to_decimal(T x) noexcept -> decimal_fp - { - // Step 1: integer promotion & Schubfach multiplier calculation. - - using carrier_uint = typename float_info::carrier_uint; - using cache_entry_type = typename cache_accessor::cache_entry_type; - auto br = bit_cast(x); - - // Extract significand bits and exponent bits. - const carrier_uint significand_mask = (static_cast(1) << num_significand_bits()) - 1; - carrier_uint significand = (br & significand_mask); - int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); - - if (exponent != 0) - { // Check if normal. - exponent -= exponent_bias() + num_significand_bits(); - - // Shorter interval case; proceed like Schubfach. - // In fact, when exponent == 1 and significand == 0, the interval is - // regular. However, it can be shown that the end-results are anyway same. - if (significand == 0) - return shorter_interval_case(exponent); - - significand |= (static_cast(1) << num_significand_bits()); - } - else - { - // Subnormal case; the interval is always regular. - if (significand == 0) - return {0, 0}; - exponent = std::numeric_limits::min_exponent - num_significand_bits() - 1; - } - - const bool include_left_endpoint = (significand % 2 == 0); - const bool include_right_endpoint = include_left_endpoint; - - // Compute k and beta. - const int minus_k = floor_log10_pow2(exponent) - float_info::kappa; - const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); - const int beta = exponent + floor_log2_pow10(-minus_k); - - // Compute zi and deltai. - // 10^kappa <= deltai < 10^(kappa + 1) - const uint32_t deltai = cache_accessor::compute_delta(cache, beta); - const carrier_uint two_fc = significand << 1; - - // For the case of binary32, the result of integer check is not correct for - // 29711844 * 2^-82 - // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 - // and 29711844 * 2^-81 - // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, - // and they are the unique counterexamples. However, since 29711844 is even, - // this does not cause any problem for the endpoints calculations; it can only - // cause a problem when we need to perform integer check for the center. - // Fortunately, with these inputs, that branch is never executed, so we are - // fine. - const typename cache_accessor::compute_mul_result z_mul = cache_accessor::compute_mul((two_fc | 1) << beta, cache); - - // Step 2: Try larger divisor; remove trailing zeros if necessary. - - // Using an upper bound on zi, we might be able to optimize the division - // better than the compiler; we are computing zi / big_divisor here. - decimal_fp ret_value; - ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); - uint32_t r = static_cast(z_mul.result - float_info::big_divisor * ret_value.significand); - - if (r < deltai) - { - // Exclude the right endpoint if necessary. - if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) - { - --ret_value.significand; - r = float_info::big_divisor; - goto small_divisor_case_label; - } - } - else if (r > deltai) - { - goto small_divisor_case_label; - } - else - { - // r == deltai; compare fractional parts. - const typename cache_accessor::compute_mul_parity_result x_mul = cache_accessor::compute_mul_parity(two_fc - 1, cache, beta); - - if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) - goto small_divisor_case_label; - } - ret_value.exponent = minus_k + float_info::kappa + 1; - - // We may need to remove trailing zeros. - ret_value.exponent += remove_trailing_zeros(ret_value.significand); - return ret_value; - - // Step 3: Find the significand with the smaller divisor. - - small_divisor_case_label: - ret_value.significand *= 10; - ret_value.exponent = minus_k + float_info::kappa; - - uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2); - const bool approx_y_parity = ((dist ^ (float_info::small_divisor / 2)) & 1) != 0; - - // Is dist divisible by 10^kappa? - const bool divisible_by_small_divisor = check_divisibility_and_divide_by_pow10::kappa>(dist); - - // Add dist / 10^kappa to the significand. - ret_value.significand += dist; - - if (!divisible_by_small_divisor) - return ret_value; - - // Check z^(f) >= epsilon^(f). - // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, - // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). - // Since there are only 2 possibilities, we only need to care about the - // parity. Also, zi and r should have the same parity since the divisor - // is an even number. - const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta); - - // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), - // or equivalently, when y is an integer. - if (y_mul.parity != approx_y_parity) - --ret_value.significand; - else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) - --ret_value.significand; - return ret_value; - } - } // namespace dragonbox -} // namespace detail +// The main algorithm for shorter interval case +template +FMT_INLINE decimal_fp shorter_interval_case(int exponent) noexcept { + decimal_fp ret_value; + // Compute k and beta + const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); + const int beta = exponent + floor_log2_pow10(-minus_k); + + // Compute xi and zi + using cache_entry_type = typename cache_accessor::cache_entry_type; + const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); + + auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case( + cache, beta); + auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case( + cache, beta); + + // If the left endpoint is not an integer, increase it + if (!is_left_endpoint_integer_shorter_interval(exponent)) ++xi; + + // Try bigger divisor + ret_value.significand = zi / 10; + + // If succeed, remove trailing zeros if necessary and return + if (ret_value.significand * 10 >= xi) { + ret_value.exponent = minus_k + 1; + ret_value.exponent += remove_trailing_zeros(ret_value.significand); + return ret_value; + } + + // Otherwise, compute the round-up of y + ret_value.significand = + cache_accessor::compute_round_up_for_shorter_interval_case(cache, + beta); + ret_value.exponent = minus_k; + + // When tie occurs, choose one of them according to the rule + if (exponent >= float_info::shorter_interval_tie_lower_threshold && + exponent <= float_info::shorter_interval_tie_upper_threshold) { + ret_value.significand = ret_value.significand % 2 == 0 + ? ret_value.significand + : ret_value.significand - 1; + } else if (ret_value.significand < xi) { + ++ret_value.significand; + } + return ret_value; +} -template <> -struct formatter { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> format_parse_context::iterator { return ctx.begin(); } - - auto format(const detail::bigint& n, format_context& ctx) const -> format_context::iterator - { - auto out = ctx.out(); - bool first = true; - for (auto i = n.bigits_.size(); i > 0; --i) - { - auto value = n.bigits_[i - 1u]; - if (first) - { - out = fmt::format_to(out, FMT_STRING("{:x}"), value); - first = false; - continue; - } - out = fmt::format_to(out, FMT_STRING("{:08x}"), value); - } - if (n.exp_ > 0) - out = fmt::format_to(out, FMT_STRING("p{}"), n.exp_ * detail::bigint::bigit_bits); - return out; +template auto to_decimal(T x) noexcept -> decimal_fp { + // Step 1: integer promotion & Schubfach multiplier calculation. + + using carrier_uint = typename float_info::carrier_uint; + using cache_entry_type = typename cache_accessor::cache_entry_type; + auto br = bit_cast(x); + + // Extract significand bits and exponent bits. + const carrier_uint significand_mask = + (static_cast(1) << num_significand_bits()) - 1; + carrier_uint significand = (br & significand_mask); + int exponent = + static_cast((br & exponent_mask()) >> num_significand_bits()); + + if (exponent != 0) { // Check if normal. + exponent -= exponent_bias() + num_significand_bits(); + + // Shorter interval case; proceed like Schubfach. + // In fact, when exponent == 1 and significand == 0, the interval is + // regular. However, it can be shown that the end-results are anyway same. + if (significand == 0) return shorter_interval_case(exponent); + + significand |= (static_cast(1) << num_significand_bits()); + } else { + // Subnormal case; the interval is always regular. + if (significand == 0) return {0, 0}; + exponent = + std::numeric_limits::min_exponent - num_significand_bits() - 1; + } + + const bool include_left_endpoint = (significand % 2 == 0); + const bool include_right_endpoint = include_left_endpoint; + + // Compute k and beta. + const int minus_k = floor_log10_pow2(exponent) - float_info::kappa; + const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); + const int beta = exponent + floor_log2_pow10(-minus_k); + + // Compute zi and deltai. + // 10^kappa <= deltai < 10^(kappa + 1) + const uint32_t deltai = cache_accessor::compute_delta(cache, beta); + const carrier_uint two_fc = significand << 1; + + // For the case of binary32, the result of integer check is not correct for + // 29711844 * 2^-82 + // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 + // and 29711844 * 2^-81 + // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, + // and they are the unique counterexamples. However, since 29711844 is even, + // this does not cause any problem for the endpoints calculations; it can only + // cause a problem when we need to perform integer check for the center. + // Fortunately, with these inputs, that branch is never executed, so we are + // fine. + const typename cache_accessor::compute_mul_result z_mul = + cache_accessor::compute_mul((two_fc | 1) << beta, cache); + + // Step 2: Try larger divisor; remove trailing zeros if necessary. + + // Using an upper bound on zi, we might be able to optimize the division + // better than the compiler; we are computing zi / big_divisor here. + decimal_fp ret_value; + ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); + uint32_t r = static_cast(z_mul.result - float_info::big_divisor * + ret_value.significand); + + if (r < deltai) { + // Exclude the right endpoint if necessary. + if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) { + --ret_value.significand; + r = float_info::big_divisor; + goto small_divisor_case_label; + } + } else if (r > deltai) { + goto small_divisor_case_label; + } else { + // r == deltai; compare fractional parts. + const typename cache_accessor::compute_mul_parity_result x_mul = + cache_accessor::compute_mul_parity(two_fc - 1, cache, beta); + + if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) + goto small_divisor_case_label; + } + ret_value.exponent = minus_k + float_info::kappa + 1; + + // We may need to remove trailing zeros. + ret_value.exponent += remove_trailing_zeros(ret_value.significand); + return ret_value; + + // Step 3: Find the significand with the smaller divisor. + +small_divisor_case_label: + ret_value.significand *= 10; + ret_value.exponent = minus_k + float_info::kappa; + + uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2); + const bool approx_y_parity = + ((dist ^ (float_info::small_divisor / 2)) & 1) != 0; + + // Is dist divisible by 10^kappa? + const bool divisible_by_small_divisor = + check_divisibility_and_divide_by_pow10::kappa>(dist); + + // Add dist / 10^kappa to the significand. + ret_value.significand += dist; + + if (!divisible_by_small_divisor) return ret_value; + + // Check z^(f) >= epsilon^(f). + // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, + // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). + // Since there are only 2 possibilities, we only need to care about the + // parity. Also, zi and r should have the same parity since the divisor + // is an even number. + const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta); + + // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), + // or equivalently, when y is an integer. + if (y_mul.parity != approx_y_parity) + --ret_value.significand; + else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) + --ret_value.significand; + return ret_value; +} +} // namespace dragonbox +} // namespace detail + +template <> struct formatter { + FMT_CONSTEXPR auto parse(format_parse_context& ctx) + -> format_parse_context::iterator { + return ctx.begin(); + } + + auto format(const detail::bigint& n, format_context& ctx) const + -> format_context::iterator { + auto out = ctx.out(); + bool first = true; + for (auto i = n.bigits_.size(); i > 0; --i) { + auto value = n.bigits_[i - 1u]; + if (first) { + out = fmt::format_to(out, FMT_STRING("{:x}"), value); + first = false; + continue; + } + out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } + if (n.exp_ > 0) + out = fmt::format_to(out, FMT_STRING("p{}"), + n.exp_ * detail::bigint::bigit_bits); + return out; + } }; -FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) -{ - for_each_codepoint(s, - [this](uint32_t cp, string_view) - { - if (cp == invalid_code_point) - FMT_THROW(std::runtime_error("invalid utf8")); - if (cp <= 0xFFFF) - { - buffer_.push_back(static_cast(cp)); - } - else - { - cp -= 0x10000; - buffer_.push_back(static_cast(0xD800 + (cp >> 10))); - buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF))); - } - return true; - }); - buffer_.push_back(0); -} - -FMT_FUNC void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept -{ - FMT_TRY - { - auto ec = std::error_code(error_code, std::generic_category()); - write(std::back_inserter(out), std::system_error(ec, message).what()); - return; +FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { + for_each_codepoint(s, [this](uint32_t cp, string_view) { + if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8")); + if (cp <= 0xFFFF) { + buffer_.push_back(static_cast(cp)); + } else { + cp -= 0x10000; + buffer_.push_back(static_cast(0xD800 + (cp >> 10))); + buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF))); } - FMT_CATCH(...) {} - format_error_code(out, error_code, message); + return true; + }); + buffer_.push_back(0); } -FMT_FUNC void report_system_error(int error_code, const char* message) noexcept { report_error(format_system_error, error_code, message); } +FMT_FUNC void format_system_error(detail::buffer& out, int error_code, + const char* message) noexcept { + FMT_TRY { + auto ec = std::error_code(error_code, std::generic_category()); + write(std::back_inserter(out), std::system_error(ec, message).what()); + return; + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} -FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string -{ - // Don't optimize the "{}" case to keep the binary size small and because it - // can be better optimized in fmt::format anyway. - auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, args); - return to_string(buffer); +FMT_FUNC void report_system_error(int error_code, + const char* message) noexcept { + report_error(format_system_error, error_code, message); } -namespace detail -{ +FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { + // Don't optimize the "{}" case to keep the binary size small and because it + // can be better optimized in fmt::format anyway. + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + return to_string(buffer); +} + +namespace detail { #if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR) - FMT_FUNC auto write_console(int, string_view) -> bool { return false; } - FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; } +FMT_FUNC auto write_console(int, string_view) -> bool { return false; } +FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; } #else - using dword = conditional_t; - extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // +using dword = conditional_t; +extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // void*, const void*, dword, dword*, void*); - FMT_FUNC bool write_console(int fd, string_view text) - { - auto u16 = utf8_to_utf16(text); - return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(), static_cast(u16.size()), nullptr, nullptr) != 0; - } +FMT_FUNC bool write_console(int fd, string_view text) { + auto u16 = utf8_to_utf16(text); + return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(), + static_cast(u16.size()), nullptr, nullptr) != 0; +} - FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool { return write_console(_fileno(f), text); } +FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool { + return write_console(_fileno(f), text); +} #endif #ifdef _WIN32 - // Print assuming legacy (non-Unicode) encoding. - FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) - { - auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, args); - fwrite_fully(buffer.data(), buffer.size(), f); - } +// Print assuming legacy (non-Unicode) encoding. +FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + fwrite_fully(buffer.data(), buffer.size(), f); +} #endif - FMT_FUNC void print(std::FILE* f, string_view text) - { +FMT_FUNC void print(std::FILE* f, string_view text) { #ifdef _WIN32 - int fd = _fileno(f); - if (_isatty(fd)) - { - std::fflush(f); - if (write_console(fd, text)) - return; - } + int fd = _fileno(f); + if (_isatty(fd)) { + std::fflush(f); + if (write_console(fd, text)) return; + } #endif - fwrite_fully(text.data(), text.size(), f); - } -} // namespace detail + fwrite_fully(text.data(), text.size(), f); +} +} // namespace detail -FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) -{ - auto buffer = memory_buffer(); - detail::vformat_to(buffer, fmt, args); - detail::print(f, {buffer.data(), buffer.size()}); +FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + detail::print(f, {buffer.data(), buffer.size()}); } -FMT_FUNC void vprint(string_view fmt, format_args args) { vprint(stdout, fmt, args); } +FMT_FUNC void vprint(string_view fmt, format_args args) { + vprint(stdout, fmt, args); +} -namespace detail -{ +namespace detail { - struct singleton { - unsigned char upper; - unsigned char lower_count; - }; +struct singleton { + unsigned char upper; + unsigned char lower_count; +}; - inline auto is_printable(uint16_t x, const singleton* singletons, size_t singletons_size, const unsigned char* singleton_lowers, const unsigned char* normal, size_t normal_size) -> bool - { - auto upper = x >> 8; - auto lower_start = 0; - for (size_t i = 0; i < singletons_size; ++i) - { - auto s = singletons[i]; - auto lower_end = lower_start + s.lower_count; - if (upper < s.upper) - break; - if (upper == s.upper) - { - for (auto j = lower_start; j < lower_end; ++j) - { - if (singleton_lowers[j] == (x & 0xff)) - return false; - } - } - lower_start = lower_end; - } - - auto xsigned = static_cast(x); - auto current = true; - for (size_t i = 0; i < normal_size; ++i) - { - auto v = static_cast(normal[i]); - auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; - xsigned -= len; - if (xsigned < 0) - break; - current = !current; - } - return current; +inline auto is_printable(uint16_t x, const singleton* singletons, + size_t singletons_size, + const unsigned char* singleton_lowers, + const unsigned char* normal, size_t normal_size) + -> bool { + auto upper = x >> 8; + auto lower_start = 0; + for (size_t i = 0; i < singletons_size; ++i) { + auto s = singletons[i]; + auto lower_end = lower_start + s.lower_count; + if (upper < s.upper) break; + if (upper == s.upper) { + for (auto j = lower_start; j < lower_end; ++j) { + if (singleton_lowers[j] == (x & 0xff)) return false; + } } + lower_start = lower_end; + } + + auto xsigned = static_cast(x); + auto current = true; + for (size_t i = 0; i < normal_size; ++i) { + auto v = static_cast(normal[i]); + auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; + xsigned -= len; + if (xsigned < 0) break; + current = !current; + } + return current; +} - // This code is generated by support/printable.py. - FMT_FUNC auto is_printable(uint32_t cp) -> bool - { - static constexpr singleton singletons0[] = { - {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, - }; - static constexpr unsigned char singletons0_lower[] = { - 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, - 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, 0xce, 0xcf, - 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, 0x7f, 0xb5, 0xc5, - 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff, - }; - static constexpr singleton singletons1[] = { - {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, {0xfa, 2}, {0xfb, 1}, - }; - static constexpr unsigned char singletons1_lower[] = { - 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, - 0x1b, 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, - 0xa6, 0xa7, 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, - }; - static constexpr unsigned char normal0[] = { - 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, - 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, - 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, - 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, - }; - static constexpr unsigned char normal1[] = { - 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, - 0x05, 0x2f, 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, - 0x01, 0x05, 0x10, 0x03, 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, - 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, 0x04, 0x6b, 0x05, 0x0d, - 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, 0x1b, 0x34, - 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, - }; - auto lower = static_cast(cp); - if (cp < 0x10000) - { - return is_printable(lower, singletons0, sizeof(singletons0) / sizeof(*singletons0), singletons0_lower, normal0, sizeof(normal0)); - } - if (cp < 0x20000) - { - return is_printable(lower, singletons1, sizeof(singletons1) / sizeof(*singletons1), singletons1_lower, normal1, sizeof(normal1)); - } - if (0x2a6de <= cp && cp < 0x2a700) - return false; - if (0x2b735 <= cp && cp < 0x2b740) - return false; - if (0x2b81e <= cp && cp < 0x2b820) - return false; - if (0x2cea2 <= cp && cp < 0x2ceb0) - return false; - if (0x2ebe1 <= cp && cp < 0x2f800) - return false; - if (0x2fa1e <= cp && cp < 0x30000) - return false; - if (0x3134b <= cp && cp < 0xe0100) - return false; - if (0xe01f0 <= cp && cp < 0x110000) - return false; - return cp < 0x110000; - } +// This code is generated by support/printable.py. +FMT_FUNC auto is_printable(uint32_t cp) -> bool { + static constexpr singleton singletons0[] = { + {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, + {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, + {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, + {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, + {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, + {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, + {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, + }; + static constexpr unsigned char singletons0_lower[] = { + 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, + 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, + 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, + 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, + 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, + 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, + 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, + 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, + 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, + 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, + 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, + 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, + 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, + 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, + 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, + 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, + 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, + 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, + 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, + 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, + 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, + 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, + 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, + 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, + 0xfe, 0xff, + }; + static constexpr singleton singletons1[] = { + {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, + {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, + {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, + {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, + {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, + {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, + {0xfa, 2}, {0xfb, 1}, + }; + static constexpr unsigned char singletons1_lower[] = { + 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, + 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, + 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, + 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, + 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b, + 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, + 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, + 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, + 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, + 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, + 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, + 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, + 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, + 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, + 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, + }; + static constexpr unsigned char normal0[] = { + 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, + 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, + 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, + 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, + 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, + 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, + 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, + 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, + 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, + 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, + 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, + 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, + 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, + 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, + 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, + 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, + 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, + 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, + 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, + 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, + 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, + 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, + 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, + 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, + 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, + 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, + }; + static constexpr unsigned char normal1[] = { + 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, + 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, + 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, + 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, + 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, + 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f, + 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, + 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, + 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, + 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, + 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, + 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03, + 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, + 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, + 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, + 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, + 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, + 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, + 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, + 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, + 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, + 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, + 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, + 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, + 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, + 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, + 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, + 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, + 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, + 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, + 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, + 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, + 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, + 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, + 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, + }; + auto lower = static_cast(cp); + if (cp < 0x10000) { + return is_printable(lower, singletons0, + sizeof(singletons0) / sizeof(*singletons0), + singletons0_lower, normal0, sizeof(normal0)); + } + if (cp < 0x20000) { + return is_printable(lower, singletons1, + sizeof(singletons1) / sizeof(*singletons1), + singletons1_lower, normal1, sizeof(normal1)); + } + if (0x2a6de <= cp && cp < 0x2a700) return false; + if (0x2b735 <= cp && cp < 0x2b740) return false; + if (0x2b81e <= cp && cp < 0x2b820) return false; + if (0x2cea2 <= cp && cp < 0x2ceb0) return false; + if (0x2ebe1 <= cp && cp < 0x2f800) return false; + if (0x2fa1e <= cp && cp < 0x30000) return false; + if (0x3134b <= cp && cp < 0xe0100) return false; + if (0xe01f0 <= cp && cp < 0x110000) return false; + return cp < 0x110000; +} -} // namespace detail +} // namespace detail FMT_END_NAMESPACE -#endif // FMT_FORMAT_INL_H_ +#endif // FMT_FORMAT_INL_H_ diff --git a/lib/spdlog/fmt/bundled/format.h b/lib/spdlog/fmt/bundled/format.h index 13288d7f..7637c8a0 100644 --- a/lib/spdlog/fmt/bundled/format.h +++ b/lib/spdlog/fmt/bundled/format.h @@ -33,124 +33,122 @@ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ -#include // std::signbit -#include // uint32_t -#include // std::memcpy -#include // std::initializer_list -#include // std::numeric_limits -#include // std::uninitialized_copy -#include // std::runtime_error -#include // std::system_error +#include // std::signbit +#include // uint32_t +#include // std::memcpy +#include // std::initializer_list +#include // std::numeric_limits +#include // std::uninitialized_copy +#include // std::runtime_error +#include // std::system_error #ifdef __cpp_lib_bit_cast -#include // std::bit_cast +# include // std::bit_cast #endif #include "core.h" #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L -#define FMT_INLINE_VARIABLE inline +# define FMT_INLINE_VARIABLE inline #else -#define FMT_INLINE_VARIABLE +# define FMT_INLINE_VARIABLE #endif #if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) -#define FMT_FALLTHROUGH [[fallthrough]] +# define FMT_FALLTHROUGH [[fallthrough]] #elif defined(__clang__) -#define FMT_FALLTHROUGH [[clang::fallthrough]] -#elif FMT_GCC_VERSION >= 700 && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) -#define FMT_FALLTHROUGH [[gnu::fallthrough]] +# define FMT_FALLTHROUGH [[clang::fallthrough]] +#elif FMT_GCC_VERSION >= 700 && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) +# define FMT_FALLTHROUGH [[gnu::fallthrough]] #else -#define FMT_FALLTHROUGH +# define FMT_FALLTHROUGH #endif #ifndef FMT_DEPRECATED -#if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 -#define FMT_DEPRECATED [[deprecated]] -#else -#if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) -#define FMT_DEPRECATED __attribute__((deprecated)) -#elif FMT_MSC_VERSION -#define FMT_DEPRECATED __declspec(deprecated) -#else -#define FMT_DEPRECATED /* deprecated */ -#endif -#endif +# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 +# define FMT_DEPRECATED [[deprecated]] +# else +# if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) +# define FMT_DEPRECATED __attribute__((deprecated)) +# elif FMT_MSC_VERSION +# define FMT_DEPRECATED __declspec(deprecated) +# else +# define FMT_DEPRECATED /* deprecated */ +# endif +# endif #endif #ifndef FMT_NO_UNIQUE_ADDRESS -#if FMT_CPLUSPLUS >= 202002L -#if FMT_HAS_CPP_ATTRIBUTE(no_unique_address) -#define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] +# if FMT_CPLUSPLUS >= 202002L +# if FMT_HAS_CPP_ATTRIBUTE(no_unique_address) +# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] // VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485) -#elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION -#define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] -#endif -#endif +# elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION +# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] +# endif +# endif #endif #ifndef FMT_NO_UNIQUE_ADDRESS -#define FMT_NO_UNIQUE_ADDRESS +# define FMT_NO_UNIQUE_ADDRESS #endif // Visibility when compiled as a shared library/object. #if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) -#define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) +# define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) #else -#define FMT_SO_VISIBILITY(value) +# define FMT_SO_VISIBILITY(value) #endif #ifdef __has_builtin -#define FMT_HAS_BUILTIN(x) __has_builtin(x) +# define FMT_HAS_BUILTIN(x) __has_builtin(x) #else -#define FMT_HAS_BUILTIN(x) 0 +# define FMT_HAS_BUILTIN(x) 0 #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION -#define FMT_NOINLINE __attribute__((noinline)) +# define FMT_NOINLINE __attribute__((noinline)) #else -#define FMT_NOINLINE +# define FMT_NOINLINE #endif #ifndef FMT_THROW -#if FMT_EXCEPTIONS -#if FMT_MSC_VERSION || defined(__NVCC__) +# if FMT_EXCEPTIONS +# if FMT_MSC_VERSION || defined(__NVCC__) FMT_BEGIN_NAMESPACE -namespace detail -{ - template - inline void do_throw(const Exception& x) - { - // Silence unreachable code warnings in MSVC and NVCC because these - // are nearly impossible to fix in a generic code. - volatile bool b = true; - if (b) - throw x; - } -} // namespace detail +namespace detail { +template inline void do_throw(const Exception& x) { + // Silence unreachable code warnings in MSVC and NVCC because these + // are nearly impossible to fix in a generic code. + volatile bool b = true; + if (b) throw x; +} +} // namespace detail FMT_END_NAMESPACE -#define FMT_THROW(x) detail::do_throw(x) -#else -#define FMT_THROW(x) throw x -#endif -#else -#define FMT_THROW(x) ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) -#endif +# define FMT_THROW(x) detail::do_throw(x) +# else +# define FMT_THROW(x) throw x +# endif +# else +# define FMT_THROW(x) \ + ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) +# endif #endif #if FMT_EXCEPTIONS -#define FMT_TRY try -#define FMT_CATCH(x) catch (x) +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) #else -#define FMT_TRY if (true) -#define FMT_CATCH(x) if (false) +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) #endif #ifndef FMT_MAYBE_UNUSED -#if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) -#define FMT_MAYBE_UNUSED [[maybe_unused]] -#else -#define FMT_MAYBE_UNUSED -#endif +# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) +# define FMT_MAYBE_UNUSED [[maybe_unused]] +# else +# define FMT_MAYBE_UNUSED +# endif #endif #ifndef FMT_USE_USER_DEFINED_LITERALS @@ -158,11 +156,13 @@ FMT_END_NAMESPACE // // GCC before 4.9 requires a space in `operator"" _a` which is invalid in later // compiler versions. -#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || FMT_MSC_VERSION >= 1900) && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) -#define FMT_USE_USER_DEFINED_LITERALS 1 -#else -#define FMT_USE_USER_DEFINED_LITERALS 0 -#endif +# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \ + FMT_MSC_VERSION >= 1900) && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) +# define FMT_USE_USER_DEFINED_LITERALS 1 +# else +# define FMT_USE_USER_DEFINED_LITERALS 0 +# endif #endif // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of @@ -170,722 +170,686 @@ FMT_END_NAMESPACE // largest integer type. This results in a reduction in binary size but will // cause a decrease in integer formatting performance. #if !defined(FMT_REDUCE_INT_INSTANTIATIONS) -#define FMT_REDUCE_INT_INSTANTIATIONS 0 +# define FMT_REDUCE_INT_INSTANTIATIONS 0 #endif // __builtin_clz is broken in clang with Microsoft CodeGen: // https://github.com/fmtlib/fmt/issues/519. #if !FMT_MSC_VERSION -#if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION -#define FMT_BUILTIN_CLZ(n) __builtin_clz(n) -#endif -#if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION -#define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) -#endif +# if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION +# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +# endif +# if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION +# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +# endif #endif // __builtin_ctz is broken in Intel Compiler Classic on Windows: // https://github.com/fmtlib/fmt/issues/2510. #ifndef __ICL -#if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || defined(__NVCOMPILER) -#define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) -#endif -#if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || FMT_ICC_VERSION || defined(__NVCOMPILER) -#define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) -#endif +# if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \ + defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) +# endif +# if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \ + FMT_ICC_VERSION || defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) +# endif #endif #if FMT_MSC_VERSION -#include // _BitScanReverse[64], _BitScanForward[64], _umul128 +# include // _BitScanReverse[64], _BitScanForward[64], _umul128 #endif // Some compilers masquerade as both MSVC and GCC-likes or otherwise support // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the // MSVC intrinsics if the clz and clzll builtins are not available. -#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && !defined(FMT_BUILTIN_CTZLL) +#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \ + !defined(FMT_BUILTIN_CTZLL) FMT_BEGIN_NAMESPACE -namespace detail -{ +namespace detail { // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. -#if !defined(__clang__) -#pragma intrinsic(_BitScanForward) -#pragma intrinsic(_BitScanReverse) -#if defined(_WIN64) -#pragma intrinsic(_BitScanForward64) -#pragma intrinsic(_BitScanReverse64) -#endif -#endif - - inline auto clz(uint32_t x) -> int - { - unsigned long r = 0; - _BitScanReverse(&r, x); - FMT_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. - FMT_MSC_WARNING(suppress : 6102) - return 31 ^ static_cast(r); - } -#define FMT_BUILTIN_CLZ(n) detail::clz(n) - - inline auto clzll(uint64_t x) -> int - { - unsigned long r = 0; -#ifdef _WIN64 - _BitScanReverse64(&r, x); -#else - // Scan the high 32 bits. - if (_BitScanReverse(&r, static_cast(x >> 32))) - return 63 ^ static_cast(r + 32); - // Scan the low 32 bits. - _BitScanReverse(&r, static_cast(x)); -#endif - FMT_ASSERT(x != 0, ""); - FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. - return 63 ^ static_cast(r); - } -#define FMT_BUILTIN_CLZLL(n) detail::clzll(n) - - inline auto ctz(uint32_t x) -> int - { - unsigned long r = 0; - _BitScanForward(&r, x); - FMT_ASSERT(x != 0, ""); - FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. - return static_cast(r); - } -#define FMT_BUILTIN_CTZ(n) detail::ctz(n) - - inline auto ctzll(uint64_t x) -> int - { - unsigned long r = 0; - FMT_ASSERT(x != 0, ""); - FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. -#ifdef _WIN64 - _BitScanForward64(&r, x); -#else - // Scan the low 32 bits. - if (_BitScanForward(&r, static_cast(x))) - return static_cast(r); - // Scan the high 32 bits. - _BitScanForward(&r, static_cast(x >> 32)); - r += 32; -#endif - return static_cast(r); - } -#define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) -} // namespace detail +# if !defined(__clang__) +# pragma intrinsic(_BitScanForward) +# pragma intrinsic(_BitScanReverse) +# if defined(_WIN64) +# pragma intrinsic(_BitScanForward64) +# pragma intrinsic(_BitScanReverse64) +# endif +# endif + +inline auto clz(uint32_t x) -> int { + unsigned long r = 0; + _BitScanReverse(&r, x); + FMT_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. + FMT_MSC_WARNING(suppress : 6102) + return 31 ^ static_cast(r); +} +# define FMT_BUILTIN_CLZ(n) detail::clz(n) + +inline auto clzll(uint64_t x) -> int { + unsigned long r = 0; +# ifdef _WIN64 + _BitScanReverse64(&r, x); +# else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 ^ static_cast(r + 32); + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +# endif + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return 63 ^ static_cast(r); +} +# define FMT_BUILTIN_CLZLL(n) detail::clzll(n) + +inline auto ctz(uint32_t x) -> int { + unsigned long r = 0; + _BitScanForward(&r, x); + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return static_cast(r); +} +# define FMT_BUILTIN_CTZ(n) detail::ctz(n) + +inline auto ctzll(uint64_t x) -> int { + unsigned long r = 0; + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. +# ifdef _WIN64 + _BitScanForward64(&r, x); +# else + // Scan the low 32 bits. + if (_BitScanForward(&r, static_cast(x))) return static_cast(r); + // Scan the high 32 bits. + _BitScanForward(&r, static_cast(x >> 32)); + r += 32; +# endif + return static_cast(r); +} +# define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) +} // namespace detail FMT_END_NAMESPACE #endif FMT_BEGIN_NAMESPACE -namespace detail -{ +namespace detail { - FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) - { - ignore_unused(condition); +FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { + ignore_unused(condition); #ifdef FMT_FUZZ - if (condition) - throw std::runtime_error("fuzzing limit reached"); + if (condition) throw std::runtime_error("fuzzing limit reached"); #endif - } +} - template - struct string_literal { - static constexpr CharT value[sizeof...(C)] = {C...}; - constexpr operator basic_string_view() const { return {value, sizeof...(C)}; } - }; +template struct string_literal { + static constexpr CharT value[sizeof...(C)] = {C...}; + constexpr operator basic_string_view() const { + return {value, sizeof...(C)}; + } +}; #if FMT_CPLUSPLUS < 201703L - template - constexpr CharT string_literal::value[sizeof...(C)]; +template +constexpr CharT string_literal::value[sizeof...(C)]; #endif - // Implementation of std::bit_cast for pre-C++20. - template - FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To - { +// Implementation of std::bit_cast for pre-C++20. +template +FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { #ifdef __cpp_lib_bit_cast - if (is_constant_evaluated()) - return std::bit_cast(from); + if (is_constant_evaluated()) return std::bit_cast(from); #endif - auto to = To(); - // The cast suppresses a bogus -Wclass-memaccess on GCC. - std::memcpy(static_cast(&to), &from, sizeof(to)); - return to; - } + auto to = To(); + // The cast suppresses a bogus -Wclass-memaccess on GCC. + std::memcpy(static_cast(&to), &from, sizeof(to)); + return to; +} - inline auto is_big_endian() -> bool - { +inline auto is_big_endian() -> bool { #ifdef _WIN32 - return false; + return false; #elif defined(__BIG_ENDIAN__) - return true; + return true; #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) - return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; + return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; #else - struct bytes { - char data[sizeof(int)]; - }; - return bit_cast(1).data[0] == 0; + struct bytes { + char data[sizeof(int)]; + }; + return bit_cast(1).data[0] == 0; #endif - } - - class uint128_fallback { - private: - uint64_t lo_, hi_; - - public: - constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} - constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} - - constexpr auto high() const noexcept -> uint64_t { return hi_; } - constexpr auto low() const noexcept -> uint64_t { return lo_; } - - template ::value)> - constexpr explicit operator T() const - { - return static_cast(lo_); - } - - friend constexpr auto operator==(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; } - friend constexpr auto operator!=(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return !(lhs == rhs); } - friend constexpr auto operator>(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; } - friend constexpr auto operator|(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; } - friend constexpr auto operator&(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; } - friend constexpr auto operator~(const uint128_fallback& n) -> uint128_fallback { return {~n.hi_, ~n.lo_}; } - friend auto operator+(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback - { - auto result = uint128_fallback(lhs); - result += rhs; - return result; - } - friend auto operator*(const uint128_fallback& lhs, uint32_t rhs) -> uint128_fallback - { - FMT_ASSERT(lhs.hi_ == 0, ""); - uint64_t hi = (lhs.lo_ >> 32) * rhs; - uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; - uint64_t new_lo = (hi << 32) + lo; - return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; - } - friend auto operator-(const uint128_fallback& lhs, uint64_t rhs) -> uint128_fallback { return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; } - FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback - { - if (shift == 64) - return {0, hi_}; - if (shift > 64) - return uint128_fallback(0, hi_) >> (shift - 64); - return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; - } - FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback - { - if (shift == 64) - return {lo_, 0}; - if (shift > 64) - return uint128_fallback(lo_, 0) << (shift - 64); - return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; - } - FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { return *this = *this >> shift; } - FMT_CONSTEXPR void operator+=(uint128_fallback n) - { - uint64_t new_lo = lo_ + n.lo_; - uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); - FMT_ASSERT(new_hi >= hi_, ""); - lo_ = new_lo; - hi_ = new_hi; - } - FMT_CONSTEXPR void operator&=(uint128_fallback n) - { - lo_ &= n.lo_; - hi_ &= n.hi_; - } +} - FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& - { - if (is_constant_evaluated()) - { - lo_ += n; - hi_ += (lo_ < n ? 1 : 0); - return *this; - } +class uint128_fallback { + private: + uint64_t lo_, hi_; + + public: + constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} + constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} + + constexpr auto high() const noexcept -> uint64_t { return hi_; } + constexpr auto low() const noexcept -> uint64_t { return lo_; } + + template ::value)> + constexpr explicit operator T() const { + return static_cast(lo_); + } + + friend constexpr auto operator==(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; + } + friend constexpr auto operator!=(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return !(lhs == rhs); + } + friend constexpr auto operator>(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; + } + friend constexpr auto operator|(const uint128_fallback& lhs, + const uint128_fallback& rhs) + -> uint128_fallback { + return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; + } + friend constexpr auto operator&(const uint128_fallback& lhs, + const uint128_fallback& rhs) + -> uint128_fallback { + return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; + } + friend constexpr auto operator~(const uint128_fallback& n) + -> uint128_fallback { + return {~n.hi_, ~n.lo_}; + } + friend auto operator+(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> uint128_fallback { + auto result = uint128_fallback(lhs); + result += rhs; + return result; + } + friend auto operator*(const uint128_fallback& lhs, uint32_t rhs) + -> uint128_fallback { + FMT_ASSERT(lhs.hi_ == 0, ""); + uint64_t hi = (lhs.lo_ >> 32) * rhs; + uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; + uint64_t new_lo = (hi << 32) + lo; + return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; + } + friend auto operator-(const uint128_fallback& lhs, uint64_t rhs) + -> uint128_fallback { + return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; + } + FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback { + if (shift == 64) return {0, hi_}; + if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64); + return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; + } + FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback { + if (shift == 64) return {lo_, 0}; + if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64); + return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; + } + FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { + return *this = *this >> shift; + } + FMT_CONSTEXPR void operator+=(uint128_fallback n) { + uint64_t new_lo = lo_ + n.lo_; + uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); + FMT_ASSERT(new_hi >= hi_, ""); + lo_ = new_lo; + hi_ = new_hi; + } + FMT_CONSTEXPR void operator&=(uint128_fallback n) { + lo_ &= n.lo_; + hi_ &= n.hi_; + } + + FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& { + if (is_constant_evaluated()) { + lo_ += n; + hi_ += (lo_ < n ? 1 : 0); + return *this; + } #if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__) - unsigned long long carry; - lo_ = __builtin_addcll(lo_, n, 0, &carry); - hi_ += carry; + unsigned long long carry; + lo_ = __builtin_addcll(lo_, n, 0, &carry); + hi_ += carry; #elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__) - unsigned long long result; - auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); - lo_ = result; - hi_ += carry; + unsigned long long result; + auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); + lo_ = result; + hi_ += carry; #elif defined(_MSC_VER) && defined(_M_X64) - auto carry = _addcarry_u64(0, lo_, n, &lo_); - _addcarry_u64(carry, hi_, 0, &hi_); + auto carry = _addcarry_u64(0, lo_, n, &lo_); + _addcarry_u64(carry, hi_, 0, &hi_); #else - lo_ += n; - hi_ += (lo_ < n ? 1 : 0); + lo_ += n; + hi_ += (lo_ < n ? 1 : 0); #endif - return *this; - } - }; + return *this; + } +}; - using uint128_t = conditional_t; +using uint128_t = conditional_t; #ifdef UINTPTR_MAX - using uintptr_t = ::uintptr_t; +using uintptr_t = ::uintptr_t; #else - using uintptr_t = uint128_t; +using uintptr_t = uint128_t; #endif - // Returns the largest possible value for type T. Same as - // std::numeric_limits::max() but shorter and not affected by the max macro. - template - constexpr auto max_value() -> T - { - return (std::numeric_limits::max)(); - } - template - constexpr auto num_bits() -> int - { - return std::numeric_limits::digits; - } - // std::numeric_limits::digits may return 0 for 128-bit ints. - template <> - constexpr auto num_bits() -> int - { - return 128; - } - template <> - constexpr auto num_bits() -> int - { - return 128; - } - - // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t - // and 128-bit pointers to uint128_fallback. - template sizeof(From))> - inline auto bit_cast(const From& from) -> To - { - constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned)); - struct data_t { - unsigned value[static_cast(size)]; - } data = bit_cast(from); - auto result = To(); - if (const_check(is_big_endian())) - { - for (int i = 0; i < size; ++i) - result = (result << num_bits()) | data.value[i]; - } - else - { - for (int i = size - 1; i >= 0; --i) - result = (result << num_bits()) | data.value[i]; - } - return result; - } +// Returns the largest possible value for type T. Same as +// std::numeric_limits::max() but shorter and not affected by the max macro. +template constexpr auto max_value() -> T { + return (std::numeric_limits::max)(); +} +template constexpr auto num_bits() -> int { + return std::numeric_limits::digits; +} +// std::numeric_limits::digits may return 0 for 128-bit ints. +template <> constexpr auto num_bits() -> int { return 128; } +template <> constexpr auto num_bits() -> int { return 128; } + +// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t +// and 128-bit pointers to uint128_fallback. +template sizeof(From))> +inline auto bit_cast(const From& from) -> To { + constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned)); + struct data_t { + unsigned value[static_cast(size)]; + } data = bit_cast(from); + auto result = To(); + if (const_check(is_big_endian())) { + for (int i = 0; i < size; ++i) + result = (result << num_bits()) | data.value[i]; + } else { + for (int i = size - 1; i >= 0; --i) + result = (result << num_bits()) | data.value[i]; + } + return result; +} - template - FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int - { - int lz = 0; - constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1); - for (; (n & msb_mask) == 0; n <<= 1) - lz++; - return lz; - } +template +FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int { + int lz = 0; + constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1); + for (; (n & msb_mask) == 0; n <<= 1) lz++; + return lz; +} - FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int - { +FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ - if (!is_constant_evaluated()) - return FMT_BUILTIN_CLZ(n); + if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n); #endif - return countl_zero_fallback(n); - } + return countl_zero_fallback(n); +} - FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int - { +FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL - if (!is_constant_evaluated()) - return FMT_BUILTIN_CLZLL(n); + if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n); #endif - return countl_zero_fallback(n); - } + return countl_zero_fallback(n); +} - FMT_INLINE void assume(bool condition) - { - (void)condition; +FMT_INLINE void assume(bool condition) { + (void)condition; #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION - __builtin_assume(condition); + __builtin_assume(condition); #elif FMT_GCC_VERSION - if (!condition) - __builtin_unreachable(); + if (!condition) __builtin_unreachable(); #endif - } +} - // An approximation of iterator_t for pre-C++20 systems. - template - using iterator_t = decltype(std::begin(std::declval())); - template - using sentinel_t = decltype(std::end(std::declval())); +// An approximation of iterator_t for pre-C++20 systems. +template +using iterator_t = decltype(std::begin(std::declval())); +template using sentinel_t = decltype(std::end(std::declval())); - // A workaround for std::string not having mutable data() until C++17. - template - inline auto get_data(std::basic_string& s) -> Char* - { - return &s[0]; - } - template - inline auto get_data(Container& c) -> typename Container::value_type* - { - return c.data(); - } +// A workaround for std::string not having mutable data() until C++17. +template +inline auto get_data(std::basic_string& s) -> Char* { + return &s[0]; +} +template +inline auto get_data(Container& c) -> typename Container::value_type* { + return c.data(); +} - // Attempts to reserve space for n extra characters in the output range. - // Returns a pointer to the reserved range or a reference to it. - template ::value)> +// Attempts to reserve space for n extra characters in the output range. +// Returns a pointer to the reserved range or a reference to it. +template ::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION - __attribute__((no_sanitize("undefined"))) +__attribute__((no_sanitize("undefined"))) #endif - inline auto - reserve(std::back_insert_iterator it, size_t n) -> typename Container::value_type* - { - Container& c = get_container(it); - size_t size = c.size(); - c.resize(size + n); - return get_data(c) + size; - } +inline auto +reserve(std::back_insert_iterator it, size_t n) -> + typename Container::value_type* { + Container& c = get_container(it); + size_t size = c.size(); + c.resize(size + n); + return get_data(c) + size; +} - template - inline auto reserve(buffer_appender it, size_t n) -> buffer_appender - { - buffer& buf = get_container(it); - buf.try_reserve(buf.size() + n); - return it; - } +template +inline auto reserve(buffer_appender it, size_t n) -> buffer_appender { + buffer& buf = get_container(it); + buf.try_reserve(buf.size() + n); + return it; +} - template - constexpr auto reserve(Iterator& it, size_t) -> Iterator& - { - return it; - } +template +constexpr auto reserve(Iterator& it, size_t) -> Iterator& { + return it; +} - template - using reserve_iterator = remove_reference_t(), 0))>; +template +using reserve_iterator = + remove_reference_t(), 0))>; - template - constexpr auto to_pointer(OutputIt, size_t) -> T* - { - return nullptr; - } - template - auto to_pointer(buffer_appender it, size_t n) -> T* - { - buffer& buf = get_container(it); - auto size = buf.size(); - if (buf.capacity() < size + n) - return nullptr; - buf.try_resize(size + n); - return buf.data() + size; - } +template +constexpr auto to_pointer(OutputIt, size_t) -> T* { + return nullptr; +} +template auto to_pointer(buffer_appender it, size_t n) -> T* { + buffer& buf = get_container(it); + auto size = buf.size(); + if (buf.capacity() < size + n) return nullptr; + buf.try_resize(size + n); + return buf.data() + size; +} - template ::value)> - inline auto base_iterator(std::back_insert_iterator it, typename Container::value_type*) -> std::back_insert_iterator - { - return it; - } +template ::value)> +inline auto base_iterator(std::back_insert_iterator it, + typename Container::value_type*) + -> std::back_insert_iterator { + return it; +} - template - constexpr auto base_iterator(Iterator, Iterator it) -> Iterator - { - return it; - } +template +constexpr auto base_iterator(Iterator, Iterator it) -> Iterator { + return it; +} - // is spectacularly slow to compile in C++20 so use a simple fill_n - // instead (#1998). - template - FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) -> OutputIt - { - for (Size i = 0; i < count; ++i) - *out++ = value; - return out; - } - template - FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* - { - if (is_constant_evaluated()) - { - return fill_n(out, count, value); - } - std::memset(out, value, to_unsigned(count)); - return out + count; - } +// is spectacularly slow to compile in C++20 so use a simple fill_n +// instead (#1998). +template +FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) + -> OutputIt { + for (Size i = 0; i < count; ++i) *out++ = value; + return out; +} +template +FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { + if (is_constant_evaluated()) { + return fill_n(out, count, value); + } + std::memset(out, value, to_unsigned(count)); + return out + count; +} #ifdef __cpp_char8_t - using char8_type = char8_t; +using char8_type = char8_t; #else - enum char8_type : unsigned char {}; +enum char8_type : unsigned char {}; #endif - template - FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, OutputIt out) -> OutputIt - { - return copy_str(begin, end, out); - } - - // A public domain branchless UTF-8 decoder by Christopher Wellons: - // https://github.com/skeeto/branchless-utf8 - /* Decode the next character, c, from s, reporting errors in e. - * - * Since this is a branchless decoder, four bytes will be read from the - * buffer regardless of the actual length of the next character. This - * means the buffer _must_ have at least three bytes of zero padding - * following the end of the data stream. - * - * Errors are reported in e, which will be non-zero if the parsed - * character was somehow invalid: invalid byte sequence, non-canonical - * encoding, or a surrogate half. - * - * The function returns a pointer to the next character. When an error - * occurs, this pointer will be a guess that depends on the particular - * error, but it will always advance at least one byte. - */ - FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) -> const char* - { - constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; - constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; - constexpr const int shiftc[] = {0, 18, 12, 6, 0}; - constexpr const int shifte[] = {0, 6, 4, 2, 0}; - - int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"[static_cast(*s) >> 3]; - // Compute the pointer to the next character early so that the next - // iteration can start working on the next character. Neither Clang - // nor GCC figure out this reordering on their own. - const char* next = s + len + !len; - - using uchar = unsigned char; - - // Assume a four-byte character and load four bytes. Unused bits are - // shifted out. - *c = uint32_t(uchar(s[0]) & masks[len]) << 18; - *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; - *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; - *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; - *c >>= shiftc[len]; - - // Accumulate the various error conditions. - *e = (*c < mins[len]) << 6; // non-canonical encoding - *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? - *e |= (*c > 0x10FFFF) << 8; // out of range? - *e |= (uchar(s[1]) & 0xc0) >> 2; - *e |= (uchar(s[2]) & 0xc0) >> 4; - *e |= uchar(s[3]) >> 6; - *e ^= 0x2a; // top two bits of each tail byte correct? - *e >>= shifte[len]; - - return next; - } +template +FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, + OutputIt out) -> OutputIt { + return copy_str(begin, end, out); +} - constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); +// A public domain branchless UTF-8 decoder by Christopher Wellons: +// https://github.com/skeeto/branchless-utf8 +/* Decode the next character, c, from s, reporting errors in e. + * + * Since this is a branchless decoder, four bytes will be read from the + * buffer regardless of the actual length of the next character. This + * means the buffer _must_ have at least three bytes of zero padding + * following the end of the data stream. + * + * Errors are reported in e, which will be non-zero if the parsed + * character was somehow invalid: invalid byte sequence, non-canonical + * encoding, or a surrogate half. + * + * The function returns a pointer to the next character. When an error + * occurs, this pointer will be a guess that depends on the particular + * error, but it will always advance at least one byte. + */ +FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) + -> const char* { + constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; + constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; + constexpr const int shiftc[] = {0, 18, 12, 6, 0}; + constexpr const int shifte[] = {0, 6, 4, 2, 0}; + + int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4" + [static_cast(*s) >> 3]; + // Compute the pointer to the next character early so that the next + // iteration can start working on the next character. Neither Clang + // nor GCC figure out this reordering on their own. + const char* next = s + len + !len; + + using uchar = unsigned char; + + // Assume a four-byte character and load four bytes. Unused bits are + // shifted out. + *c = uint32_t(uchar(s[0]) & masks[len]) << 18; + *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; + *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; + *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; + *c >>= shiftc[len]; + + // Accumulate the various error conditions. + *e = (*c < mins[len]) << 6; // non-canonical encoding + *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? + *e |= (*c > 0x10FFFF) << 8; // out of range? + *e |= (uchar(s[1]) & 0xc0) >> 2; + *e |= (uchar(s[2]) & 0xc0) >> 4; + *e |= uchar(s[3]) >> 6; + *e ^= 0x2a; // top two bits of each tail byte correct? + *e >>= shifte[len]; + + return next; +} - // Invokes f(cp, sv) for every code point cp in s with sv being the string view - // corresponding to the code point. cp is invalid_code_point on error. - template - FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) - { - auto decode = [f](const char* buf_ptr, const char* ptr) - { - auto cp = uint32_t(); - auto error = 0; - auto end = utf8_decode(buf_ptr, &cp, &error); - bool result = f(error ? invalid_code_point : cp, string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); - return result ? (error ? buf_ptr + 1 : end) : nullptr; - }; - auto p = s.data(); - const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. - if (s.size() >= block_size) - { - for (auto end = p + s.size() - block_size + 1; p < end;) - { - p = decode(p, p); - if (!p) - return; - } - } - if (auto num_chars_left = s.data() + s.size() - p) - { - char buf[2 * block_size - 1] = {}; - copy_str(p, p + num_chars_left, buf); - const char* buf_ptr = buf; - do - { - auto end = decode(buf_ptr, p); - if (!end) - return; - p += end - buf_ptr; - buf_ptr = end; - } - while (buf_ptr - buf < num_chars_left); - } - } +constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); + +// Invokes f(cp, sv) for every code point cp in s with sv being the string view +// corresponding to the code point. cp is invalid_code_point on error. +template +FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { + auto decode = [f](const char* buf_ptr, const char* ptr) { + auto cp = uint32_t(); + auto error = 0; + auto end = utf8_decode(buf_ptr, &cp, &error); + bool result = f(error ? invalid_code_point : cp, + string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); + return result ? (error ? buf_ptr + 1 : end) : nullptr; + }; + auto p = s.data(); + const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. + if (s.size() >= block_size) { + for (auto end = p + s.size() - block_size + 1; p < end;) { + p = decode(p, p); + if (!p) return; + } + } + if (auto num_chars_left = s.data() + s.size() - p) { + char buf[2 * block_size - 1] = {}; + copy_str(p, p + num_chars_left, buf); + const char* buf_ptr = buf; + do { + auto end = decode(buf_ptr, p); + if (!end) return; + p += end - buf_ptr; + buf_ptr = end; + } while (buf_ptr - buf < num_chars_left); + } +} - template - inline auto compute_width(basic_string_view s) -> size_t - { - return s.size(); - } +template +inline auto compute_width(basic_string_view s) -> size_t { + return s.size(); +} - // Computes approximate display width of a UTF-8 string. - FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t - { - size_t num_code_points = 0; - // It is not a lambda for compatibility with C++14. - struct count_code_points { - size_t* count; - FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool - { - *count += detail::to_unsigned(1 + - (cp >= 0x1100 && - (cp <= 0x115f || // Hangul Jamo init. consonants - cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET - cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET - // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: - (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables - (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs - (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms - (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms - (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms - (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms - (cp >= 0x20000 && cp <= 0x2fffd) || // CJK - (cp >= 0x30000 && cp <= 0x3fffd) || - // Miscellaneous Symbols and Pictographs + Emoticons: - (cp >= 0x1f300 && cp <= 0x1f64f) || - // Supplemental Symbols and Pictographs: - (cp >= 0x1f900 && cp <= 0x1f9ff)))); - return true; - } - }; - // We could avoid branches by using utf8_decode directly. - for_each_codepoint(s, count_code_points{&num_code_points}); - return num_code_points; - } +// Computes approximate display width of a UTF-8 string. +FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { + size_t num_code_points = 0; + // It is not a lambda for compatibility with C++14. + struct count_code_points { + size_t* count; + FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool { + *count += detail::to_unsigned( + 1 + + (cp >= 0x1100 && + (cp <= 0x115f || // Hangul Jamo init. consonants + cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET + cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET + // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: + (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || + (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables + (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs + (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms + (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms + (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms + (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms + (cp >= 0x20000 && cp <= 0x2fffd) || // CJK + (cp >= 0x30000 && cp <= 0x3fffd) || + // Miscellaneous Symbols and Pictographs + Emoticons: + (cp >= 0x1f300 && cp <= 0x1f64f) || + // Supplemental Symbols and Pictographs: + (cp >= 0x1f900 && cp <= 0x1f9ff)))); + return true; + } + }; + // We could avoid branches by using utf8_decode directly. + for_each_codepoint(s, count_code_points{&num_code_points}); + return num_code_points; +} - inline auto compute_width(basic_string_view s) -> size_t { return compute_width(string_view(reinterpret_cast(s.data()), s.size())); } +inline auto compute_width(basic_string_view s) -> size_t { + return compute_width( + string_view(reinterpret_cast(s.data()), s.size())); +} - template - inline auto code_point_index(basic_string_view s, size_t n) -> size_t - { - size_t size = s.size(); - return n < size ? n : size; - } +template +inline auto code_point_index(basic_string_view s, size_t n) -> size_t { + size_t size = s.size(); + return n < size ? n : size; +} - // Calculates the index of the nth code point in a UTF-8 string. - inline auto code_point_index(string_view s, size_t n) -> size_t - { - size_t result = s.size(); - const char* begin = s.begin(); - for_each_codepoint(s, - [begin, &n, &result](uint32_t, string_view sv) - { - if (n != 0) - { - --n; - return true; - } - result = to_unsigned(sv.begin() - begin); - return false; - }); - return result; - } +// Calculates the index of the nth code point in a UTF-8 string. +inline auto code_point_index(string_view s, size_t n) -> size_t { + size_t result = s.size(); + const char* begin = s.begin(); + for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) { + if (n != 0) { + --n; + return true; + } + result = to_unsigned(sv.begin() - begin); + return false; + }); + return result; +} - inline auto code_point_index(basic_string_view s, size_t n) -> size_t { return code_point_index(string_view(reinterpret_cast(s.data()), s.size()), n); } +inline auto code_point_index(basic_string_view s, size_t n) + -> size_t { + return code_point_index( + string_view(reinterpret_cast(s.data()), s.size()), n); +} - template - struct is_integral : std::is_integral {}; - template <> - struct is_integral : std::true_type {}; - template <> - struct is_integral : std::true_type {}; +template struct is_integral : std::is_integral {}; +template <> struct is_integral : std::true_type {}; +template <> struct is_integral : std::true_type {}; - template - using is_signed = std::integral_constant::is_signed || std::is_same::value>; +template +using is_signed = + std::integral_constant::is_signed || + std::is_same::value>; - template - using is_integer = bool_constant::value && !std::is_same::value && !std::is_same::value && !std::is_same::value>; +template +using is_integer = + bool_constant::value && !std::is_same::value && + !std::is_same::value && + !std::is_same::value>; #ifndef FMT_USE_FLOAT -#define FMT_USE_FLOAT 1 +# define FMT_USE_FLOAT 1 #endif #ifndef FMT_USE_DOUBLE -#define FMT_USE_DOUBLE 1 +# define FMT_USE_DOUBLE 1 #endif #ifndef FMT_USE_LONG_DOUBLE -#define FMT_USE_LONG_DOUBLE 1 +# define FMT_USE_LONG_DOUBLE 1 #endif #ifndef FMT_USE_FLOAT128 -#ifdef __clang__ +# ifdef __clang__ // Clang emulates GCC, so it has to appear early. -#if FMT_HAS_INCLUDE() -#define FMT_USE_FLOAT128 1 -#endif -#elif defined(__GNUC__) +# if FMT_HAS_INCLUDE() +# define FMT_USE_FLOAT128 1 +# endif +# elif defined(__GNUC__) // GNU C++: -#if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) -#define FMT_USE_FLOAT128 1 -#endif -#endif -#ifndef FMT_USE_FLOAT128 -#define FMT_USE_FLOAT128 0 -#endif +# if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) +# define FMT_USE_FLOAT128 1 +# endif +# endif +# ifndef FMT_USE_FLOAT128 +# define FMT_USE_FLOAT128 0 +# endif #endif #if FMT_USE_FLOAT128 - using float128 = __float128; +using float128 = __float128; #else - using float128 = void; +using float128 = void; #endif - template - using is_float128 = std::is_same; +template using is_float128 = std::is_same; - template - using is_floating_point = bool_constant::value || is_float128::value>; +template +using is_floating_point = + bool_constant::value || is_float128::value>; - template ::value> - struct is_fast_float : bool_constant::is_iec559 && sizeof(T) <= sizeof(double)> {}; - template - struct is_fast_float : std::false_type {}; +template ::value> +struct is_fast_float : bool_constant::is_iec559 && + sizeof(T) <= sizeof(double)> {}; +template struct is_fast_float : std::false_type {}; - template - using is_double_double = bool_constant::digits == 106>; +template +using is_double_double = bool_constant::digits == 106>; #ifndef FMT_USE_FULL_CACHE_DRAGONBOX -#define FMT_USE_FULL_CACHE_DRAGONBOX 0 +# define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif - template - template - void buffer::append(const U* begin, const U* end) - { - while (begin != end) - { - auto count = to_unsigned(end - begin); - try_reserve(size_ + count); - auto free_cap = capacity_ - size_; - if (free_cap < count) - count = free_cap; - std::uninitialized_copy_n(begin, count, ptr_ + size_); - size_ += count; - begin += count; - } - } +template +template +void buffer::append(const U* begin, const U* end) { + while (begin != end) { + auto count = to_unsigned(end - begin); + try_reserve(size_ + count); + auto free_cap = capacity_ - size_; + if (free_cap < count) count = free_cap; + std::uninitialized_copy_n(begin, count, ptr_ + size_); + size_ += count; + begin += count; + } +} - template - struct is_locale : std::false_type {}; - template - struct is_locale> : std::true_type {}; -} // namespace detail +template +struct is_locale : std::false_type {}; +template +struct is_locale> : std::true_type {}; +} // namespace detail FMT_BEGIN_EXPORT @@ -914,1036 +878,962 @@ enum { inline_buffer_size = 500 }; The output can be converted to an ``std::string`` with ``to_string(out)``. \endrst */ -template > +template > class basic_memory_buffer final : public detail::buffer { -private: - T store_[SIZE]; - - // Don't inherit from Allocator to avoid generating type_info for it. - FMT_NO_UNIQUE_ADDRESS Allocator alloc_; - - // Deallocate memory allocated by the buffer. - FMT_CONSTEXPR20 void deallocate() - { - T* data = this->data(); - if (data != store_) - alloc_.deallocate(data, this->capacity()); - } - -protected: - FMT_CONSTEXPR20 void grow(size_t size) override - { - detail::abort_fuzzing_if(size > 5000); - const size_t max_size = std::allocator_traits::max_size(alloc_); - size_t old_capacity = this->capacity(); - size_t new_capacity = old_capacity + old_capacity / 2; - if (size > new_capacity) - new_capacity = size; - else if (new_capacity > max_size) - new_capacity = size > max_size ? size : max_size; - T* old_data = this->data(); - T* new_data = std::allocator_traits::allocate(alloc_, new_capacity); - // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). - detail::assume(this->size() <= new_capacity); - // The following code doesn't throw, so the raw pointer above doesn't leak. - std::uninitialized_copy_n(old_data, this->size(), new_data); - this->set(new_data, new_capacity); - // deallocate must not throw according to the standard, but even if it does, - // the buffer already uses the new storage and will deallocate it in - // destructor. - if (old_data != store_) - alloc_.deallocate(old_data, old_capacity); - } - -public: - using value_type = T; - using const_reference = const T&; - - FMT_CONSTEXPR20 explicit basic_memory_buffer(const Allocator& alloc = Allocator()) : alloc_(alloc) - { - this->set(store_, SIZE); - if (detail::is_constant_evaluated()) - detail::fill_n(store_, SIZE, T()); - } - FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } - -private: - // Move data from other to this buffer. - FMT_CONSTEXPR20 void move(basic_memory_buffer& other) - { - alloc_ = std::move(other.alloc_); - T* data = other.data(); - size_t size = other.size(), capacity = other.capacity(); - if (data == other.store_) - { - this->set(store_, capacity); - detail::copy_str(other.store_, other.store_ + size, store_); - } - else - { - this->set(data, capacity); - // Set pointer to the inline array so that delete is not called - // when deallocating. - other.set(other.store_, 0); - other.clear(); - } - this->resize(size); - } - -public: - /** - \rst - Constructs a :class:`fmt::basic_memory_buffer` object moving the content - of the other object to it. - \endrst - */ - FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept { move(other); } - - /** - \rst - Moves the content of the other ``basic_memory_buffer`` object to this one. - \endrst - */ - auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& - { - FMT_ASSERT(this != &other, ""); - deallocate(); - move(other); - return *this; - } - - // Returns a copy of the allocator associated with this buffer. - auto get_allocator() const -> Allocator { return alloc_; } - - /** - Resizes the buffer to contain *count* elements. If T is a POD type new - elements may not be initialized. - */ - FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } - - /** Increases the buffer capacity to *new_capacity*. */ - void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } - - using detail::buffer::append; - template - void append(const ContiguousRange& range) - { - append(range.data(), range.data() + range.size()); - } + private: + T store_[SIZE]; + + // Don't inherit from Allocator to avoid generating type_info for it. + FMT_NO_UNIQUE_ADDRESS Allocator alloc_; + + // Deallocate memory allocated by the buffer. + FMT_CONSTEXPR20 void deallocate() { + T* data = this->data(); + if (data != store_) alloc_.deallocate(data, this->capacity()); + } + + protected: + FMT_CONSTEXPR20 void grow(size_t size) override { + detail::abort_fuzzing_if(size > 5000); + const size_t max_size = std::allocator_traits::max_size(alloc_); + size_t old_capacity = this->capacity(); + size_t new_capacity = old_capacity + old_capacity / 2; + if (size > new_capacity) + new_capacity = size; + else if (new_capacity > max_size) + new_capacity = size > max_size ? size : max_size; + T* old_data = this->data(); + T* new_data = + std::allocator_traits::allocate(alloc_, new_capacity); + // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). + detail::assume(this->size() <= new_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy_n(old_data, this->size(), new_data); + this->set(new_data, new_capacity); + // deallocate must not throw according to the standard, but even if it does, + // the buffer already uses the new storage and will deallocate it in + // destructor. + if (old_data != store_) alloc_.deallocate(old_data, old_capacity); + } + + public: + using value_type = T; + using const_reference = const T&; + + FMT_CONSTEXPR20 explicit basic_memory_buffer( + const Allocator& alloc = Allocator()) + : alloc_(alloc) { + this->set(store_, SIZE); + if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); + } + FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } + + private: + // Move data from other to this buffer. + FMT_CONSTEXPR20 void move(basic_memory_buffer& other) { + alloc_ = std::move(other.alloc_); + T* data = other.data(); + size_t size = other.size(), capacity = other.capacity(); + if (data == other.store_) { + this->set(store_, capacity); + detail::copy_str(other.store_, other.store_ + size, store_); + } else { + this->set(data, capacity); + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.set(other.store_, 0); + other.clear(); + } + this->resize(size); + } + + public: + /** + \rst + Constructs a :class:`fmt::basic_memory_buffer` object moving the content + of the other object to it. + \endrst + */ + FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept { + move(other); + } + + /** + \rst + Moves the content of the other ``basic_memory_buffer`` object to this one. + \endrst + */ + auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { + FMT_ASSERT(this != &other, ""); + deallocate(); + move(other); + return *this; + } + + // Returns a copy of the allocator associated with this buffer. + auto get_allocator() const -> Allocator { return alloc_; } + + /** + Resizes the buffer to contain *count* elements. If T is a POD type new + elements may not be initialized. + */ + FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } + + /** Increases the buffer capacity to *new_capacity*. */ + void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } + + using detail::buffer::append; + template + void append(const ContiguousRange& range) { + append(range.data(), range.data() + range.size()); + } }; using memory_buffer = basic_memory_buffer; template -struct is_contiguous> : std::true_type {}; +struct is_contiguous> : std::true_type { +}; FMT_END_EXPORT -namespace detail -{ - FMT_API auto write_console(int fd, string_view text) -> bool; - FMT_API auto write_console(std::FILE* f, string_view text) -> bool; - FMT_API void print(std::FILE*, string_view); -} // namespace detail +namespace detail { +FMT_API auto write_console(int fd, string_view text) -> bool; +FMT_API auto write_console(std::FILE* f, string_view text) -> bool; +FMT_API void print(std::FILE*, string_view); +} // namespace detail FMT_BEGIN_EXPORT // Suppress a misleading warning in older versions of clang. #if FMT_CLANG_VERSION -#pragma clang diagnostic ignored "-Wweak-vtables" +# pragma clang diagnostic ignored "-Wweak-vtables" #endif /** An error reported from a formatting function. */ class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { -public: - using std::runtime_error::runtime_error; + public: + using std::runtime_error::runtime_error; }; -namespace detail_exported -{ +namespace detail_exported { #if FMT_USE_NONTYPE_TEMPLATE_ARGS - template - struct fixed_string { - constexpr fixed_string(const Char (&str)[N]) { detail::copy_str(static_cast(str), str + N, data); } - Char data[N] = {}; - }; +template struct fixed_string { + constexpr fixed_string(const Char (&str)[N]) { + detail::copy_str(static_cast(str), + str + N, data); + } + Char data[N] = {}; +}; #endif - // Converts a compile-time string to basic_string_view. - template - constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view - { - // Remove trailing NUL character if needed. Won't be present if this is used - // with a raw character array (i.e. not defined as a string). - return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; - } - template - constexpr auto compile_string_to_view(detail::std_string_view s) -> basic_string_view - { - return {s.data(), s.size()}; - } -} // namespace detail_exported +// Converts a compile-time string to basic_string_view. +template +constexpr auto compile_string_to_view(const Char (&s)[N]) + -> basic_string_view { + // Remove trailing NUL character if needed. Won't be present if this is used + // with a raw character array (i.e. not defined as a string). + return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; +} +template +constexpr auto compile_string_to_view(detail::std_string_view s) + -> basic_string_view { + return {s.data(), s.size()}; +} +} // namespace detail_exported class loc_value { -private: - basic_format_arg value_; + private: + basic_format_arg value_; -public: - template ::value)> - loc_value(T value) : value_(detail::make_arg(value)) - { - } + public: + template ::value)> + loc_value(T value) : value_(detail::make_arg(value)) {} - template ::value)> - loc_value(T) - { - } + template ::value)> + loc_value(T) {} - template - auto visit(Visitor&& vis) -> decltype(vis(0)) - { - return visit_format_arg(vis, value_); - } + template auto visit(Visitor&& vis) -> decltype(vis(0)) { + return visit_format_arg(vis, value_); + } }; // A locale facet that formats values in UTF-8. // It is parameterized on the locale to avoid the heavy include. -template -class format_facet : public Locale::facet { -private: - std::string separator_; - std::string grouping_; - std::string decimal_point_; - -protected: - virtual auto do_put(appender out, loc_value val, const format_specs<>& specs) const -> bool; - -public: - static FMT_API typename Locale::id id; - - explicit format_facet(Locale& loc); - explicit format_facet(string_view sep = "", std::initializer_list g = {3}, std::string decimal_point = ".") : separator_(sep.data(), sep.size()), grouping_(g.begin(), g.end()), decimal_point_(decimal_point) {} - - auto put(appender out, loc_value val, const format_specs<>& specs) const -> bool { return do_put(out, val, specs); } +template class format_facet : public Locale::facet { + private: + std::string separator_; + std::string grouping_; + std::string decimal_point_; + + protected: + virtual auto do_put(appender out, loc_value val, + const format_specs<>& specs) const -> bool; + + public: + static FMT_API typename Locale::id id; + + explicit format_facet(Locale& loc); + explicit format_facet(string_view sep = "", + std::initializer_list g = {3}, + std::string decimal_point = ".") + : separator_(sep.data(), sep.size()), + grouping_(g.begin(), g.end()), + decimal_point_(decimal_point) {} + + auto put(appender out, loc_value val, const format_specs<>& specs) const + -> bool { + return do_put(out, val, specs); + } }; -namespace detail -{ - - // Returns true if value is negative, false otherwise. - // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. - template ::value)> - constexpr auto is_negative(T value) -> bool - { - return value < 0; - } - template ::value)> - constexpr auto is_negative(T) -> bool - { - return false; - } - - template - FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool - { - if (std::is_same()) - return FMT_USE_FLOAT; - if (std::is_same()) - return FMT_USE_DOUBLE; - if (std::is_same()) - return FMT_USE_LONG_DOUBLE; - return true; - } +namespace detail { - // Smallest of uint32_t, uint64_t, uint128_t that is large enough to - // represent all values of an integral type T. - template - using uint32_or_64_or_128_t = conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t() <= 64, uint64_t, uint128_t>>; - template - using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; +// Returns true if value is negative, false otherwise. +// Same as `value < 0` but doesn't produce warnings if T is an unsigned type. +template ::value)> +constexpr auto is_negative(T value) -> bool { + return value < 0; +} +template ::value)> +constexpr auto is_negative(T) -> bool { + return false; +} -#define FMT_POWERS_OF_10(factor) factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, (factor) * 100000, (factor) * 1000000, (factor) * 10000000, (factor) * 100000000, (factor) * 1000000000 +template +FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool { + if (std::is_same()) return FMT_USE_FLOAT; + if (std::is_same()) return FMT_USE_DOUBLE; + if (std::is_same()) return FMT_USE_LONG_DOUBLE; + return true; +} - // Converts value in the range [0, 100) to a string. - constexpr auto digits2(size_t value) -> const char* - { - // GCC generates slightly better code when value is pointer-size. - return &"0001020304050607080910111213141516171819" - "2021222324252627282930313233343536373839" - "4041424344454647484950515253545556575859" - "6061626364656667686970717273747576777879" - "8081828384858687888990919293949596979899"[value * 2]; - } +// Smallest of uint32_t, uint64_t, uint128_t that is large enough to +// represent all values of an integral type T. +template +using uint32_or_64_or_128_t = + conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, + uint32_t, + conditional_t() <= 64, uint64_t, uint128_t>>; +template +using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ + (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ + (factor) * 100000000, (factor) * 1000000000 + +// Converts value in the range [0, 100) to a string. +constexpr auto digits2(size_t value) -> const char* { + // GCC generates slightly better code when value is pointer-size. + return &"0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"[value * 2]; +} - // Sign is a template parameter to workaround a bug in gcc 4.8. - template - constexpr auto sign(Sign s) -> Char - { +// Sign is a template parameter to workaround a bug in gcc 4.8. +template constexpr auto sign(Sign s) -> Char { #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604 - static_assert(std::is_same::value, ""); + static_assert(std::is_same::value, ""); #endif - return static_cast("\0-+ "[s]); - } + return static_cast("\0-+ "[s]); +} - template - FMT_CONSTEXPR auto count_digits_fallback(T n) -> int - { - int 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; - } - } +template FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { + int 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; + } +} #if FMT_USE_INT128 - FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { return count_digits_fallback(n); } +FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { + return count_digits_fallback(n); +} #endif #ifdef FMT_BUILTIN_CLZLL - // It is a separate function rather than a part of count_digits to workaround - // the lack of static constexpr in constexpr functions. - inline auto do_count_digits(uint64_t n) -> int - { - // This has comparable performance to the version by Kendall Willets - // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) - // but uses smaller tables. - // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). - static constexpr uint8_t bsr2log10[] = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; - auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; - static constexpr const uint64_t zero_or_powers_of_10[] = {0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL}; - return t - (n < zero_or_powers_of_10[t]); - } +// It is a separate function rather than a part of count_digits to workaround +// the lack of static constexpr in constexpr functions. +inline auto do_count_digits(uint64_t n) -> int { + // This has comparable performance to the version by Kendall Willets + // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) + // but uses smaller tables. + // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). + static constexpr uint8_t bsr2log10[] = { + 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, + 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, + 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, + 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; + auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; + static constexpr const uint64_t zero_or_powers_of_10[] = { + 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + return t - (n < zero_or_powers_of_10[t]); +} #endif - // Returns the number of decimal digits in n. Leading zeros are not counted - // except for n == 0 in which case count_digits returns 1. - FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int - { +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case count_digits returns 1. +FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL - if (!is_constant_evaluated()) - { - return do_count_digits(n); - } + if (!is_constant_evaluated()) { + return do_count_digits(n); + } #endif - return count_digits_fallback(n); - } + return count_digits_fallback(n); +} - // Counts the number of digits in n. BITS = log2(radix). - template - FMT_CONSTEXPR auto count_digits(UInt n) -> int - { +// Counts the number of digits in n. BITS = log2(radix). +template +FMT_CONSTEXPR auto count_digits(UInt n) -> int { #ifdef FMT_BUILTIN_CLZ - if (!is_constant_evaluated() && num_bits() == 32) - return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; + if (!is_constant_evaluated() && num_bits() == 32) + return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; #endif - // Lambda avoids unreachable code warnings from NVHPC. - return [](UInt m) - { - int num_digits = 0; - do - { - ++num_digits; - } - while ((m >>= BITS) != 0); - return num_digits; - }(n); - } + // Lambda avoids unreachable code warnings from NVHPC. + return [](UInt m) { + int num_digits = 0; + do { + ++num_digits; + } while ((m >>= BITS) != 0); + return num_digits; + }(n); +} #ifdef FMT_BUILTIN_CLZ - // It is a separate function rather than a part of count_digits to workaround - // the lack of static constexpr in constexpr functions. - FMT_INLINE auto do_count_digits(uint32_t n) -> int - { +// It is a separate function rather than a part of count_digits to workaround +// the lack of static constexpr in constexpr functions. +FMT_INLINE auto do_count_digits(uint32_t n) -> int { // An optimization by Kendall Willets from https://bit.ly/3uOIQrB. // This increments the upper 32 bits (log10(T) - 1) when >= T is added. -#define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) - static constexpr uint64_t table[] = { - FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 - FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 - FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 - FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 - FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k - FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k - FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k - FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M - FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M - FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M - FMT_INC(1000000000), FMT_INC(1000000000) // 4B - }; - auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; - return static_cast((n + inc) >> 32); - } +# define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) + static constexpr uint64_t table[] = { + FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 + FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 + FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 + FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 + FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k + FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k + FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k + FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M + FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M + FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M + FMT_INC(1000000000), FMT_INC(1000000000) // 4B + }; + auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; + return static_cast((n + inc) >> 32); +} #endif - // Optional version of count_digits for better performance on 32-bit platforms. - FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int - { +// Optional version of count_digits for better performance on 32-bit platforms. +FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ - if (!is_constant_evaluated()) - { - return do_count_digits(n); - } + if (!is_constant_evaluated()) { + return do_count_digits(n); + } #endif - return count_digits_fallback(n); - } + return count_digits_fallback(n); +} - template - constexpr auto digits10() noexcept -> int - { - return std::numeric_limits::digits10; - } - template <> - constexpr auto digits10() noexcept -> int - { - return 38; - } - template <> - constexpr auto digits10() noexcept -> int - { - return 38; - } +template constexpr auto digits10() noexcept -> int { + return std::numeric_limits::digits10; +} +template <> constexpr auto digits10() noexcept -> int { return 38; } +template <> constexpr auto digits10() noexcept -> int { return 38; } - template - struct thousands_sep_result { - std::string grouping; - Char thousands_sep; - }; +template struct thousands_sep_result { + std::string grouping; + Char thousands_sep; +}; - template - FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result; - template - inline auto thousands_sep(locale_ref loc) -> thousands_sep_result - { - auto result = thousands_sep_impl(loc); - return {result.grouping, Char(result.thousands_sep)}; - } - template <> - inline auto thousands_sep(locale_ref loc) -> thousands_sep_result - { - return thousands_sep_impl(loc); - } +template +FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result; +template +inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { + auto result = thousands_sep_impl(loc); + return {result.grouping, Char(result.thousands_sep)}; +} +template <> +inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { + return thousands_sep_impl(loc); +} - template - FMT_API auto decimal_point_impl(locale_ref loc) -> Char; - template - inline auto decimal_point(locale_ref loc) -> Char - { - return Char(decimal_point_impl(loc)); - } - template <> - inline auto decimal_point(locale_ref loc) -> wchar_t - { - return decimal_point_impl(loc); - } +template +FMT_API auto decimal_point_impl(locale_ref loc) -> Char; +template inline auto decimal_point(locale_ref loc) -> Char { + return Char(decimal_point_impl(loc)); +} +template <> inline auto decimal_point(locale_ref loc) -> wchar_t { + return decimal_point_impl(loc); +} - // Compares two characters for equality. - template - auto equal2(const Char* lhs, const char* rhs) -> bool - { - return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); - } - inline auto equal2(const char* lhs, const char* rhs) -> bool { return memcmp(lhs, rhs, 2) == 0; } +// Compares two characters for equality. +template auto equal2(const Char* lhs, const char* rhs) -> bool { + return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); +} +inline auto equal2(const char* lhs, const char* rhs) -> bool { + return memcmp(lhs, rhs, 2) == 0; +} - // Copies two characters from src to dst. - template - FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) - { - if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) - { - memcpy(dst, src, 2); - return; - } - *dst++ = static_cast(*src++); - *dst = static_cast(*src); - } +// Copies two characters from src to dst. +template +FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) { + if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) { + memcpy(dst, src, 2); + return; + } + *dst++ = static_cast(*src++); + *dst = static_cast(*src); +} - template - struct format_decimal_result { - Iterator begin; - Iterator end; - }; +template struct format_decimal_result { + Iterator begin; + Iterator end; +}; - // Formats a decimal unsigned integer value writing into out pointing to a - // buffer of specified size. The caller must ensure that the buffer is large - // enough. - template - FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) -> format_decimal_result - { - FMT_ASSERT(size >= count_digits(value), "invalid digit count"); - out += size; - Char* end = out; - 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. - out -= 2; - copy2(out, digits2(static_cast(value % 100))); - value /= 100; - } - if (value < 10) - { - *--out = static_cast('0' + value); - return {out, end}; - } - out -= 2; - copy2(out, digits2(static_cast(value))); - return {out, end}; - } +// Formats a decimal unsigned integer value writing into out pointing to a +// buffer of specified size. The caller must ensure that the buffer is large +// enough. +template +FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) + -> format_decimal_result { + FMT_ASSERT(size >= count_digits(value), "invalid digit count"); + out += size; + Char* end = out; + 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. + out -= 2; + copy2(out, digits2(static_cast(value % 100))); + value /= 100; + } + if (value < 10) { + *--out = static_cast('0' + value); + return {out, end}; + } + out -= 2; + copy2(out, digits2(static_cast(value))); + return {out, end}; +} - template >::value)> - FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) -> format_decimal_result - { - // Buffer is large enough to hold all digits (digits10 + 1). - Char buffer[digits10() + 1] = {}; - auto end = format_decimal(buffer, value, size).end; - return {out, detail::copy_str_noinline(buffer, end, out)}; - } +template >::value)> +FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) + -> format_decimal_result { + // Buffer is large enough to hold all digits (digits10 + 1). + Char buffer[digits10() + 1] = {}; + auto end = format_decimal(buffer, value, size).end; + return {out, detail::copy_str_noinline(buffer, end, out)}; +} - template - FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, bool upper = false) -> Char* - { - buffer += num_digits; - Char* end = buffer; - do - { - const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; - unsigned digit = static_cast(value & ((1 << BASE_BITS) - 1)); - *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]); - } - while ((value >>= BASE_BITS) != 0); - return end; - } +template +FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, + bool upper = false) -> Char* { + buffer += num_digits; + Char* end = buffer; + do { + const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; + unsigned digit = static_cast(value & ((1 << BASE_BITS) - 1)); + *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) + : digits[digit]); + } while ((value >>= BASE_BITS) != 0); + return end; +} - template - FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) -> It - { - if (auto ptr = to_pointer(out, to_unsigned(num_digits))) - { - format_uint(ptr, value, num_digits, upper); - return out; - } - // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). - char buffer[num_bits() / BASE_BITS + 1] = {}; - format_uint(buffer, value, num_digits, upper); - return detail::copy_str_noinline(buffer, buffer + num_digits, out); - } +template +FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits, + bool upper = false) -> It { + if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { + format_uint(ptr, value, num_digits, upper); + return out; + } + // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). + char buffer[num_bits() / BASE_BITS + 1] = {}; + format_uint(buffer, value, num_digits, upper); + return detail::copy_str_noinline(buffer, buffer + num_digits, out); +} - // A converter from UTF-8 to UTF-16. - class utf8_to_utf16 { - private: - basic_memory_buffer buffer_; - - public: - FMT_API explicit utf8_to_utf16(string_view s); - operator basic_string_view() const { return {&buffer_[0], size()}; } - auto size() const -> size_t { return buffer_.size() - 1; } - auto c_str() const -> const wchar_t* { return &buffer_[0]; } - auto str() const -> std::wstring { return {&buffer_[0], size()}; } - }; +// A converter from UTF-8 to UTF-16. +class utf8_to_utf16 { + private: + basic_memory_buffer buffer_; + + public: + FMT_API explicit utf8_to_utf16(string_view s); + operator basic_string_view() const { return {&buffer_[0], size()}; } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const wchar_t* { return &buffer_[0]; } + auto str() const -> std::wstring { return {&buffer_[0], size()}; } +}; - enum class to_utf8_error_policy { abort, replace }; - - // A converter from UTF-16/UTF-32 (host endian) to UTF-8. - template - class to_utf8 { - private: - Buffer buffer_; - - public: - to_utf8() {} - explicit to_utf8(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) - { - static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, "Expect utf16 or utf32"); - if (!convert(s, policy)) - FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32")); +enum class to_utf8_error_policy { abort, replace }; + +// A converter from UTF-16/UTF-32 (host endian) to UTF-8. +template class to_utf8 { + private: + Buffer buffer_; + + public: + to_utf8() {} + explicit to_utf8(basic_string_view s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) { + static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, + "Expect utf16 or utf32"); + if (!convert(s, policy)) + FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" + : "invalid utf32")); + } + operator string_view() const { return string_view(&buffer_[0], size()); } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const char* { return &buffer_[0]; } + auto str() const -> std::string { return std::string(&buffer_[0], size()); } + + // Performs conversion returning a bool instead of throwing exception on + // conversion error. This method may still throw in case of memory allocation + // error. + auto convert(basic_string_view s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { + if (!convert(buffer_, s, policy)) return false; + buffer_.push_back(0); + return true; + } + static auto convert(Buffer& buf, basic_string_view s, + to_utf8_error_policy policy = to_utf8_error_policy::abort) + -> bool { + for (auto p = s.begin(); p != s.end(); ++p) { + uint32_t c = static_cast(*p); + if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { + // Handle a surrogate pair. + ++p; + if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { + if (policy == to_utf8_error_policy::abort) return false; + buf.append(string_view("\xEF\xBF\xBD")); + --p; + } else { + c = (c << 10) + static_cast(*p) - 0x35fdc00; } - operator string_view() const { return string_view(&buffer_[0], size()); } - auto size() const -> size_t { return buffer_.size() - 1; } - auto c_str() const -> const char* { return &buffer_[0]; } - auto str() const -> std::string { return std::string(&buffer_[0], size()); } - - // Performs conversion returning a bool instead of throwing exception on - // conversion error. This method may still throw in case of memory allocation - // error. - auto convert(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool - { - if (!convert(buffer_, s, policy)) - return false; - buffer_.push_back(0); - return true; - } - static auto convert(Buffer& buf, basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool - { - for (auto p = s.begin(); p != s.end(); ++p) - { - uint32_t c = static_cast(*p); - if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) - { - // Handle a surrogate pair. - ++p; - if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) - { - if (policy == to_utf8_error_policy::abort) - return false; - buf.append(string_view("\xEF\xBF\xBD")); - --p; - } - else - { - c = (c << 10) + static_cast(*p) - 0x35fdc00; - } - } - else if (c < 0x80) - { - buf.push_back(static_cast(c)); - } - else if (c < 0x800) - { - buf.push_back(static_cast(0xc0 | (c >> 6))); - buf.push_back(static_cast(0x80 | (c & 0x3f))); - } - else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) - { - buf.push_back(static_cast(0xe0 | (c >> 12))); - buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); - buf.push_back(static_cast(0x80 | (c & 0x3f))); - } - else if (c >= 0x10000 && c <= 0x10ffff) - { - buf.push_back(static_cast(0xf0 | (c >> 18))); - buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12))); - buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); - buf.push_back(static_cast(0x80 | (c & 0x3f))); - } - else - { - return false; - } - } - return true; - } - }; + } else if (c < 0x80) { + buf.push_back(static_cast(c)); + } else if (c < 0x800) { + buf.push_back(static_cast(0xc0 | (c >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) { + buf.push_back(static_cast(0xe0 | (c >> 12))); + buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else if (c >= 0x10000 && c <= 0x10ffff) { + buf.push_back(static_cast(0xf0 | (c >> 18))); + buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12))); + buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else { + return false; + } + } + return true; + } +}; - // Computes 128-bit result of multiplication of two 64-bit unsigned integers. - inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback - { +// Computes 128-bit result of multiplication of two 64-bit unsigned integers. +inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback { #if FMT_USE_INT128 - auto p = static_cast(x) * static_cast(y); - return {static_cast(p >> 64), static_cast(p)}; + auto p = static_cast(x) * static_cast(y); + return {static_cast(p >> 64), static_cast(p)}; #elif defined(_MSC_VER) && defined(_M_X64) - auto hi = uint64_t(); - auto lo = _umul128(x, y, &hi); - return {hi, lo}; + auto hi = uint64_t(); + auto lo = _umul128(x, y, &hi); + return {hi, lo}; #else - const uint64_t mask = static_cast(max_value()); + const uint64_t mask = static_cast(max_value()); - uint64_t a = x >> 32; - uint64_t b = x & mask; - uint64_t c = y >> 32; - uint64_t d = y & mask; + uint64_t a = x >> 32; + uint64_t b = x & mask; + uint64_t c = y >> 32; + uint64_t d = y & mask; - uint64_t ac = a * c; - uint64_t bc = b * c; - uint64_t ad = a * d; - uint64_t bd = b * d; + uint64_t ac = a * c; + uint64_t bc = b * c; + uint64_t ad = a * d; + uint64_t bd = b * d; - uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); + uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); - return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), (intermediate << 32) + (bd & mask)}; + return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), + (intermediate << 32) + (bd & mask)}; #endif - } +} - namespace dragonbox - { - // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from - // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. - inline auto floor_log10_pow2(int e) noexcept -> int - { - FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); - static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); - return (e * 315653) >> 20; - } +namespace dragonbox { +// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from +// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. +inline auto floor_log10_pow2(int e) noexcept -> int { + FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); + static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); + return (e * 315653) >> 20; +} - inline auto floor_log2_pow10(int e) noexcept -> int - { - FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); - return (e * 1741647) >> 19; - } +inline auto floor_log2_pow10(int e) noexcept -> int { + FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); + return (e * 1741647) >> 19; +} - // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. - inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t - { +// Computes upper 64 bits of multiplication of two 64-bit unsigned integers. +inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t { #if FMT_USE_INT128 - auto p = static_cast(x) * static_cast(y); - return static_cast(p >> 64); + auto p = static_cast(x) * static_cast(y); + return static_cast(p >> 64); #elif defined(_MSC_VER) && defined(_M_X64) - return __umulh(x, y); + return __umulh(x, y); #else - return umul128(x, y).high(); + return umul128(x, y).high(); #endif - } - - // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a - // 128-bit unsigned integer. - inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback - { - uint128_fallback r = umul128(x, y.high()); - r += umul128_upper64(x, y.low()); - return r; - } - - FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; - - // Type-specific information that Dragonbox uses. - template - struct float_info; - - template <> - struct float_info { - using carrier_uint = uint32_t; - static const int exponent_bits = 8; - static const int kappa = 1; - static const int big_divisor = 100; - static const int small_divisor = 10; - static const int min_k = -31; - static const int max_k = 46; - static const int shorter_interval_tie_lower_threshold = -35; - static const int shorter_interval_tie_upper_threshold = -35; - }; - - template <> - struct float_info { - using carrier_uint = uint64_t; - static const int exponent_bits = 11; - static const int kappa = 2; - static const int big_divisor = 1000; - static const int small_divisor = 100; - static const int min_k = -292; - static const int max_k = 341; - static const int shorter_interval_tie_lower_threshold = -77; - static const int shorter_interval_tie_upper_threshold = -77; - }; - - // An 80- or 128-bit floating point number. - template - struct float_info::digits == 64 || std::numeric_limits::digits == 113 || is_float128::value>> { - using carrier_uint = detail::uint128_t; - static const int exponent_bits = 15; - }; - - // A double-double floating point number. - template - struct float_info::value>> { - using carrier_uint = detail::uint128_t; - }; - - template - struct decimal_fp { - using significand_type = typename float_info::carrier_uint; - significand_type significand; - int exponent; - }; +} - template - FMT_API auto to_decimal(T x) noexcept -> decimal_fp; - } // namespace dragonbox +// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a +// 128-bit unsigned integer. +inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept + -> uint128_fallback { + uint128_fallback r = umul128(x, y.high()); + r += umul128_upper64(x, y.low()); + return r; +} - // Returns true iff Float has the implicit bit which is not stored. - template - constexpr auto has_implicit_bit() -> bool - { - // An 80-bit FP number has a 64-bit significand an no implicit bit. - return std::numeric_limits::digits != 64; - } +FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; + +// Type-specific information that Dragonbox uses. +template struct float_info; + +template <> struct float_info { + using carrier_uint = uint32_t; + static const int exponent_bits = 8; + static const int kappa = 1; + static const int big_divisor = 100; + static const int small_divisor = 10; + static const int min_k = -31; + static const int max_k = 46; + static const int shorter_interval_tie_lower_threshold = -35; + static const int shorter_interval_tie_upper_threshold = -35; +}; - // Returns the number of significand bits stored in Float. The implicit bit is - // not counted since it is not stored. - template - constexpr auto num_significand_bits() -> int - { - // std::numeric_limits may not support __float128. - return is_float128() ? 112 : (std::numeric_limits::digits - (has_implicit_bit() ? 1 : 0)); - } +template <> struct float_info { + using carrier_uint = uint64_t; + static const int exponent_bits = 11; + static const int kappa = 2; + static const int big_divisor = 1000; + static const int small_divisor = 100; + static const int min_k = -292; + static const int max_k = 341; + static const int shorter_interval_tie_lower_threshold = -77; + static const int shorter_interval_tie_upper_threshold = -77; +}; - template - constexpr auto exponent_mask() -> typename dragonbox::float_info::carrier_uint - { - using float_uint = typename dragonbox::float_info::carrier_uint; - return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1) << num_significand_bits(); - } - template - constexpr auto exponent_bias() -> int - { - // std::numeric_limits may not support __float128. - return is_float128() ? 16383 : std::numeric_limits::max_exponent - 1; - } +// An 80- or 128-bit floating point number. +template +struct float_info::digits == 64 || + std::numeric_limits::digits == 113 || + is_float128::value>> { + using carrier_uint = detail::uint128_t; + static const int exponent_bits = 15; +}; - // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. - template - FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It - { - FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); - if (exp < 0) - { - *it++ = static_cast('-'); - exp = -exp; - } - else - { - *it++ = static_cast('+'); - } - if (exp >= 100) - { - const char* top = digits2(to_unsigned(exp / 100)); - if (exp >= 1000) - *it++ = static_cast(top[0]); - *it++ = static_cast(top[1]); - exp %= 100; - } - const char* d = digits2(to_unsigned(exp)); - *it++ = static_cast(d[0]); - *it++ = static_cast(d[1]); - return it; - } +// A double-double floating point number. +template +struct float_info::value>> { + using carrier_uint = detail::uint128_t; +}; - // A floating-point number f * pow(2, e) where F is an unsigned type. - template - struct basic_fp { - F f; - int e; +template struct decimal_fp { + using significand_type = typename float_info::carrier_uint; + significand_type significand; + int exponent; +}; - static constexpr const int num_significand_bits = static_cast(sizeof(F) * num_bits()); +template FMT_API auto to_decimal(T x) noexcept -> decimal_fp; +} // namespace dragonbox - constexpr basic_fp() : f(0), e(0) {} - constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} +// Returns true iff Float has the implicit bit which is not stored. +template constexpr auto has_implicit_bit() -> bool { + // An 80-bit FP number has a 64-bit significand an no implicit bit. + return std::numeric_limits::digits != 64; +} - // Constructs fp from an IEEE754 floating-point number. - template - FMT_CONSTEXPR basic_fp(Float n) - { - assign(n); - } +// Returns the number of significand bits stored in Float. The implicit bit is +// not counted since it is not stored. +template constexpr auto num_significand_bits() -> int { + // std::numeric_limits may not support __float128. + return is_float128() ? 112 + : (std::numeric_limits::digits - + (has_implicit_bit() ? 1 : 0)); +} - // Assigns n to this and return true iff predecessor is closer than successor. - template ::value)> - FMT_CONSTEXPR auto assign(Float n) -> bool - { - static_assert(std::numeric_limits::digits <= 113, "unsupported FP"); - // Assume Float is in the format [sign][exponent][significand]. - using carrier_uint = typename dragonbox::float_info::carrier_uint; - const auto num_float_significand_bits = detail::num_significand_bits(); - const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; - const auto significand_mask = implicit_bit - 1; - auto u = bit_cast(n); - f = static_cast(u & significand_mask); - auto biased_e = static_cast((u & exponent_mask()) >> num_float_significand_bits); - // The predecessor is closer if n is a normalized power of 2 (f == 0) - // other than the smallest normalized number (biased_e > 1). - auto is_predecessor_closer = f == 0 && biased_e > 1; - if (biased_e == 0) - biased_e = 1; // Subnormals use biased exponent 1 (min exponent). - else if (has_implicit_bit()) - f += static_cast(implicit_bit); - e = biased_e - exponent_bias() - num_float_significand_bits; - if (!has_implicit_bit()) - ++e; - return is_predecessor_closer; - } +template +constexpr auto exponent_mask() -> + typename dragonbox::float_info::carrier_uint { + using float_uint = typename dragonbox::float_info::carrier_uint; + return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1) + << num_significand_bits(); +} +template constexpr auto exponent_bias() -> int { + // std::numeric_limits may not support __float128. + return is_float128() ? 16383 + : std::numeric_limits::max_exponent - 1; +} - template ::value)> - FMT_CONSTEXPR auto assign(Float n) -> bool - { - static_assert(std::numeric_limits::is_iec559, "unsupported FP"); - return assign(static_cast(n)); - } - }; +// Writes the exponent exp in the form "[+-]d{2,3}" to buffer. +template +FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It { + FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); + if (exp < 0) { + *it++ = static_cast('-'); + exp = -exp; + } else { + *it++ = static_cast('+'); + } + if (exp >= 100) { + const char* top = digits2(to_unsigned(exp / 100)); + if (exp >= 1000) *it++ = static_cast(top[0]); + *it++ = static_cast(top[1]); + exp %= 100; + } + const char* d = digits2(to_unsigned(exp)); + *it++ = static_cast(d[0]); + *it++ = static_cast(d[1]); + return it; +} - using fp = basic_fp; +// A floating-point number f * pow(2, e) where F is an unsigned type. +template struct basic_fp { + F f; + int e; + + static constexpr const int num_significand_bits = + static_cast(sizeof(F) * num_bits()); + + constexpr basic_fp() : f(0), e(0) {} + constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} + + // Constructs fp from an IEEE754 floating-point number. + template FMT_CONSTEXPR basic_fp(Float n) { assign(n); } + + // Assigns n to this and return true iff predecessor is closer than successor. + template ::value)> + FMT_CONSTEXPR auto assign(Float n) -> bool { + static_assert(std::numeric_limits::digits <= 113, "unsupported FP"); + // Assume Float is in the format [sign][exponent][significand]. + using carrier_uint = typename dragonbox::float_info::carrier_uint; + const auto num_float_significand_bits = + detail::num_significand_bits(); + const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; + const auto significand_mask = implicit_bit - 1; + auto u = bit_cast(n); + f = static_cast(u & significand_mask); + auto biased_e = static_cast((u & exponent_mask()) >> + num_float_significand_bits); + // The predecessor is closer if n is a normalized power of 2 (f == 0) + // other than the smallest normalized number (biased_e > 1). + auto is_predecessor_closer = f == 0 && biased_e > 1; + if (biased_e == 0) + biased_e = 1; // Subnormals use biased exponent 1 (min exponent). + else if (has_implicit_bit()) + f += static_cast(implicit_bit); + e = biased_e - exponent_bias() - num_float_significand_bits; + if (!has_implicit_bit()) ++e; + return is_predecessor_closer; + } + + template ::value)> + FMT_CONSTEXPR auto assign(Float n) -> bool { + static_assert(std::numeric_limits::is_iec559, "unsupported FP"); + return assign(static_cast(n)); + } +}; - // Normalizes the value converted from double and multiplied by (1 << SHIFT). - template - FMT_CONSTEXPR auto normalize(basic_fp value) -> basic_fp - { - // Handle subnormals. - const auto implicit_bit = F(1) << num_significand_bits(); - const auto shifted_implicit_bit = implicit_bit << SHIFT; - while ((value.f & shifted_implicit_bit) == 0) - { - value.f <<= 1; - --value.e; - } - // Subtract 1 to account for hidden bit. - const auto offset = basic_fp::num_significand_bits - num_significand_bits() - SHIFT - 1; - value.f <<= offset; - value.e -= offset; - return value; - } +using fp = basic_fp; + +// Normalizes the value converted from double and multiplied by (1 << SHIFT). +template +FMT_CONSTEXPR auto normalize(basic_fp value) -> basic_fp { + // Handle subnormals. + const auto implicit_bit = F(1) << num_significand_bits(); + const auto shifted_implicit_bit = implicit_bit << SHIFT; + while ((value.f & shifted_implicit_bit) == 0) { + value.f <<= 1; + --value.e; + } + // Subtract 1 to account for hidden bit. + const auto offset = basic_fp::num_significand_bits - + num_significand_bits() - SHIFT - 1; + value.f <<= offset; + value.e -= offset; + return value; +} - // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. - FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t - { +// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. +FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t { #if FMT_USE_INT128 - auto product = static_cast<__uint128_t>(lhs) * rhs; - auto f = static_cast(product >> 64); - return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; + auto product = static_cast<__uint128_t>(lhs) * rhs; + auto f = static_cast(product >> 64); + return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; #else - // Multiply 32-bit parts of significands. - uint64_t mask = (1ULL << 32) - 1; - uint64_t a = lhs >> 32, b = lhs & mask; - uint64_t c = rhs >> 32, d = rhs & mask; - uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; - // Compute mid 64-bit of result and round. - uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); - return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); + // Multiply 32-bit parts of significands. + uint64_t mask = (1ULL << 32) - 1; + uint64_t a = lhs >> 32, b = lhs & mask; + uint64_t c = rhs >> 32, d = rhs & mask; + uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; + // Compute mid 64-bit of result and round. + uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); + return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); #endif - } - - FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { return {multiply(x.f, y.f), x.e + y.e + 64}; } +} - template () == num_bits()> - using convert_float_result = conditional_t::value || doublish, double, T>; +FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { + return {multiply(x.f, y.f), x.e + y.e + 64}; +} - template - constexpr auto convert_float(T value) -> convert_float_result - { - return static_cast>(value); - } +template () == num_bits()> +using convert_float_result = + conditional_t::value || doublish, double, T>; - template - FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t& fill) -> OutputIt - { - auto fill_size = fill.size(); - if (fill_size == 1) - return detail::fill_n(it, n, fill[0]); - auto data = fill.data(); - for (size_t i = 0; i < n; ++i) - it = copy_str(data, data + fill_size, it); - return it; - } +template +constexpr auto convert_float(T value) -> convert_float_result { + return static_cast>(value); +} - // Writes the output of f, padded according to format specifications in specs. - // size: output size in code units. - // width: output display width in (terminal) column positions. - template - FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt - { - static_assert(align == align::left || align == align::right, ""); - unsigned spec_width = to_unsigned(specs.width); - size_t padding = spec_width > width ? spec_width - width : 0; - // Shifts are encoded as string literals because static constexpr is not - // supported in constexpr functions. - auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; - size_t left_padding = padding >> shifts[specs.align]; - size_t right_padding = padding - left_padding; - auto it = reserve(out, size + padding * specs.fill.size()); - if (left_padding != 0) - it = fill(it, left_padding, specs.fill); - it = f(it); - if (right_padding != 0) - it = fill(it, right_padding, specs.fill); - return base_iterator(out, it); - } +template +FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, + const fill_t& fill) -> OutputIt { + auto fill_size = fill.size(); + if (fill_size == 1) return detail::fill_n(it, n, fill[0]); + auto data = fill.data(); + for (size_t i = 0; i < n; ++i) + it = copy_str(data, data + fill_size, it); + return it; +} - template - constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt - { - return write_padded(out, specs, size, size, f); - } +// Writes the output of f, padded according to format specifications in specs. +// size: output size in code units. +// width: output display width in (terminal) column positions. +template +FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, + size_t size, size_t width, F&& f) -> OutputIt { + static_assert(align == align::left || align == align::right, ""); + unsigned spec_width = to_unsigned(specs.width); + size_t padding = spec_width > width ? spec_width - width : 0; + // Shifts are encoded as string literals because static constexpr is not + // supported in constexpr functions. + auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; + size_t left_padding = padding >> shifts[specs.align]; + size_t right_padding = padding - left_padding; + auto it = reserve(out, size + padding * specs.fill.size()); + if (left_padding != 0) it = fill(it, left_padding, specs.fill); + it = f(it); + if (right_padding != 0) it = fill(it, right_padding, specs.fill); + return base_iterator(out, it); +} - template - FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, const format_specs& specs) -> OutputIt - { - return write_padded(out, specs, bytes.size(), - [bytes](reserve_iterator it) - { - const char* data = bytes.data(); - return copy_str(data, data + bytes.size(), it); - }); - } +template +constexpr auto write_padded(OutputIt out, const format_specs& specs, + size_t size, F&& f) -> OutputIt { + return write_padded(out, specs, size, size, f); +} - template - auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt - { - int num_digits = count_digits<4>(value); - auto size = to_unsigned(num_digits) + size_t(2); - auto write = [=](reserve_iterator it) - { - *it++ = static_cast('0'); - *it++ = static_cast('x'); - return format_uint<4, Char>(it, value, num_digits); - }; - return specs ? write_padded(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); - } +template +FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, + const format_specs& specs) -> OutputIt { + return write_padded( + out, specs, bytes.size(), [bytes](reserve_iterator it) { + const char* data = bytes.data(); + return copy_str(data, data + bytes.size(), it); + }); +} - // Returns true iff the code point cp is printable. - FMT_API auto is_printable(uint32_t cp) -> bool; +template +auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) + -> OutputIt { + int num_digits = count_digits<4>(value); + auto size = to_unsigned(num_digits) + size_t(2); + auto write = [=](reserve_iterator it) { + *it++ = static_cast('0'); + *it++ = static_cast('x'); + return format_uint<4, Char>(it, value, num_digits); + }; + return specs ? write_padded(out, *specs, size, write) + : base_iterator(out, write(reserve(out, size))); +} - inline auto needs_escape(uint32_t cp) -> bool { return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || !is_printable(cp); } +// Returns true iff the code point cp is printable. +FMT_API auto is_printable(uint32_t cp) -> bool; - template - struct find_escape_result { - const Char* begin; - const Char* end; - uint32_t cp; - }; +inline auto needs_escape(uint32_t cp) -> bool { + return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || + !is_printable(cp); +} - template - using make_unsigned_char = typename conditional_t::value, std::make_unsigned, type_identity>::type; +template struct find_escape_result { + const Char* begin; + const Char* end; + uint32_t cp; +}; - template - auto find_escape(const Char* begin, const Char* end) -> find_escape_result - { - for (; begin != end; ++begin) - { - uint32_t cp = static_cast>(*begin); - if (const_check(sizeof(Char) == 1) && cp >= 0x80) - continue; - if (needs_escape(cp)) - return {begin, begin + 1, cp}; - } - return {begin, nullptr, 0}; - } +template +using make_unsigned_char = + typename conditional_t::value, + std::make_unsigned, + type_identity>::type; + +template +auto find_escape(const Char* begin, const Char* end) + -> find_escape_result { + for (; begin != end; ++begin) { + uint32_t cp = static_cast>(*begin); + if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; + if (needs_escape(cp)) return {begin, begin + 1, cp}; + } + return {begin, nullptr, 0}; +} - inline auto find_escape(const char* begin, const char* end) -> find_escape_result - { - if (!is_utf8()) - return find_escape(begin, end); - auto result = find_escape_result{end, nullptr, 0}; - for_each_codepoint(string_view(begin, to_unsigned(end - begin)), - [&](uint32_t cp, string_view sv) - { - if (needs_escape(cp)) - { - result = {sv.begin(), sv.end(), cp}; - return false; - } - return true; - }); - return result; - } +inline auto find_escape(const char* begin, const char* end) + -> find_escape_result { + if (!is_utf8()) return find_escape(begin, end); + auto result = find_escape_result{end, nullptr, 0}; + for_each_codepoint(string_view(begin, to_unsigned(end - begin)), + [&](uint32_t cp, string_view sv) { + if (needs_escape(cp)) { + result = {sv.begin(), sv.end(), cp}; + return false; + } + return true; + }); + return result; +} -#define FMT_STRING_IMPL(s, base, explicit) \ - [] \ - { \ - /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ - /* Use a macro-like name to avoid shadowing warnings. */ \ - struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ - using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t; \ - FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit operator fmt::basic_string_view() const { return fmt::detail_exported::compile_string_to_view(s); } \ - }; \ - return FMT_COMPILE_STRING(); \ - }() +#define FMT_STRING_IMPL(s, base, explicit) \ + [] { \ + /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ + /* Use a macro-like name to avoid shadowing warnings. */ \ + struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ + using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t; \ + FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \ + operator fmt::basic_string_view() const { \ + return fmt::detail_exported::compile_string_to_view(s); \ + } \ + }; \ + return FMT_COMPILE_STRING(); \ + }() /** \rst @@ -1957,2214 +1847,2078 @@ namespace detail */ #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, ) - template - auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt - { - *out++ = static_cast('\\'); - *out++ = static_cast(prefix); - Char buf[width]; - fill_n(buf, width, static_cast('0')); - format_uint<4>(buf, cp, width); - return copy_str(buf, buf + width, out); - } - - template - auto write_escaped_cp(OutputIt out, const find_escape_result& escape) -> OutputIt - { - auto c = static_cast(escape.cp); - switch (escape.cp) - { - case '\n': - *out++ = static_cast('\\'); - c = static_cast('n'); - break; - case '\r': - *out++ = static_cast('\\'); - c = static_cast('r'); - break; - case '\t': - *out++ = static_cast('\\'); - c = static_cast('t'); - break; - case '"': - FMT_FALLTHROUGH; - case '\'': - FMT_FALLTHROUGH; - case '\\': - *out++ = static_cast('\\'); - break; - default: - if (escape.cp < 0x100) - { - return write_codepoint<2, Char>(out, 'x', escape.cp); - } - if (escape.cp < 0x10000) - { - return write_codepoint<4, Char>(out, 'u', escape.cp); - } - if (escape.cp < 0x110000) - { - return write_codepoint<8, Char>(out, 'U', escape.cp); - } - for (Char escape_char : basic_string_view(escape.begin, to_unsigned(escape.end - escape.begin))) - { - out = write_codepoint<2, Char>(out, 'x', static_cast(escape_char) & 0xFF); - } - return out; - } - *out++ = c; - return out; - } - - template - auto write_escaped_string(OutputIt out, basic_string_view str) -> OutputIt - { - *out++ = static_cast('"'); - auto begin = str.begin(), end = str.end(); - do - { - auto escape = find_escape(begin, end); - out = copy_str(begin, escape.begin, out); - begin = escape.end; - if (!begin) - break; - out = write_escaped_cp(out, escape); - } - while (begin != end); - *out++ = static_cast('"'); - return out; - } - - template - auto write_escaped_char(OutputIt out, Char v) -> OutputIt - { - Char v_array[1] = {v}; - *out++ = static_cast('\''); - if ((needs_escape(static_cast(v)) && v != static_cast('"')) || v == static_cast('\'')) - { - out = write_escaped_cp(out, find_escape_result{v_array, v_array + 1, static_cast(v)}); - } - else - { - *out++ = v; - } - *out++ = static_cast('\''); - return out; - } - - template - FMT_CONSTEXPR auto write_char(OutputIt out, Char value, const format_specs& specs) -> OutputIt - { - bool is_debug = specs.type == presentation_type::debug; - return write_padded(out, specs, 1, - [=](reserve_iterator it) - { - if (is_debug) - return write_escaped_char(it, value); - *it++ = value; - return it; - }); - } - template - FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, locale_ref loc = {}) -> OutputIt - { - // char is formatted as unsigned char for consistency across platforms. - using unsigned_type = conditional_t::value, unsigned char, unsigned>; - return check_char_specs(specs) ? write_char(out, value, specs) : write(out, static_cast(value), specs, loc); - } - - // Data for write_int that doesn't depend on output iterator type. It is used to - // avoid template code bloat. - template - struct write_int_data { - size_t size; - size_t padding; - - FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, const format_specs& specs) : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) - { - if (specs.align == align::numeric) - { - auto width = to_unsigned(specs.width); - if (width > size) - { - padding = width - size; - size = width; - } - } - else if (specs.precision > num_digits) - { - size = (prefix >> 24) + to_unsigned(specs.precision); - padding = to_unsigned(specs.precision - num_digits); - } - } - }; - - // Writes an integer in the format - // - // where are written by write_digits(it). - // prefix contains chars in three lower bytes and the size in the fourth byte. - template - FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, unsigned prefix, const format_specs& specs, W write_digits) -> OutputIt - { - // Slightly faster check for specs.width == 0 && specs.precision == -1. - if ((specs.width | (specs.precision + 1)) == 0) - { - auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); - if (prefix != 0) - { - for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) - *it++ = static_cast(p & 0xff); - } - return base_iterator(out, write_digits(it)); - } - auto data = write_int_data(num_digits, prefix, specs); - return write_padded(out, specs, data.size, - [=](reserve_iterator it) - { - for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) - *it++ = static_cast(p & 0xff); - it = detail::fill_n(it, data.padding, static_cast('0')); - return write_digits(it); - }); - } - - template - class digit_grouping { - private: - std::string grouping_; - std::basic_string thousands_sep_; - - struct next_state { - std::string::const_iterator group; - int pos; - }; - auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } - - // Returns the next digit group separator position. - auto next(next_state& state) const -> int - { - if (thousands_sep_.empty()) - return max_value(); - if (state.group == grouping_.end()) - return state.pos += grouping_.back(); - if (*state.group <= 0 || *state.group == max_value()) - return max_value(); - state.pos += *state.group++; - return state.pos; - } - - public: - explicit digit_grouping(locale_ref loc, bool localized = true) - { - if (!localized) - return; - auto sep = thousands_sep(loc); - grouping_ = sep.grouping; - if (sep.thousands_sep) - thousands_sep_.assign(1, sep.thousands_sep); - } - digit_grouping(std::string grouping, std::basic_string sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} - - auto has_separator() const -> bool { return !thousands_sep_.empty(); } - - auto count_separators(int num_digits) const -> int - { - int count = 0; - auto state = initial_state(); - while (num_digits > next(state)) - ++count; - return count; - } - - // Applies grouping to digits and write the output to out. - template - auto apply(Out out, basic_string_view digits) const -> Out - { - auto num_digits = static_cast(digits.size()); - auto separators = basic_memory_buffer(); - separators.push_back(0); - auto state = initial_state(); - while (int i = next(state)) - { - if (i >= num_digits) - break; - separators.push_back(i); - } - for (int i = 0, sep_index = static_cast(separators.size() - 1); i < num_digits; ++i) - { - if (num_digits - i == separators[sep_index]) - { - out = copy_str(thousands_sep_.data(), thousands_sep_.data() + thousands_sep_.size(), out); - --sep_index; - } - *out++ = static_cast(digits[to_unsigned(i)]); - } - return out; - } - }; - - FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) - { - prefix |= prefix != 0 ? value << 8 : value; - prefix += (1u + (value > 0xff ? 1 : 0)) << 24; - } - - // Writes a decimal integer with digit grouping. - template - auto write_int(OutputIt out, UInt value, unsigned prefix, const format_specs& specs, const digit_grouping& grouping) -> OutputIt - { - static_assert(std::is_same, UInt>::value, ""); - int num_digits = 0; - auto buffer = memory_buffer(); - switch (specs.type) - { - case presentation_type::none: - case presentation_type::dec: - { - num_digits = count_digits(value); - format_decimal(appender(buffer), value, num_digits); - break; - } - case presentation_type::hex_lower: - case presentation_type::hex_upper: - { - bool upper = specs.type == presentation_type::hex_upper; - if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); - num_digits = count_digits<4>(value); - format_uint<4, char>(appender(buffer), value, num_digits, upper); - break; - } - case presentation_type::bin_lower: - case presentation_type::bin_upper: - { - bool upper = specs.type == presentation_type::bin_upper; - if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); - num_digits = count_digits<1>(value); - format_uint<1, char>(appender(buffer), value, num_digits); - break; - } - case presentation_type::oct: - { - num_digits = count_digits<3>(value); - // Octal prefix '0' is counted as a digit, so only add it if precision - // is not greater than the number of digits. - if (specs.alt && specs.precision <= num_digits && value != 0) - prefix_append(prefix, '0'); - format_uint<3, char>(appender(buffer), value, num_digits); - break; - } - case presentation_type::chr: - return write_char(out, static_cast(value), specs); - default: - throw_format_error("invalid format specifier"); - } - - unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + to_unsigned(grouping.count_separators(num_digits)); - return write_padded(out, specs, size, size, - [&](reserve_iterator it) - { - for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) - *it++ = static_cast(p & 0xff); - return grouping.apply(it, string_view(buffer.data(), buffer.size())); - }); - } - - // Writes a localized value. - FMT_API auto write_loc(appender out, loc_value value, const format_specs<>& specs, locale_ref loc) -> bool; - template - inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref) -> bool - { - return false; - } - - template - struct write_int_arg { - UInt abs_value; - unsigned prefix; - }; - - template - FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) -> write_int_arg> - { - auto prefix = 0u; - auto abs_value = static_cast>(value); - if (is_negative(value)) - { - prefix = 0x01000000 | '-'; - abs_value = 0 - abs_value; - } - else - { - constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '}; - prefix = prefixes[sign]; - } - return {abs_value, prefix}; - } - - template - struct loc_writer { - buffer_appender out; - const format_specs& specs; - std::basic_string sep; - std::string grouping; - std::basic_string decimal_point; - - template ::value)> - auto operator()(T value) -> bool - { - auto arg = make_write_int_arg(value, specs.sign); - write_int(out, static_cast>(arg.abs_value), arg.prefix, specs, digit_grouping(grouping, sep)); - return true; - } - - template ::value)> - auto operator()(T) -> bool - { - return false; - } - }; - - template - FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, const format_specs& specs, locale_ref) -> OutputIt - { - static_assert(std::is_same>::value, ""); - auto abs_value = arg.abs_value; - auto prefix = arg.prefix; - switch (specs.type) - { - case presentation_type::none: - case presentation_type::dec: - { - auto num_digits = count_digits(abs_value); - return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_decimal(it, abs_value, num_digits).end; }); - } - case presentation_type::hex_lower: - case presentation_type::hex_upper: - { - bool upper = specs.type == presentation_type::hex_upper; - if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); - int num_digits = count_digits<4>(abs_value); - return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<4, Char>(it, abs_value, num_digits, upper); }); - } - case presentation_type::bin_lower: - case presentation_type::bin_upper: - { - bool upper = specs.type == presentation_type::bin_upper; - if (specs.alt) - prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); - int num_digits = count_digits<1>(abs_value); - return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<1, Char>(it, abs_value, num_digits); }); - } - case presentation_type::oct: - { - int num_digits = count_digits<3>(abs_value); - // Octal prefix '0' is counted as a digit, so only add it if precision - // is not greater than the number of digits. - if (specs.alt && specs.precision <= num_digits && abs_value != 0) - prefix_append(prefix, '0'); - return write_int(out, num_digits, prefix, specs, [=](reserve_iterator it) { return format_uint<3, Char>(it, abs_value, num_digits); }); - } - case presentation_type::chr: - return write_char(out, static_cast(abs_value), specs); - default: - throw_format_error("invalid format specifier"); - } - return out; - } - template - FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out, write_int_arg arg, const format_specs& specs, locale_ref loc) -> OutputIt - { - return write_int(out, arg, specs, loc); - } - template ::value && !std::is_same::value && std::is_same>::value)> - FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt - { - if (specs.localized && write_loc(out, value, specs, loc)) - return out; - return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, loc); - } - // An inlined version of write used in format string compilation. - template ::value && !std::is_same::value && !std::is_same>::value)> - FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt - { - if (specs.localized && write_loc(out, value, specs, loc)) - return out; - return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); - } - - // An output iterator that counts the number of objects written to it and - // discards them. - class counting_iterator { - private: - size_t count_; - - public: - using iterator_category = std::output_iterator_tag; - using difference_type = std::ptrdiff_t; - using pointer = void; - using reference = void; - FMT_UNCHECKED_ITERATOR(counting_iterator); - - struct value_type { - template - FMT_CONSTEXPR void operator=(const T&) - { - } - }; - - FMT_CONSTEXPR counting_iterator() : count_(0) {} - - FMT_CONSTEXPR auto count() const -> size_t { return count_; } - - FMT_CONSTEXPR auto operator++() -> counting_iterator& - { - ++count_; - return *this; - } - FMT_CONSTEXPR auto operator++(int) -> counting_iterator - { - auto it = *this; - ++*this; - return it; - } - - FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) -> counting_iterator - { - it.count_ += static_cast(n); - return it; - } - - FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } - }; - - template - FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, const format_specs& specs) -> OutputIt - { - auto data = s.data(); - auto size = s.size(); - if (specs.precision >= 0 && to_unsigned(specs.precision) < size) - size = code_point_index(s, to_unsigned(specs.precision)); - bool is_debug = specs.type == presentation_type::debug; - size_t width = 0; - if (specs.width != 0) - { - if (is_debug) - width = write_escaped_string(counting_iterator{}, s).count(); - else - width = compute_width(basic_string_view(data, size)); - } - return write_padded(out, specs, size, width, - [=](reserve_iterator it) - { - if (is_debug) - return write_escaped_string(it, s); - return copy_str(data, data + size, it); - }); - } - template - FMT_CONSTEXPR auto write(OutputIt out, basic_string_view> s, const format_specs& specs, locale_ref) -> OutputIt - { - return write(out, s, specs); - } - template - FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, locale_ref) -> OutputIt - { - if (specs.type == presentation_type::pointer) - return write_ptr(out, bit_cast(s), &specs); - if (!s) - throw_format_error("string pointer is null"); - return write(out, basic_string_view(s), specs, {}); - } - - template ::value && !std::is_same::value && !std::is_same::value)> - FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt - { - auto abs_value = static_cast>(value); - bool negative = is_negative(value); - // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. - if (negative) - abs_value = ~abs_value + 1; - int num_digits = count_digits(abs_value); - auto size = (negative ? 1 : 0) + static_cast(num_digits); - auto it = reserve(out, size); - if (auto ptr = to_pointer(it, size)) - { - if (negative) - *ptr++ = static_cast('-'); - format_decimal(ptr, abs_value, num_digits); - return out; - } - if (negative) - *it++ = static_cast('-'); - it = format_decimal(it, abs_value, num_digits).end; - return base_iterator(out, it); - } - - // DEPRECATED! - template - FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, format_specs& specs) -> const Char* - { - FMT_ASSERT(begin != end, ""); - auto align = align::none; - auto p = begin + code_point_length(begin); - if (end - p <= 0) - p = begin; - for (;;) - { - switch (to_ascii(*p)) - { - case '<': - align = align::left; - break; - case '>': - align = align::right; - break; - case '^': - align = align::center; - break; - } - if (align != align::none) - { - if (p != begin) - { - auto c = *begin; - if (c == '}') - return begin; - if (c == '{') - { - throw_format_error("invalid fill character '{'"); - return begin; - } - specs.fill = {begin, to_unsigned(p - begin)}; - begin = p + 1; - } - else - { - ++begin; - } - break; - } - else if (p == begin) - { - break; - } - p = begin; - } - specs.align = align; - return begin; - } - - // A floating-point presentation format. - enum class float_format : unsigned char { - general, // General: exponent notation or fixed point based on magnitude. - exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. - fixed, // Fixed point with the default precision of 6, e.g. 0.0012. - hex - }; - - struct float_specs { - int precision; - float_format format : 8; - sign_t sign : 8; - bool upper : 1; - bool locale : 1; - bool binary32 : 1; - bool showpoint : 1; - }; - - template - FMT_CONSTEXPR auto parse_float_type_spec(const format_specs& specs) -> float_specs - { - auto result = float_specs(); - result.showpoint = specs.alt; - result.locale = specs.localized; - switch (specs.type) - { - case presentation_type::none: - result.format = float_format::general; - break; - case presentation_type::general_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::general_lower: - result.format = float_format::general; - break; - case presentation_type::exp_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::exp_lower: - result.format = float_format::exp; - result.showpoint |= specs.precision != 0; - break; - case presentation_type::fixed_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::fixed_lower: - result.format = float_format::fixed; - result.showpoint |= specs.precision != 0; - break; - case presentation_type::hexfloat_upper: - result.upper = true; - FMT_FALLTHROUGH; - case presentation_type::hexfloat_lower: - result.format = float_format::hex; - break; - default: - throw_format_error("invalid format specifier"); - break; - } - return result; - } - - template - FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, format_specs specs, const float_specs& fspecs) -> OutputIt - { - auto str = isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); - constexpr size_t str_size = 3; - auto sign = fspecs.sign; - auto size = str_size + (sign ? 1 : 0); - // Replace '0'-padding with space for non-finite values. - const bool is_zero_fill = specs.fill.size() == 1 && *specs.fill.data() == static_cast('0'); - if (is_zero_fill) - specs.fill[0] = static_cast(' '); - return write_padded(out, specs, size, - [=](reserve_iterator it) - { - if (sign) - *it++ = detail::sign(sign); - return copy_str(str, str + str_size, it); - }); - } - - // A decimal floating-point number significand * pow(10, exp). - struct big_decimal_fp { - const char* significand; - int significand_size; - int exponent; - }; +template +auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { + *out++ = static_cast('\\'); + *out++ = static_cast(prefix); + Char buf[width]; + fill_n(buf, width, static_cast('0')); + format_uint<4>(buf, cp, width); + return copy_str(buf, buf + width, out); +} - constexpr auto get_significand_size(const big_decimal_fp& f) -> int { return f.significand_size; } - template - inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int - { - return count_digits(f.significand); - } +template +auto write_escaped_cp(OutputIt out, const find_escape_result& escape) + -> OutputIt { + auto c = static_cast(escape.cp); + switch (escape.cp) { + case '\n': + *out++ = static_cast('\\'); + c = static_cast('n'); + break; + case '\r': + *out++ = static_cast('\\'); + c = static_cast('r'); + break; + case '\t': + *out++ = static_cast('\\'); + c = static_cast('t'); + break; + case '"': + FMT_FALLTHROUGH; + case '\'': + FMT_FALLTHROUGH; + case '\\': + *out++ = static_cast('\\'); + break; + default: + if (escape.cp < 0x100) { + return write_codepoint<2, Char>(out, 'x', escape.cp); + } + if (escape.cp < 0x10000) { + return write_codepoint<4, Char>(out, 'u', escape.cp); + } + if (escape.cp < 0x110000) { + return write_codepoint<8, Char>(out, 'U', escape.cp); + } + for (Char escape_char : basic_string_view( + escape.begin, to_unsigned(escape.end - escape.begin))) { + out = write_codepoint<2, Char>(out, 'x', + static_cast(escape_char) & 0xFF); + } + return out; + } + *out++ = c; + return out; +} - template - constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt - { - return copy_str(significand, significand + significand_size, out); - } - template - inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt - { - return format_decimal(out, significand, significand_size).end; - } - template - FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt - { - if (!grouping.has_separator()) - { - out = write_significand(out, significand, significand_size); - return detail::fill_n(out, exponent, static_cast('0')); - } - auto buffer = memory_buffer(); - write_significand(appender(buffer), significand, significand_size); - detail::fill_n(appender(buffer), exponent, '0'); - return grouping.apply(out, string_view(buffer.data(), buffer.size())); - } +template +auto write_escaped_string(OutputIt out, basic_string_view str) + -> OutputIt { + *out++ = static_cast('"'); + auto begin = str.begin(), end = str.end(); + do { + auto escape = find_escape(begin, end); + out = copy_str(begin, escape.begin, out); + begin = escape.end; + if (!begin) break; + out = write_escaped_cp(out, escape); + } while (begin != end); + *out++ = static_cast('"'); + return out; +} - template ::value)> - inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* - { - if (!decimal_point) - return format_decimal(out, significand, significand_size).end; - out += significand_size + 1; - Char* end = out; - int floating_size = significand_size - integral_size; - for (int i = floating_size / 2; i > 0; --i) - { - out -= 2; - copy2(out, digits2(static_cast(significand % 100))); - significand /= 100; - } - if (floating_size % 2 != 0) - { - *--out = static_cast('0' + significand % 10); - significand /= 10; - } - *--out = decimal_point; - format_decimal(out - integral_size, significand, integral_size); - return end; - } +template +auto write_escaped_char(OutputIt out, Char v) -> OutputIt { + Char v_array[1] = {v}; + *out++ = static_cast('\''); + if ((needs_escape(static_cast(v)) && v != static_cast('"')) || + v == static_cast('\'')) { + out = write_escaped_cp(out, + find_escape_result{v_array, v_array + 1, + static_cast(v)}); + } else { + *out++ = v; + } + *out++ = static_cast('\''); + return out; +} - template >::value)> - inline auto write_significand(OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt - { - // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. - Char buffer[digits10() + 2]; - auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); - return detail::copy_str_noinline(buffer, end, out); - } +template +FMT_CONSTEXPR auto write_char(OutputIt out, Char value, + const format_specs& specs) -> OutputIt { + bool is_debug = specs.type == presentation_type::debug; + return write_padded(out, specs, 1, [=](reserve_iterator it) { + if (is_debug) return write_escaped_char(it, value); + *it++ = value; + return it; + }); +} +template +FMT_CONSTEXPR auto write(OutputIt out, Char value, + const format_specs& specs, locale_ref loc = {}) + -> OutputIt { + // char is formatted as unsigned char for consistency across platforms. + using unsigned_type = + conditional_t::value, unsigned char, unsigned>; + return check_char_specs(specs) + ? write_char(out, value, specs) + : write(out, static_cast(value), specs, loc); +} - template - FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt - { - out = detail::copy_str_noinline(significand, significand + integral_size, out); - if (!decimal_point) - return out; - *out++ = decimal_point; - return detail::copy_str_noinline(significand + integral_size, significand + significand_size, out); - } +// Data for write_int that doesn't depend on output iterator type. It is used to +// avoid template code bloat. +template struct write_int_data { + size_t size; + size_t padding; + + FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, + const format_specs& specs) + : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { + if (specs.align == align::numeric) { + auto width = to_unsigned(specs.width); + if (width > size) { + padding = width - size; + size = width; + } + } else if (specs.precision > num_digits) { + size = (prefix >> 24) + to_unsigned(specs.precision); + padding = to_unsigned(specs.precision - num_digits); + } + } +}; - template - FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt - { - if (!grouping.has_separator()) - { - return write_significand(out, significand, significand_size, integral_size, decimal_point); - } - auto buffer = basic_memory_buffer(); - write_significand(buffer_appender(buffer), significand, significand_size, integral_size, decimal_point); - grouping.apply(out, basic_string_view(buffer.data(), to_unsigned(integral_size))); - return detail::copy_str_noinline(buffer.data() + integral_size, buffer.end(), out); - } +// Writes an integer in the format +// +// where are written by write_digits(it). +// prefix contains chars in three lower bytes and the size in the fourth byte. +template +FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, + unsigned prefix, + const format_specs& specs, + W write_digits) -> OutputIt { + // Slightly faster check for specs.width == 0 && specs.precision == -1. + if ((specs.width | (specs.precision + 1)) == 0) { + auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); + if (prefix != 0) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + } + return base_iterator(out, write_digits(it)); + } + auto data = write_int_data(num_digits, prefix, specs); + return write_padded( + out, specs, data.size, [=](reserve_iterator it) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + it = detail::fill_n(it, data.padding, static_cast('0')); + return write_digits(it); + }); +} - template > - FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, float_specs fspecs, locale_ref loc) -> OutputIt - { - auto significand = f.significand; - int significand_size = get_significand_size(f); - const Char zero = static_cast('0'); - auto sign = fspecs.sign; - size_t size = to_unsigned(significand_size) + (sign ? 1 : 0); - using iterator = reserve_iterator; - - Char decimal_point = fspecs.locale ? detail::decimal_point(loc) : static_cast('.'); - - int output_exp = f.exponent + significand_size - 1; - auto use_exp_format = [=]() - { - if (fspecs.format == float_format::exp) - return true; - if (fspecs.format != float_format::general) - return false; - // Use the fixed notation if the exponent is in [exp_lower, exp_upper), - // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. - const int exp_lower = -4, exp_upper = 16; - return output_exp < exp_lower || output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper); - }; - if (use_exp_format()) - { - int num_zeros = 0; - if (fspecs.showpoint) - { - num_zeros = fspecs.precision - significand_size; - if (num_zeros < 0) - num_zeros = 0; - size += to_unsigned(num_zeros); - } - else if (significand_size == 1) - { - decimal_point = Char(); - } - auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp; - int exp_digits = 2; - if (abs_output_exp >= 100) - exp_digits = abs_output_exp >= 1000 ? 4 : 3; - - size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); - char exp_char = fspecs.upper ? 'E' : 'e'; - auto write = [=](iterator it) - { - if (sign) - *it++ = detail::sign(sign); - // Insert a decimal point after the first digit and add an exponent. - it = write_significand(it, significand, significand_size, 1, decimal_point); - if (num_zeros > 0) - it = detail::fill_n(it, num_zeros, zero); - *it++ = static_cast(exp_char); - return write_exponent(output_exp, it); - }; - return specs.width > 0 ? write_padded(out, specs, size, write) : base_iterator(out, write(reserve(out, size))); - } +template class digit_grouping { + private: + std::string grouping_; + std::basic_string thousands_sep_; + + struct next_state { + std::string::const_iterator group; + int pos; + }; + auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } + + // Returns the next digit group separator position. + auto next(next_state& state) const -> int { + if (thousands_sep_.empty()) return max_value(); + if (state.group == grouping_.end()) return state.pos += grouping_.back(); + if (*state.group <= 0 || *state.group == max_value()) + return max_value(); + state.pos += *state.group++; + return state.pos; + } + + public: + explicit digit_grouping(locale_ref loc, bool localized = true) { + if (!localized) return; + auto sep = thousands_sep(loc); + grouping_ = sep.grouping; + if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep); + } + digit_grouping(std::string grouping, std::basic_string sep) + : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} + + auto has_separator() const -> bool { return !thousands_sep_.empty(); } + + auto count_separators(int num_digits) const -> int { + int count = 0; + auto state = initial_state(); + while (num_digits > next(state)) ++count; + return count; + } + + // Applies grouping to digits and write the output to out. + template + auto apply(Out out, basic_string_view digits) const -> Out { + auto num_digits = static_cast(digits.size()); + auto separators = basic_memory_buffer(); + separators.push_back(0); + auto state = initial_state(); + while (int i = next(state)) { + if (i >= num_digits) break; + separators.push_back(i); + } + for (int i = 0, sep_index = static_cast(separators.size() - 1); + i < num_digits; ++i) { + if (num_digits - i == separators[sep_index]) { + out = + copy_str(thousands_sep_.data(), + thousands_sep_.data() + thousands_sep_.size(), out); + --sep_index; + } + *out++ = static_cast(digits[to_unsigned(i)]); + } + return out; + } +}; - int exp = f.exponent + significand_size; - if (f.exponent >= 0) - { - // 1234e5 -> 123400000[.0+] - size += to_unsigned(f.exponent); - int num_zeros = fspecs.precision - exp; - abort_fuzzing_if(num_zeros > 5000); - if (fspecs.showpoint) - { - ++size; - if (num_zeros <= 0 && fspecs.format != float_format::fixed) - num_zeros = 0; - if (num_zeros > 0) - size += to_unsigned(num_zeros); - } - auto grouping = Grouping(loc, fspecs.locale); - size += to_unsigned(grouping.count_separators(exp)); - return write_padded(out, specs, size, - [&](iterator it) - { - if (sign) - *it++ = detail::sign(sign); - it = write_significand(it, significand, significand_size, f.exponent, grouping); - if (!fspecs.showpoint) - return it; - *it++ = decimal_point; - return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; - }); - } - else if (exp > 0) - { - // 1234e-2 -> 12.34[0+] - int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0; - size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); - auto grouping = Grouping(loc, fspecs.locale); - size += to_unsigned(grouping.count_separators(exp)); - return write_padded(out, specs, size, - [&](iterator it) - { - if (sign) - *it++ = detail::sign(sign); - it = write_significand(it, significand, significand_size, exp, decimal_point, grouping); - return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; - }); - } - // 1234e-6 -> 0.001234 - int num_zeros = -exp; - if (significand_size == 0 && fspecs.precision >= 0 && fspecs.precision < num_zeros) - { - num_zeros = fspecs.precision; - } - bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; - size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); - return write_padded(out, specs, size, - [&](iterator it) - { - if (sign) - *it++ = detail::sign(sign); - *it++ = zero; - if (!pointy) - return it; - *it++ = decimal_point; - it = detail::fill_n(it, num_zeros, zero); - return write_significand(it, significand, significand_size); - }); - } +FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { + prefix |= prefix != 0 ? value << 8 : value; + prefix += (1u + (value > 0xff ? 1 : 0)) << 24; +} - template - class fallback_digit_grouping { - public: - constexpr fallback_digit_grouping(locale_ref, bool) {} +// Writes a decimal integer with digit grouping. +template +auto write_int(OutputIt out, UInt value, unsigned prefix, + const format_specs& specs, + const digit_grouping& grouping) -> OutputIt { + static_assert(std::is_same, UInt>::value, ""); + int num_digits = 0; + auto buffer = memory_buffer(); + switch (specs.type) { + case presentation_type::none: + case presentation_type::dec: { + num_digits = count_digits(value); + format_decimal(appender(buffer), value, num_digits); + break; + } + case presentation_type::hex_lower: + case presentation_type::hex_upper: { + bool upper = specs.type == presentation_type::hex_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); + num_digits = count_digits<4>(value); + format_uint<4, char>(appender(buffer), value, num_digits, upper); + break; + } + case presentation_type::bin_lower: + case presentation_type::bin_upper: { + bool upper = specs.type == presentation_type::bin_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); + num_digits = count_digits<1>(value); + format_uint<1, char>(appender(buffer), value, num_digits); + break; + } + case presentation_type::oct: { + num_digits = count_digits<3>(value); + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + if (specs.alt && specs.precision <= num_digits && value != 0) + prefix_append(prefix, '0'); + format_uint<3, char>(appender(buffer), value, num_digits); + break; + } + case presentation_type::chr: + return write_char(out, static_cast(value), specs); + default: + throw_format_error("invalid format specifier"); + } + + unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + + to_unsigned(grouping.count_separators(num_digits)); + return write_padded( + out, specs, size, size, [&](reserve_iterator it) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + return grouping.apply(it, string_view(buffer.data(), buffer.size())); + }); +} - constexpr auto has_separator() const -> bool { return false; } +// Writes a localized value. +FMT_API auto write_loc(appender out, loc_value value, + const format_specs<>& specs, locale_ref loc) -> bool; +template +inline auto write_loc(OutputIt, loc_value, const format_specs&, + locale_ref) -> bool { + return false; +} - constexpr auto count_separators(int) const -> int { return 0; } +template struct write_int_arg { + UInt abs_value; + unsigned prefix; +}; - template - constexpr auto apply(Out out, basic_string_view) const -> Out - { - return out; - } - }; +template +FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) + -> write_int_arg> { + auto prefix = 0u; + auto abs_value = static_cast>(value); + if (is_negative(value)) { + prefix = 0x01000000 | '-'; + abs_value = 0 - abs_value; + } else { + constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', + 0x1000000u | ' '}; + prefix = prefixes[sign]; + } + return {abs_value, prefix}; +} - template - FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, float_specs fspecs, locale_ref loc) -> OutputIt - { - if (is_constant_evaluated()) - { - return do_write_float>(out, f, specs, fspecs, loc); - } - else - { - return do_write_float(out, f, specs, fspecs, loc); - } - } +template struct loc_writer { + buffer_appender out; + const format_specs& specs; + std::basic_string sep; + std::string grouping; + std::basic_string decimal_point; + + template ::value)> + auto operator()(T value) -> bool { + auto arg = make_write_int_arg(value, specs.sign); + write_int(out, static_cast>(arg.abs_value), arg.prefix, + specs, digit_grouping(grouping, sep)); + return true; + } + + template ::value)> + auto operator()(T) -> bool { + return false; + } +}; - template - constexpr auto isnan(T value) -> bool - { - return !(value >= value); // std::isnan doesn't support __float128. - } +template +FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, + const format_specs& specs, + locale_ref) -> OutputIt { + static_assert(std::is_same>::value, ""); + auto abs_value = arg.abs_value; + auto prefix = arg.prefix; + switch (specs.type) { + case presentation_type::none: + case presentation_type::dec: { + auto num_digits = count_digits(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_decimal(it, abs_value, num_digits).end; + }); + } + case presentation_type::hex_lower: + case presentation_type::hex_upper: { + bool upper = specs.type == presentation_type::hex_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); + int num_digits = count_digits<4>(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_uint<4, Char>(it, abs_value, num_digits, upper); + }); + } + case presentation_type::bin_lower: + case presentation_type::bin_upper: { + bool upper = specs.type == presentation_type::bin_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); + int num_digits = count_digits<1>(abs_value); + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<1, Char>(it, abs_value, num_digits); + }); + } + case presentation_type::oct: { + int num_digits = count_digits<3>(abs_value); + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + if (specs.alt && specs.precision <= num_digits && abs_value != 0) + prefix_append(prefix, '0'); + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<3, Char>(it, abs_value, num_digits); + }); + } + case presentation_type::chr: + return write_char(out, static_cast(abs_value), specs); + default: + throw_format_error("invalid format specifier"); + } + return out; +} +template +FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( + OutputIt out, write_int_arg arg, const format_specs& specs, + locale_ref loc) -> OutputIt { + return write_int(out, arg, specs, loc); +} +template ::value && + !std::is_same::value && + std::is_same>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, + loc); +} +// An inlined version of write used in format string compilation. +template ::value && + !std::is_same::value && + !std::is_same>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); +} - template - struct has_isfinite : std::false_type {}; +// An output iterator that counts the number of objects written to it and +// discards them. +class counting_iterator { + private: + size_t count_; + + public: + using iterator_category = std::output_iterator_tag; + using difference_type = std::ptrdiff_t; + using pointer = void; + using reference = void; + FMT_UNCHECKED_ITERATOR(counting_iterator); + + struct value_type { + template FMT_CONSTEXPR void operator=(const T&) {} + }; + + FMT_CONSTEXPR counting_iterator() : count_(0) {} + + FMT_CONSTEXPR auto count() const -> size_t { return count_; } + + FMT_CONSTEXPR auto operator++() -> counting_iterator& { + ++count_; + return *this; + } + FMT_CONSTEXPR auto operator++(int) -> counting_iterator { + auto it = *this; + ++*this; + return it; + } + + FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n) + -> counting_iterator { + it.count_ += static_cast(n); + return it; + } + + FMT_CONSTEXPR auto operator*() const -> value_type { return {}; } +}; - template - struct has_isfinite> : std::true_type {}; +template +FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, + const format_specs& specs) -> OutputIt { + auto data = s.data(); + auto size = s.size(); + if (specs.precision >= 0 && to_unsigned(specs.precision) < size) + size = code_point_index(s, to_unsigned(specs.precision)); + bool is_debug = specs.type == presentation_type::debug; + size_t width = 0; + if (specs.width != 0) { + if (is_debug) + width = write_escaped_string(counting_iterator{}, s).count(); + else + width = compute_width(basic_string_view(data, size)); + } + return write_padded(out, specs, size, width, + [=](reserve_iterator it) { + if (is_debug) return write_escaped_string(it, s); + return copy_str(data, data + size, it); + }); +} +template +FMT_CONSTEXPR auto write(OutputIt out, + basic_string_view> s, + const format_specs& specs, locale_ref) + -> OutputIt { + return write(out, s, specs); +} +template +FMT_CONSTEXPR auto write(OutputIt out, const Char* s, + const format_specs& specs, locale_ref) + -> OutputIt { + if (specs.type == presentation_type::pointer) + return write_ptr(out, bit_cast(s), &specs); + if (!s) throw_format_error("string pointer is null"); + return write(out, basic_string_view(s), specs, {}); +} - template ::value&& has_isfinite::value)> - FMT_CONSTEXPR20 auto isfinite(T value) -> bool - { - constexpr T inf = T(std::numeric_limits::infinity()); - if (is_constant_evaluated()) - return !detail::isnan(value) && value < inf && value > -inf; - return std::isfinite(value); - } - template ::value)> - FMT_CONSTEXPR auto isfinite(T value) -> bool - { - T inf = T(std::numeric_limits::infinity()); - // std::isfinite doesn't support __float128. - return !detail::isnan(value) && value < inf && value > -inf; - } +template ::value && + !std::is_same::value && + !std::is_same::value)> +FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { + auto abs_value = static_cast>(value); + bool negative = is_negative(value); + // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. + if (negative) abs_value = ~abs_value + 1; + int num_digits = count_digits(abs_value); + auto size = (negative ? 1 : 0) + static_cast(num_digits); + auto it = reserve(out, size); + if (auto ptr = to_pointer(it, size)) { + if (negative) *ptr++ = static_cast('-'); + format_decimal(ptr, abs_value, num_digits); + return out; + } + if (negative) *it++ = static_cast('-'); + it = format_decimal(it, abs_value, num_digits).end; + return base_iterator(out, it); +} - template ::value)> - FMT_INLINE FMT_CONSTEXPR bool signbit(T value) - { - if (is_constant_evaluated()) - { -#ifdef __cpp_if_constexpr - if constexpr (std::numeric_limits::is_iec559) - { - auto bits = detail::bit_cast(static_cast(value)); - return (bits >> (num_bits() - 1)) != 0; - } -#endif +// DEPRECATED! +template +FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, + format_specs& specs) -> const Char* { + FMT_ASSERT(begin != end, ""); + auto align = align::none; + auto p = begin + code_point_length(begin); + if (end - p <= 0) p = begin; + for (;;) { + switch (to_ascii(*p)) { + case '<': + align = align::left; + break; + case '>': + align = align::right; + break; + case '^': + align = align::center; + break; + } + if (align != align::none) { + if (p != begin) { + auto c = *begin; + if (c == '}') return begin; + if (c == '{') { + throw_format_error("invalid fill character '{'"); + return begin; } - return std::signbit(static_cast(value)); - } + specs.fill = {begin, to_unsigned(p - begin)}; + begin = p + 1; + } else { + ++begin; + } + break; + } else if (p == begin) { + break; + } + p = begin; + } + specs.align = align; + return begin; +} - inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) - { - // Adjust fixed precision by exponent because it is relative to decimal - // point. - if (exp10 > 0 && precision > max_value() - exp10) - FMT_THROW(format_error("number is too big")); - precision += exp10; - } +// A floating-point presentation format. +enum class float_format : unsigned char { + general, // General: exponent notation or fixed point based on magnitude. + exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. + fixed, // Fixed point with the default precision of 6, e.g. 0.0012. + hex +}; - class bigint { - private: - // A bigint is stored as an array of bigits (big digits), with bigit at index - // 0 being the least significant one. - using bigit = uint32_t; - using double_bigit = uint64_t; - enum { bigits_capacity = 32 }; - basic_memory_buffer bigits_; - int exp_; +struct float_specs { + int precision; + float_format format : 8; + sign_t sign : 8; + bool upper : 1; + bool locale : 1; + bool binary32 : 1; + bool showpoint : 1; +}; - FMT_CONSTEXPR20 auto operator[](int index) const -> bigit { return bigits_[to_unsigned(index)]; } - FMT_CONSTEXPR20 auto operator[](int index) -> bigit& { return bigits_[to_unsigned(index)]; } +template +FMT_CONSTEXPR auto parse_float_type_spec(const format_specs& specs) + -> float_specs { + auto result = float_specs(); + result.showpoint = specs.alt; + result.locale = specs.localized; + switch (specs.type) { + case presentation_type::none: + result.format = float_format::general; + break; + case presentation_type::general_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::general_lower: + result.format = float_format::general; + break; + case presentation_type::exp_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::exp_lower: + result.format = float_format::exp; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::fixed_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::fixed_lower: + result.format = float_format::fixed; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::hexfloat_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::hexfloat_lower: + result.format = float_format::hex; + break; + default: + throw_format_error("invalid format specifier"); + break; + } + return result; +} - static constexpr const int bigit_bits = num_bits(); +template +FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, + format_specs specs, + const float_specs& fspecs) -> OutputIt { + auto str = + isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); + constexpr size_t str_size = 3; + auto sign = fspecs.sign; + auto size = str_size + (sign ? 1 : 0); + // Replace '0'-padding with space for non-finite values. + const bool is_zero_fill = + specs.fill.size() == 1 && *specs.fill.data() == static_cast('0'); + if (is_zero_fill) specs.fill[0] = static_cast(' '); + return write_padded(out, specs, size, [=](reserve_iterator it) { + if (sign) *it++ = detail::sign(sign); + return copy_str(str, str + str_size, it); + }); +} - friend struct formatter; +// A decimal floating-point number significand * pow(10, exp). +struct big_decimal_fp { + const char* significand; + int significand_size; + int exponent; +}; - FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) - { - auto result = static_cast((*this)[index]) - other - borrow; - (*this)[index] = static_cast(result); - borrow = static_cast(result >> (bigit_bits * 2 - 1)); - } +constexpr auto get_significand_size(const big_decimal_fp& f) -> int { + return f.significand_size; +} +template +inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int { + return count_digits(f.significand); +} - FMT_CONSTEXPR20 void remove_leading_zeros() - { - int num_bigits = static_cast(bigits_.size()) - 1; - while (num_bigits > 0 && (*this)[num_bigits] == 0) - --num_bigits; - bigits_.resize(to_unsigned(num_bigits + 1)); - } +template +constexpr auto write_significand(OutputIt out, const char* significand, + int significand_size) -> OutputIt { + return copy_str(significand, significand + significand_size, out); +} +template +inline auto write_significand(OutputIt out, UInt significand, + int significand_size) -> OutputIt { + return format_decimal(out, significand, significand_size).end; +} +template +FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, + int significand_size, int exponent, + const Grouping& grouping) -> OutputIt { + if (!grouping.has_separator()) { + out = write_significand(out, significand, significand_size); + return detail::fill_n(out, exponent, static_cast('0')); + } + auto buffer = memory_buffer(); + write_significand(appender(buffer), significand, significand_size); + detail::fill_n(appender(buffer), exponent, '0'); + return grouping.apply(out, string_view(buffer.data(), buffer.size())); +} - // Computes *this -= other assuming aligned bigints and *this >= other. - FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) - { - FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); - FMT_ASSERT(compare(*this, other) >= 0, ""); - bigit borrow = 0; - int i = other.exp_ - exp_; - for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) - subtract_bigits(i, other.bigits_[j], borrow); - while (borrow > 0) - subtract_bigits(i, 0, borrow); - remove_leading_zeros(); - } +template ::value)> +inline auto write_significand(Char* out, UInt significand, int significand_size, + int integral_size, Char decimal_point) -> Char* { + if (!decimal_point) + return format_decimal(out, significand, significand_size).end; + out += significand_size + 1; + Char* end = out; + int floating_size = significand_size - integral_size; + for (int i = floating_size / 2; i > 0; --i) { + out -= 2; + copy2(out, digits2(static_cast(significand % 100))); + significand /= 100; + } + if (floating_size % 2 != 0) { + *--out = static_cast('0' + significand % 10); + significand /= 10; + } + *--out = decimal_point; + format_decimal(out - integral_size, significand, integral_size); + return end; +} - FMT_CONSTEXPR20 void multiply(uint32_t value) - { - const double_bigit wide_value = value; - bigit carry = 0; - for (size_t i = 0, n = bigits_.size(); i < n; ++i) - { - double_bigit result = bigits_[i] * wide_value + carry; - bigits_[i] = static_cast(result); - carry = static_cast(result >> bigit_bits); - } - if (carry != 0) - bigits_.push_back(carry); - } +template >::value)> +inline auto write_significand(OutputIt out, UInt significand, + int significand_size, int integral_size, + Char decimal_point) -> OutputIt { + // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. + Char buffer[digits10() + 2]; + auto end = write_significand(buffer, significand, significand_size, + integral_size, decimal_point); + return detail::copy_str_noinline(buffer, end, out); +} - template ::value || std::is_same::value)> - FMT_CONSTEXPR20 void multiply(UInt value) - { - using half_uint = conditional_t::value, uint64_t, uint32_t>; - const int shift = num_bits() - bigit_bits; - const UInt lower = static_cast(value); - const UInt upper = value >> num_bits(); - UInt carry = 0; - for (size_t i = 0, n = bigits_.size(); i < n; ++i) - { - UInt result = lower * bigits_[i] + static_cast(carry); - carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + (carry >> bigit_bits); - bigits_[i] = static_cast(result); - } - while (carry != 0) - { - bigits_.push_back(static_cast(carry)); - carry >>= bigit_bits; - } - } +template +FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, + int significand_size, int integral_size, + Char decimal_point) -> OutputIt { + out = detail::copy_str_noinline(significand, + significand + integral_size, out); + if (!decimal_point) return out; + *out++ = decimal_point; + return detail::copy_str_noinline(significand + integral_size, + significand + significand_size, out); +} - template ::value || std::is_same::value)> - FMT_CONSTEXPR20 void assign(UInt n) - { - size_t num_bigits = 0; - do - { - bigits_[num_bigits++] = static_cast(n); - n >>= bigit_bits; - } - while (n != 0); - bigits_.resize(num_bigits); - exp_ = 0; - } +template +FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, + int significand_size, int integral_size, + Char decimal_point, + const Grouping& grouping) -> OutputIt { + if (!grouping.has_separator()) { + return write_significand(out, significand, significand_size, integral_size, + decimal_point); + } + auto buffer = basic_memory_buffer(); + write_significand(buffer_appender(buffer), significand, + significand_size, integral_size, decimal_point); + grouping.apply( + out, basic_string_view(buffer.data(), to_unsigned(integral_size))); + return detail::copy_str_noinline(buffer.data() + integral_size, + buffer.end(), out); +} - public: - FMT_CONSTEXPR20 bigint() : exp_(0) {} - explicit bigint(uint64_t n) { assign(n); } +template > +FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { + auto significand = f.significand; + int significand_size = get_significand_size(f); + const Char zero = static_cast('0'); + auto sign = fspecs.sign; + size_t size = to_unsigned(significand_size) + (sign ? 1 : 0); + using iterator = reserve_iterator; + + Char decimal_point = + fspecs.locale ? detail::decimal_point(loc) : static_cast('.'); + + int output_exp = f.exponent + significand_size - 1; + auto use_exp_format = [=]() { + if (fspecs.format == float_format::exp) return true; + if (fspecs.format != float_format::general) return false; + // Use the fixed notation if the exponent is in [exp_lower, exp_upper), + // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. + const int exp_lower = -4, exp_upper = 16; + return output_exp < exp_lower || + output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper); + }; + if (use_exp_format()) { + int num_zeros = 0; + if (fspecs.showpoint) { + num_zeros = fspecs.precision - significand_size; + if (num_zeros < 0) num_zeros = 0; + size += to_unsigned(num_zeros); + } else if (significand_size == 1) { + decimal_point = Char(); + } + auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp; + int exp_digits = 2; + if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; + + size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); + char exp_char = fspecs.upper ? 'E' : 'e'; + auto write = [=](iterator it) { + if (sign) *it++ = detail::sign(sign); + // Insert a decimal point after the first digit and add an exponent. + it = write_significand(it, significand, significand_size, 1, + decimal_point); + if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero); + *it++ = static_cast(exp_char); + return write_exponent(output_exp, it); + }; + return specs.width > 0 ? write_padded(out, specs, size, write) + : base_iterator(out, write(reserve(out, size))); + } + + int exp = f.exponent + significand_size; + if (f.exponent >= 0) { + // 1234e5 -> 123400000[.0+] + size += to_unsigned(f.exponent); + int num_zeros = fspecs.precision - exp; + abort_fuzzing_if(num_zeros > 5000); + if (fspecs.showpoint) { + ++size; + if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0; + if (num_zeros > 0) size += to_unsigned(num_zeros); + } + auto grouping = Grouping(loc, fspecs.locale); + size += to_unsigned(grouping.count_separators(exp)); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + it = write_significand(it, significand, significand_size, + f.exponent, grouping); + if (!fspecs.showpoint) return it; + *it++ = decimal_point; + return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; + }); + } else if (exp > 0) { + // 1234e-2 -> 12.34[0+] + int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0; + size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); + auto grouping = Grouping(loc, fspecs.locale); + size += to_unsigned(grouping.count_separators(exp)); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + it = write_significand(it, significand, significand_size, exp, + decimal_point, grouping); + return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; + }); + } + // 1234e-6 -> 0.001234 + int num_zeros = -exp; + if (significand_size == 0 && fspecs.precision >= 0 && + fspecs.precision < num_zeros) { + num_zeros = fspecs.precision; + } + bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; + size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + *it++ = zero; + if (!pointy) return it; + *it++ = decimal_point; + it = detail::fill_n(it, num_zeros, zero); + return write_significand(it, significand, significand_size); + }); +} - bigint(const bigint&) = delete; - void operator=(const bigint&) = delete; +template class fallback_digit_grouping { + public: + constexpr fallback_digit_grouping(locale_ref, bool) {} - FMT_CONSTEXPR20 void assign(const bigint& other) - { - auto size = other.bigits_.size(); - bigits_.resize(size); - auto data = other.bigits_.data(); - copy_str(data, data + size, bigits_.data()); - exp_ = other.exp_; - } + constexpr auto has_separator() const -> bool { return false; } - template - FMT_CONSTEXPR20 void operator=(Int n) - { - FMT_ASSERT(n > 0, ""); - assign(uint64_or_128_t(n)); - } + constexpr auto count_separators(int) const -> int { return 0; } - FMT_CONSTEXPR20 auto num_bigits() const -> int { return static_cast(bigits_.size()) + exp_; } - - FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& - { - FMT_ASSERT(shift >= 0, ""); - exp_ += shift / bigit_bits; - shift %= bigit_bits; - if (shift == 0) - return *this; - bigit carry = 0; - for (size_t i = 0, n = bigits_.size(); i < n; ++i) - { - bigit c = bigits_[i] >> (bigit_bits - shift); - bigits_[i] = (bigits_[i] << shift) + carry; - carry = c; - } - if (carry != 0) - bigits_.push_back(carry); - return *this; - } + template + constexpr auto apply(Out out, basic_string_view) const -> Out { + return out; + } +}; - template - FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& - { - FMT_ASSERT(value > 0, ""); - multiply(uint32_or_64_or_128_t(value)); - return *this; - } +template +FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { + if (is_constant_evaluated()) { + return do_write_float>(out, f, specs, fspecs, + loc); + } else { + return do_write_float(out, f, specs, fspecs, loc); + } +} - friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs) -> int - { - int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); - if (num_lhs_bigits != num_rhs_bigits) - return num_lhs_bigits > num_rhs_bigits ? 1 : -1; - int i = static_cast(lhs.bigits_.size()) - 1; - int j = static_cast(rhs.bigits_.size()) - 1; - int end = i - j; - if (end < 0) - end = 0; - for (; i >= end; --i, --j) - { - bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j]; - if (lhs_bigit != rhs_bigit) - return lhs_bigit > rhs_bigit ? 1 : -1; - } - if (i != j) - return i > j ? 1 : -1; - return 0; - } +template constexpr auto isnan(T value) -> bool { + return !(value >= value); // std::isnan doesn't support __float128. +} - // Returns compare(lhs1 + lhs2, rhs). - friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1, const bigint& lhs2, const bigint& rhs) -> int - { - auto minimum = [](int a, int b) { return a < b ? a : b; }; - auto maximum = [](int a, int b) { return a > b ? a : b; }; - int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); - int num_rhs_bigits = rhs.num_bigits(); - if (max_lhs_bigits + 1 < num_rhs_bigits) - return -1; - if (max_lhs_bigits > num_rhs_bigits) - return 1; - auto get_bigit = [](const bigint& n, int i) -> bigit { return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; }; - double_bigit borrow = 0; - int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_); - for (int i = num_rhs_bigits - 1; i >= min_exp; --i) - { - double_bigit sum = static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i); - bigit rhs_bigit = get_bigit(rhs, i); - if (sum > rhs_bigit + borrow) - return 1; - borrow = rhs_bigit + borrow - sum; - if (borrow > 1) - return -1; - borrow <<= bigit_bits; - } - return borrow != 0 ? -1 : 0; - } +template +struct has_isfinite : std::false_type {}; - // Assigns pow(10, exp) to this bigint. - FMT_CONSTEXPR20 void assign_pow10(int exp) - { - FMT_ASSERT(exp >= 0, ""); - if (exp == 0) - return *this = 1; - // Find the top bit. - int bitmask = 1; - while (exp >= bitmask) - bitmask <<= 1; - bitmask >>= 1; - // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by - // repeated squaring and multiplication. - *this = 5; - bitmask >>= 1; - while (bitmask != 0) - { - square(); - if ((exp & bitmask) != 0) - *this *= 5; - bitmask >>= 1; - } - *this <<= exp; // Multiply by pow(2, exp) by shifting. - } +template +struct has_isfinite> + : std::true_type {}; + +template ::value&& + has_isfinite::value)> +FMT_CONSTEXPR20 auto isfinite(T value) -> bool { + constexpr T inf = T(std::numeric_limits::infinity()); + if (is_constant_evaluated()) + return !detail::isnan(value) && value < inf && value > -inf; + return std::isfinite(value); +} +template ::value)> +FMT_CONSTEXPR auto isfinite(T value) -> bool { + T inf = T(std::numeric_limits::infinity()); + // std::isfinite doesn't support __float128. + return !detail::isnan(value) && value < inf && value > -inf; +} - FMT_CONSTEXPR20 void square() - { - int num_bigits = static_cast(bigits_.size()); - int num_result_bigits = 2 * num_bigits; - basic_memory_buffer n(std::move(bigits_)); - bigits_.resize(to_unsigned(num_result_bigits)); - auto sum = uint128_t(); - for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) - { - // Compute bigit at position bigit_index of the result by adding - // cross-product terms n[i] * n[j] such that i + j == bigit_index. - for (int i = 0, j = bigit_index; j >= 0; ++i, --j) - { - // Most terms are multiplied twice which can be optimized in the future. - sum += static_cast(n[i]) * n[j]; - } - (*this)[bigit_index] = static_cast(sum); - sum >>= num_bits(); // Compute the carry. - } - // Do the same for the top half. - for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) - { - for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) - sum += static_cast(n[i++]) * n[j--]; - (*this)[bigit_index] = static_cast(sum); - sum >>= num_bits(); - } - remove_leading_zeros(); - exp_ *= 2; - } +template ::value)> +FMT_INLINE FMT_CONSTEXPR bool signbit(T value) { + if (is_constant_evaluated()) { +#ifdef __cpp_if_constexpr + if constexpr (std::numeric_limits::is_iec559) { + auto bits = detail::bit_cast(static_cast(value)); + return (bits >> (num_bits() - 1)) != 0; + } +#endif + } + return std::signbit(static_cast(value)); +} - // If this bigint has a bigger exponent than other, adds trailing zero to make - // exponents equal. This simplifies some operations such as subtraction. - FMT_CONSTEXPR20 void align(const bigint& other) - { - int exp_difference = exp_ - other.exp_; - if (exp_difference <= 0) - return; - int num_bigits = static_cast(bigits_.size()); - bigits_.resize(to_unsigned(num_bigits + exp_difference)); - for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) - bigits_[j] = bigits_[i]; - std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u); - exp_ -= exp_difference; - } +inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { + // Adjust fixed precision by exponent because it is relative to decimal + // point. + if (exp10 > 0 && precision > max_value() - exp10) + FMT_THROW(format_error("number is too big")); + precision += exp10; +} - // Divides this bignum by divisor, assigning the remainder to this and - // returning the quotient. - FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int - { - FMT_ASSERT(this != &divisor, ""); - if (compare(*this, divisor) < 0) - return 0; - FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); - align(divisor); - int quotient = 0; - do - { - subtract_aligned(divisor); - ++quotient; - } - while (compare(*this, divisor) >= 0); - return quotient; - } +class bigint { + private: + // A bigint is stored as an array of bigits (big digits), with bigit at index + // 0 being the least significant one. + using bigit = uint32_t; + using double_bigit = uint64_t; + enum { bigits_capacity = 32 }; + basic_memory_buffer bigits_; + int exp_; + + FMT_CONSTEXPR20 auto operator[](int index) const -> bigit { + return bigits_[to_unsigned(index)]; + } + FMT_CONSTEXPR20 auto operator[](int index) -> bigit& { + return bigits_[to_unsigned(index)]; + } + + static constexpr const int bigit_bits = num_bits(); + + friend struct formatter; + + FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) { + auto result = static_cast((*this)[index]) - other - borrow; + (*this)[index] = static_cast(result); + borrow = static_cast(result >> (bigit_bits * 2 - 1)); + } + + FMT_CONSTEXPR20 void remove_leading_zeros() { + int num_bigits = static_cast(bigits_.size()) - 1; + while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits; + bigits_.resize(to_unsigned(num_bigits + 1)); + } + + // Computes *this -= other assuming aligned bigints and *this >= other. + FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) { + FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); + FMT_ASSERT(compare(*this, other) >= 0, ""); + bigit borrow = 0; + int i = other.exp_ - exp_; + for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) + subtract_bigits(i, other.bigits_[j], borrow); + while (borrow > 0) subtract_bigits(i, 0, borrow); + remove_leading_zeros(); + } + + FMT_CONSTEXPR20 void multiply(uint32_t value) { + const double_bigit wide_value = value; + bigit carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + double_bigit result = bigits_[i] * wide_value + carry; + bigits_[i] = static_cast(result); + carry = static_cast(result >> bigit_bits); + } + if (carry != 0) bigits_.push_back(carry); + } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR20 void multiply(UInt value) { + using half_uint = + conditional_t::value, uint64_t, uint32_t>; + const int shift = num_bits() - bigit_bits; + const UInt lower = static_cast(value); + const UInt upper = value >> num_bits(); + UInt carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + UInt result = lower * bigits_[i] + static_cast(carry); + carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + + (carry >> bigit_bits); + bigits_[i] = static_cast(result); + } + while (carry != 0) { + bigits_.push_back(static_cast(carry)); + carry >>= bigit_bits; + } + } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR20 void assign(UInt n) { + size_t num_bigits = 0; + do { + bigits_[num_bigits++] = static_cast(n); + n >>= bigit_bits; + } while (n != 0); + bigits_.resize(num_bigits); + exp_ = 0; + } + + public: + FMT_CONSTEXPR20 bigint() : exp_(0) {} + explicit bigint(uint64_t n) { assign(n); } + + bigint(const bigint&) = delete; + void operator=(const bigint&) = delete; + + FMT_CONSTEXPR20 void assign(const bigint& other) { + auto size = other.bigits_.size(); + bigits_.resize(size); + auto data = other.bigits_.data(); + copy_str(data, data + size, bigits_.data()); + exp_ = other.exp_; + } + + template FMT_CONSTEXPR20 void operator=(Int n) { + FMT_ASSERT(n > 0, ""); + assign(uint64_or_128_t(n)); + } + + FMT_CONSTEXPR20 auto num_bigits() const -> int { + return static_cast(bigits_.size()) + exp_; + } + + FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& { + FMT_ASSERT(shift >= 0, ""); + exp_ += shift / bigit_bits; + shift %= bigit_bits; + if (shift == 0) return *this; + bigit carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + bigit c = bigits_[i] >> (bigit_bits - shift); + bigits_[i] = (bigits_[i] << shift) + carry; + carry = c; + } + if (carry != 0) bigits_.push_back(carry); + return *this; + } + + template + FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& { + FMT_ASSERT(value > 0, ""); + multiply(uint32_or_64_or_128_t(value)); + return *this; + } + + friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs) + -> int { + int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); + if (num_lhs_bigits != num_rhs_bigits) + return num_lhs_bigits > num_rhs_bigits ? 1 : -1; + int i = static_cast(lhs.bigits_.size()) - 1; + int j = static_cast(rhs.bigits_.size()) - 1; + int end = i - j; + if (end < 0) end = 0; + for (; i >= end; --i, --j) { + bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j]; + if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1; + } + if (i != j) return i > j ? 1 : -1; + return 0; + } + + // Returns compare(lhs1 + lhs2, rhs). + friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1, + const bigint& lhs2, const bigint& rhs) + -> int { + auto minimum = [](int a, int b) { return a < b ? a : b; }; + auto maximum = [](int a, int b) { return a > b ? a : b; }; + int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); + int num_rhs_bigits = rhs.num_bigits(); + if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; + if (max_lhs_bigits > num_rhs_bigits) return 1; + auto get_bigit = [](const bigint& n, int i) -> bigit { + return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; }; + double_bigit borrow = 0; + int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_); + for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { + double_bigit sum = + static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i); + bigit rhs_bigit = get_bigit(rhs, i); + if (sum > rhs_bigit + borrow) return 1; + borrow = rhs_bigit + borrow - sum; + if (borrow > 1) return -1; + borrow <<= bigit_bits; + } + return borrow != 0 ? -1 : 0; + } + + // Assigns pow(10, exp) to this bigint. + FMT_CONSTEXPR20 void assign_pow10(int exp) { + FMT_ASSERT(exp >= 0, ""); + if (exp == 0) return *this = 1; + // Find the top bit. + int bitmask = 1; + while (exp >= bitmask) bitmask <<= 1; + bitmask >>= 1; + // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by + // repeated squaring and multiplication. + *this = 5; + bitmask >>= 1; + while (bitmask != 0) { + square(); + if ((exp & bitmask) != 0) *this *= 5; + bitmask >>= 1; + } + *this <<= exp; // Multiply by pow(2, exp) by shifting. + } + + FMT_CONSTEXPR20 void square() { + int num_bigits = static_cast(bigits_.size()); + int num_result_bigits = 2 * num_bigits; + basic_memory_buffer n(std::move(bigits_)); + bigits_.resize(to_unsigned(num_result_bigits)); + auto sum = uint128_t(); + for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { + // Compute bigit at position bigit_index of the result by adding + // cross-product terms n[i] * n[j] such that i + j == bigit_index. + for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { + // Most terms are multiplied twice which can be optimized in the future. + sum += static_cast(n[i]) * n[j]; + } + (*this)[bigit_index] = static_cast(sum); + sum >>= num_bits(); // Compute the carry. + } + // Do the same for the top half. + for (int bigit_index = num_bigits; bigit_index < num_result_bigits; + ++bigit_index) { + for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) + sum += static_cast(n[i++]) * n[j--]; + (*this)[bigit_index] = static_cast(sum); + sum >>= num_bits(); + } + remove_leading_zeros(); + exp_ *= 2; + } + + // If this bigint has a bigger exponent than other, adds trailing zero to make + // exponents equal. This simplifies some operations such as subtraction. + FMT_CONSTEXPR20 void align(const bigint& other) { + int exp_difference = exp_ - other.exp_; + if (exp_difference <= 0) return; + int num_bigits = static_cast(bigits_.size()); + bigits_.resize(to_unsigned(num_bigits + exp_difference)); + for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) + bigits_[j] = bigits_[i]; + std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u); + exp_ -= exp_difference; + } + + // Divides this bignum by divisor, assigning the remainder to this and + // returning the quotient. + FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int { + FMT_ASSERT(this != &divisor, ""); + if (compare(*this, divisor) < 0) return 0; + FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); + align(divisor); + int quotient = 0; + do { + subtract_aligned(divisor); + ++quotient; + } while (compare(*this, divisor) >= 0); + return quotient; + } +}; - // format_dragon flags. - enum dragon { - predecessor_closer = 1, - fixup = 2, // Run fixup to correct exp10 which can be off by one. - fixed = 4, - }; +// format_dragon flags. +enum dragon { + predecessor_closer = 1, + fixup = 2, // Run fixup to correct exp10 which can be off by one. + fixed = 4, +}; - // Formats a floating-point number using a variation of the Fixed-Precision - // Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: - // https://fmt.dev/papers/p372-steele.pdf. - FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, unsigned flags, int num_digits, buffer& buf, int& exp10) - { - bigint numerator; // 2 * R in (FPP)^2. - bigint denominator; // 2 * S in (FPP)^2. - // lower and upper are differences between value and corresponding boundaries. - bigint lower; // (M^- in (FPP)^2). - bigint upper_store; // upper's value if different from lower. - bigint* upper = nullptr; // (M^+ in (FPP)^2). - // Shift numerator and denominator by an extra bit or two (if lower boundary - // is closer) to make lower and upper integers. This eliminates multiplication - // by 2 during later computations. - bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; - int shift = is_predecessor_closer ? 2 : 1; - if (value.e >= 0) - { - numerator = value.f; - numerator <<= value.e + shift; - lower = 1; - lower <<= value.e; - if (is_predecessor_closer) - { - upper_store = 1; - upper_store <<= value.e + 1; - upper = &upper_store; - } - denominator.assign_pow10(exp10); - denominator <<= shift; - } - else if (exp10 < 0) - { - numerator.assign_pow10(-exp10); - lower.assign(numerator); - if (is_predecessor_closer) - { - upper_store.assign(numerator); - upper_store <<= 1; - upper = &upper_store; - } - numerator *= value.f; - numerator <<= shift; - denominator = 1; - denominator <<= shift - value.e; - } - else - { - numerator = value.f; - numerator <<= shift; - denominator.assign_pow10(exp10); - denominator <<= shift - value.e; - lower = 1; - if (is_predecessor_closer) - { - upper_store = 1ULL << 1; - upper = &upper_store; - } - } - int even = static_cast((value.f & 1) == 0); - if (!upper) - upper = &lower; - bool shortest = num_digits < 0; - if ((flags & dragon::fixup) != 0) - { - if (add_compare(numerator, *upper, denominator) + even <= 0) - { - --exp10; - numerator *= 10; - if (num_digits < 0) - { - lower *= 10; - if (upper != &lower) - *upper *= 10; - } - } - if ((flags & dragon::fixed) != 0) - adjust_precision(num_digits, exp10 + 1); - } - // Invariant: value == (numerator / denominator) * pow(10, exp10). - if (shortest) - { - // Generate the shortest representation. - num_digits = 0; - char* data = buf.data(); - for (;;) - { - int digit = numerator.divmod_assign(denominator); - bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. - // numerator + upper >[=] pow10: - bool high = add_compare(numerator, *upper, denominator) + even > 0; - data[num_digits++] = static_cast('0' + digit); - if (low || high) - { - if (!low) - { - ++data[num_digits - 1]; - } - else if (high) - { - int result = add_compare(numerator, numerator, denominator); - // Round half to even. - if (result > 0 || (result == 0 && (digit % 2) != 0)) - ++data[num_digits - 1]; - } - buf.try_resize(to_unsigned(num_digits)); - exp10 -= num_digits - 1; - return; - } - numerator *= 10; - lower *= 10; - if (upper != &lower) - *upper *= 10; - } - } - // Generate the given number of digits. - exp10 -= num_digits - 1; - if (num_digits <= 0) - { - denominator *= 10; - auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; - buf.push_back(digit); - return; +// Formats a floating-point number using a variation of the Fixed-Precision +// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: +// https://fmt.dev/papers/p372-steele.pdf. +FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, + unsigned flags, int num_digits, + buffer& buf, int& exp10) { + bigint numerator; // 2 * R in (FPP)^2. + bigint denominator; // 2 * S in (FPP)^2. + // lower and upper are differences between value and corresponding boundaries. + bigint lower; // (M^- in (FPP)^2). + bigint upper_store; // upper's value if different from lower. + bigint* upper = nullptr; // (M^+ in (FPP)^2). + // Shift numerator and denominator by an extra bit or two (if lower boundary + // is closer) to make lower and upper integers. This eliminates multiplication + // by 2 during later computations. + bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; + int shift = is_predecessor_closer ? 2 : 1; + if (value.e >= 0) { + numerator = value.f; + numerator <<= value.e + shift; + lower = 1; + lower <<= value.e; + if (is_predecessor_closer) { + upper_store = 1; + upper_store <<= value.e + 1; + upper = &upper_store; + } + denominator.assign_pow10(exp10); + denominator <<= shift; + } else if (exp10 < 0) { + numerator.assign_pow10(-exp10); + lower.assign(numerator); + if (is_predecessor_closer) { + upper_store.assign(numerator); + upper_store <<= 1; + upper = &upper_store; + } + numerator *= value.f; + numerator <<= shift; + denominator = 1; + denominator <<= shift - value.e; + } else { + numerator = value.f; + numerator <<= shift; + denominator.assign_pow10(exp10); + denominator <<= shift - value.e; + lower = 1; + if (is_predecessor_closer) { + upper_store = 1ULL << 1; + upper = &upper_store; + } + } + int even = static_cast((value.f & 1) == 0); + if (!upper) upper = &lower; + bool shortest = num_digits < 0; + if ((flags & dragon::fixup) != 0) { + if (add_compare(numerator, *upper, denominator) + even <= 0) { + --exp10; + numerator *= 10; + if (num_digits < 0) { + lower *= 10; + if (upper != &lower) *upper *= 10; + } + } + if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); + } + // Invariant: value == (numerator / denominator) * pow(10, exp10). + if (shortest) { + // Generate the shortest representation. + num_digits = 0; + char* data = buf.data(); + for (;;) { + int digit = numerator.divmod_assign(denominator); + bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. + // numerator + upper >[=] pow10: + bool high = add_compare(numerator, *upper, denominator) + even > 0; + data[num_digits++] = static_cast('0' + digit); + if (low || high) { + if (!low) { + ++data[num_digits - 1]; + } else if (high) { + int result = add_compare(numerator, numerator, denominator); + // Round half to even. + if (result > 0 || (result == 0 && (digit % 2) != 0)) + ++data[num_digits - 1]; } buf.try_resize(to_unsigned(num_digits)); - for (int i = 0; i < num_digits - 1; ++i) - { - int digit = numerator.divmod_assign(denominator); - buf[i] = static_cast('0' + digit); - numerator *= 10; - } - int digit = numerator.divmod_assign(denominator); - auto result = add_compare(numerator, numerator, denominator); - if (result > 0 || (result == 0 && (digit % 2) != 0)) - { - if (digit == 9) - { - const auto overflow = '0' + 10; - buf[num_digits - 1] = overflow; - // Propagate the carry. - for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) - { - buf[i] = '0'; - ++buf[i - 1]; - } - if (buf[0] == overflow) - { - buf[0] = '1'; - if ((flags & dragon::fixed) != 0) - buf.push_back('0'); - else - ++exp10; - } - return; - } - ++digit; - } - buf[num_digits - 1] = static_cast('0' + digit); - } - - // Formats a floating-point number using the hexfloat format. - template ::value)> - FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, float_specs specs, buffer& buf) - { - // float is passed as double to reduce the number of instantiations and to - // simplify implementation. - static_assert(!std::is_same::value, ""); - - using info = dragonbox::float_info; - - // Assume Float is in the format [sign][exponent][significand]. - using carrier_uint = typename info::carrier_uint; - - constexpr auto num_float_significand_bits = detail::num_significand_bits(); - - basic_fp f(value); - f.e += num_float_significand_bits; - if (!has_implicit_bit()) - --f.e; - - constexpr auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit() ? 1 : 0); - constexpr auto num_xdigits = (num_fraction_bits + 3) / 4; - - constexpr auto leading_shift = ((num_xdigits - 1) * 4); - const auto leading_mask = carrier_uint(0xF) << leading_shift; - const auto leading_xdigit = static_cast((f.f & leading_mask) >> leading_shift); - if (leading_xdigit > 1) - f.e -= (32 - countl_zero(leading_xdigit) - 1); - - int print_xdigits = num_xdigits - 1; - if (precision >= 0 && print_xdigits > precision) - { - const int shift = ((print_xdigits - precision - 1) * 4); - const auto mask = carrier_uint(0xF) << shift; - const auto v = static_cast((f.f & mask) >> shift); - - if (v >= 8) - { - const auto inc = carrier_uint(1) << (shift + 4); - f.f += inc; - f.f &= ~(inc - 1); - } - - // Check long double overflow - if (!has_implicit_bit()) - { - const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; - if ((f.f & implicit_bit) == implicit_bit) - { - f.f >>= 4; - f.e += 4; - } - } - - print_xdigits = precision; - } - - char xdigits[num_bits() / 4]; - detail::fill_n(xdigits, sizeof(xdigits), '0'); - format_uint<4>(xdigits, f.f, num_xdigits, specs.upper); - - // Remove zero tail - while (print_xdigits > 0 && xdigits[print_xdigits] == '0') - --print_xdigits; - - buf.push_back('0'); - buf.push_back(specs.upper ? 'X' : 'x'); - buf.push_back(xdigits[0]); - if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) - buf.push_back('.'); - buf.append(xdigits + 1, xdigits + 1 + print_xdigits); - for (; print_xdigits < precision; ++print_xdigits) - buf.push_back('0'); - - buf.push_back(specs.upper ? 'P' : 'p'); - - uint32_t abs_e; - if (f.e < 0) - { - buf.push_back('-'); - abs_e = static_cast(-f.e); - } + exp10 -= num_digits - 1; + return; + } + numerator *= 10; + lower *= 10; + if (upper != &lower) *upper *= 10; + } + } + // Generate the given number of digits. + exp10 -= num_digits - 1; + if (num_digits <= 0) { + denominator *= 10; + auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; + buf.push_back(digit); + return; + } + buf.try_resize(to_unsigned(num_digits)); + for (int i = 0; i < num_digits - 1; ++i) { + int digit = numerator.divmod_assign(denominator); + buf[i] = static_cast('0' + digit); + numerator *= 10; + } + int digit = numerator.divmod_assign(denominator); + auto result = add_compare(numerator, numerator, denominator); + if (result > 0 || (result == 0 && (digit % 2) != 0)) { + if (digit == 9) { + const auto overflow = '0' + 10; + buf[num_digits - 1] = overflow; + // Propagate the carry. + for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) { + buf[i] = '0'; + ++buf[i - 1]; + } + if (buf[0] == overflow) { + buf[0] = '1'; + if ((flags & dragon::fixed) != 0) + buf.push_back('0'); else - { - buf.push_back('+'); - abs_e = static_cast(f.e); - } - format_decimal(appender(buf), abs_e, detail::count_digits(abs_e)); - } - - template ::value)> - FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, float_specs specs, buffer& buf) - { - format_hexfloat(static_cast(value), precision, specs, buf); + ++exp10; + } + return; } + ++digit; + } + buf[num_digits - 1] = static_cast('0' + digit); +} - constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t - { - // For checking rounding thresholds. - // The kth entry is chosen to be the smallest integer such that the - // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. - // It is equal to ceil(2^31 + 2^32/10^(k + 1)). - // These are stored in a string literal because we cannot have static arrays - // in constexpr functions and non-static ones are poorly optimized. - return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" - U"\x800001ae\x8000002b"[index]; - } +// Formats a floating-point number using the hexfloat format. +template ::value)> +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { + // float is passed as double to reduce the number of instantiations and to + // simplify implementation. + static_assert(!std::is_same::value, ""); + + using info = dragonbox::float_info; + + // Assume Float is in the format [sign][exponent][significand]. + using carrier_uint = typename info::carrier_uint; + + constexpr auto num_float_significand_bits = + detail::num_significand_bits(); + + basic_fp f(value); + f.e += num_float_significand_bits; + if (!has_implicit_bit()) --f.e; + + constexpr auto num_fraction_bits = + num_float_significand_bits + (has_implicit_bit() ? 1 : 0); + constexpr auto num_xdigits = (num_fraction_bits + 3) / 4; + + constexpr auto leading_shift = ((num_xdigits - 1) * 4); + const auto leading_mask = carrier_uint(0xF) << leading_shift; + const auto leading_xdigit = + static_cast((f.f & leading_mask) >> leading_shift); + if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); + + int print_xdigits = num_xdigits - 1; + if (precision >= 0 && print_xdigits > precision) { + const int shift = ((print_xdigits - precision - 1) * 4); + const auto mask = carrier_uint(0xF) << shift; + const auto v = static_cast((f.f & mask) >> shift); + + if (v >= 8) { + const auto inc = carrier_uint(1) << (shift + 4); + f.f += inc; + f.f &= ~(inc - 1); + } + + // Check long double overflow + if (!has_implicit_bit()) { + const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; + if ((f.f & implicit_bit) == implicit_bit) { + f.f >>= 4; + f.e += 4; + } + } + + print_xdigits = precision; + } + + char xdigits[num_bits() / 4]; + detail::fill_n(xdigits, sizeof(xdigits), '0'); + format_uint<4>(xdigits, f.f, num_xdigits, specs.upper); + + // Remove zero tail + while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; + + buf.push_back('0'); + buf.push_back(specs.upper ? 'X' : 'x'); + buf.push_back(xdigits[0]); + if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) + buf.push_back('.'); + buf.append(xdigits + 1, xdigits + 1 + print_xdigits); + for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0'); + + buf.push_back(specs.upper ? 'P' : 'p'); + + uint32_t abs_e; + if (f.e < 0) { + buf.push_back('-'); + abs_e = static_cast(-f.e); + } else { + buf.push_back('+'); + abs_e = static_cast(f.e); + } + format_decimal(appender(buf), abs_e, detail::count_digits(abs_e)); +} - template - FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, buffer& buf) -> int - { - // float is passed as double to reduce the number of instantiations. - static_assert(!std::is_same::value, ""); - FMT_ASSERT(value >= 0, "value is negative"); - auto converted_value = convert_float(value); - - const bool fixed = specs.format == float_format::fixed; - if (value <= 0) - { // <= instead of == to silence a warning. - if (precision <= 0 || !fixed) - { - buf.push_back('0'); - return 0; - } - buf.try_resize(to_unsigned(precision)); - fill_n(buf.data(), precision, '0'); - return -precision; - } +template ::value)> +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { + format_hexfloat(static_cast(value), precision, specs, buf); +} - int exp = 0; - bool use_dragon = true; - unsigned dragon_flags = 0; - if (!is_fast_float() || is_constant_evaluated()) - { - const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) - using info = dragonbox::float_info; - const auto f = basic_fp(converted_value); - // Compute exp, an approximate power of 10, such that - // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). - // This is based on log10(value) == log2(value) / log2(10) and approximation - // of log2(value) by e + num_fraction_bits idea from double-conversion. - auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; - exp = static_cast(e); - if (e > exp) - ++exp; // Compute ceil. - dragon_flags = dragon::fixup; - } - else if (precision < 0) - { - // Use Dragonbox for the shortest format. - if (specs.binary32) - { - auto dec = dragonbox::to_decimal(static_cast(value)); - write(buffer_appender(buf), dec.significand); - return dec.exponent; - } - auto dec = dragonbox::to_decimal(static_cast(value)); - write(buffer_appender(buf), dec.significand); - return dec.exponent; - } - else - { - // Extract significand bits and exponent bits. - using info = dragonbox::float_info; - auto br = bit_cast(static_cast(value)); - - const uint64_t significand_mask = (static_cast(1) << num_significand_bits()) - 1; - uint64_t significand = (br & significand_mask); - int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); - - if (exponent != 0) - { // Check if normal. - exponent -= exponent_bias() + num_significand_bits(); - significand |= (static_cast(1) << num_significand_bits()); - significand <<= 1; - } - else - { - // Normalize subnormal inputs. - FMT_ASSERT(significand != 0, "zeros should not appear here"); - int shift = countl_zero(significand); - FMT_ASSERT(shift >= num_bits() - num_significand_bits(), ""); - shift -= (num_bits() - num_significand_bits() - 2); - exponent = (std::numeric_limits::min_exponent - num_significand_bits()) - shift; - significand <<= shift; - } - - // Compute the first several nonzero decimal significand digits. - // We call the number we get the first segment. - const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); - exp = -k; - const int beta = exponent + dragonbox::floor_log2_pow10(k); - uint64_t first_segment; - bool has_more_segments; - int digits_in_the_first_segment; - { - const auto r = dragonbox::umul192_upper128(significand << beta, dragonbox::get_cached_power(k)); - first_segment = r.high(); - has_more_segments = r.low() != 0; - - // The first segment can have 18 ~ 19 digits. - if (first_segment >= 1000000000000000000ULL) - { - digits_in_the_first_segment = 19; - } - else - { - // When it is of 18-digits, we align it to 19-digits by adding a bogus - // zero at the end. - digits_in_the_first_segment = 18; - first_segment *= 10; - } - } - - // Compute the actual number of decimal digits to print. - if (fixed) - adjust_precision(precision, exp + digits_in_the_first_segment); - - // Use Dragon4 only when there might be not enough digits in the first - // segment. - if (digits_in_the_first_segment > precision) - { - use_dragon = false; - - if (precision <= 0) - { - exp += digits_in_the_first_segment; - - if (precision < 0) - { - // Nothing to do, since all we have are just leading zeros. - buf.try_resize(0); - } - else - { - // We may need to round-up. - buf.try_resize(1); - if ((first_segment | static_cast(has_more_segments)) > 5000000000000000000ULL) - { - buf[0] = '1'; - } - else - { - buf[0] = '0'; - } - } - } // precision <= 0 - else - { - exp += digits_in_the_first_segment - precision; - - // When precision > 0, we divide the first segment into three - // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits - // in 32-bits which usually allows faster calculation than in - // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize - // division-by-constant for large 64-bit divisors, we do it here - // manually. The magic number 7922816251426433760 below is equal to - // ceil(2^(64+32) / 10^10). - const uint32_t first_subsegment = static_cast(dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> 32); - const uint64_t second_third_subsegments = first_segment - first_subsegment * 10000000000ULL; - - uint64_t prod; - uint32_t digits; - bool should_round_up; - int number_of_digits_to_print = precision > 9 ? 9 : precision; - - // Print a 9-digits subsegment, either the first or the second. - auto print_subsegment = [&](uint32_t subsegment, char* buffer) - { - int number_of_digits_printed = 0; - - // If we want to print an odd number of digits from the subsegment, - if ((number_of_digits_to_print & 1) != 0) - { - // Convert to 64-bit fixed-point fractional form with 1-digit - // integer part. The magic number 720575941 is a good enough - // approximation of 2^(32 + 24) / 10^8; see - // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case - // for details. - prod = ((subsegment * static_cast(720575941)) >> 24) + 1; - digits = static_cast(prod >> 32); - *buffer = static_cast('0' + digits); - number_of_digits_printed++; - } - // If we want to print an even number of digits from the - // first_subsegment, - else - { - // Convert to 64-bit fixed-point fractional form with 2-digits - // integer part. The magic number 450359963 is a good enough - // approximation of 2^(32 + 20) / 10^7; see - // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case - // for details. - prod = ((subsegment * static_cast(450359963)) >> 20) + 1; - digits = static_cast(prod >> 32); - copy2(buffer, digits2(digits)); - number_of_digits_printed += 2; - } - - // Print all digit pairs. - while (number_of_digits_printed < number_of_digits_to_print) - { - prod = static_cast(prod) * static_cast(100); - digits = static_cast(prod >> 32); - copy2(buffer + number_of_digits_printed, digits2(digits)); - number_of_digits_printed += 2; - } - }; - - // Print first subsegment. - print_subsegment(first_subsegment, buf.data()); - - // Perform rounding if the first subsegment is the last subsegment to - // print. - if (precision <= 9) - { - // Rounding inside the subsegment. - // We round-up if: - // - either the fractional part is strictly larger than 1/2, or - // - the fractional part is exactly 1/2 and the last digit is odd. - // We rely on the following observations: - // - If fractional_part >= threshold, then the fractional part is - // strictly larger than 1/2. - // - If the MSB of fractional_part is set, then the fractional part - // must be at least 1/2. - // - When the MSB of fractional_part is set, either - // second_third_subsegments being nonzero or has_more_segments - // being true means there are further digits not printed, so the - // fractional part is strictly larger than 1/2. - if (precision < 9) - { - uint32_t fractional_part = static_cast(prod); - should_round_up = fractional_part >= fractional_part_rounding_thresholds(8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (second_third_subsegments != 0) | has_more_segments)) != 0; - } - // Rounding at the subsegment boundary. - // In this case, the fractional part is at least 1/2 if and only if - // second_third_subsegments >= 5000000000ULL, and is strictly larger - // than 1/2 if we further have either second_third_subsegments > - // 5000000000ULL or has_more_segments == true. - else - { - should_round_up = second_third_subsegments > 5000000000ULL || (second_third_subsegments == 5000000000ULL && ((digits & 1) != 0 || has_more_segments)); - } - } - // Otherwise, print the second subsegment. - else - { - // Compilers are not aware of how to leverage the maximum value of - // second_third_subsegments to find out a better magic number which - // allows us to eliminate an additional shift. 1844674407370955162 = - // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). - const uint32_t second_subsegment = static_cast(dragonbox::umul128_upper64(second_third_subsegments, 1844674407370955162ULL)); - const uint32_t third_subsegment = static_cast(second_third_subsegments) - second_subsegment * 10; - - number_of_digits_to_print = precision - 9; - print_subsegment(second_subsegment, buf.data() + 9); - - // Rounding inside the subsegment. - if (precision < 18) - { - // The condition third_subsegment != 0 implies that the segment was - // of 19 digits, so in this case the third segment should be - // consisting of a genuine digit from the input. - uint32_t fractional_part = static_cast(prod); - should_round_up = fractional_part >= fractional_part_rounding_thresholds(8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (third_subsegment != 0) | has_more_segments)) != 0; - } - // Rounding at the subsegment boundary. - else - { - // In this case, the segment must be of 19 digits, thus - // the third subsegment should be consisting of a genuine digit from - // the input. - should_round_up = third_subsegment > 5 || (third_subsegment == 5 && ((digits & 1) != 0 || has_more_segments)); - } - } - - // Round-up if necessary. - if (should_round_up) - { - ++buf[precision - 1]; - for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) - { - buf[i] = '0'; - ++buf[i - 1]; - } - if (buf[0] > '9') - { - buf[0] = '1'; - if (fixed) - buf[precision++] = '0'; - else - ++exp; - } - } - buf.try_resize(to_unsigned(precision)); - } - } // if (digits_in_the_first_segment > precision) - else - { - // Adjust the exponent for its use in Dragon4. - exp += digits_in_the_first_segment - 1; - } - } - if (use_dragon) - { - auto f = basic_fp(); - bool is_predecessor_closer = specs.binary32 ? f.assign(static_cast(value)) : f.assign(converted_value); - if (is_predecessor_closer) - dragon_flags |= dragon::predecessor_closer; - if (fixed) - dragon_flags |= dragon::fixed; - // Limit precision to the maximum possible number of significant digits in - // an IEEE754 double because we don't need to generate zeros. - const int max_double_digits = 767; - if (precision > max_double_digits) - precision = max_double_digits; - format_dragon(f, dragon_flags, precision, buf, exp); - } - if (!fixed && !specs.showpoint) - { - // Remove trailing zeros. - auto num_digits = buf.size(); - while (num_digits > 0 && buf[num_digits - 1] == '0') - { - --num_digits; - ++exp; - } - buf.try_resize(num_digits); - } - return exp; - } - template - FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, locale_ref loc) -> OutputIt - { - float_specs fspecs = parse_float_type_spec(specs); - fspecs.sign = specs.sign; - if (detail::signbit(value)) - { // value < 0 is false for NaN so use signbit. - fspecs.sign = sign::minus; - value = -value; - } - else if (fspecs.sign == sign::minus) - { - fspecs.sign = sign::none; - } +constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { + // For checking rounding thresholds. + // The kth entry is chosen to be the smallest integer such that the + // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. + // It is equal to ceil(2^31 + 2^32/10^(k + 1)). + // These are stored in a string literal because we cannot have static arrays + // in constexpr functions and non-static ones are poorly optimized. + return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" + U"\x800001ae\x8000002b"[index]; +} - if (!detail::isfinite(value)) - return write_nonfinite(out, detail::isnan(value), specs, fspecs); - - if (specs.align == align::numeric && fspecs.sign) - { - auto it = reserve(out, 1); - *it++ = detail::sign(fspecs.sign); - out = base_iterator(out, it); - fspecs.sign = sign::none; - if (specs.width != 0) - --specs.width; +template +FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, + buffer& buf) -> int { + // float is passed as double to reduce the number of instantiations. + static_assert(!std::is_same::value, ""); + FMT_ASSERT(value >= 0, "value is negative"); + auto converted_value = convert_float(value); + + const bool fixed = specs.format == float_format::fixed; + if (value <= 0) { // <= instead of == to silence a warning. + if (precision <= 0 || !fixed) { + buf.push_back('0'); + return 0; + } + buf.try_resize(to_unsigned(precision)); + fill_n(buf.data(), precision, '0'); + return -precision; + } + + int exp = 0; + bool use_dragon = true; + unsigned dragon_flags = 0; + if (!is_fast_float() || is_constant_evaluated()) { + const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) + using info = dragonbox::float_info; + const auto f = basic_fp(converted_value); + // Compute exp, an approximate power of 10, such that + // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). + // This is based on log10(value) == log2(value) / log2(10) and approximation + // of log2(value) by e + num_fraction_bits idea from double-conversion. + auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; + exp = static_cast(e); + if (e > exp) ++exp; // Compute ceil. + dragon_flags = dragon::fixup; + } else if (precision < 0) { + // Use Dragonbox for the shortest format. + if (specs.binary32) { + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; + } + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; + } else { + // Extract significand bits and exponent bits. + using info = dragonbox::float_info; + auto br = bit_cast(static_cast(value)); + + const uint64_t significand_mask = + (static_cast(1) << num_significand_bits()) - 1; + uint64_t significand = (br & significand_mask); + int exponent = static_cast((br & exponent_mask()) >> + num_significand_bits()); + + if (exponent != 0) { // Check if normal. + exponent -= exponent_bias() + num_significand_bits(); + significand |= + (static_cast(1) << num_significand_bits()); + significand <<= 1; + } else { + // Normalize subnormal inputs. + FMT_ASSERT(significand != 0, "zeros should not appear here"); + int shift = countl_zero(significand); + FMT_ASSERT(shift >= num_bits() - num_significand_bits(), + ""); + shift -= (num_bits() - num_significand_bits() - 2); + exponent = (std::numeric_limits::min_exponent - + num_significand_bits()) - + shift; + significand <<= shift; + } + + // Compute the first several nonzero decimal significand digits. + // We call the number we get the first segment. + const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); + exp = -k; + const int beta = exponent + dragonbox::floor_log2_pow10(k); + uint64_t first_segment; + bool has_more_segments; + int digits_in_the_first_segment; + { + const auto r = dragonbox::umul192_upper128( + significand << beta, dragonbox::get_cached_power(k)); + first_segment = r.high(); + has_more_segments = r.low() != 0; + + // The first segment can have 18 ~ 19 digits. + if (first_segment >= 1000000000000000000ULL) { + digits_in_the_first_segment = 19; + } else { + // When it is of 18-digits, we align it to 19-digits by adding a bogus + // zero at the end. + digits_in_the_first_segment = 18; + first_segment *= 10; + } + } + + // Compute the actual number of decimal digits to print. + if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment); + + // Use Dragon4 only when there might be not enough digits in the first + // segment. + if (digits_in_the_first_segment > precision) { + use_dragon = false; + + if (precision <= 0) { + exp += digits_in_the_first_segment; + + if (precision < 0) { + // Nothing to do, since all we have are just leading zeros. + buf.try_resize(0); + } else { + // We may need to round-up. + buf.try_resize(1); + if ((first_segment | static_cast(has_more_segments)) > + 5000000000000000000ULL) { + buf[0] = '1'; + } else { + buf[0] = '0'; + } } + } // precision <= 0 + else { + exp += digits_in_the_first_segment - precision; + + // When precision > 0, we divide the first segment into three + // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits + // in 32-bits which usually allows faster calculation than in + // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize + // division-by-constant for large 64-bit divisors, we do it here + // manually. The magic number 7922816251426433760 below is equal to + // ceil(2^(64+32) / 10^10). + const uint32_t first_subsegment = static_cast( + dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> + 32); + const uint64_t second_third_subsegments = + first_segment - first_subsegment * 10000000000ULL; + + uint64_t prod; + uint32_t digits; + bool should_round_up; + int number_of_digits_to_print = precision > 9 ? 9 : precision; + + // Print a 9-digits subsegment, either the first or the second. + auto print_subsegment = [&](uint32_t subsegment, char* buffer) { + int number_of_digits_printed = 0; + + // If we want to print an odd number of digits from the subsegment, + if ((number_of_digits_to_print & 1) != 0) { + // Convert to 64-bit fixed-point fractional form with 1-digit + // integer part. The magic number 720575941 is a good enough + // approximation of 2^(32 + 24) / 10^8; see + // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case + // for details. + prod = ((subsegment * static_cast(720575941)) >> 24) + 1; + digits = static_cast(prod >> 32); + *buffer = static_cast('0' + digits); + number_of_digits_printed++; + } + // If we want to print an even number of digits from the + // first_subsegment, + else { + // Convert to 64-bit fixed-point fractional form with 2-digits + // integer part. The magic number 450359963 is a good enough + // approximation of 2^(32 + 20) / 10^7; see + // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case + // for details. + prod = ((subsegment * static_cast(450359963)) >> 20) + 1; + digits = static_cast(prod >> 32); + copy2(buffer, digits2(digits)); + number_of_digits_printed += 2; + } + + // Print all digit pairs. + while (number_of_digits_printed < number_of_digits_to_print) { + prod = static_cast(prod) * static_cast(100); + digits = static_cast(prod >> 32); + copy2(buffer + number_of_digits_printed, digits2(digits)); + number_of_digits_printed += 2; + } + }; - memory_buffer buffer; - if (fspecs.format == float_format::hex) - { - if (fspecs.sign) - buffer.push_back(detail::sign(fspecs.sign)); - format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); - return write_bytes(out, {buffer.data(), buffer.size()}, specs); - } - int precision = specs.precision >= 0 || specs.type == presentation_type::none ? specs.precision : 6; - if (fspecs.format == float_format::exp) - { - if (precision == max_value()) - throw_format_error("number is too big"); - else - ++precision; + // Print first subsegment. + print_subsegment(first_subsegment, buf.data()); + + // Perform rounding if the first subsegment is the last subsegment to + // print. + if (precision <= 9) { + // Rounding inside the subsegment. + // We round-up if: + // - either the fractional part is strictly larger than 1/2, or + // - the fractional part is exactly 1/2 and the last digit is odd. + // We rely on the following observations: + // - If fractional_part >= threshold, then the fractional part is + // strictly larger than 1/2. + // - If the MSB of fractional_part is set, then the fractional part + // must be at least 1/2. + // - When the MSB of fractional_part is set, either + // second_third_subsegments being nonzero or has_more_segments + // being true means there are further digits not printed, so the + // fractional part is strictly larger than 1/2. + if (precision < 9) { + uint32_t fractional_part = static_cast(prod); + should_round_up = + fractional_part >= fractional_part_rounding_thresholds( + 8 - number_of_digits_to_print) || + ((fractional_part >> 31) & + ((digits & 1) | (second_third_subsegments != 0) | + has_more_segments)) != 0; + } + // Rounding at the subsegment boundary. + // In this case, the fractional part is at least 1/2 if and only if + // second_third_subsegments >= 5000000000ULL, and is strictly larger + // than 1/2 if we further have either second_third_subsegments > + // 5000000000ULL or has_more_segments == true. + else { + should_round_up = second_third_subsegments > 5000000000ULL || + (second_third_subsegments == 5000000000ULL && + ((digits & 1) != 0 || has_more_segments)); + } } - else if (fspecs.format != float_format::fixed && precision == 0) - { - precision = 1; + // Otherwise, print the second subsegment. + else { + // Compilers are not aware of how to leverage the maximum value of + // second_third_subsegments to find out a better magic number which + // allows us to eliminate an additional shift. 1844674407370955162 = + // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). + const uint32_t second_subsegment = + static_cast(dragonbox::umul128_upper64( + second_third_subsegments, 1844674407370955162ULL)); + const uint32_t third_subsegment = + static_cast(second_third_subsegments) - + second_subsegment * 10; + + number_of_digits_to_print = precision - 9; + print_subsegment(second_subsegment, buf.data() + 9); + + // Rounding inside the subsegment. + if (precision < 18) { + // The condition third_subsegment != 0 implies that the segment was + // of 19 digits, so in this case the third segment should be + // consisting of a genuine digit from the input. + uint32_t fractional_part = static_cast(prod); + should_round_up = + fractional_part >= fractional_part_rounding_thresholds( + 8 - number_of_digits_to_print) || + ((fractional_part >> 31) & + ((digits & 1) | (third_subsegment != 0) | + has_more_segments)) != 0; + } + // Rounding at the subsegment boundary. + else { + // In this case, the segment must be of 19 digits, thus + // the third subsegment should be consisting of a genuine digit from + // the input. + should_round_up = third_subsegment > 5 || + (third_subsegment == 5 && + ((digits & 1) != 0 || has_more_segments)); + } } - if (const_check(std::is_same())) - fspecs.binary32 = true; - int exp = format_float(convert_float(value), precision, fspecs, buffer); - fspecs.precision = precision; - auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; - return write_float(out, f, specs, fspecs, loc); - } - - template ::value)> - FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt - { - if (const_check(!is_supported_floating_point(value))) - return out; - return specs.localized && write_loc(out, value, specs, loc) ? out : write_float(out, value, specs, loc); - } - template ::value)> - FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt - { - if (is_constant_evaluated()) - return write(out, value, format_specs()); - if (const_check(!is_supported_floating_point(value))) - return out; - - auto fspecs = float_specs(); - if (detail::signbit(value)) - { - fspecs.sign = sign::minus; - value = -value; + // Round-up if necessary. + if (should_round_up) { + ++buf[precision - 1]; + for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) { + buf[i] = '0'; + ++buf[i - 1]; + } + if (buf[0] > '9') { + buf[0] = '1'; + if (fixed) + buf[precision++] = '0'; + else + ++exp; + } } + buf.try_resize(to_unsigned(precision)); + } + } // if (digits_in_the_first_segment > precision) + else { + // Adjust the exponent for its use in Dragon4. + exp += digits_in_the_first_segment - 1; + } + } + if (use_dragon) { + auto f = basic_fp(); + bool is_predecessor_closer = specs.binary32 + ? f.assign(static_cast(value)) + : f.assign(converted_value); + if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; + if (fixed) dragon_flags |= dragon::fixed; + // Limit precision to the maximum possible number of significant digits in + // an IEEE754 double because we don't need to generate zeros. + const int max_double_digits = 767; + if (precision > max_double_digits) precision = max_double_digits; + format_dragon(f, dragon_flags, precision, buf, exp); + } + if (!fixed && !specs.showpoint) { + // Remove trailing zeros. + auto num_digits = buf.size(); + while (num_digits > 0 && buf[num_digits - 1] == '0') { + --num_digits; + ++exp; + } + buf.try_resize(num_digits); + } + return exp; +} +template +FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, + format_specs specs, locale_ref loc) + -> OutputIt { + float_specs fspecs = parse_float_type_spec(specs); + fspecs.sign = specs.sign; + if (detail::signbit(value)) { // value < 0 is false for NaN so use signbit. + fspecs.sign = sign::minus; + value = -value; + } else if (fspecs.sign == sign::minus) { + fspecs.sign = sign::none; + } + + if (!detail::isfinite(value)) + return write_nonfinite(out, detail::isnan(value), specs, fspecs); + + if (specs.align == align::numeric && fspecs.sign) { + auto it = reserve(out, 1); + *it++ = detail::sign(fspecs.sign); + out = base_iterator(out, it); + fspecs.sign = sign::none; + if (specs.width != 0) --specs.width; + } + + memory_buffer buffer; + if (fspecs.format == float_format::hex) { + if (fspecs.sign) buffer.push_back(detail::sign(fspecs.sign)); + format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); + return write_bytes(out, {buffer.data(), buffer.size()}, + specs); + } + int precision = specs.precision >= 0 || specs.type == presentation_type::none + ? specs.precision + : 6; + if (fspecs.format == float_format::exp) { + if (precision == max_value()) + throw_format_error("number is too big"); + else + ++precision; + } else if (fspecs.format != float_format::fixed && precision == 0) { + precision = 1; + } + if (const_check(std::is_same())) fspecs.binary32 = true; + int exp = format_float(convert_float(value), precision, fspecs, buffer); + fspecs.precision = precision; + auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; + return write_float(out, f, specs, fspecs, loc); +} - constexpr auto specs = format_specs(); - using floaty = conditional_t::value, double, T>; - using floaty_uint = typename dragonbox::float_info::carrier_uint; - floaty_uint mask = exponent_mask(); - if ((bit_cast(value) & mask) == mask) - return write_nonfinite(out, std::isnan(value), specs, fspecs); - - auto dec = dragonbox::to_decimal(static_cast(value)); - return write_float(out, dec, specs, fspecs, {}); - } - - template ::value && !is_fast_float::value)> - inline auto write(OutputIt out, T value) -> OutputIt - { - return write(out, value, format_specs()); - } - - template - auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt - { - FMT_ASSERT(false, ""); - return out; - } - - template - FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) -> OutputIt - { - auto it = reserve(out, value.size()); - it = copy_str_noinline(value.begin(), value.end(), it); - return base_iterator(out, it); - } +template ::value)> +FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, + locale_ref loc = {}) -> OutputIt { + if (const_check(!is_supported_floating_point(value))) return out; + return specs.localized && write_loc(out, value, specs, loc) + ? out + : write_float(out, value, specs, loc); +} - template ::value)> - constexpr auto write(OutputIt out, const T& value) -> OutputIt - { - return write(out, to_string_view(value)); - } +template ::value)> +FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { + if (is_constant_evaluated()) return write(out, value, format_specs()); + if (const_check(!is_supported_floating_point(value))) return out; + + auto fspecs = float_specs(); + if (detail::signbit(value)) { + fspecs.sign = sign::minus; + value = -value; + } + + constexpr auto specs = format_specs(); + using floaty = conditional_t::value, double, T>; + using floaty_uint = typename dragonbox::float_info::carrier_uint; + floaty_uint mask = exponent_mask(); + if ((bit_cast(value) & mask) == mask) + return write_nonfinite(out, std::isnan(value), specs, fspecs); + + auto dec = dragonbox::to_decimal(static_cast(value)); + return write_float(out, dec, specs, fspecs, {}); +} - // FMT_ENABLE_IF() condition separated to workaround an MSVC bug. - template ::value && !std::is_same::value && mapped_type_constant>::value != type::custom_type, FMT_ENABLE_IF(check)> - FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt - { - return write(out, static_cast>(value)); - } +template ::value && + !is_fast_float::value)> +inline auto write(OutputIt out, T value) -> OutputIt { + return write(out, value, format_specs()); +} - template ::value)> - FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt - { - return specs.type != presentation_type::none && specs.type != presentation_type::string ? write(out, value ? 1 : 0, specs, {}) : write_bytes(out, value ? "true" : "false", specs); - } +template +auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) + -> OutputIt { + FMT_ASSERT(false, ""); + return out; +} - template - FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt - { - auto it = reserve(out, 1); - *it++ = value; - return base_iterator(out, it); - } +template +FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) + -> OutputIt { + auto it = reserve(out, value.size()); + it = copy_str_noinline(value.begin(), value.end(), it); + return base_iterator(out, it); +} - template - FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value) -> OutputIt - { - if (value) - return write(out, basic_string_view(value)); - throw_format_error("string pointer is null"); - return out; - } +template ::value)> +constexpr auto write(OutputIt out, const T& value) -> OutputIt { + return write(out, to_string_view(value)); +} - template ::value)> - auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt - { - return write_ptr(out, bit_cast(value), &specs); - } +// FMT_ENABLE_IF() condition separated to workaround an MSVC bug. +template < + typename Char, typename OutputIt, typename T, + bool check = + std::is_enum::value && !std::is_same::value && + mapped_type_constant>::value != + type::custom_type, + FMT_ENABLE_IF(check)> +FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { + return write(out, static_cast>(value)); +} - // A write overload that handles implicit conversions. - template > - FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t::value && !is_string::value && !is_floating_point::value && !std::is_same::value && !std::is_same().map(value))>>::value, OutputIt> - { - return write(out, arg_mapper().map(value)); - } +template ::value)> +FMT_CONSTEXPR auto write(OutputIt out, T value, + const format_specs& specs = {}, locale_ref = {}) + -> OutputIt { + return specs.type != presentation_type::none && + specs.type != presentation_type::string + ? write(out, value ? 1 : 0, specs, {}) + : write_bytes(out, value ? "true" : "false", specs); +} - template > - FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t::value == type::custom_type, OutputIt> - { - auto formatter = typename Context::template formatter_type(); - auto parse_ctx = typename Context::parse_context_type({}); - formatter.parse(parse_ctx); - auto ctx = Context(out, {}, {}); - return formatter.format(value, ctx); - } +template +FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { + auto it = reserve(out, 1); + *it++ = value; + return base_iterator(out, it); +} - // An argument visitor that formats the argument and writes it via the output - // iterator. It's a class and not a generic lambda for compatibility with C++11. - template - struct default_arg_formatter { - using iterator = buffer_appender; - using context = buffer_context; - - iterator out; - basic_format_args args; - locale_ref loc; - - template - auto operator()(T value) -> iterator - { - return write(out, value); - } - auto operator()(typename basic_format_arg::handle h) -> iterator - { - basic_format_parse_context parse_ctx({}); - context format_ctx(out, args, loc); - h.format(parse_ctx, format_ctx); - return format_ctx.out(); - } - }; +template +FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value) + -> OutputIt { + if (value) return write(out, basic_string_view(value)); + throw_format_error("string pointer is null"); + return out; +} - template - struct arg_formatter { - using iterator = buffer_appender; - using context = buffer_context; +template ::value)> +auto write(OutputIt out, const T* value, const format_specs& specs = {}, + locale_ref = {}) -> OutputIt { + return write_ptr(out, bit_cast(value), &specs); +} - iterator out; - const format_specs& specs; - locale_ref locale; +// A write overload that handles implicit conversions. +template > +FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< + std::is_class::value && !is_string::value && + !is_floating_point::value && !std::is_same::value && + !std::is_same().map( + value))>>::value, + OutputIt> { + return write(out, arg_mapper().map(value)); +} - template - FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator - { - return detail::write(out, value, specs, locale); - } - auto operator()(typename basic_format_arg::handle) -> iterator - { - // User-defined types are handled separately because they require access - // to the parse context. - return out; - } - }; +template > +FMT_CONSTEXPR auto write(OutputIt out, const T& value) + -> enable_if_t::value == type::custom_type, + OutputIt> { + auto formatter = typename Context::template formatter_type(); + auto parse_ctx = typename Context::parse_context_type({}); + formatter.parse(parse_ctx); + auto ctx = Context(out, {}, {}); + return formatter.format(value, ctx); +} - struct width_checker { - template ::value)> - FMT_CONSTEXPR auto operator()(T value) -> unsigned long long - { - if (is_negative(value)) - throw_format_error("negative width"); - return static_cast(value); - } +// An argument visitor that formats the argument and writes it via the output +// iterator. It's a class and not a generic lambda for compatibility with C++11. +template struct default_arg_formatter { + using iterator = buffer_appender; + using context = buffer_context; + + iterator out; + basic_format_args args; + locale_ref loc; + + template auto operator()(T value) -> iterator { + return write(out, value); + } + auto operator()(typename basic_format_arg::handle h) -> iterator { + basic_format_parse_context parse_ctx({}); + context format_ctx(out, args, loc); + h.format(parse_ctx, format_ctx); + return format_ctx.out(); + } +}; - template ::value)> - FMT_CONSTEXPR auto operator()(T) -> unsigned long long - { - throw_format_error("width is not integer"); - return 0; - } - }; +template struct arg_formatter { + using iterator = buffer_appender; + using context = buffer_context; + + iterator out; + const format_specs& specs; + locale_ref locale; + + template + FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator { + return detail::write(out, value, specs, locale); + } + auto operator()(typename basic_format_arg::handle) -> iterator { + // User-defined types are handled separately because they require access + // to the parse context. + return out; + } +}; - struct precision_checker { - template ::value)> - FMT_CONSTEXPR auto operator()(T value) -> unsigned long long - { - if (is_negative(value)) - throw_format_error("negative precision"); - return static_cast(value); - } +struct width_checker { + template ::value)> + FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { + if (is_negative(value)) throw_format_error("negative width"); + return static_cast(value); + } + + template ::value)> + FMT_CONSTEXPR auto operator()(T) -> unsigned long long { + throw_format_error("width is not integer"); + return 0; + } +}; - template ::value)> - FMT_CONSTEXPR auto operator()(T) -> unsigned long long - { - throw_format_error("precision is not integer"); - return 0; - } - }; +struct precision_checker { + template ::value)> + FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { + if (is_negative(value)) throw_format_error("negative precision"); + return static_cast(value); + } + + template ::value)> + FMT_CONSTEXPR auto operator()(T) -> unsigned long long { + throw_format_error("precision is not integer"); + return 0; + } +}; - template - FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int - { - unsigned long long value = visit_format_arg(Handler(), arg); - if (value > to_unsigned(max_value())) - throw_format_error("number is too big"); - return static_cast(value); - } +template +FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int { + unsigned long long value = visit_format_arg(Handler(), arg); + if (value > to_unsigned(max_value())) + throw_format_error("number is too big"); + return static_cast(value); +} - template - FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) - { - auto arg = ctx.arg(id); - if (!arg) - ctx.on_error("argument not found"); - return arg; - } +template +FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) { + auto arg = ctx.arg(id); + if (!arg) ctx.on_error("argument not found"); + return arg; +} - template - FMT_CONSTEXPR void handle_dynamic_spec(int& value, arg_ref ref, Context& ctx) - { - switch (ref.kind) - { - case arg_id_kind::none: - break; - case arg_id_kind::index: - value = detail::get_dynamic_spec(get_arg(ctx, ref.val.index)); - break; - case arg_id_kind::name: - value = detail::get_dynamic_spec(get_arg(ctx, ref.val.name)); - break; - } - } +template +FMT_CONSTEXPR void handle_dynamic_spec(int& value, + arg_ref ref, + Context& ctx) { + switch (ref.kind) { + case arg_id_kind::none: + break; + case arg_id_kind::index: + value = detail::get_dynamic_spec(get_arg(ctx, ref.val.index)); + break; + case arg_id_kind::name: + value = detail::get_dynamic_spec(get_arg(ctx, ref.val.name)); + break; + } +} #if FMT_USE_USER_DEFINED_LITERALS -#if FMT_USE_NONTYPE_TEMPLATE_ARGS - template Str> - struct statically_named_arg : view { - static constexpr auto name = Str.data; - - const T& value; - statically_named_arg(const T& v) : value(v) {} - }; - - template Str> - struct is_named_arg> : std::true_type {}; - - template Str> - struct is_statically_named_arg> : std::true_type {}; +# if FMT_USE_NONTYPE_TEMPLATE_ARGS +template Str> +struct statically_named_arg : view { + static constexpr auto name = Str.data; + + const T& value; + statically_named_arg(const T& v) : value(v) {} +}; - template Str> - struct udl_arg { - template - auto operator=(T&& value) const - { - return statically_named_arg(std::forward(value)); - } - }; -#else - template - struct udl_arg { - const Char* str; - - template - auto operator=(T&& value) const -> named_arg - { - return {str, std::forward(value)}; - } - }; -#endif -#endif // FMT_USE_USER_DEFINED_LITERALS +template Str> +struct is_named_arg> : std::true_type {}; + +template Str> +struct is_statically_named_arg> + : std::true_type {}; + +template Str> +struct udl_arg { + template auto operator=(T&& value) const { + return statically_named_arg(std::forward(value)); + } +}; +# else +template struct udl_arg { + const Char* str; - template - auto vformat(const Locale& loc, basic_string_view fmt, basic_format_args>> args) -> std::basic_string - { - auto buf = basic_memory_buffer(); - detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); - return {buf.data(), buf.size()}; - } + template auto operator=(T&& value) const -> named_arg { + return {str, std::forward(value)}; + } +}; +# endif +#endif // FMT_USE_USER_DEFINED_LITERALS + +template +auto vformat(const Locale& loc, basic_string_view fmt, + basic_format_args>> args) + -> std::basic_string { + auto buf = basic_memory_buffer(); + detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); + return {buf.data(), buf.size()}; +} - using format_func = void (*)(detail::buffer&, int, const char*); +using format_func = void (*)(detail::buffer&, int, const char*); - FMT_API void format_error_code(buffer& out, int error_code, string_view message) noexcept; +FMT_API void format_error_code(buffer& out, int error_code, + string_view message) noexcept; - FMT_API void report_error(format_func func, int error_code, const char* message) noexcept; -} // namespace detail +FMT_API void report_error(format_func func, int error_code, + const char* message) noexcept; +} // namespace detail -FMT_API auto vsystem_error(int error_code, string_view format_str, format_args args) -> std::system_error; +FMT_API auto vsystem_error(int error_code, string_view format_str, + format_args args) -> std::system_error; /** \rst @@ -4184,9 +3938,9 @@ FMT_API auto vsystem_error(int error_code, string_view format_str, format_args a \endrst */ template -auto system_error(int error_code, format_string fmt, T&&... args) -> std::system_error -{ - return vsystem_error(error_code, fmt, fmt::make_format_args(args...)); +auto system_error(int error_code, format_string fmt, T&&... args) + -> std::system_error { + return vsystem_error(error_code, fmt, fmt::make_format_args(args...)); } /** @@ -4205,7 +3959,8 @@ auto system_error(int error_code, format_string fmt, T&&... args) -> std:: *error_code* is a system error code as given by ``errno``. \endrst */ -FMT_API void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept; +FMT_API void format_system_error(detail::buffer& out, int error_code, + const char* message) noexcept; // Reports a system error without throwing an exception. // Can be used to report errors from destructors. @@ -4213,81 +3968,77 @@ FMT_API void report_system_error(int error_code, const char* message) noexcept; /** Fast integer formatter. */ class format_int { -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_; - - template - auto format_unsigned(UInt value) -> char* - { - auto n = static_cast>(value); - return detail::format_decimal(buffer_, n, buffer_size - 1).begin; - } - - template - auto format_signed(Int value) -> char* - { - auto abs_value = static_cast>(value); - bool negative = value < 0; - if (negative) - abs_value = 0 - abs_value; - auto begin = format_unsigned(abs_value); - if (negative) - *--begin = '-'; - return begin; - } - -public: - explicit format_int(int value) : str_(format_signed(value)) {} - explicit format_int(long value) : str_(format_signed(value)) {} - explicit format_int(long long value) : str_(format_signed(value)) {} - explicit format_int(unsigned value) : str_(format_unsigned(value)) {} - explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} - explicit format_int(unsigned long long value) : str_(format_unsigned(value)) {} - - /** Returns the number of characters written to the output buffer. */ - auto size() const -> size_t { return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } - - /** - Returns a pointer to the output buffer content. No terminating null - character is appended. - */ - auto data() const -> const char* { return str_; } - - /** - Returns a pointer to the output buffer content with terminating null - character appended. - */ - auto c_str() const -> const char* - { - buffer_[buffer_size - 1] = '\0'; - return str_; - } - - /** - \rst - Returns the content of the output buffer as an ``std::string``. - \endrst - */ - auto str() const -> std::string { return std::string(str_, size()); } + 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_; + + template auto format_unsigned(UInt value) -> char* { + auto n = static_cast>(value); + return detail::format_decimal(buffer_, n, buffer_size - 1).begin; + } + + template auto format_signed(Int value) -> char* { + auto abs_value = static_cast>(value); + bool negative = value < 0; + if (negative) abs_value = 0 - abs_value; + auto begin = format_unsigned(abs_value); + if (negative) *--begin = '-'; + return begin; + } + + public: + explicit format_int(int value) : str_(format_signed(value)) {} + explicit format_int(long value) : str_(format_signed(value)) {} + explicit format_int(long long value) : str_(format_signed(value)) {} + explicit format_int(unsigned value) : str_(format_unsigned(value)) {} + explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} + explicit format_int(unsigned long long value) + : str_(format_unsigned(value)) {} + + /** Returns the number of characters written to the output buffer. */ + auto size() const -> size_t { + return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); + } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + auto data() const -> const char* { return str_; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + auto c_str() const -> const char* { + buffer_[buffer_size - 1] = '\0'; + return str_; + } + + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + auto str() const -> std::string { return std::string(str_, size()); } }; template -struct formatter::value>> : formatter, Char> { - template - auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) - { - using base = formatter, Char>; - return base::format(format_as(value), ctx); - } +struct formatter::value>> + : formatter, Char> { + template + auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { + using base = formatter, Char>; + return base::format(format_as(value), ctx); + } }; -#define FMT_FORMAT_AS(Type, Base) \ - template \ - struct formatter : formatter {} +#define FMT_FORMAT_AS(Type, Base) \ + template \ + struct formatter : formatter {} FMT_FORMAT_AS(signed char, int); FMT_FORMAT_AS(unsigned char, unsigned); @@ -4313,21 +4064,16 @@ struct formatter : formatter, Char> {}; auto s = fmt::format("{}", fmt::ptr(p)); \endrst */ -template -auto ptr(T p) -> const void* -{ - static_assert(std::is_pointer::value, ""); - return detail::bit_cast(p); +template auto ptr(T p) -> const void* { + static_assert(std::is_pointer::value, ""); + return detail::bit_cast(p); } template -auto ptr(const std::unique_ptr& p) -> const void* -{ - return p.get(); +auto ptr(const std::unique_ptr& p) -> const void* { + return p.get(); } -template -auto ptr(const std::shared_ptr& p) -> const void* -{ - return p.get(); +template auto ptr(const std::shared_ptr& p) -> const void* { + return p.get(); } /** @@ -4341,54 +4087,50 @@ auto ptr(const std::shared_ptr& p) -> const void* \endrst */ template -constexpr auto underlying(Enum e) noexcept -> underlying_t -{ - return static_cast>(e); +constexpr auto underlying(Enum e) noexcept -> underlying_t { + return static_cast>(e); } -namespace enums -{ - template ::value)> - constexpr auto format_as(Enum e) noexcept -> underlying_t - { - return static_cast>(e); - } -} // namespace enums +namespace enums { +template ::value)> +constexpr auto format_as(Enum e) noexcept -> underlying_t { + return static_cast>(e); +} +} // namespace enums class bytes { -private: - string_view data_; - friend struct formatter; + private: + string_view data_; + friend struct formatter; -public: - explicit bytes(string_view data) : data_(data) {} + public: + explicit bytes(string_view data) : data_(data) {} }; -template <> -struct formatter { -private: - detail::dynamic_format_specs<> specs_; - -public: - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* - { - return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::string_type); - } - - template - auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) - { - detail::handle_dynamic_spec(specs_.width, specs_.width_ref, ctx); - detail::handle_dynamic_spec(specs_.precision, specs_.precision_ref, ctx); - return detail::write_bytes(ctx.out(), b.data_, specs_); - } +template <> struct formatter { + private: + detail::dynamic_format_specs<> specs_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { + return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, + detail::type::string_type); + } + + template + auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) { + detail::handle_dynamic_spec(specs_.width, + specs_.width_ref, ctx); + detail::handle_dynamic_spec( + specs_.precision, specs_.precision_ref, ctx); + return detail::write_bytes(ctx.out(), b.data_, specs_); + } }; // group_digits_view is not derived from view because it copies the argument. -template -struct group_digits_view { - T value; +template struct group_digits_view { + T value; }; /** @@ -4402,131 +4144,132 @@ struct group_digits_view { // Output: "12,345" \endrst */ -template -auto group_digits(T value) -> group_digits_view -{ - return {value}; +template auto group_digits(T value) -> group_digits_view { + return {value}; } -template -struct formatter> : formatter { -private: - detail::dynamic_format_specs<> specs_; - -public: - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* - { - return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::int_type); - } - - template - auto format(group_digits_view t, FormatContext& ctx) -> decltype(ctx.out()) - { - detail::handle_dynamic_spec(specs_.width, specs_.width_ref, ctx); - detail::handle_dynamic_spec(specs_.precision, specs_.precision_ref, ctx); - return detail::write_int(ctx.out(), static_cast>(t.value), 0, specs_, detail::digit_grouping("\3", ",")); - } +template struct formatter> : formatter { + private: + detail::dynamic_format_specs<> specs_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* { + return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, + detail::type::int_type); + } + + template + auto format(group_digits_view t, FormatContext& ctx) + -> decltype(ctx.out()) { + detail::handle_dynamic_spec(specs_.width, + specs_.width_ref, ctx); + detail::handle_dynamic_spec( + specs_.precision, specs_.precision_ref, ctx); + return detail::write_int( + ctx.out(), static_cast>(t.value), 0, specs_, + detail::digit_grouping("\3", ",")); + } }; -template -struct nested_view { - const formatter* fmt; - const T* value; +template struct nested_view { + const formatter* fmt; + const T* value; }; -template -struct formatter> { - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { return ctx.begin(); } - auto format(nested_view view, format_context& ctx) const -> decltype(ctx.out()) { return view.fmt->format(*view.value, ctx); } +template struct formatter> { + FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { + return ctx.begin(); + } + auto format(nested_view view, format_context& ctx) const + -> decltype(ctx.out()) { + return view.fmt->format(*view.value, ctx); + } }; -template -struct nested_formatter { -private: - int width_; - detail::fill_t fill_; - align_t align_ : 4; - formatter formatter_; - -public: - constexpr nested_formatter() : width_(0), align_(align_t::none) {} - - FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* - { - auto specs = detail::dynamic_format_specs(); - auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx, detail::type::none_type); - width_ = specs.width; - fill_ = specs.fill; - align_ = specs.align; - ctx.advance_to(it); - return formatter_.parse(ctx); - } - - template - auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) - { - if (width_ == 0) - return write(ctx.out()); - auto buf = memory_buffer(); - write(std::back_inserter(buf)); - auto specs = format_specs<>(); - specs.width = width_; - specs.fill = fill_; - specs.align = align_; - return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs); - } - - auto nested(const T& value) const -> nested_view { return nested_view{&formatter_, &value}; } +template struct nested_formatter { + private: + int width_; + detail::fill_t fill_; + align_t align_ : 4; + formatter formatter_; + + public: + constexpr nested_formatter() : width_(0), align_(align_t::none) {} + + FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* { + auto specs = detail::dynamic_format_specs(); + auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx, + detail::type::none_type); + width_ = specs.width; + fill_ = specs.fill; + align_ = specs.align; + ctx.advance_to(it); + return formatter_.parse(ctx); + } + + template + auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) { + if (width_ == 0) return write(ctx.out()); + auto buf = memory_buffer(); + write(std::back_inserter(buf)); + auto specs = format_specs<>(); + specs.width = width_; + specs.fill = fill_; + specs.align = align_; + return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs); + } + + auto nested(const T& value) const -> nested_view { + return nested_view{&formatter_, &value}; + } }; // DEPRECATED! join_view will be moved to ranges.h. template struct join_view : detail::view { - It begin; - Sentinel end; - basic_string_view sep; + It begin; + Sentinel end; + basic_string_view sep; - join_view(It b, Sentinel e, basic_string_view s) : begin(b), end(e), sep(s) {} + join_view(It b, Sentinel e, basic_string_view s) + : begin(b), end(e), sep(s) {} }; template struct formatter, Char> { -private: - using value_type = + private: + using value_type = #ifdef __cpp_lib_ranges - std::iter_value_t; + std::iter_value_t; #else - typename std::iterator_traits::value_type; + typename std::iterator_traits::value_type; #endif - formatter, Char> value_formatter_; - -public: - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* - { - return value_formatter_.parse(ctx); - } - - template - auto format(const join_view& value, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto it = value.begin; - auto out = ctx.out(); - if (it != value.end) - { - out = value_formatter_.format(*it, ctx); - ++it; - while (it != value.end) - { - out = detail::copy_str(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); - out = value_formatter_.format(*it, ctx); - ++it; - } - } - return out; - } + formatter, Char> value_formatter_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + return value_formatter_.parse(ctx); + } + + template + auto format(const join_view& value, + FormatContext& ctx) const -> decltype(ctx.out()) { + auto it = value.begin; + auto out = ctx.out(); + if (it != value.end) { + out = value_formatter_.format(*it, ctx); + ++it; + while (it != value.end) { + out = detail::copy_str(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + out = value_formatter_.format(*it, ctx); + ++it; + } + } + return out; + } }; /** @@ -4534,9 +4277,8 @@ struct formatter, Char> { separated by `sep`. */ template -auto join(It begin, Sentinel end, string_view sep) -> join_view -{ - return {begin, end, sep}; +auto join(It begin, Sentinel end, string_view sep) -> join_view { + return {begin, end, sep}; } /** @@ -4556,9 +4298,9 @@ auto join(It begin, Sentinel end, string_view sep) -> join_view \endrst */ template -auto join(Range&& range, string_view sep) -> join_view, detail::sentinel_t> -{ - return join(std::begin(range), std::end(range), sep); +auto join(Range&& range, string_view sep) + -> join_view, detail::sentinel_t> { + return join(std::begin(range), std::end(range), sep); } /** @@ -4572,120 +4314,127 @@ auto join(Range&& range, string_view sep) -> join_view std::string answer = fmt::to_string(42); \endrst */ -template ::value && !detail::has_format_as::value)> -inline auto to_string(const T& value) -> std::string -{ - auto buffer = memory_buffer(); - detail::write(appender(buffer), value); - return {buffer.data(), buffer.size()}; +template ::value && + !detail::has_format_as::value)> +inline auto to_string(const T& value) -> std::string { + auto buffer = memory_buffer(); + detail::write(appender(buffer), value); + return {buffer.data(), buffer.size()}; } template ::value)> -FMT_NODISCARD inline auto to_string(T value) -> std::string -{ - // The buffer should be large enough to store the number including the sign - // or "false" for bool. - constexpr int max_size = detail::digits10() + 2; - char buffer[max_size > 5 ? static_cast(max_size) : 5]; - char* begin = buffer; - return std::string(begin, detail::write(begin, value)); +FMT_NODISCARD inline auto to_string(T value) -> std::string { + // The buffer should be large enough to store the number including the sign + // or "false" for bool. + constexpr int max_size = detail::digits10() + 2; + char buffer[max_size > 5 ? static_cast(max_size) : 5]; + char* begin = buffer; + return std::string(begin, detail::write(begin, value)); } template -FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) -> std::basic_string -{ - auto size = buf.size(); - detail::assume(size < std::basic_string().max_size()); - return std::basic_string(buf.data(), size); +FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) + -> std::basic_string { + auto size = buf.size(); + detail::assume(size < std::basic_string().max_size()); + return std::basic_string(buf.data(), size); } -template ::value && detail::has_format_as::value)> -inline auto to_string(const T& value) -> std::string -{ - return to_string(format_as(value)); +template ::value && + detail::has_format_as::value)> +inline auto to_string(const T& value) -> std::string { + return to_string(format_as(value)); } FMT_END_EXPORT -namespace detail -{ - - template - void vformat_to(buffer& buf, basic_string_view fmt, typename vformat_args::type args, locale_ref loc) - { - auto out = buffer_appender(buf); - if (fmt.size() == 2 && equal2(fmt.data(), "{}")) - { - auto arg = args.get(0); - if (!arg) - throw_format_error("argument not found"); - visit_format_arg(default_arg_formatter{out, args, loc}, arg); - return; - } - - struct format_handler : error_handler { - basic_format_parse_context parse_context; - buffer_context context; - - format_handler(buffer_appender p_out, basic_string_view str, basic_format_args> p_args, locale_ref p_loc) : parse_context(str), context(p_out, p_args, p_loc) {} - - void on_text(const Char* begin, const Char* end) - { - auto text = basic_string_view(begin, to_unsigned(end - begin)); - context.advance_to(write(context.out(), text)); - } - - FMT_CONSTEXPR auto on_arg_id() -> int { return parse_context.next_arg_id(); } - FMT_CONSTEXPR auto on_arg_id(int id) -> int { return parse_context.check_arg_id(id), id; } - FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int - { - int arg_id = context.arg_id(id); - if (arg_id < 0) - throw_format_error("argument not found"); - return arg_id; - } - - FMT_INLINE void on_replacement_field(int id, const Char*) - { - auto arg = get_arg(context, id); - context.advance_to(visit_format_arg(default_arg_formatter{context.out(), context.args(), context.locale()}, arg)); - } - - auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* - { - auto arg = get_arg(context, id); - // Not using a visitor for custom types gives better codegen. - if (arg.format_custom(begin, parse_context, context)) - return parse_context.begin(); - auto specs = detail::dynamic_format_specs(); - begin = parse_format_specs(begin, end, specs, parse_context, arg.type()); - detail::handle_dynamic_spec(specs.width, specs.width_ref, context); - detail::handle_dynamic_spec(specs.precision, specs.precision_ref, context); - if (begin == end || *begin != '}') - throw_format_error("missing '}' in format string"); - auto f = arg_formatter{context.out(), specs, context.locale()}; - context.advance_to(visit_format_arg(f, arg)); - return begin; - } - }; - detail::parse_format_string(fmt, format_handler(out, fmt, args, loc)); - } +namespace detail { + +template +void vformat_to(buffer& buf, basic_string_view fmt, + typename vformat_args::type args, locale_ref loc) { + auto out = buffer_appender(buf); + if (fmt.size() == 2 && equal2(fmt.data(), "{}")) { + auto arg = args.get(0); + if (!arg) throw_format_error("argument not found"); + visit_format_arg(default_arg_formatter{out, args, loc}, arg); + return; + } + + struct format_handler : error_handler { + basic_format_parse_context parse_context; + buffer_context context; + + format_handler(buffer_appender p_out, basic_string_view str, + basic_format_args> p_args, + locale_ref p_loc) + : parse_context(str), context(p_out, p_args, p_loc) {} + + void on_text(const Char* begin, const Char* end) { + auto text = basic_string_view(begin, to_unsigned(end - begin)); + context.advance_to(write(context.out(), text)); + } + + FMT_CONSTEXPR auto on_arg_id() -> int { + return parse_context.next_arg_id(); + } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return parse_context.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { + int arg_id = context.arg_id(id); + if (arg_id < 0) throw_format_error("argument not found"); + return arg_id; + } + + FMT_INLINE void on_replacement_field(int id, const Char*) { + auto arg = get_arg(context, id); + context.advance_to(visit_format_arg( + default_arg_formatter{context.out(), context.args(), + context.locale()}, + arg)); + } + + auto on_format_specs(int id, const Char* begin, const Char* end) + -> const Char* { + auto arg = get_arg(context, id); + // Not using a visitor for custom types gives better codegen. + if (arg.format_custom(begin, parse_context, context)) + return parse_context.begin(); + auto specs = detail::dynamic_format_specs(); + begin = parse_format_specs(begin, end, specs, parse_context, arg.type()); + detail::handle_dynamic_spec( + specs.width, specs.width_ref, context); + detail::handle_dynamic_spec( + specs.precision, specs.precision_ref, context); + if (begin == end || *begin != '}') + throw_format_error("missing '}' in format string"); + auto f = arg_formatter{context.out(), specs, context.locale()}; + context.advance_to(visit_format_arg(f, arg)); + return begin; + } + }; + detail::parse_format_string(fmt, format_handler(out, fmt, args, loc)); +} - FMT_BEGIN_EXPORT +FMT_BEGIN_EXPORT #ifndef FMT_HEADER_ONLY - extern template FMT_API void vformat_to(buffer&, string_view, typename vformat_args<>::type, locale_ref); - extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; - extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; - extern template FMT_API auto decimal_point_impl(locale_ref) -> char; - extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; -#endif // FMT_HEADER_ONLY - -} // namespace detail +extern template FMT_API void vformat_to(buffer&, string_view, + typename vformat_args<>::type, + locale_ref); +extern template FMT_API auto thousands_sep_impl(locale_ref) + -> thousands_sep_result; +extern template FMT_API auto thousands_sep_impl(locale_ref) + -> thousands_sep_result; +extern template FMT_API auto decimal_point_impl(locale_ref) -> char; +extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; +#endif // FMT_HEADER_ONLY + +} // namespace detail #if FMT_USE_USER_DEFINED_LITERALS -inline namespace literals -{ +inline namespace literals { /** \rst User-defined literal equivalent of :func:`fmt::arg`. @@ -4696,77 +4445,91 @@ inline namespace literals fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); \endrst */ -#if FMT_USE_NONTYPE_TEMPLATE_ARGS - template - constexpr auto operator""_a() - { - using char_t = remove_cvref_t; - return detail::udl_arg(); - } -#else - constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg { return {s}; } -#endif -} // namespace literals -#endif // FMT_USE_USER_DEFINED_LITERALS +# if FMT_USE_NONTYPE_TEMPLATE_ARGS +template constexpr auto operator""_a() { + using char_t = remove_cvref_t; + return detail::udl_arg(); +} +# else +constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg { + return {s}; +} +# endif +} // namespace literals +#endif // FMT_USE_USER_DEFINED_LITERALS template ::value)> -inline auto vformat(const Locale& loc, string_view fmt, format_args args) -> std::string -{ - return detail::vformat(loc, fmt, args); +inline auto vformat(const Locale& loc, string_view fmt, format_args args) + -> std::string { + return detail::vformat(loc, fmt, args); } -template ::value)> -inline auto format(const Locale& loc, format_string fmt, T&&... args) -> std::string -{ - return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...)); +template ::value)> +inline auto format(const Locale& loc, format_string fmt, T&&... args) + -> std::string { + return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...)); } -template ::value&& detail::is_locale::value)> -auto vformat_to(OutputIt out, const Locale& loc, string_view fmt, format_args args) -> OutputIt -{ - using detail::get_buffer; - auto&& buf = get_buffer(out); - detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); - return detail::get_iterator(buf, out); +template ::value&& + detail::is_locale::value)> +auto vformat_to(OutputIt out, const Locale& loc, string_view fmt, + format_args args) -> OutputIt { + using detail::get_buffer; + auto&& buf = get_buffer(out); + detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); + return detail::get_iterator(buf, out); } -template ::value&& detail::is_locale::value)> -FMT_INLINE auto format_to(OutputIt out, const Locale& loc, format_string fmt, T&&... args) -> OutputIt -{ - return vformat_to(out, loc, fmt, fmt::make_format_args(args...)); +template ::value&& + detail::is_locale::value)> +FMT_INLINE auto format_to(OutputIt out, const Locale& loc, + format_string fmt, T&&... args) -> OutputIt { + return vformat_to(out, loc, fmt, fmt::make_format_args(args...)); } -template ::value)> -FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc, format_string fmt, T&&... args) -> size_t -{ - auto buf = detail::counting_buffer<>(); - detail::vformat_to(buf, fmt, fmt::make_format_args(args...), detail::locale_ref(loc)); - return buf.count(); +template ::value)> +FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc, + format_string fmt, + T&&... args) -> size_t { + auto buf = detail::counting_buffer<>(); + detail::vformat_to(buf, fmt, fmt::make_format_args(args...), + detail::locale_ref(loc)); + return buf.count(); } FMT_END_EXPORT template template -FMT_CONSTEXPR FMT_INLINE auto formatter::value != detail::type::custom_type>>::format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()) -{ - if (specs_.width_ref.kind == detail::arg_id_kind::none && specs_.precision_ref.kind == detail::arg_id_kind::none) - { - return detail::write(ctx.out(), val, specs_, ctx.locale()); - } - auto specs = specs_; - detail::handle_dynamic_spec(specs.width, specs.width_ref, ctx); - detail::handle_dynamic_spec(specs.precision, specs.precision_ref, ctx); - return detail::write(ctx.out(), val, specs, ctx.locale()); +FMT_CONSTEXPR FMT_INLINE auto +formatter::value != + detail::type::custom_type>>::format(const T& val, + FormatContext& ctx) + const -> decltype(ctx.out()) { + if (specs_.width_ref.kind == detail::arg_id_kind::none && + specs_.precision_ref.kind == detail::arg_id_kind::none) { + return detail::write(ctx.out(), val, specs_, ctx.locale()); + } + auto specs = specs_; + detail::handle_dynamic_spec(specs.width, + specs.width_ref, ctx); + detail::handle_dynamic_spec( + specs.precision, specs.precision_ref, ctx); + return detail::write(ctx.out(), val, specs, ctx.locale()); } FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY -#define FMT_FUNC inline -#include "format-inl.h" +# define FMT_FUNC inline +# include "format-inl.h" #else -#define FMT_FUNC +# define FMT_FUNC #endif -#endif // FMT_FORMAT_H_ +#endif // FMT_FORMAT_H_ diff --git a/lib/spdlog/fmt/bundled/os.h b/lib/spdlog/fmt/bundled/os.h index 0c813d6c..3c7b3ccb 100644 --- a/lib/spdlog/fmt/bundled/os.h +++ b/lib/spdlog/fmt/bundled/os.h @@ -11,63 +11,64 @@ #include #include #include -#include // std::system_error +#include // std::system_error #include "format.h" #if defined __APPLE__ || defined(__FreeBSD__) -#if FMT_HAS_INCLUDE() -#include // for LC_NUMERIC_MASK on OS X -#endif +# if FMT_HAS_INCLUDE() +# include // for LC_NUMERIC_MASK on OS X +# endif #endif #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. -#if FMT_HAS_INCLUDE("winapifamily.h") -#include -#endif -#if (FMT_HAS_INCLUDE() || defined(__APPLE__) || defined(__linux__)) && (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) -#include // for O_RDONLY -#define FMT_USE_FCNTL 1 -#else -#define FMT_USE_FCNTL 0 -#endif +# if FMT_HAS_INCLUDE("winapifamily.h") +# include +# endif +# if (FMT_HAS_INCLUDE() || defined(__APPLE__) || \ + defined(__linux__)) && \ + (!defined(WINAPI_FAMILY) || \ + (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) +# include // for O_RDONLY +# define FMT_USE_FCNTL 1 +# else +# define FMT_USE_FCNTL 0 +# endif #endif #ifndef FMT_POSIX -#if defined(_WIN32) && !defined(__MINGW32__) +# if defined(_WIN32) && !defined(__MINGW32__) // Fix warnings about deprecated symbols. -#define FMT_POSIX(call) _##call -#else -#define FMT_POSIX(call) call -#endif +# define FMT_POSIX(call) _##call +# else +# define FMT_POSIX(call) call +# endif #endif // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM -#define FMT_HAS_SYSTEM -#define FMT_POSIX_CALL(call) FMT_SYSTEM(call) +# define FMT_HAS_SYSTEM +# define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else -#define FMT_SYSTEM(call) ::call -#ifdef _WIN32 +# define FMT_SYSTEM(call) ::call +# ifdef _WIN32 // Fix warnings about deprecated symbols. -#define FMT_POSIX_CALL(call) ::_##call -#else -#define FMT_POSIX_CALL(call) ::call -#endif +# define FMT_POSIX_CALL(call) ::_##call +# else +# define FMT_POSIX_CALL(call) ::call +# endif #endif // Retries the expression while it evaluates to error_result and errno // equals to EINTR. #ifndef _WIN32 -#define FMT_RETRY_VAL(result, expression, error_result) \ - do \ - { \ - (result) = (expression); \ - } \ - while ((result) == (error_result) && errno == EINTR) +# define FMT_RETRY_VAL(result, expression, error_result) \ + do { \ + (result) = (expression); \ + } while ((result) == (error_result) && errno == EINTR) #else -#define FMT_RETRY_VAL(result, expression, error_result) result = (expression) +# define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #endif #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) @@ -100,24 +101,23 @@ FMT_BEGIN_EXPORT format(std::string("{}"), 42); \endrst */ -template -class basic_cstring_view { -private: - const Char* data_; - -public: - /** Constructs a string reference object from a C string. */ - basic_cstring_view(const Char* s) : data_(s) {} - - /** - \rst - Constructs a string reference from an ``std::string`` object. - \endrst - */ - basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {} - - /** Returns the pointer to a C string. */ - auto c_str() const -> const Char* { return data_; } +template class basic_cstring_view { + private: + const Char* data_; + + public: + /** Constructs a string reference object from a C string. */ + basic_cstring_view(const Char* s) : data_(s) {} + + /** + \rst + Constructs a string reference from an ``std::string`` object. + \endrst + */ + basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {} + + /** Returns the pointer to a C string. */ + auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view; @@ -126,12 +126,13 @@ using wcstring_view = basic_cstring_view; #ifdef _WIN32 FMT_API const std::error_category& system_category() noexcept; -namespace detail -{ - FMT_API void format_windows_error(buffer& out, int error_code, const char* message) noexcept; +namespace detail { +FMT_API void format_windows_error(buffer& out, int error_code, + const char* message) noexcept; } -FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args); +FMT_API std::system_error vwindows_error(int error_code, string_view format_str, + format_args args); /** \rst @@ -162,75 +163,78 @@ FMT_API std::system_error vwindows_error(int error_code, string_view format_str, \endrst */ template -std::system_error windows_error(int error_code, string_view message, const Args&... args) -{ - return vwindows_error(error_code, message, fmt::make_format_args(args...)); +std::system_error windows_error(int error_code, string_view message, + const Args&... args) { + return vwindows_error(error_code, message, fmt::make_format_args(args...)); } // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else -inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } -#endif // _WIN32 +inline auto system_category() noexcept -> const std::error_category& { + return std::system_category(); +} +#endif // _WIN32 // std::system is not available on some platforms such as iOS (#2248). #ifdef __OSX__ template > -void say(const S& format_str, Args&&... args) -{ - std::system(format("say \"{}\"", format(format_str, args...)).c_str()); +void say(const S& format_str, Args&&... args) { + std::system(format("say \"{}\"", format(format_str, args...)).c_str()); } #endif // A buffered file. class buffered_file { -private: - FILE* file_; + private: + FILE* file_; - friend class file; + friend class file; - explicit buffered_file(FILE* f) : file_(f) {} + explicit buffered_file(FILE* f) : file_(f) {} -public: - buffered_file(const buffered_file&) = delete; - void operator=(const buffered_file&) = delete; + public: + buffered_file(const buffered_file&) = delete; + void operator=(const buffered_file&) = delete; - // Constructs a buffered_file object which doesn't represent any file. - buffered_file() noexcept : file_(nullptr) {} + // Constructs a buffered_file object which doesn't represent any file. + buffered_file() noexcept : file_(nullptr) {} - // Destroys the object closing the file it represents if any. - FMT_API ~buffered_file() noexcept; + // Destroys the object closing the file it represents if any. + FMT_API ~buffered_file() noexcept; -public: - buffered_file(buffered_file&& other) noexcept : file_(other.file_) { other.file_ = nullptr; } + public: + buffered_file(buffered_file&& other) noexcept : file_(other.file_) { + other.file_ = nullptr; + } - auto operator=(buffered_file&& other) -> buffered_file& - { - close(); - file_ = other.file_; - other.file_ = nullptr; - return *this; - } + auto operator=(buffered_file&& other) -> buffered_file& { + close(); + file_ = other.file_; + other.file_ = nullptr; + return *this; + } - // Opens a file. - FMT_API buffered_file(cstring_view filename, cstring_view mode); + // Opens a file. + FMT_API buffered_file(cstring_view filename, cstring_view 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. - auto get() const noexcept -> FILE* { return file_; } + // Returns the pointer to a FILE object representing this file. + auto get() const noexcept -> FILE* { return file_; } - FMT_API auto descriptor() const -> int; + FMT_API auto descriptor() const -> int; - void vprint(string_view format_str, format_args args) { fmt::vprint(file_, format_str, args); } + void vprint(string_view format_str, format_args args) { + fmt::vprint(file_, format_str, args); + } - template - inline void print(string_view format_str, const Args&... args) - { - vprint(format_str, fmt::make_format_args(args...)); - } + template + inline void print(string_view format_str, const Args&... args) { + vprint(format_str, fmt::make_format_args(args...)); + } }; #if FMT_USE_FCNTL @@ -241,160 +245,153 @@ class buffered_file { // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. class FMT_API file { -private: - int fd_; // File descriptor. - - // 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. - CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. - APPEND = FMT_POSIX(O_APPEND), // Open in append mode. - TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file. - }; - - // Constructs a file object which doesn't represent any file. - file() noexcept : fd_(-1) {} - - // Opens a file and constructs a file object representing this file. - file(cstring_view path, int oflag); - -public: - file(const file&) = delete; - void operator=(const file&) = delete; - - file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } - - // Move assignment is not noexcept because close may throw. - auto operator=(file&& other) -> file& - { - close(); - fd_ = other.fd_; - other.fd_ = -1; - return *this; - } - - // Destroys the object closing the file it represents if any. - ~file() noexcept; - - // Returns the file descriptor. - auto descriptor() const noexcept -> int { return fd_; } - - // Closes the file. - void close(); - - // Returns the file size. The size has signed type for consistency with - // stat::st_size. - auto size() const -> long long; - - // Attempts to read count bytes from the file into the specified buffer. - auto read(void* buffer, size_t count) -> size_t; - - // Attempts to write count bytes from the specified buffer to the file. - auto write(const void* buffer, size_t count) -> size_t; - - // Duplicates a file descriptor with the dup function and returns - // the duplicate as a file object. - static auto dup(int fd) -> file; - - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - void dup2(int fd); - - // Makes fd be the copy of this file descriptor, closing fd first if - // necessary. - void dup2(int fd, std::error_code& ec) noexcept; - - // Creates a pipe setting up read_end and write_end file objects for reading - // and writing respectively. - // DEPRECATED! Taking files as out parameters is deprecated. - static void pipe(file& read_end, file& write_end); - - // Creates a buffered_file object associated with this file and detaches - // this file object from the file. - auto fdopen(const char* mode) -> buffered_file; - -#if defined(_WIN32) && !defined(__MINGW32__) - // Opens a file and constructs a file object representing this file by - // wcstring_view filename. Windows only. - static file open_windows_file(wcstring_view path, int oflag); -#endif + private: + int fd_; // File descriptor. + + // 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. + CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. + APPEND = FMT_POSIX(O_APPEND), // Open in append mode. + TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file. + }; + + // Constructs a file object which doesn't represent any file. + file() noexcept : fd_(-1) {} + + // Opens a file and constructs a file object representing this file. + file(cstring_view path, int oflag); + + public: + file(const file&) = delete; + void operator=(const file&) = delete; + + file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } + + // Move assignment is not noexcept because close may throw. + auto operator=(file&& other) -> file& { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } + + // Destroys the object closing the file it represents if any. + ~file() noexcept; + + // Returns the file descriptor. + auto descriptor() const noexcept -> int { return fd_; } + + // Closes the file. + void close(); + + // Returns the file size. The size has signed type for consistency with + // stat::st_size. + auto size() const -> long long; + + // Attempts to read count bytes from the file into the specified buffer. + auto read(void* buffer, size_t count) -> size_t; + + // Attempts to write count bytes from the specified buffer to the file. + auto write(const void* buffer, size_t count) -> size_t; + + // Duplicates a file descriptor with the dup function and returns + // the duplicate as a file object. + static auto dup(int fd) -> file; + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + void dup2(int fd); + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + void dup2(int fd, std::error_code& ec) noexcept; + + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + // DEPRECATED! Taking files as out parameters is deprecated. + static void pipe(file& read_end, file& write_end); + + // Creates a buffered_file object associated with this file and detaches + // this file object from the file. + auto fdopen(const char* mode) -> buffered_file; + +# if defined(_WIN32) && !defined(__MINGW32__) + // Opens a file and constructs a file object representing this file by + // wcstring_view filename. Windows only. + static file open_windows_file(wcstring_view path, int oflag); +# endif }; // Returns the memory page size. auto getpagesize() -> long; -namespace detail -{ - - struct buffer_size { - buffer_size() = default; - size_t value = 0; - auto operator=(size_t val) const -> buffer_size - { - auto bs = buffer_size(); - bs.value = val; - return bs; - } - }; - - struct ostream_params { - int oflag = file::WRONLY | file::CREATE | file::TRUNC; - size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; - - ostream_params() {} - - template - ostream_params(T... params, int new_oflag) : ostream_params(params...) - { - oflag = new_oflag; - } - - template - ostream_params(T... params, detail::buffer_size bs) : ostream_params(params...) - { - this->buffer_size = bs.value; - } +namespace detail { + +struct buffer_size { + buffer_size() = default; + size_t value = 0; + auto operator=(size_t val) const -> buffer_size { + auto bs = buffer_size(); + bs.value = val; + return bs; + } +}; + +struct ostream_params { + int oflag = file::WRONLY | file::CREATE | file::TRUNC; + size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; + + ostream_params() {} + + template + ostream_params(T... params, int new_oflag) : ostream_params(params...) { + oflag = new_oflag; + } + + template + ostream_params(T... params, detail::buffer_size bs) + : ostream_params(params...) { + this->buffer_size = bs.value; + } // Intel has a bug that results in failure to deduce a constructor // for empty parameter packs. -#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000 - ostream_params(int new_oflag) : oflag(new_oflag) {} - ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {} -#endif - }; +# if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000 + ostream_params(int new_oflag) : oflag(new_oflag) {} + ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {} +# endif +}; - class file_buffer final : public buffer { - file file_; +class file_buffer final : public buffer { + file file_; - FMT_API void grow(size_t) override; + FMT_API void grow(size_t) override; - public: - FMT_API file_buffer(cstring_view path, const ostream_params& params); - FMT_API file_buffer(file_buffer&& other); - FMT_API ~file_buffer(); + public: + FMT_API file_buffer(cstring_view path, const ostream_params& params); + FMT_API file_buffer(file_buffer&& other); + FMT_API ~file_buffer(); - void flush() - { - if (size() == 0) - return; - file_.write(data(), size() * sizeof(data()[0])); - clear(); - } + void flush() { + if (size() == 0) return; + file_.write(data(), size() * sizeof(data()[0])); + clear(); + } - void close() - { - flush(); - file_.close(); - } - }; + void close() { + flush(); + file_.close(); + } +}; -} // namespace detail +} // namespace detail // Added {} below to work around default constructor error known to // occur in Xcode versions 7.2.1 and 8.2.1. @@ -402,33 +399,33 @@ constexpr detail::buffer_size buffer_size{}; /** A fast output stream which is not thread-safe. */ class FMT_API ostream { -private: - FMT_MSC_WARNING(suppress : 4251) - detail::file_buffer buffer_; + private: + FMT_MSC_WARNING(suppress : 4251) + detail::file_buffer buffer_; - ostream(cstring_view path, const detail::ostream_params& params) : buffer_(path, params) {} + ostream(cstring_view path, const detail::ostream_params& params) + : buffer_(path, params) {} -public: - ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {} + public: + ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {} - ~ostream(); + ~ostream(); - void flush() { buffer_.flush(); } + void flush() { buffer_.flush(); } - template - friend auto output_file(cstring_view path, T... params) -> ostream; + template + friend auto output_file(cstring_view path, T... params) -> ostream; - void close() { buffer_.close(); } + void close() { buffer_.close(); } - /** - Formats ``args`` according to specifications in ``fmt`` and writes the - output to the file. - */ - template - void print(format_string fmt, T&&... args) - { - vformat_to(std::back_inserter(buffer_), fmt, fmt::make_format_args(args...)); - } + /** + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file. + */ + template void print(format_string fmt, T&&... args) { + vformat_to(std::back_inserter(buffer_), fmt, + fmt::make_format_args(args...)); + } }; /** @@ -447,13 +444,12 @@ class FMT_API ostream { \endrst */ template -inline auto output_file(cstring_view path, T... params) -> ostream -{ - return {path, detail::ostream_params(params...)}; +inline auto output_file(cstring_view path, T... params) -> ostream { + return {path, detail::ostream_params(params...)}; } -#endif // FMT_USE_FCNTL +#endif // FMT_USE_FCNTL FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_OS_H_ +#endif // FMT_OS_H_ diff --git a/lib/spdlog/fmt/bundled/ostream.h b/lib/spdlog/fmt/bundled/ostream.h index 99d3f3fd..26fb3b5a 100644 --- a/lib/spdlog/fmt/bundled/ostream.h +++ b/lib/spdlog/fmt/bundled/ostream.h @@ -8,167 +8,161 @@ #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ -#include // std::filebuf +#include // std::filebuf #ifdef _WIN32 -#ifdef __GLIBCXX__ -#include -#include -#endif -#include +# ifdef __GLIBCXX__ +# include +# include +# endif +# include #endif #include "format.h" FMT_BEGIN_NAMESPACE -namespace detail -{ - - template - class formatbuf : public Streambuf { - private: - using char_type = typename Streambuf::char_type; - using streamsize = decltype(std::declval().sputn(nullptr, 0)); - using int_type = typename Streambuf::int_type; - using traits_type = typename Streambuf::traits_type; - - buffer& buffer_; - - public: - explicit formatbuf(buffer& buf) : buffer_(buf) {} - - protected: - // The put area is 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. A 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. - - auto overflow(int_type ch) -> int_type override - { - if (!traits_type::eq_int_type(ch, traits_type::eof())) - buffer_.push_back(static_cast(ch)); - return ch; - } - - auto xsputn(const char_type* s, streamsize count) -> streamsize override - { - buffer_.append(s, s + count); - return count; - } - }; - - // Generate a unique explicit instantion in every translation unit using a tag - // type in an anonymous namespace. - namespace - { - struct file_access_tag {}; - } // namespace - template - class file_access { - friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } - }; +namespace detail { + +template class formatbuf : public Streambuf { + private: + using char_type = typename Streambuf::char_type; + using streamsize = decltype(std::declval().sputn(nullptr, 0)); + using int_type = typename Streambuf::int_type; + using traits_type = typename Streambuf::traits_type; + + buffer& buffer_; + + public: + explicit formatbuf(buffer& buf) : buffer_(buf) {} + + protected: + // The put area is 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. A 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. + + auto overflow(int_type ch) -> int_type override { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + auto xsputn(const char_type* s, streamsize count) -> streamsize override { + buffer_.append(s, s + count); + return count; + } +}; + +// Generate a unique explicit instantion in every translation unit using a tag +// type in an anonymous namespace. +namespace { +struct file_access_tag {}; +} // namespace +template +class file_access { + friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } +}; #if FMT_MSC_VERSION - template class file_access; - auto get_file(std::filebuf&) -> FILE*; +template class file_access; +auto get_file(std::filebuf&) -> FILE*; #endif - inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data) -> bool - { - FILE* f = nullptr; +inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data) + -> bool { + FILE* f = nullptr; #if FMT_MSC_VERSION - if (auto* buf = dynamic_cast(os.rdbuf())) - f = get_file(*buf); - else - return false; + if (auto* buf = dynamic_cast(os.rdbuf())) + f = get_file(*buf); + else + return false; #elif defined(_WIN32) && defined(__GLIBCXX__) - auto* rdbuf = os.rdbuf(); - if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) - f = sfbuf->file(); - else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) - f = fbuf->file(); - else - return false; + auto* rdbuf = os.rdbuf(); + if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) + f = sfbuf->file(); + else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) + f = fbuf->file(); + else + return false; #else - ignore_unused(os, data, f); + ignore_unused(os, data, f); #endif #ifdef _WIN32 - if (f) - { - int fd = _fileno(f); - if (_isatty(fd)) - { - os.flush(); - return write_console(fd, data); - } - } -#endif - return false; - } - inline auto write_ostream_unicode(std::wostream&, fmt::basic_string_view) -> bool { return false; } - - // Write the content of buf to os. - // It is a separate function rather than a part of vprint to simplify testing. - template - void write_buffer(std::basic_ostream& os, buffer& buf) - { - const Char* buf_data = buf.data(); - using unsigned_streamsize = std::make_unsigned::type; - unsigned_streamsize size = buf.size(); - unsigned_streamsize max_size = to_unsigned(max_value()); - do - { - unsigned_streamsize n = size <= max_size ? size : max_size; - os.write(buf_data, static_cast(n)); - buf_data += n; - size -= n; - } - while (size != 0); + if (f) { + int fd = _fileno(f); + if (_isatty(fd)) { + os.flush(); + return write_console(fd, data); } + } +#endif + return false; +} +inline auto write_ostream_unicode(std::wostream&, + fmt::basic_string_view) -> bool { + return false; +} + +// Write the content of buf to os. +// It is a separate function rather than a part of vprint to simplify testing. +template +void write_buffer(std::basic_ostream& os, buffer& buf) { + const Char* buf_data = buf.data(); + using unsigned_streamsize = std::make_unsigned::type; + unsigned_streamsize size = buf.size(); + unsigned_streamsize max_size = to_unsigned(max_value()); + do { + unsigned_streamsize n = size <= max_size ? size : max_size; + os.write(buf_data, static_cast(n)); + buf_data += n; + size -= n; + } while (size != 0); +} - template - void format_value(buffer& buf, const T& value) - { - auto&& format_buf = formatbuf>(buf); - auto&& output = std::basic_ostream(&format_buf); +template +void format_value(buffer& buf, const T& value) { + auto&& format_buf = formatbuf>(buf); + auto&& output = std::basic_ostream(&format_buf); #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR) - output.imbue(std::locale::classic()); // The default is always unlocalized. + output.imbue(std::locale::classic()); // The default is always unlocalized. #endif - output << value; - output.exceptions(std::ios_base::failbit | std::ios_base::badbit); - } + output << value; + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); +} - template - struct streamed_view { - const T& value; - }; +template struct streamed_view { + const T& value; +}; -} // namespace detail +} // namespace detail // Formats an object of type T that has an overloaded ostream operator<<. template struct basic_ostream_formatter : formatter, Char> { - void set_debug_format() = delete; - - template - auto format(const T& value, basic_format_context& ctx) const -> OutputIt - { - auto buffer = basic_memory_buffer(); - detail::format_value(buffer, value); - return formatter, Char>::format({buffer.data(), buffer.size()}, ctx); - } + void set_debug_format() = delete; + + template + auto format(const T& value, basic_format_context& ctx) const + -> OutputIt { + auto buffer = basic_memory_buffer(); + detail::format_value(buffer, value); + return formatter, Char>::format( + {buffer.data(), buffer.size()}, ctx); + } }; using ostream_formatter = basic_ostream_formatter; template -struct formatter, Char> : basic_ostream_formatter { - template - auto format(detail::streamed_view view, basic_format_context& ctx) const -> OutputIt - { - return basic_ostream_formatter::format(view.value, ctx); - } +struct formatter, Char> + : basic_ostream_formatter { + template + auto format(detail::streamed_view view, + basic_format_context& ctx) const -> OutputIt { + return basic_ostream_formatter::format(view.value, ctx); + } }; /** @@ -182,31 +176,29 @@ struct formatter, Char> : basic_ostream_formatter \endrst */ template -constexpr auto streamed(const T& value) -> detail::streamed_view -{ - return {value}; +constexpr auto streamed(const T& value) -> detail::streamed_view { + return {value}; } -namespace detail -{ +namespace detail { - inline void vprint_directly(std::ostream& os, string_view format_str, format_args args) - { - auto buffer = memory_buffer(); - detail::vformat_to(buffer, format_str, args); - detail::write_buffer(os, buffer); - } +inline void vprint_directly(std::ostream& os, string_view format_str, + format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, format_str, args); + detail::write_buffer(os, buffer); +} -} // namespace detail +} // namespace detail FMT_EXPORT template -void vprint(std::basic_ostream& os, basic_string_view> format_str, basic_format_args>> args) -{ - auto buffer = basic_memory_buffer(); - detail::vformat_to(buffer, format_str, args); - if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) - return; - detail::write_buffer(os, buffer); +void vprint(std::basic_ostream& os, + basic_string_view> format_str, + basic_format_args>> args) { + auto buffer = basic_memory_buffer(); + detail::vformat_to(buffer, format_str, args); + if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return; + detail::write_buffer(os, buffer); } /** @@ -219,35 +211,35 @@ void vprint(std::basic_ostream& os, basic_string_view -void print(std::ostream& os, format_string fmt, T&&... args) -{ - const auto& vargs = fmt::make_format_args(args...); - if (detail::is_utf8()) - vprint(os, fmt, vargs); - else - detail::vprint_directly(os, fmt, vargs); +void print(std::ostream& os, format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + if (detail::is_utf8()) + vprint(os, fmt, vargs); + else + detail::vprint_directly(os, fmt, vargs); } FMT_EXPORT template -void print(std::wostream& os, basic_format_string...> fmt, Args&&... args) -{ - vprint(os, fmt, fmt::make_format_args>(args...)); +void print(std::wostream& os, + basic_format_string...> fmt, + Args&&... args) { + vprint(os, fmt, fmt::make_format_args>(args...)); } FMT_EXPORT template -void println(std::ostream& os, format_string fmt, T&&... args) -{ - fmt::print(os, "{}\n", fmt::format(fmt, std::forward(args)...)); +void println(std::ostream& os, format_string fmt, T&&... args) { + fmt::print(os, "{}\n", fmt::format(fmt, std::forward(args)...)); } FMT_EXPORT template -void println(std::wostream& os, basic_format_string...> fmt, Args&&... args) -{ - print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); +void println(std::wostream& os, + basic_format_string...> fmt, + Args&&... args) { + print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); } FMT_END_NAMESPACE -#endif // FMT_OSTREAM_H_ +#endif // FMT_OSTREAM_H_ diff --git a/lib/spdlog/fmt/bundled/printf.h b/lib/spdlog/fmt/bundled/printf.h index 0dbf675f..07e81577 100644 --- a/lib/spdlog/fmt/bundled/printf.h +++ b/lib/spdlog/fmt/bundled/printf.h @@ -8,641 +8,560 @@ #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ -#include // std::max -#include // std::numeric_limits +#include // std::max +#include // std::numeric_limits #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT -template -struct printf_formatter { - printf_formatter() = delete; +template struct printf_formatter { + printf_formatter() = delete; }; -template -class basic_printf_context { -private: - detail::buffer_appender out_; - basic_format_args args_; +template class basic_printf_context { + private: + detail::buffer_appender out_; + basic_format_args args_; + + static_assert(std::is_same::value || + std::is_same::value, + "Unsupported code unit type."); + + public: + using char_type = Char; + using parse_context_type = basic_format_parse_context; + template using formatter_type = printf_formatter; + + /** + \rst + Constructs a ``printf_context`` object. References to the arguments are + stored in the context object so make sure they have appropriate lifetimes. + \endrst + */ + basic_printf_context(detail::buffer_appender out, + basic_format_args args) + : out_(out), args_(args) {} + + auto out() -> detail::buffer_appender { return out_; } + void advance_to(detail::buffer_appender) {} + + auto locale() -> detail::locale_ref { return {}; } + + auto arg(int id) const -> basic_format_arg { + return args_.get(id); + } + + FMT_CONSTEXPR void on_error(const char* message) { + detail::error_handler().on_error(message); + } +}; - static_assert(std::is_same::value || std::is_same::value, "Unsupported code unit type."); +namespace detail { -public: - using char_type = Char; - using parse_context_type = basic_format_parse_context; - template - using formatter_type = printf_formatter; +// Checks if a value fits in int - used to avoid warnings about comparing +// signed and unsigned integers. +template struct int_checker { + template static auto fits_in_int(T value) -> bool { + unsigned max = max_value(); + return value <= max; + } + static auto fits_in_int(bool) -> bool { return true; } +}; - /** - \rst - Constructs a ``printf_context`` object. References to the arguments are - stored in the context object so make sure they have appropriate lifetimes. - \endrst - */ - basic_printf_context(detail::buffer_appender out, basic_format_args args) : out_(out), args_(args) {} +template <> struct int_checker { + template static auto fits_in_int(T value) -> bool { + return value >= (std::numeric_limits::min)() && + value <= max_value(); + } + static auto fits_in_int(int) -> bool { return true; } +}; - auto out() -> detail::buffer_appender { return out_; } - void advance_to(detail::buffer_appender) {} +struct printf_precision_handler { + template ::value)> + auto operator()(T value) -> int { + if (!int_checker::is_signed>::fits_in_int(value)) + throw_format_error("number is too big"); + return (std::max)(static_cast(value), 0); + } + + template ::value)> + auto operator()(T) -> int { + throw_format_error("precision is not integer"); + return 0; + } +}; - auto locale() -> detail::locale_ref { return {}; } +// An argument visitor that returns true iff arg is a zero integer. +struct is_zero_int { + template ::value)> + auto operator()(T value) -> bool { + return value == 0; + } + + template ::value)> + auto operator()(T) -> bool { + return false; + } +}; - auto arg(int id) const -> basic_format_arg { return args_.get(id); } +template struct make_unsigned_or_bool : std::make_unsigned {}; - FMT_CONSTEXPR void on_error(const char* message) { detail::error_handler().on_error(message); } +template <> struct make_unsigned_or_bool { + using type = bool; }; -namespace detail -{ - - // Checks if a value fits in int - used to avoid warnings about comparing - // signed and unsigned integers. - template - struct int_checker { - template - static auto fits_in_int(T value) -> bool - { - unsigned max = max_value(); - return value <= max; - } - static auto fits_in_int(bool) -> bool { return true; } - }; - - template <> - struct int_checker { - template - static auto fits_in_int(T value) -> bool - { - return value >= (std::numeric_limits::min)() && value <= max_value(); - } - static auto fits_in_int(int) -> bool { return true; } - }; - - struct printf_precision_handler { - template ::value)> - auto operator()(T value) -> int - { - if (!int_checker::is_signed>::fits_in_int(value)) - throw_format_error("number is too big"); - return (std::max)(static_cast(value), 0); - } - - template ::value)> - auto operator()(T) -> int - { - throw_format_error("precision is not integer"); - return 0; - } - }; - - // An argument visitor that returns true iff arg is a zero integer. - struct is_zero_int { - template ::value)> - auto operator()(T value) -> bool - { - return value == 0; - } - - template ::value)> - auto operator()(T) -> bool - { - return false; - } - }; - - template - struct make_unsigned_or_bool : std::make_unsigned {}; - - template <> - struct make_unsigned_or_bool { - using type = bool; - }; - - template - class arg_converter { - private: - using char_type = typename Context::char_type; - - basic_format_arg& arg_; - char_type type_; - - public: - arg_converter(basic_format_arg& arg, char_type type) : arg_(arg), type_(type) {} - - void operator()(bool value) - { - if (type_ != 's') - operator()(value); - } - - template ::value)> - void operator()(U value) - { - bool is_signed = type_ == 'd' || type_ == 'i'; - using target_type = conditional_t::value, U, T>; - if (const_check(sizeof(target_type) <= sizeof(int))) - { - // Extra casts are used to silence warnings. - if (is_signed) - { - auto n = static_cast(static_cast(value)); - arg_ = detail::make_arg(n); - } - else - { - using unsigned_type = typename make_unsigned_or_bool::type; - auto n = static_cast(static_cast(value)); - arg_ = detail::make_arg(n); - } - } - else - { - if (is_signed) - { - // 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. - auto n = static_cast(value); - arg_ = detail::make_arg(n); - } - else - { - auto n = static_cast::type>(value); - arg_ = detail::make_arg(n); - } - } - } - - template ::value)> - void operator()(U) - { - } // No conversion needed for non-integral types. - }; - - // Converts an integer argument to T for printf, if T is an integral type. - // If T is void, the argument is converted to corresponding signed or unsigned - // type depending on the type specifier: 'd' and 'i' - signed, other - - // unsigned). - template - void convert_arg(basic_format_arg& arg, Char type) - { - visit_format_arg(arg_converter(arg, type), arg); +template class arg_converter { + private: + using char_type = typename Context::char_type; + + basic_format_arg& arg_; + char_type type_; + + public: + arg_converter(basic_format_arg& arg, char_type type) + : arg_(arg), type_(type) {} + + void operator()(bool value) { + if (type_ != 's') operator()(value); + } + + template ::value)> + void operator()(U value) { + bool is_signed = type_ == 'd' || type_ == 'i'; + using target_type = conditional_t::value, U, T>; + if (const_check(sizeof(target_type) <= sizeof(int))) { + // Extra casts are used to silence warnings. + if (is_signed) { + auto n = static_cast(static_cast(value)); + arg_ = detail::make_arg(n); + } else { + using unsigned_type = typename make_unsigned_or_bool::type; + auto n = static_cast(static_cast(value)); + arg_ = detail::make_arg(n); + } + } else { + if (is_signed) { + // 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. + auto n = static_cast(value); + arg_ = detail::make_arg(n); + } else { + auto n = static_cast::type>(value); + arg_ = detail::make_arg(n); + } } + } + + template ::value)> + void operator()(U) {} // No conversion needed for non-integral types. +}; + +// Converts an integer argument to T for printf, if T is an integral type. +// If T is void, the argument is converted to corresponding signed or unsigned +// type depending on the type specifier: 'd' and 'i' - signed, other - +// unsigned). +template +void convert_arg(basic_format_arg& arg, Char type) { + visit_format_arg(arg_converter(arg, type), arg); +} + +// Converts an integer argument to char for printf. +template class char_converter { + private: + basic_format_arg& arg_; - // Converts an integer argument to char for printf. - template - class char_converter { - private: - basic_format_arg& arg_; - - public: - explicit char_converter(basic_format_arg& arg) : arg_(arg) {} - - template ::value)> - void operator()(T value) - { - auto c = static_cast(value); - arg_ = detail::make_arg(c); - } - - template ::value)> - void operator()(T) - { - } // No conversion needed for non-integral types. - }; - - // An argument visitor that return a pointer to a C string if argument is a - // string or null otherwise. - template - struct get_cstring { - template - auto operator()(T) -> const Char* - { - return nullptr; - } - auto operator()(const Char* s) -> const Char* { return s; } - }; - - // Checks if an argument is a valid printf width specifier and sets - // left alignment if it is negative. - template - class printf_width_handler { - private: - format_specs& specs_; - - public: - explicit printf_width_handler(format_specs& specs) : specs_(specs) {} - - template ::value)> - auto operator()(T value) -> unsigned - { - auto width = static_cast>(value); - if (detail::is_negative(value)) - { - specs_.align = align::left; - width = 0 - width; - } - unsigned int_max = max_value(); - if (width > int_max) - throw_format_error("number is too big"); - return static_cast(width); - } - - template ::value)> - auto operator()(T) -> unsigned - { - throw_format_error("width is not integer"); - return 0; - } - }; - - // Workaround for a bug with the XL compiler when initializing - // printf_arg_formatter's base class. - template - auto make_arg_formatter(buffer_appender iter, format_specs& s) -> arg_formatter - { - return {iter, s, locale_ref()}; + public: + explicit char_converter(basic_format_arg& arg) : arg_(arg) {} + + template ::value)> + void operator()(T value) { + auto c = static_cast(value); + arg_ = detail::make_arg(c); + } + + template ::value)> + void operator()(T) {} // No conversion needed for non-integral types. +}; + +// An argument visitor that return a pointer to a C string if argument is a +// string or null otherwise. +template struct get_cstring { + template auto operator()(T) -> const Char* { return nullptr; } + auto operator()(const Char* s) -> const Char* { return s; } +}; + +// Checks if an argument is a valid printf width specifier and sets +// left alignment if it is negative. +template class printf_width_handler { + private: + format_specs& specs_; + + public: + explicit printf_width_handler(format_specs& specs) : specs_(specs) {} + + template ::value)> + auto operator()(T value) -> unsigned { + auto width = static_cast>(value); + if (detail::is_negative(value)) { + specs_.align = align::left; + width = 0 - width; } + unsigned int_max = max_value(); + if (width > int_max) throw_format_error("number is too big"); + return static_cast(width); + } + + template ::value)> + auto operator()(T) -> unsigned { + throw_format_error("width is not integer"); + return 0; + } +}; - // The ``printf`` argument formatter. - template - class printf_arg_formatter : public arg_formatter { - private: - using base = arg_formatter; - using context_type = basic_printf_context; - - context_type& context_; - - void write_null_pointer(bool is_string = false) - { - auto s = this->specs; - s.type = presentation_type::none; - write_bytes(this->out, is_string ? "(null)" : "(nil)", s); - } - - public: - printf_arg_formatter(buffer_appender iter, format_specs& s, context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} - - void operator()(monostate value) { base::operator()(value); } - - template ::value)> - void operator()(T value) - { - // MSVC2013 fails to compile separate overloads for bool and Char so use - // std::is_same instead. - if (!std::is_same::value) - { - base::operator()(value); - return; - } - format_specs fmt_specs = this->specs; - if (fmt_specs.type != presentation_type::none && fmt_specs.type != presentation_type::chr) - { - return (*this)(static_cast(value)); - } - fmt_specs.sign = sign::none; - fmt_specs.alt = false; - fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types. - // align::numeric needs to be overwritten here since the '0' flag is - // ignored for non-numeric types - if (fmt_specs.align == align::none || fmt_specs.align == align::numeric) - fmt_specs.align = align::right; - write(this->out, static_cast(value), fmt_specs); - } - - template ::value)> - void operator()(T value) - { - base::operator()(value); - } - - /** Formats a null-terminated C string. */ - void operator()(const char* value) - { - if (value) - base::operator()(value); - else - write_null_pointer(this->specs.type != presentation_type::pointer); - } - - /** Formats a null-terminated wide C string. */ - void operator()(const wchar_t* value) - { - if (value) - base::operator()(value); - else - write_null_pointer(this->specs.type != presentation_type::pointer); - } - - void operator()(basic_string_view value) { base::operator()(value); } - - /** Formats a pointer. */ - void operator()(const void* value) - { - if (value) - base::operator()(value); - else - write_null_pointer(); - } - - /** Formats an argument of a custom (user-defined) type. */ - void operator()(typename basic_format_arg::handle handle) - { - auto parse_ctx = basic_format_parse_context({}); - handle.format(parse_ctx, context_); - } - }; - - template - void parse_flags(format_specs& specs, const Char*& it, const Char* end) - { - for (; it != end; ++it) - { - switch (*it) - { - case '-': - specs.align = align::left; - break; - case '+': - specs.sign = sign::plus; - break; - case '0': - specs.fill[0] = '0'; - break; - case ' ': - if (specs.sign != sign::plus) - specs.sign = sign::space; - break; - case '#': - specs.alt = true; - break; - default: - return; - } - } +// Workaround for a bug with the XL compiler when initializing +// printf_arg_formatter's base class. +template +auto make_arg_formatter(buffer_appender iter, format_specs& s) + -> arg_formatter { + return {iter, s, locale_ref()}; +} + +// The ``printf`` argument formatter. +template +class printf_arg_formatter : public arg_formatter { + private: + using base = arg_formatter; + using context_type = basic_printf_context; + + context_type& context_; + + void write_null_pointer(bool is_string = false) { + auto s = this->specs; + s.type = presentation_type::none; + write_bytes(this->out, is_string ? "(null)" : "(nil)", s); + } + + public: + printf_arg_formatter(buffer_appender iter, format_specs& s, + context_type& ctx) + : base(make_arg_formatter(iter, s)), context_(ctx) {} + + void operator()(monostate value) { base::operator()(value); } + + template ::value)> + void operator()(T value) { + // MSVC2013 fails to compile separate overloads for bool and Char so use + // std::is_same instead. + if (!std::is_same::value) { + base::operator()(value); + return; } + format_specs fmt_specs = this->specs; + if (fmt_specs.type != presentation_type::none && + fmt_specs.type != presentation_type::chr) { + return (*this)(static_cast(value)); + } + fmt_specs.sign = sign::none; + fmt_specs.alt = false; + fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types. + // align::numeric needs to be overwritten here since the '0' flag is + // ignored for non-numeric types + if (fmt_specs.align == align::none || fmt_specs.align == align::numeric) + fmt_specs.align = align::right; + write(this->out, static_cast(value), fmt_specs); + } + + template ::value)> + void operator()(T value) { + base::operator()(value); + } + + /** Formats a null-terminated C string. */ + void operator()(const char* value) { + if (value) + base::operator()(value); + else + write_null_pointer(this->specs.type != presentation_type::pointer); + } + + /** Formats a null-terminated wide C string. */ + void operator()(const wchar_t* value) { + if (value) + base::operator()(value); + else + write_null_pointer(this->specs.type != presentation_type::pointer); + } + + void operator()(basic_string_view value) { base::operator()(value); } + + /** Formats a pointer. */ + void operator()(const void* value) { + if (value) + base::operator()(value); + else + write_null_pointer(); + } + + /** Formats an argument of a custom (user-defined) type. */ + void operator()(typename basic_format_arg::handle handle) { + auto parse_ctx = basic_format_parse_context({}); + handle.format(parse_ctx, context_); + } +}; + +template +void parse_flags(format_specs& specs, const Char*& it, const Char* end) { + for (; it != end; ++it) { + switch (*it) { + case '-': + specs.align = align::left; + break; + case '+': + specs.sign = sign::plus; + break; + case '0': + specs.fill[0] = '0'; + break; + case ' ': + if (specs.sign != sign::plus) specs.sign = sign::space; + break; + case '#': + specs.alt = true; + break; + default: + return; + } + } +} - template - auto parse_header(const Char*& it, const Char* end, format_specs& specs, GetArg get_arg) -> int - { - int arg_index = -1; - Char c = *it; - if (c >= '0' && c <= '9') - { - // Parse an argument index (if followed by '$') or a width possibly - // preceded with '0' flag(s). - int value = parse_nonnegative_int(it, end, -1); - if (it != end && *it == '$') - { // value is an argument index - ++it; - arg_index = value != -1 ? value : max_value(); - } - else - { - if (c == '0') - specs.fill[0] = '0'; - if (value != 0) - { - // Nonzero value means that we parsed width and don't need to - // parse it or flags again, so return now. - if (value == -1) - throw_format_error("number is too big"); - specs.width = value; - return arg_index; - } - } - } - parse_flags(specs, it, end); - // Parse width. - if (it != end) - { - if (*it >= '0' && *it <= '9') - { - specs.width = parse_nonnegative_int(it, end, -1); - if (specs.width == -1) - throw_format_error("number is too big"); - } - else if (*it == '*') - { - ++it; - specs.width = static_cast(visit_format_arg(detail::printf_width_handler(specs), get_arg(-1))); - } - } +template +auto parse_header(const Char*& it, const Char* end, format_specs& specs, + GetArg get_arg) -> int { + int arg_index = -1; + Char c = *it; + if (c >= '0' && c <= '9') { + // Parse an argument index (if followed by '$') or a width possibly + // preceded with '0' flag(s). + int value = parse_nonnegative_int(it, end, -1); + if (it != end && *it == '$') { // value is an argument index + ++it; + arg_index = value != -1 ? value : max_value(); + } else { + if (c == '0') specs.fill[0] = '0'; + if (value != 0) { + // Nonzero value means that we parsed width and don't need to + // parse it or flags again, so return now. + if (value == -1) throw_format_error("number is too big"); + specs.width = value; return arg_index; + } } + } + parse_flags(specs, it, end); + // Parse width. + if (it != end) { + if (*it >= '0' && *it <= '9') { + specs.width = parse_nonnegative_int(it, end, -1); + if (specs.width == -1) throw_format_error("number is too big"); + } else if (*it == '*') { + ++it; + specs.width = static_cast(visit_format_arg( + detail::printf_width_handler(specs), get_arg(-1))); + } + } + return arg_index; +} - inline auto parse_printf_presentation_type(char c, type t) -> presentation_type - { - using pt = presentation_type; - constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; - switch (c) - { - case 'd': - return in(t, integral_set) ? pt::dec : pt::none; - case 'o': - return in(t, integral_set) ? pt::oct : pt::none; - case 'x': - return in(t, integral_set) ? pt::hex_lower : pt::none; - case 'X': - return in(t, integral_set) ? pt::hex_upper : pt::none; - case 'a': - return in(t, float_set) ? pt::hexfloat_lower : pt::none; - case 'A': - return in(t, float_set) ? pt::hexfloat_upper : pt::none; - case 'e': - return in(t, float_set) ? pt::exp_lower : pt::none; - case 'E': - return in(t, float_set) ? pt::exp_upper : pt::none; - case 'f': - return in(t, float_set) ? pt::fixed_lower : pt::none; - case 'F': - return in(t, float_set) ? pt::fixed_upper : pt::none; - case 'g': - return in(t, float_set) ? pt::general_lower : pt::none; - case 'G': - return in(t, float_set) ? pt::general_upper : pt::none; - case 'c': - return in(t, integral_set) ? pt::chr : pt::none; - case 's': - return in(t, string_set | cstring_set) ? pt::string : pt::none; - case 'p': - return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; - default: - return pt::none; - } +inline auto parse_printf_presentation_type(char c, type t) + -> presentation_type { + using pt = presentation_type; + constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; + switch (c) { + case 'd': + return in(t, integral_set) ? pt::dec : pt::none; + case 'o': + return in(t, integral_set) ? pt::oct : pt::none; + case 'x': + return in(t, integral_set) ? pt::hex_lower : pt::none; + case 'X': + return in(t, integral_set) ? pt::hex_upper : pt::none; + case 'a': + return in(t, float_set) ? pt::hexfloat_lower : pt::none; + case 'A': + return in(t, float_set) ? pt::hexfloat_upper : pt::none; + case 'e': + return in(t, float_set) ? pt::exp_lower : pt::none; + case 'E': + return in(t, float_set) ? pt::exp_upper : pt::none; + case 'f': + return in(t, float_set) ? pt::fixed_lower : pt::none; + case 'F': + return in(t, float_set) ? pt::fixed_upper : pt::none; + case 'g': + return in(t, float_set) ? pt::general_lower : pt::none; + case 'G': + return in(t, float_set) ? pt::general_upper : pt::none; + case 'c': + return in(t, integral_set) ? pt::chr : pt::none; + case 's': + return in(t, string_set | cstring_set) ? pt::string : pt::none; + case 'p': + return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; + default: + return pt::none; + } +} + +template +void vprintf(buffer& buf, basic_string_view format, + basic_format_args args) { + using iterator = buffer_appender; + auto out = iterator(buf); + auto context = basic_printf_context(out, args); + auto parse_ctx = basic_format_parse_context(format); + + // Returns the argument with specified index or, if arg_index is -1, the next + // argument. + auto get_arg = [&](int arg_index) { + if (arg_index < 0) + arg_index = parse_ctx.next_arg_id(); + else + parse_ctx.check_arg_id(--arg_index); + return detail::get_arg(context, arg_index); + }; + + const Char* start = parse_ctx.begin(); + const Char* end = parse_ctx.end(); + auto it = start; + while (it != end) { + if (!find(it, end, '%', it)) { + it = end; // find leaves it == nullptr if it doesn't find '%'. + break; + } + Char c = *it++; + if (it != end && *it == c) { + write(out, basic_string_view(start, to_unsigned(it - start))); + start = ++it; + continue; + } + write(out, basic_string_view(start, to_unsigned(it - 1 - start))); + + auto specs = format_specs(); + specs.align = align::right; + + // Parse argument index, flags and width. + int arg_index = parse_header(it, end, specs, get_arg); + if (arg_index == 0) throw_format_error("argument not found"); + + // Parse precision. + if (it != end && *it == '.') { + ++it; + c = it != end ? *it : 0; + if ('0' <= c && c <= '9') { + specs.precision = parse_nonnegative_int(it, end, 0); + } else if (c == '*') { + ++it; + specs.precision = static_cast( + visit_format_arg(printf_precision_handler(), get_arg(-1))); + } else { + specs.precision = 0; + } + } + + auto arg = get_arg(arg_index); + // For d, i, o, u, x, and X conversion specifiers, if a precision is + // specified, the '0' flag is ignored + if (specs.precision >= 0 && arg.is_integral()) { + // Ignore '0' for non-numeric types or if '-' present. + specs.fill[0] = ' '; + } + if (specs.precision >= 0 && arg.type() == type::cstring_type) { + auto str = visit_format_arg(get_cstring(), arg); + auto str_end = str + specs.precision; + auto nul = std::find(str, str_end, Char()); + auto sv = basic_string_view( + str, to_unsigned(nul != str_end ? nul - str : specs.precision)); + arg = make_arg>(sv); + } + if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false; + if (specs.fill[0] == '0') { + if (arg.is_arithmetic() && specs.align != align::left) + specs.align = align::numeric; + else + specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' + // flag is also present. } - template - void vprintf(buffer& buf, basic_string_view format, basic_format_args args) - { - using iterator = buffer_appender; - auto out = iterator(buf); - auto context = basic_printf_context(out, args); - auto parse_ctx = basic_format_parse_context(format); - - // Returns the argument with specified index or, if arg_index is -1, the next - // argument. - auto get_arg = [&](int arg_index) - { - if (arg_index < 0) - arg_index = parse_ctx.next_arg_id(); - else - parse_ctx.check_arg_id(--arg_index); - return detail::get_arg(context, arg_index); - }; - - const Char* start = parse_ctx.begin(); - const Char* end = parse_ctx.end(); - auto it = start; - while (it != end) - { - if (!find(it, end, '%', it)) - { - it = end; // find leaves it == nullptr if it doesn't find '%'. - break; - } - Char c = *it++; - if (it != end && *it == c) - { - write(out, basic_string_view(start, to_unsigned(it - start))); - start = ++it; - continue; - } - write(out, basic_string_view(start, to_unsigned(it - 1 - start))); - - auto specs = format_specs(); - specs.align = align::right; - - // Parse argument index, flags and width. - int arg_index = parse_header(it, end, specs, get_arg); - if (arg_index == 0) - throw_format_error("argument not found"); - - // Parse precision. - if (it != end && *it == '.') - { - ++it; - c = it != end ? *it : 0; - if ('0' <= c && c <= '9') - { - specs.precision = parse_nonnegative_int(it, end, 0); - } - else if (c == '*') - { - ++it; - specs.precision = static_cast(visit_format_arg(printf_precision_handler(), get_arg(-1))); - } - else - { - specs.precision = 0; - } - } - - auto arg = get_arg(arg_index); - // For d, i, o, u, x, and X conversion specifiers, if a precision is - // specified, the '0' flag is ignored - if (specs.precision >= 0 && arg.is_integral()) - { - // Ignore '0' for non-numeric types or if '-' present. - specs.fill[0] = ' '; - } - if (specs.precision >= 0 && arg.type() == type::cstring_type) - { - auto str = visit_format_arg(get_cstring(), arg); - auto str_end = str + specs.precision; - auto nul = std::find(str, str_end, Char()); - auto sv = basic_string_view(str, to_unsigned(nul != str_end ? nul - str : specs.precision)); - arg = make_arg>(sv); - } - if (specs.alt && visit_format_arg(is_zero_int(), arg)) - specs.alt = false; - if (specs.fill[0] == '0') - { - if (arg.is_arithmetic() && specs.align != align::left) - specs.align = align::numeric; - else - specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' - // flag is also present. - } - - // Parse length and convert the argument to the required type. - c = it != end ? *it++ : 0; - Char t = it != end ? *it : 0; - switch (c) - { - case 'h': - if (t == 'h') - { - ++it; - t = it != end ? *it : 0; - convert_arg(arg, t); - } - else - { - convert_arg(arg, t); - } - break; - case 'l': - if (t == 'l') - { - ++it; - t = it != end ? *it : 0; - convert_arg(arg, t); - } - else - { - convert_arg(arg, t); - } - break; - case 'j': - convert_arg(arg, t); - break; - case 'z': - convert_arg(arg, t); - break; - case 't': - convert_arg(arg, t); - break; - case 'L': - // printf produces garbage when 'L' is omitted for long double, no - // need to do the same. - break; - default: - --it; - convert_arg(arg, c); - } - - // Parse type. - if (it == end) - throw_format_error("invalid format string"); - char type = static_cast(*it++); - if (arg.is_integral()) - { - // Normalize type. - switch (type) - { - case 'i': - case 'u': - type = 'd'; - break; - case 'c': - visit_format_arg(char_converter>(arg), arg); - break; - } - } - specs.type = parse_printf_presentation_type(type, arg.type()); - if (specs.type == presentation_type::none) - throw_format_error("invalid format specifier"); - - start = it; - - // Format argument. - visit_format_arg(printf_arg_formatter(out, specs, context), arg); - } - write(out, basic_string_view(start, to_unsigned(it - start))); + // Parse length and convert the argument to the required type. + c = it != end ? *it++ : 0; + Char t = it != end ? *it : 0; + switch (c) { + case 'h': + if (t == 'h') { + ++it; + t = it != end ? *it : 0; + convert_arg(arg, t); + } else { + convert_arg(arg, t); + } + break; + case 'l': + if (t == 'l') { + ++it; + t = it != end ? *it : 0; + convert_arg(arg, t); + } else { + convert_arg(arg, t); + } + break; + case 'j': + convert_arg(arg, t); + break; + case 'z': + convert_arg(arg, t); + break; + case 't': + convert_arg(arg, t); + break; + case 'L': + // printf produces garbage when 'L' is omitted for long double, no + // need to do the same. + break; + default: + --it; + convert_arg(arg, c); } -} // namespace detail + + // Parse type. + if (it == end) throw_format_error("invalid format string"); + char type = static_cast(*it++); + if (arg.is_integral()) { + // Normalize type. + switch (type) { + case 'i': + case 'u': + type = 'd'; + break; + case 'c': + visit_format_arg(char_converter>(arg), arg); + break; + } + } + specs.type = parse_printf_presentation_type(type, arg.type()); + if (specs.type == presentation_type::none) + throw_format_error("invalid format specifier"); + + start = it; + + // Format argument. + visit_format_arg(printf_arg_formatter(out, specs, context), arg); + } + write(out, basic_string_view(start, to_unsigned(it - start))); +} +} // namespace detail using printf_context = basic_printf_context; using wprintf_context = basic_printf_context; @@ -657,24 +576,26 @@ using wprintf_args = basic_format_args; \endrst */ template -inline auto make_printf_args(const T&... args) -> format_arg_store -{ - return {args...}; +inline auto make_printf_args(const T&... args) + -> format_arg_store { + return {args...}; } // DEPRECATED! template -inline auto make_wprintf_args(const T&... args) -> format_arg_store -{ - return {args...}; +inline auto make_wprintf_args(const T&... args) + -> format_arg_store { + return {args...}; } template -inline auto vsprintf(basic_string_view fmt, basic_format_args>> args) -> std::basic_string -{ - auto buf = basic_memory_buffer(); - detail::vprintf(buf, fmt, args); - return to_string(buf); +inline auto vsprintf( + basic_string_view fmt, + basic_format_args>> args) + -> std::basic_string { + auto buf = basic_memory_buffer(); + detail::vprintf(buf, fmt, args); + return to_string(buf); } /** @@ -686,19 +607,24 @@ inline auto vsprintf(basic_string_view fmt, basic_format_args::value, char_t>> -inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string -{ - return vsprintf(detail::to_string_view(fmt), fmt::make_format_args>(args...)); +template ::value, char_t>> +inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string { + return vsprintf(detail::to_string_view(fmt), + fmt::make_format_args>(args...)); } template -inline auto vfprintf(std::FILE* f, basic_string_view fmt, basic_format_args>> args) -> int -{ - auto buf = basic_memory_buffer(); - detail::vprintf(buf, fmt, args); - size_t size = buf.size(); - return std::fwrite(buf.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); +inline auto vfprintf( + std::FILE* f, basic_string_view fmt, + basic_format_args>> args) + -> int { + auto buf = basic_memory_buffer(); + detail::vprintf(buf, fmt, args); + size_t size = buf.size(); + return std::fwrite(buf.data(), sizeof(Char), size, f) < size + ? -1 + : static_cast(size); } /** @@ -711,15 +637,17 @@ inline auto vfprintf(std::FILE* f, basic_string_view fmt, basic_format_arg \endrst */ template > -inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int -{ - return vfprintf(f, detail::to_string_view(fmt), fmt::make_format_args>(args...)); +inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { + return vfprintf(f, detail::to_string_view(fmt), + fmt::make_format_args>(args...)); } template -FMT_DEPRECATED inline auto vprintf(basic_string_view fmt, basic_format_args>> args) -> int -{ - return vfprintf(stdout, fmt, args); +FMT_DEPRECATED inline auto vprintf( + basic_string_view fmt, + basic_format_args>> args) + -> int { + return vfprintf(stdout, fmt, args); } /** @@ -732,17 +660,16 @@ FMT_DEPRECATED inline auto vprintf(basic_string_view fmt, basic_format_arg \endrst */ template -inline auto printf(string_view fmt, const T&... args) -> int -{ - return vfprintf(stdout, fmt, make_printf_args(args...)); +inline auto printf(string_view fmt, const T&... args) -> int { + return vfprintf(stdout, fmt, make_printf_args(args...)); } template -FMT_DEPRECATED inline auto printf(basic_string_view fmt, const T&... args) -> int -{ - return vfprintf(stdout, fmt, make_wprintf_args(args...)); +FMT_DEPRECATED inline auto printf(basic_string_view fmt, + const T&... args) -> int { + return vfprintf(stdout, fmt, make_wprintf_args(args...)); } FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_PRINTF_H_ +#endif // FMT_PRINTF_H_ diff --git a/lib/spdlog/fmt/bundled/ranges.h b/lib/spdlog/fmt/bundled/ranges.h index 93637335..3638fffb 100644 --- a/lib/spdlog/fmt/bundled/ranges.h +++ b/lib/spdlog/fmt/bundled/ranges.h @@ -16,659 +16,677 @@ FMT_BEGIN_NAMESPACE -namespace detail -{ - - template - auto copy(const Range& range, OutputIt out) -> OutputIt - { - for (auto it = range.begin(), end = range.end(); it != end; ++it) - *out++ = *it; - return out; - } +namespace detail { - template - auto copy(const char* str, OutputIt out) -> OutputIt - { - while (*str) - *out++ = *str++; - return out; - } +template +auto copy(const Range& range, OutputIt out) -> OutputIt { + for (auto it = range.begin(), end = range.end(); it != end; ++it) + *out++ = *it; + return out; +} - template - auto copy(char ch, OutputIt out) -> OutputIt - { - *out++ = ch; - return out; - } +template +auto copy(const char* str, OutputIt out) -> OutputIt { + while (*str) *out++ = *str++; + return out; +} - template - auto copy(wchar_t ch, OutputIt out) -> OutputIt - { - *out++ = ch; - return out; - } +template auto copy(char ch, OutputIt out) -> OutputIt { + *out++ = ch; + return out; +} - // Returns true if T has a std::string-like interface, like std::string_view. - template - class is_std_string_like { - template - static auto check(U* p) -> decltype((void)p->find('a'), p->length(), (void)p->data(), int()); - template - static void check(...); +template auto copy(wchar_t ch, OutputIt out) -> OutputIt { + *out++ = ch; + return out; +} - public: - static constexpr const bool value = is_string::value || std::is_convertible>::value || !std::is_void(nullptr))>::value; - }; +// Returns true if T has a std::string-like interface, like std::string_view. +template class is_std_string_like { + template + static auto check(U* p) + -> decltype((void)p->find('a'), p->length(), (void)p->data(), int()); + template static void check(...); + + public: + static constexpr const bool value = + is_string::value || + std::is_convertible>::value || + !std::is_void(nullptr))>::value; +}; - template - struct is_std_string_like> : std::true_type {}; +template +struct is_std_string_like> : std::true_type {}; - template - class is_map { - template - static auto check(U*) -> typename U::mapped_type; - template - static void check(...); +template class is_map { + template static auto check(U*) -> typename U::mapped_type; + template static void check(...); - public: -#ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED! - static constexpr const bool value = false; + public: +#ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED! + static constexpr const bool value = false; #else - static constexpr const bool value = !std::is_void(nullptr))>::value; + static constexpr const bool value = + !std::is_void(nullptr))>::value; #endif - }; +}; - template - class is_set { - template - static auto check(U*) -> typename U::key_type; - template - static void check(...); +template class is_set { + template static auto check(U*) -> typename U::key_type; + template static void check(...); - public: -#ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED! - static constexpr const bool value = false; + public: +#ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED! + static constexpr const bool value = false; #else - static constexpr const bool value = !std::is_void(nullptr))>::value && !is_map::value; + static constexpr const bool value = + !std::is_void(nullptr))>::value && !is_map::value; #endif - }; +}; - template - struct conditional_helper {}; +template struct conditional_helper {}; - template - struct is_range_ : std::false_type {}; +template struct is_range_ : std::false_type {}; #if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800 -#define FMT_DECLTYPE_RETURN(val) \ - ->decltype(val) { return val; } \ - static_assert(true, "") // This makes it so that a semicolon is required after the - // macro, which helps clang-format handle the formatting. +# define FMT_DECLTYPE_RETURN(val) \ + ->decltype(val) { return val; } \ + static_assert( \ + true, "") // This makes it so that a semicolon is required after the + // macro, which helps clang-format handle the formatting. - // C array overload - template - auto range_begin(const T (&arr)[N]) -> const T* - { - return arr; - } - template - auto range_end(const T (&arr)[N]) -> const T* - { - return arr + N; - } +// C array overload +template +auto range_begin(const T (&arr)[N]) -> const T* { + return arr; +} +template +auto range_end(const T (&arr)[N]) -> const T* { + return arr + N; +} - template - struct has_member_fn_begin_end_t : std::false_type {}; +template +struct has_member_fn_begin_end_t : std::false_type {}; - template - struct has_member_fn_begin_end_t().begin()), decltype(std::declval().end())>> : std::true_type {}; +template +struct has_member_fn_begin_end_t().begin()), + decltype(std::declval().end())>> + : std::true_type {}; - // Member function overload - template - auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).begin()); - template - auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).end()); +// Member function overload +template +auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).begin()); +template +auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast(rng).end()); - // ADL overload. Only participates in overload resolution if member functions - // are not found. - template - auto range_begin(T&& rng) -> enable_if_t::value, decltype(begin(static_cast(rng)))> - { - return begin(static_cast(rng)); - } - template - auto range_end(T&& rng) -> enable_if_t::value, decltype(end(static_cast(rng)))> - { - return end(static_cast(rng)); - } +// ADL overload. Only participates in overload resolution if member functions +// are not found. +template +auto range_begin(T&& rng) + -> enable_if_t::value, + decltype(begin(static_cast(rng)))> { + return begin(static_cast(rng)); +} +template +auto range_end(T&& rng) -> enable_if_t::value, + decltype(end(static_cast(rng)))> { + return end(static_cast(rng)); +} - template - struct has_const_begin_end : std::false_type {}; - template - struct has_mutable_begin_end : std::false_type {}; +template +struct has_const_begin_end : std::false_type {}; +template +struct has_mutable_begin_end : std::false_type {}; - template - struct has_const_begin_end&>())), decltype(detail::range_end(std::declval&>()))>> : std::true_type {}; +template +struct has_const_begin_end< + T, + void_t< + decltype(detail::range_begin(std::declval&>())), + decltype(detail::range_end(std::declval&>()))>> + : std::true_type {}; - template - struct has_mutable_begin_end())), decltype(detail::range_end(std::declval())), - // the extra int here is because older versions of MSVC don't - // SFINAE properly unless there are distinct types - int>> : std::true_type {}; +template +struct has_mutable_begin_end< + T, void_t())), + decltype(detail::range_end(std::declval())), + // the extra int here is because older versions of MSVC don't + // SFINAE properly unless there are distinct types + int>> : std::true_type {}; - template - struct is_range_ : std::integral_constant::value || has_mutable_begin_end::value)> {}; -#undef FMT_DECLTYPE_RETURN +template +struct is_range_ + : std::integral_constant::value || + has_mutable_begin_end::value)> {}; +# undef FMT_DECLTYPE_RETURN #endif - // tuple_size and tuple_element check. - template - class is_tuple_like_ { - template - static auto check(U* p) -> decltype(std::tuple_size::value, int()); - template - static void check(...); +// tuple_size and tuple_element check. +template class is_tuple_like_ { + template + static auto check(U* p) -> decltype(std::tuple_size::value, int()); + template static void check(...); - public: - static constexpr const bool value = !std::is_void(nullptr))>::value; - }; + public: + static constexpr const bool value = + !std::is_void(nullptr))>::value; +}; // Check for integer_sequence #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900 - template - using integer_sequence = std::integer_sequence; - template - using index_sequence = std::index_sequence; - template - using make_index_sequence = std::make_index_sequence; +template +using integer_sequence = std::integer_sequence; +template using index_sequence = std::index_sequence; +template using make_index_sequence = std::make_index_sequence; #else - template - struct integer_sequence { - using value_type = T; +template struct integer_sequence { + using value_type = T; - static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } - }; + static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } +}; - template - using index_sequence = integer_sequence; +template using index_sequence = integer_sequence; - template - struct make_integer_sequence : make_integer_sequence {}; - template - struct make_integer_sequence : integer_sequence {}; +template +struct make_integer_sequence : make_integer_sequence {}; +template +struct make_integer_sequence : integer_sequence {}; - template - using make_index_sequence = make_integer_sequence; +template +using make_index_sequence = make_integer_sequence; #endif - template - using tuple_index_sequence = make_index_sequence::value>; +template +using tuple_index_sequence = make_index_sequence::value>; - template ::value> - class is_tuple_formattable_ { - public: - static constexpr const bool value = false; - }; - template - class is_tuple_formattable_ { - template - static auto check2(index_sequence, integer_sequence) -> std::true_type; - static auto check2(...) -> std::false_type; - template - static auto check(index_sequence) -> decltype(check2(index_sequence{}, integer_sequence::type, C>::value)...>{})); - - public: - static constexpr const bool value = decltype(check(tuple_index_sequence{}))::value; - }; +template ::value> +class is_tuple_formattable_ { + public: + static constexpr const bool value = false; +}; +template class is_tuple_formattable_ { + template + static auto check2(index_sequence, + integer_sequence) -> std::true_type; + static auto check2(...) -> std::false_type; + template + static auto check(index_sequence) -> decltype(check2( + index_sequence{}, + integer_sequence::type, + C>::value)...>{})); + + public: + static constexpr const bool value = + decltype(check(tuple_index_sequence{}))::value; +}; - template - FMT_CONSTEXPR void for_each(index_sequence, Tuple&& t, F&& f) - { - using std::get; - // Using a free function get(Tuple) now. - const int unused[] = {0, ((void)f(get(t)), 0)...}; - ignore_unused(unused); - } +template +FMT_CONSTEXPR void for_each(index_sequence, Tuple&& t, F&& f) { + using std::get; + // Using a free function get(Tuple) now. + const int unused[] = {0, ((void)f(get(t)), 0)...}; + ignore_unused(unused); +} - template - FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) - { - for_each(tuple_index_sequence>(), std::forward(t), std::forward(f)); - } +template +FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) { + for_each(tuple_index_sequence>(), + std::forward(t), std::forward(f)); +} - template - void for_each2(index_sequence, Tuple1&& t1, Tuple2&& t2, F&& f) - { - using std::get; - const int unused[] = {0, ((void)f(get(t1), get(t2)), 0)...}; - ignore_unused(unused); - } +template +void for_each2(index_sequence, Tuple1&& t1, Tuple2&& t2, F&& f) { + using std::get; + const int unused[] = {0, ((void)f(get(t1), get(t2)), 0)...}; + ignore_unused(unused); +} - template - void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) - { - for_each2(tuple_index_sequence>(), std::forward(t1), std::forward(t2), std::forward(f)); - } +template +void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) { + for_each2(tuple_index_sequence>(), + std::forward(t1), std::forward(t2), + std::forward(f)); +} - namespace tuple - { - // Workaround a bug in MSVC 2019 (v140). - template - using result_t = std::tuple, Char>...>; +namespace tuple { +// Workaround a bug in MSVC 2019 (v140). +template +using result_t = std::tuple, Char>...>; - using std::get; - template - auto get_formatters(index_sequence) -> result_t(std::declval()))...>; - } // namespace tuple +using std::get; +template +auto get_formatters(index_sequence) + -> result_t(std::declval()))...>; +} // namespace tuple #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920 - // Older MSVC doesn't get the reference type correctly for arrays. - template - struct range_reference_type_impl { - using type = decltype(*detail::range_begin(std::declval())); - }; +// Older MSVC doesn't get the reference type correctly for arrays. +template struct range_reference_type_impl { + using type = decltype(*detail::range_begin(std::declval())); +}; - template - struct range_reference_type_impl { - using type = T&; - }; +template struct range_reference_type_impl { + using type = T&; +}; - template - using range_reference_type = typename range_reference_type_impl::type; +template +using range_reference_type = typename range_reference_type_impl::type; #else - template - using range_reference_type = decltype(*detail::range_begin(std::declval())); +template +using range_reference_type = + decltype(*detail::range_begin(std::declval())); #endif - // We don't use the Range's value_type for anything, but we do need the Range's - // reference type, with cv-ref stripped. - template - using uncvref_type = remove_cvref_t>; +// We don't use the Range's value_type for anything, but we do need the Range's +// reference type, with cv-ref stripped. +template +using uncvref_type = remove_cvref_t>; - template - FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) -> decltype(f.set_debug_format(set)) - { - f.set_debug_format(set); - } - template - FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) - { - } - - // These are not generic lambdas for compatibility with C++11. - template - struct parse_empty_specs { - template - FMT_CONSTEXPR void operator()(Formatter& f) - { - f.parse(ctx); - detail::maybe_set_debug_format(f, true); - } - ParseContext& ctx; - }; - template - struct format_tuple_element { - using char_type = typename FormatContext::char_type; - - template - void operator()(const formatter& f, const T& v) - { - if (i > 0) - ctx.advance_to(detail::copy_str(separator, ctx.out())); - ctx.advance_to(f.format(v, ctx)); - ++i; - } - - int i; - FormatContext& ctx; - basic_string_view separator; - }; +template +FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) + -> decltype(f.set_debug_format(set)) { + f.set_debug_format(set); +} +template +FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} + +// These are not generic lambdas for compatibility with C++11. +template struct parse_empty_specs { + template FMT_CONSTEXPR void operator()(Formatter& f) { + f.parse(ctx); + detail::maybe_set_debug_format(f, true); + } + ParseContext& ctx; +}; +template struct format_tuple_element { + using char_type = typename FormatContext::char_type; + + template + void operator()(const formatter& f, const T& v) { + if (i > 0) + ctx.advance_to(detail::copy_str(separator, ctx.out())); + ctx.advance_to(f.format(v, ctx)); + ++i; + } + + int i; + FormatContext& ctx; + basic_string_view separator; +}; -} // namespace detail +} // namespace detail -template -struct is_tuple_like { - static constexpr const bool value = detail::is_tuple_like_::value && !detail::is_range_::value; +template struct is_tuple_like { + static constexpr const bool value = + detail::is_tuple_like_::value && !detail::is_range_::value; }; -template -struct is_tuple_formattable { - static constexpr const bool value = detail::is_tuple_formattable_::value; +template struct is_tuple_formattable { + static constexpr const bool value = + detail::is_tuple_formattable_::value; }; template -struct formatter::value && fmt::is_tuple_formattable::value>> { -private: - decltype(detail::tuple::get_formatters(detail::tuple_index_sequence())) formatters_; - - basic_string_view separator_ = detail::string_literal{}; - basic_string_view opening_bracket_ = detail::string_literal{}; - basic_string_view closing_bracket_ = detail::string_literal{}; - -public: - FMT_CONSTEXPR formatter() {} - - FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } - - FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) - { - opening_bracket_ = open; - closing_bracket_ = close; - } - - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(); - if (it != ctx.end() && *it != '}') - FMT_THROW(format_error("invalid format specifier")); - detail::for_each(formatters_, detail::parse_empty_specs{ctx}); - return it; - } - - template - auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) - { - ctx.advance_to(detail::copy_str(opening_bracket_, ctx.out())); - detail::for_each2(formatters_, value, detail::format_tuple_element{0, ctx, separator_}); - return detail::copy_str(closing_bracket_, ctx.out()); - } +struct formatter::value && + fmt::is_tuple_formattable::value>> { + private: + decltype(detail::tuple::get_formatters( + detail::tuple_index_sequence())) formatters_; + + basic_string_view separator_ = detail::string_literal{}; + basic_string_view opening_bracket_ = + detail::string_literal{}; + basic_string_view closing_bracket_ = + detail::string_literal{}; + + public: + FMT_CONSTEXPR formatter() {} + + FMT_CONSTEXPR void set_separator(basic_string_view sep) { + separator_ = sep; + } + + FMT_CONSTEXPR void set_brackets(basic_string_view open, + basic_string_view close) { + opening_bracket_ = open; + closing_bracket_ = close; + } + + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + auto it = ctx.begin(); + if (it != ctx.end() && *it != '}') + FMT_THROW(format_error("invalid format specifier")); + detail::for_each(formatters_, detail::parse_empty_specs{ctx}); + return it; + } + + template + auto format(const Tuple& value, FormatContext& ctx) const + -> decltype(ctx.out()) { + ctx.advance_to(detail::copy_str(opening_bracket_, ctx.out())); + detail::for_each2( + formatters_, value, + detail::format_tuple_element{0, ctx, separator_}); + return detail::copy_str(closing_bracket_, ctx.out()); + } }; -template -struct is_range { - static constexpr const bool value = detail::is_range_::value && !detail::is_std_string_like::value && !std::is_convertible>::value && !std::is_convertible>::value; +template struct is_range { + static constexpr const bool value = + detail::is_range_::value && !detail::is_std_string_like::value && + !std::is_convertible>::value && + !std::is_convertible>::value; }; -namespace detail -{ - template - struct range_mapper { - using mapper = arg_mapper; - - template , Context>::value)> - static auto map(T&& value) -> T&& - { - return static_cast(value); - } - template , Context>::value)> - static auto map(T&& value) -> decltype(mapper().map(static_cast(value))) - { - return mapper().map(static_cast(value)); - } - }; +namespace detail { +template struct range_mapper { + using mapper = arg_mapper; + + template , Context>::value)> + static auto map(T&& value) -> T&& { + return static_cast(value); + } + template , Context>::value)> + static auto map(T&& value) + -> decltype(mapper().map(static_cast(value))) { + return mapper().map(static_cast(value)); + } +}; - template - using range_formatter_type = formatter>{}.map(std::declval()))>, Char>; +template +using range_formatter_type = + formatter>{}.map( + std::declval()))>, + Char>; - template - using maybe_const_range = conditional_t::value, const R, R>; +template +using maybe_const_range = + conditional_t::value, const R, R>; // Workaround a bug in MSVC 2015 and earlier. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 - template - struct is_formattable_delayed : is_formattable>, Char> {}; +template +struct is_formattable_delayed + : is_formattable>, Char> {}; #endif -} // namespace detail +} // namespace detail -template -struct conjunction : std::true_type {}; -template -struct conjunction

: P {}; +template struct conjunction : std::true_type {}; +template struct conjunction

: P {}; template -struct conjunction : conditional_t, P1> {}; +struct conjunction + : conditional_t, P1> {}; template struct range_formatter; template -struct range_formatter>, is_formattable>::value>> { -private: - detail::range_formatter_type underlying_; - basic_string_view separator_ = detail::string_literal{}; - basic_string_view opening_bracket_ = detail::string_literal{}; - basic_string_view closing_bracket_ = detail::string_literal{}; - -public: - FMT_CONSTEXPR range_formatter() {} - - FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type& { return underlying_; } - - FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } - - FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) - { - opening_bracket_ = open; - closing_bracket_ = close; +struct range_formatter< + T, Char, + enable_if_t>, + is_formattable>::value>> { + private: + detail::range_formatter_type underlying_; + basic_string_view separator_ = detail::string_literal{}; + basic_string_view opening_bracket_ = + detail::string_literal{}; + basic_string_view closing_bracket_ = + detail::string_literal{}; + + public: + FMT_CONSTEXPR range_formatter() {} + + FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type& { + return underlying_; + } + + FMT_CONSTEXPR void set_separator(basic_string_view sep) { + separator_ = sep; + } + + FMT_CONSTEXPR void set_brackets(basic_string_view open, + basic_string_view close) { + opening_bracket_ = open; + closing_bracket_ = close; + } + + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + auto it = ctx.begin(); + auto end = ctx.end(); + + if (it != end && *it == 'n') { + set_brackets({}, {}); + ++it; } - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(); - auto end = ctx.end(); - - if (it != end && *it == 'n') - { - set_brackets({}, {}); - ++it; - } - - if (it != end && *it != '}') - { - if (*it != ':') - FMT_THROW(format_error("invalid format specifier")); - ++it; - } - else - { - detail::maybe_set_debug_format(underlying_, true); - } - - ctx.advance_to(it); - return underlying_.parse(ctx); + if (it != end && *it != '}') { + if (*it != ':') FMT_THROW(format_error("invalid format specifier")); + ++it; + } else { + detail::maybe_set_debug_format(underlying_, true); } - template - auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) - { - detail::range_mapper> mapper; - auto out = ctx.out(); - out = detail::copy_str(opening_bracket_, out); - int i = 0; - auto it = detail::range_begin(range); - auto end = detail::range_end(range); - for (; it != end; ++it) - { - if (i > 0) - out = detail::copy_str(separator_, out); - ctx.advance_to(out); - auto&& item = *it; - out = underlying_.format(mapper.map(item), ctx); - ++i; - } - out = detail::copy_str(closing_bracket_, out); - return out; + ctx.advance_to(it); + return underlying_.parse(ctx); + } + + template + auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { + detail::range_mapper> mapper; + auto out = ctx.out(); + out = detail::copy_str(opening_bracket_, out); + int i = 0; + auto it = detail::range_begin(range); + auto end = detail::range_end(range); + for (; it != end; ++it) { + if (i > 0) out = detail::copy_str(separator_, out); + ctx.advance_to(out); + auto&& item = *it; + out = underlying_.format(mapper.map(item), ctx); + ++i; } + out = detail::copy_str(closing_bracket_, out); + return out; + } }; enum class range_format { disabled, map, set, sequence, string, debug_string }; -namespace detail -{ - template - struct range_format_kind_ : std::integral_constant, T>::value ? range_format::disabled - : is_map::value ? range_format::map - : is_set::value ? range_format::set - : range_format::sequence> {}; - - template - struct range_default_formatter; - - template - using range_format_constant = std::integral_constant; - - template - struct range_default_formatter> { - using range_type = detail::maybe_const_range; - range_formatter, Char> underlying_; - - FMT_CONSTEXPR range_default_formatter() { init(range_format_constant()); } - - FMT_CONSTEXPR void init(range_format_constant) { underlying_.set_brackets(detail::string_literal{}, detail::string_literal{}); } - - FMT_CONSTEXPR void init(range_format_constant) - { - underlying_.set_brackets(detail::string_literal{}, detail::string_literal{}); - underlying_.underlying().set_brackets({}, {}); - underlying_.underlying().set_separator(detail::string_literal{}); - } - - FMT_CONSTEXPR void init(range_format_constant) {} - - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - return underlying_.parse(ctx); - } - - template - auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) - { - return underlying_.format(range, ctx); - } - }; -} // namespace detail +namespace detail { +template +struct range_format_kind_ + : std::integral_constant, T>::value + ? range_format::disabled + : is_map::value ? range_format::map + : is_set::value ? range_format::set + : range_format::sequence> {}; + +template +struct range_default_formatter; + +template +using range_format_constant = std::integral_constant; + +template +struct range_default_formatter< + K, R, Char, + enable_if_t<(K == range_format::sequence || K == range_format::map || + K == range_format::set)>> { + using range_type = detail::maybe_const_range; + range_formatter, Char> underlying_; + + FMT_CONSTEXPR range_default_formatter() { init(range_format_constant()); } + + FMT_CONSTEXPR void init(range_format_constant) { + underlying_.set_brackets(detail::string_literal{}, + detail::string_literal{}); + } + + FMT_CONSTEXPR void init(range_format_constant) { + underlying_.set_brackets(detail::string_literal{}, + detail::string_literal{}); + underlying_.underlying().set_brackets({}, {}); + underlying_.underlying().set_separator( + detail::string_literal{}); + } + + FMT_CONSTEXPR void init(range_format_constant) {} + + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return underlying_.parse(ctx); + } + + template + auto format(range_type& range, FormatContext& ctx) const + -> decltype(ctx.out()) { + return underlying_.format(range, ctx); + } +}; +} // namespace detail template -struct range_format_kind : conditional_t::value, detail::range_format_kind_, std::integral_constant> {}; +struct range_format_kind + : conditional_t< + is_range::value, detail::range_format_kind_, + std::integral_constant> {}; template -struct formatter::value != range_format::disabled> +struct formatter< + R, Char, + enable_if_t::value != + range_format::disabled> // Workaround a bug in MSVC 2015 and earlier. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910 - , - detail::is_formattable_delayed + , + detail::is_formattable_delayed #endif - >::value>> : detail::range_default_formatter::value, R, Char> { + >::value>> + : detail::range_default_formatter::value, R, + Char> { }; -template -struct tuple_join_view : detail::view { - const std::tuple& tuple; - basic_string_view sep; +template struct tuple_join_view : detail::view { + const std::tuple& tuple; + basic_string_view sep; - tuple_join_view(const std::tuple& t, basic_string_view s) : tuple(t), sep{s} {} + tuple_join_view(const std::tuple& t, basic_string_view s) + : tuple(t), sep{s} {} }; // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers // support in tuple_join. It is disabled by default because of issues with // the dynamic width and precision. #ifndef FMT_TUPLE_JOIN_SPECIFIERS -#define FMT_TUPLE_JOIN_SPECIFIERS 0 +# define FMT_TUPLE_JOIN_SPECIFIERS 0 #endif template struct formatter, Char> { - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - return do_parse(ctx, std::integral_constant()); - } - - template - auto format(const tuple_join_view& value, FormatContext& ctx) const -> typename FormatContext::iterator - { - return do_format(value, ctx, std::integral_constant()); - } - -private: - std::tuple::type, Char>...> formatters_; - - template - FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) -> decltype(ctx.begin()) - { - return ctx.begin(); - } - - template - FMT_CONSTEXPR auto do_parse(ParseContext& ctx, std::integral_constant) -> decltype(ctx.begin()) - { - auto end = ctx.begin(); + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return do_parse(ctx, std::integral_constant()); + } + + template + auto format(const tuple_join_view& value, + FormatContext& ctx) const -> typename FormatContext::iterator { + return do_format(value, ctx, + std::integral_constant()); + } + + private: + std::tuple::type, Char>...> formatters_; + + template + FMT_CONSTEXPR auto do_parse(ParseContext& ctx, + std::integral_constant) + -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + FMT_CONSTEXPR auto do_parse(ParseContext& ctx, + std::integral_constant) + -> decltype(ctx.begin()) { + auto end = ctx.begin(); #if FMT_TUPLE_JOIN_SPECIFIERS - end = std::get(formatters_).parse(ctx); - if (N > 1) - { - auto end1 = do_parse(ctx, std::integral_constant()); - if (end != end1) - FMT_THROW(format_error("incompatible format specs for tuple elements")); - } + end = std::get(formatters_).parse(ctx); + if (N > 1) { + auto end1 = do_parse(ctx, std::integral_constant()); + if (end != end1) + FMT_THROW(format_error("incompatible format specs for tuple elements")); + } #endif - return end; + return end; + } + + template + auto do_format(const tuple_join_view&, FormatContext& ctx, + std::integral_constant) const -> + typename FormatContext::iterator { + return ctx.out(); + } + + template + auto do_format(const tuple_join_view& value, FormatContext& ctx, + std::integral_constant) const -> + typename FormatContext::iterator { + auto out = std::get(formatters_) + .format(std::get(value.tuple), ctx); + if (N > 1) { + out = std::copy(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + return do_format(value, ctx, std::integral_constant()); } + return out; + } +}; - template - auto do_format(const tuple_join_view&, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator - { - return ctx.out(); - } +namespace detail { +// Check if T has an interface like a container adaptor (e.g. std::stack, +// std::queue, std::priority_queue). +template class is_container_adaptor_like { + template static auto check(U* p) -> typename U::container_type; + template static void check(...); - template - auto do_format(const tuple_join_view& value, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator - { - auto out = std::get(formatters_).format(std::get(value.tuple), ctx); - if (N > 1) - { - out = std::copy(value.sep.begin(), value.sep.end(), out); - ctx.advance_to(out); - return do_format(value, ctx, std::integral_constant()); - } - return out; - } + public: + static constexpr const bool value = + !std::is_void(nullptr))>::value; }; -namespace detail -{ - // Check if T has an interface like a container adaptor (e.g. std::stack, - // std::queue, std::priority_queue). - template - class is_container_adaptor_like { - template - static auto check(U* p) -> typename U::container_type; - template - static void check(...); - - public: - static constexpr const bool value = !std::is_void(nullptr))>::value; - }; - - template - struct all { - const Container& c; - auto begin() const -> typename Container::const_iterator { return c.begin(); } - auto end() const -> typename Container::const_iterator { return c.end(); } - }; -} // namespace detail +template struct all { + const Container& c; + auto begin() const -> typename Container::const_iterator { return c.begin(); } + auto end() const -> typename Container::const_iterator { return c.end(); } +}; +} // namespace detail template -struct formatter, bool_constant::value == range_format::disabled>>::value>> : formatter, Char> { - using all = detail::all; - template - auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) - { - struct getter : T { - static auto get(const T& t) -> all - { - return {t.*(&getter::c)}; // Access c through the derived class. - } - }; - return formatter::format(getter::get(t), ctx); - } +struct formatter< + T, Char, + enable_if_t, + bool_constant::value == + range_format::disabled>>::value>> + : formatter, Char> { + using all = detail::all; + template + auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) { + struct getter : T { + static auto get(const T& t) -> all { + return {t.*(&getter::c)}; // Access c through the derived class. + } + }; + return formatter::format(getter::get(t), ctx); + } }; FMT_BEGIN_EXPORT @@ -685,15 +703,16 @@ FMT_BEGIN_EXPORT \endrst */ template -FMT_CONSTEXPR auto join(const std::tuple& tuple, string_view sep) -> tuple_join_view -{ - return {tuple, sep}; +FMT_CONSTEXPR auto join(const std::tuple& tuple, string_view sep) + -> tuple_join_view { + return {tuple, sep}; } template -FMT_CONSTEXPR auto join(const std::tuple& tuple, basic_string_view sep) -> tuple_join_view -{ - return {tuple, sep}; +FMT_CONSTEXPR auto join(const std::tuple& tuple, + basic_string_view sep) + -> tuple_join_view { + return {tuple, sep}; } /** @@ -708,12 +727,12 @@ FMT_CONSTEXPR auto join(const std::tuple& tuple, basic_string_view -auto join(std::initializer_list list, string_view sep) -> join_view -{ - return join(std::begin(list), std::end(list), sep); +auto join(std::initializer_list list, string_view sep) + -> join_view { + return join(std::begin(list), std::end(list), sep); } FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_RANGES_H_ +#endif // FMT_RANGES_H_ diff --git a/lib/spdlog/fmt/bundled/std.h b/lib/spdlog/fmt/bundled/std.h index d49849d1..7cff1159 100644 --- a/lib/spdlog/fmt/bundled/std.h +++ b/lib/spdlog/fmt/bundled/std.h @@ -23,184 +23,174 @@ #include "ostream.h" #if FMT_HAS_INCLUDE() -#include +# include #endif // Checking FMT_CPLUSPLUS for warning suppression in MSVC. #if FMT_CPLUSPLUS >= 201703L -#if FMT_HAS_INCLUDE() -#include -#endif -#if FMT_HAS_INCLUDE() -#include -#endif -#if FMT_HAS_INCLUDE() -#include -#endif +# if FMT_HAS_INCLUDE() +# include +# endif +# if FMT_HAS_INCLUDE() +# include +# endif +# if FMT_HAS_INCLUDE() +# include +# endif #endif #if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE() -#include +# include #endif // GCC 4 does not support FMT_HAS_INCLUDE. #if FMT_HAS_INCLUDE() || defined(__GLIBCXX__) -#include +# include // Android NDK with gabi++ library on some architectures does not implement // abi::__cxa_demangle(). -#ifndef __GABIXX_CXXABI_H__ -#define FMT_HAS_ABI_CXA_DEMANGLE -#endif +# ifndef __GABIXX_CXXABI_H__ +# define FMT_HAS_ABI_CXA_DEMANGLE +# endif #endif // Check if typeid is available. #ifndef FMT_USE_TYPEID // __RTTI is for EDG compilers. In MSVC typeid is available without RTTI. -#if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || defined(__INTEL_RTTI__) || defined(__RTTI) -#define FMT_USE_TYPEID 1 -#else -#define FMT_USE_TYPEID 0 -#endif +# if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \ + defined(__INTEL_RTTI__) || defined(__RTTI) +# define FMT_USE_TYPEID 1 +# else +# define FMT_USE_TYPEID 0 +# endif #endif // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. #ifndef FMT_CPP_LIB_FILESYSTEM -#ifdef __cpp_lib_filesystem -#define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem -#else -#define FMT_CPP_LIB_FILESYSTEM 0 -#endif +# ifdef __cpp_lib_filesystem +# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem +# else +# define FMT_CPP_LIB_FILESYSTEM 0 +# endif #endif #ifndef FMT_CPP_LIB_VARIANT -#ifdef __cpp_lib_variant -#define FMT_CPP_LIB_VARIANT __cpp_lib_variant -#else -#define FMT_CPP_LIB_VARIANT 0 -#endif +# ifdef __cpp_lib_variant +# define FMT_CPP_LIB_VARIANT __cpp_lib_variant +# else +# define FMT_CPP_LIB_VARIANT 0 +# endif #endif #if FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE -namespace detail -{ - - template - auto get_path_string(const std::filesystem::path& p, const std::basic_string& native) - { - if constexpr (std::is_same_v && std::is_same_v) - return to_utf8(native, to_utf8_error_policy::replace); - else - return p.string(); - } - - template - void write_escaped_path(basic_memory_buffer& quoted, const std::filesystem::path& p, const std::basic_string& native) - { - if constexpr (std::is_same_v && std::is_same_v) - { - auto buf = basic_memory_buffer(); - write_escaped_string(std::back_inserter(buf), native); - bool valid = to_utf8::convert(quoted, {buf.data(), buf.size()}); - FMT_ASSERT(valid, "invalid utf16"); - } - else if constexpr (std::is_same_v) - { - write_escaped_string(std::back_inserter(quoted), native); - } - else - { - write_escaped_string(std::back_inserter(quoted), p.string()); - } - } - -} // namespace detail +namespace detail { + +template +auto get_path_string(const std::filesystem::path& p, + const std::basic_string& native) { + if constexpr (std::is_same_v && std::is_same_v) + return to_utf8(native, to_utf8_error_policy::replace); + else + return p.string(); +} + +template +void write_escaped_path(basic_memory_buffer& quoted, + const std::filesystem::path& p, + const std::basic_string& native) { + if constexpr (std::is_same_v && + std::is_same_v) { + auto buf = basic_memory_buffer(); + write_escaped_string(std::back_inserter(buf), native); + bool valid = to_utf8::convert(quoted, {buf.data(), buf.size()}); + FMT_ASSERT(valid, "invalid utf16"); + } else if constexpr (std::is_same_v) { + write_escaped_string( + std::back_inserter(quoted), native); + } else { + write_escaped_string(std::back_inserter(quoted), p.string()); + } +} + +} // namespace detail FMT_EXPORT -template -struct formatter { -private: - format_specs specs_; - detail::arg_ref width_ref_; - bool debug_ = false; - char path_type_ = 0; - -public: - FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } - - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) - { - auto it = ctx.begin(), end = ctx.end(); - if (it == end) - return it; - - it = detail::parse_align(it, end, specs_); - if (it == end) - return it; - - it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); - if (it != end && *it == '?') - { - debug_ = true; - ++it; - } - if (it != end && (*it == 'g')) - path_type_ = *it++; - return it; +template struct formatter { + private: + format_specs specs_; + detail::arg_ref width_ref_; + bool debug_ = false; + char path_type_ = 0; + + public: + FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } + + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { + auto it = ctx.begin(), end = ctx.end(); + if (it == end) return it; + + it = detail::parse_align(it, end, specs_); + if (it == end) return it; + + it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx); + if (it != end && *it == '?') { + debug_ = true; + ++it; } - - template - auto format(const std::filesystem::path& p, FormatContext& ctx) const - { - auto specs = specs_; -#ifdef _WIN32 - auto path_string = !path_type_ ? p.native() : p.generic_wstring(); -#else - auto path_string = !path_type_ ? p.native() : p.generic_string(); -#endif - - detail::handle_dynamic_spec(specs.width, width_ref_, ctx); - if (!debug_) - { - auto s = detail::get_path_string(p, path_string); - return detail::write(ctx.out(), basic_string_view(s), specs); - } - auto quoted = basic_memory_buffer(); - detail::write_escaped_path(quoted, p, path_string); - return detail::write(ctx.out(), basic_string_view(quoted.data(), quoted.size()), specs); + if (it != end && (*it == 'g')) path_type_ = *it++; + return it; + } + + template + auto format(const std::filesystem::path& p, FormatContext& ctx) const { + auto specs = specs_; +# ifdef _WIN32 + auto path_string = !path_type_ ? p.native() : p.generic_wstring(); +# else + auto path_string = !path_type_ ? p.native() : p.generic_string(); +# endif + + detail::handle_dynamic_spec(specs.width, width_ref_, + ctx); + if (!debug_) { + auto s = detail::get_path_string(p, path_string); + return detail::write(ctx.out(), basic_string_view(s), specs); } + auto quoted = basic_memory_buffer(); + detail::write_escaped_path(quoted, p, path_string); + return detail::write(ctx.out(), + basic_string_view(quoted.data(), quoted.size()), + specs); + } }; FMT_END_NAMESPACE -#endif // FMT_CPP_LIB_FILESYSTEM +#endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE FMT_EXPORT template struct formatter, Char> : nested_formatter { -private: - // Functor because C++11 doesn't support generic lambdas. - struct writer { - const std::bitset& bs; - - template - FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt - { - for (auto pos = N; pos > 0; --pos) - { - out = detail::write(out, bs[pos - 1] ? Char('1') : Char('0')); - } + private: + // Functor because C++11 doesn't support generic lambdas. + struct writer { + const std::bitset& bs; - return out; - } - }; + template + FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { + for (auto pos = N; pos > 0; --pos) { + out = detail::write(out, bs[pos - 1] ? Char('1') : Char('0')); + } -public: - template - auto format(const std::bitset& bs, FormatContext& ctx) const -> decltype(ctx.out()) - { - return write_padded(ctx, writer{bs}); + return out; } + }; + + public: + template + auto format(const std::bitset& bs, FormatContext& ctx) const + -> decltype(ctx.out()) { + return write_padded(ctx, writer{bs}); + } }; FMT_EXPORT @@ -212,340 +202,336 @@ FMT_END_NAMESPACE FMT_BEGIN_NAMESPACE FMT_EXPORT template -struct formatter, Char, std::enable_if_t::value>> { -private: - formatter underlying_; - static constexpr basic_string_view optional = detail::string_literal{}; - static constexpr basic_string_view none = detail::string_literal{}; - - template - FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) -> decltype(u.set_debug_format(set)) - { - u.set_debug_format(set); - } - - template - FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) - { - } - -public: - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) - { - maybe_set_debug_format(underlying_, true); - return underlying_.parse(ctx); - } - - template - auto format(const std::optional& opt, FormatContext& ctx) const -> decltype(ctx.out()) - { - if (!opt) - return detail::write(ctx.out(), none); - - auto out = ctx.out(); - out = detail::write(out, optional); - ctx.advance_to(out); - out = underlying_.format(*opt, ctx); - return detail::write(out, ')'); - } +struct formatter, Char, + std::enable_if_t::value>> { + private: + formatter underlying_; + static constexpr basic_string_view optional = + detail::string_literal{}; + static constexpr basic_string_view none = + detail::string_literal{}; + + template + FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) + -> decltype(u.set_debug_format(set)) { + u.set_debug_format(set); + } + + template + FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} + + public: + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { + maybe_set_debug_format(underlying_, true); + return underlying_.parse(ctx); + } + + template + auto format(const std::optional& opt, FormatContext& ctx) const + -> decltype(ctx.out()) { + if (!opt) return detail::write(ctx.out(), none); + + auto out = ctx.out(); + out = detail::write(out, optional); + ctx.advance_to(out); + out = underlying_.format(*opt, ctx); + return detail::write(out, ')'); + } }; FMT_END_NAMESPACE -#endif // __cpp_lib_optional +#endif // __cpp_lib_optional #ifdef __cpp_lib_source_location FMT_BEGIN_NAMESPACE FMT_EXPORT -template <> -struct formatter { - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) - { - return ctx.begin(); - } - - template - auto format(const std::source_location& loc, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto out = ctx.out(); - out = detail::write(out, loc.file_name()); - out = detail::write(out, ':'); - out = detail::write(out, loc.line()); - out = detail::write(out, ':'); - out = detail::write(out, loc.column()); - out = detail::write(out, ": "); - out = detail::write(out, loc.function_name()); - return out; - } +template <> struct formatter { + template FMT_CONSTEXPR auto parse(ParseContext& ctx) { + return ctx.begin(); + } + + template + auto format(const std::source_location& loc, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto out = ctx.out(); + out = detail::write(out, loc.file_name()); + out = detail::write(out, ':'); + out = detail::write(out, loc.line()); + out = detail::write(out, ':'); + out = detail::write(out, loc.column()); + out = detail::write(out, ": "); + out = detail::write(out, loc.function_name()); + return out; + } }; FMT_END_NAMESPACE #endif #if FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE -namespace detail -{ - - template - using variant_index_sequence = std::make_index_sequence::value>; - - template - struct is_variant_like_ : std::false_type {}; - template - struct is_variant_like_> : std::true_type {}; - - // formattable element check. - template - class is_variant_formattable_ { - template - static std::conjunction, C>...> check(std::index_sequence); - - public: - static constexpr const bool value = decltype(check(variant_index_sequence{}))::value; - }; - - template - auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt - { - if constexpr (is_string::value) - return write_escaped_string(out, detail::to_string_view(v)); - else if constexpr (std::is_same_v) - return write_escaped_char(out, v); - else - return write(out, v); - } - -} // namespace detail +namespace detail { template -struct is_variant_like { - static constexpr const bool value = detail::is_variant_like_::value; +using variant_index_sequence = + std::make_index_sequence::value>; + +template struct is_variant_like_ : std::false_type {}; +template +struct is_variant_like_> : std::true_type {}; + +// formattable element check. +template class is_variant_formattable_ { + template + static std::conjunction< + is_formattable, C>...> + check(std::index_sequence); + + public: + static constexpr const bool value = + decltype(check(variant_index_sequence{}))::value; }; -template -struct is_variant_formattable { - static constexpr const bool value = detail::is_variant_formattable_::value; +template +auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt { + if constexpr (is_string::value) + return write_escaped_string(out, detail::to_string_view(v)); + else if constexpr (std::is_same_v) + return write_escaped_char(out, v); + else + return write(out, v); +} + +} // namespace detail + +template struct is_variant_like { + static constexpr const bool value = detail::is_variant_like_::value; }; -FMT_EXPORT -template -struct formatter { - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); - } +template struct is_variant_formattable { + static constexpr const bool value = + detail::is_variant_formattable_::value; +}; - template - auto format(const std::monostate&, FormatContext& ctx) const -> decltype(ctx.out()) - { - return detail::write(ctx.out(), "monostate"); - } +FMT_EXPORT +template struct formatter { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + auto format(const std::monostate&, FormatContext& ctx) const + -> decltype(ctx.out()) { + return detail::write(ctx.out(), "monostate"); + } }; FMT_EXPORT template -struct formatter, is_variant_formattable>>> { - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); +struct formatter< + Variant, Char, + std::enable_if_t, is_variant_formattable>>> { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + auto format(const Variant& value, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto out = ctx.out(); + + out = detail::write(out, "variant("); + FMT_TRY { + std::visit( + [&](const auto& v) { + out = detail::write_variant_alternative(out, v); + }, + value); } - - template - auto format(const Variant& value, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto out = ctx.out(); - - out = detail::write(out, "variant("); - FMT_TRY - { - std::visit([&](const auto& v) { out = detail::write_variant_alternative(out, v); }, value); - } - FMT_CATCH(const std::bad_variant_access&) { detail::write(out, "valueless by exception"); } - *out++ = ')'; - return out; + FMT_CATCH(const std::bad_variant_access&) { + detail::write(out, "valueless by exception"); } + *out++ = ')'; + return out; + } }; FMT_END_NAMESPACE -#endif // FMT_CPP_LIB_VARIANT +#endif // FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE FMT_EXPORT -template -struct formatter { - template - FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) - { - return ctx.begin(); - } - - template - FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) - { - auto out = ctx.out(); - out = detail::write_bytes(out, ec.category().name(), format_specs()); - out = detail::write(out, Char(':')); - out = detail::write(out, ec.value()); - return out; - } +template struct formatter { + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto out = ctx.out(); + out = detail::write_bytes(out, ec.category().name(), format_specs()); + out = detail::write(out, Char(':')); + out = detail::write(out, ec.value()); + return out; + } }; FMT_EXPORT template -struct formatter::value>::type> { -private: - bool with_typename_ = false; - -public: - FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) -> decltype(ctx.begin()) - { - auto it = ctx.begin(); - auto end = ctx.end(); - if (it == end || *it == '}') - return it; - if (*it == 't') - { - ++it; - with_typename_ = FMT_USE_TYPEID != 0; - } - return it; +struct formatter< + T, Char, // DEPRECATED! Mixing code unit types. + typename std::enable_if::value>::type> { + private: + bool with_typename_ = false; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto it = ctx.begin(); + auto end = ctx.end(); + if (it == end || *it == '}') return it; + if (*it == 't') { + ++it; + with_typename_ = FMT_USE_TYPEID != 0; } + return it; + } - template - auto format(const std::exception& ex, basic_format_context& ctx) const -> OutputIt - { - format_specs spec; - auto out = ctx.out(); - if (!with_typename_) - return detail::write_bytes(out, string_view(ex.what()), spec); + template + auto format(const std::exception& ex, + basic_format_context& ctx) const -> OutputIt { + format_specs spec; + auto out = ctx.out(); + if (!with_typename_) + return detail::write_bytes(out, string_view(ex.what()), spec); #if FMT_USE_TYPEID - const std::type_info& ti = typeid(ex); -#ifdef FMT_HAS_ABI_CXA_DEMANGLE - int status = 0; - std::size_t size = 0; - std::unique_ptr demangled_name_ptr(abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); - - string_view demangled_name_view; - if (demangled_name_ptr) - { - demangled_name_view = demangled_name_ptr.get(); - - // Normalization of stdlib inline namespace names. - // libc++ inline namespaces. - // std::__1::* -> std::* - // std::__1::__fs::* -> std::* - // libstdc++ inline namespaces. - // std::__cxx11::* -> std::* - // std::filesystem::__cxx11::* -> std::filesystem::* - if (demangled_name_view.starts_with("std::")) - { - char* begin = demangled_name_ptr.get(); - char* to = begin + 5; // std:: - for (char *from = to, *end = begin + demangled_name_view.size(); from < end;) - { - // This is safe, because demangled_name is NUL-terminated. - if (from[0] == '_' && from[1] == '_') - { - char* next = from + 1; - while (next < end && *next != ':') - next++; - if (next[0] == ':' && next[1] == ':') - { - from = next + 2; - continue; - } - } - *to++ = *from++; - } - demangled_name_view = {begin, detail::to_unsigned(to - begin)}; + const std::type_info& ti = typeid(ex); +# ifdef FMT_HAS_ABI_CXA_DEMANGLE + int status = 0; + std::size_t size = 0; + std::unique_ptr demangled_name_ptr( + abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); + + string_view demangled_name_view; + if (demangled_name_ptr) { + demangled_name_view = demangled_name_ptr.get(); + + // Normalization of stdlib inline namespace names. + // libc++ inline namespaces. + // std::__1::* -> std::* + // std::__1::__fs::* -> std::* + // libstdc++ inline namespaces. + // std::__cxx11::* -> std::* + // std::filesystem::__cxx11::* -> std::filesystem::* + if (demangled_name_view.starts_with("std::")) { + char* begin = demangled_name_ptr.get(); + char* to = begin + 5; // std:: + for (char *from = to, *end = begin + demangled_name_view.size(); + from < end;) { + // This is safe, because demangled_name is NUL-terminated. + if (from[0] == '_' && from[1] == '_') { + char* next = from + 1; + while (next < end && *next != ':') next++; + if (next[0] == ':' && next[1] == ':') { + from = next + 2; + continue; } + } + *to++ = *from++; } - else - { - demangled_name_view = string_view(ti.name()); - } - out = detail::write_bytes(out, demangled_name_view, spec); -#elif FMT_MSC_VERSION - string_view demangled_name_view(ti.name()); - if (demangled_name_view.starts_with("class ")) - demangled_name_view.remove_prefix(6); - else if (demangled_name_view.starts_with("struct ")) - demangled_name_view.remove_prefix(7); - out = detail::write_bytes(out, demangled_name_view, spec); -#else - out = detail::write_bytes(out, string_view(ti.name()), spec); -#endif - *out++ = ':'; - *out++ = ' '; - return detail::write_bytes(out, string_view(ex.what()), spec); -#endif + demangled_name_view = {begin, detail::to_unsigned(to - begin)}; + } + } else { + demangled_name_view = string_view(ti.name()); } + out = detail::write_bytes(out, demangled_name_view, spec); +# elif FMT_MSC_VERSION + string_view demangled_name_view(ti.name()); + if (demangled_name_view.starts_with("class ")) + demangled_name_view.remove_prefix(6); + else if (demangled_name_view.starts_with("struct ")) + demangled_name_view.remove_prefix(7); + out = detail::write_bytes(out, demangled_name_view, spec); +# else + out = detail::write_bytes(out, string_view(ti.name()), spec); +# endif + *out++ = ':'; + *out++ = ' '; + return detail::write_bytes(out, string_view(ex.what()), spec); +#endif + } }; -namespace detail -{ +namespace detail { - template - struct has_flip : std::false_type {}; +template +struct has_flip : std::false_type {}; - template - struct has_flip().flip())>> : std::true_type {}; +template +struct has_flip().flip())>> + : std::true_type {}; - template - struct is_bit_reference_like { - static constexpr const bool value = std::is_convertible::value && std::is_nothrow_assignable::value && has_flip::value; - }; +template struct is_bit_reference_like { + static constexpr const bool value = + std::is_convertible::value && + std::is_nothrow_assignable::value && has_flip::value; +}; #ifdef _LIBCPP_VERSION - // Workaround for libc++ incompatibility with C++ standard. - // According to the Standard, `bitset::operator[] const` returns bool. - template - struct is_bit_reference_like> { - static constexpr const bool value = true; - }; +// Workaround for libc++ incompatibility with C++ standard. +// According to the Standard, `bitset::operator[] const` returns bool. +template +struct is_bit_reference_like> { + static constexpr const bool value = true; +}; #endif -} // namespace detail +} // namespace detail // We can't use std::vector::reference and // std::bitset::reference because the compiler can't deduce Allocator and N // in partial specialization. FMT_EXPORT template -struct formatter::value>> : formatter { - template - FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const -> decltype(ctx.out()) - { - return formatter::format(v, ctx); - } +struct formatter::value>> + : formatter { + template + FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter::format(v, ctx); + } }; FMT_EXPORT template -struct formatter, Char, enable_if_t::value>> : formatter { - template - auto format(const std::atomic& v, FormatContext& ctx) const -> decltype(ctx.out()) - { - return formatter::format(v.load(), ctx); - } +struct formatter, Char, + enable_if_t::value>> + : formatter { + template + auto format(const std::atomic& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter::format(v.load(), ctx); + } }; #ifdef __cpp_lib_atomic_flag_test FMT_EXPORT template struct formatter : formatter { - template - auto format(const std::atomic_flag& v, FormatContext& ctx) const -> decltype(ctx.out()) - { - return formatter::format(v.test(), ctx); - } + template + auto format(const std::atomic_flag& v, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter::format(v.test(), ctx); + } }; -#endif // __cpp_lib_atomic_flag_test +#endif // __cpp_lib_atomic_flag_test FMT_END_NAMESPACE -#endif // FMT_STD_H_ +#endif // FMT_STD_H_ diff --git a/lib/spdlog/fmt/bundled/xchar.h b/lib/spdlog/fmt/bundled/xchar.h index cc0042dc..f609c5c4 100644 --- a/lib/spdlog/fmt/bundled/xchar.h +++ b/lib/spdlog/fmt/bundled/xchar.h @@ -13,29 +13,29 @@ #include "format.h" #ifndef FMT_STATIC_THOUSANDS_SEPARATOR -#include +# include #endif FMT_BEGIN_NAMESPACE -namespace detail -{ +namespace detail { - template - using is_exotic_char = bool_constant::value>; +template +using is_exotic_char = bool_constant::value>; - inline auto write_loc(std::back_insert_iterator> out, loc_value value, const format_specs& specs, locale_ref loc) -> bool - { +inline auto write_loc(std::back_insert_iterator> out, + loc_value value, const format_specs& specs, + locale_ref loc) -> bool { #ifndef FMT_STATIC_THOUSANDS_SEPARATOR - auto& numpunct = std::use_facet>(loc.get()); - auto separator = std::wstring(); - auto grouping = numpunct.grouping(); - if (!grouping.empty()) - separator = std::wstring(1, numpunct.thousands_sep()); - return value.visit(loc_writer{out, specs, separator, grouping, {}}); + auto& numpunct = + std::use_facet>(loc.get()); + auto separator = std::wstring(); + auto grouping = numpunct.grouping(); + if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep()); + return value.visit(loc_writer{out, specs, separator, grouping, {}}); #endif - return false; - } -} // namespace detail + return false; +} +} // namespace detail FMT_BEGIN_EXPORT @@ -47,184 +47,213 @@ using wmemory_buffer = basic_memory_buffer; #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 // Workaround broken conversion on older gcc. -template -using wformat_string = wstring_view; +template using wformat_string = wstring_view; inline auto runtime(wstring_view s) -> wstring_view { return s; } #else template using wformat_string = basic_format_string...>; -inline auto runtime(wstring_view s) -> runtime_format_string { return {{s}}; } +inline auto runtime(wstring_view s) -> runtime_format_string { + return {{s}}; +} #endif -template <> -struct is_char : std::true_type {}; -template <> -struct is_char : std::true_type {}; -template <> -struct is_char : std::true_type {}; -template <> -struct is_char : std::true_type {}; +template <> struct is_char : std::true_type {}; +template <> struct is_char : std::true_type {}; +template <> struct is_char : std::true_type {}; +template <> struct is_char : std::true_type {}; template -constexpr auto make_wformat_args(const T&... args) -> format_arg_store -{ - return {args...}; +constexpr auto make_wformat_args(const T&... args) + -> format_arg_store { + return {args...}; } -inline namespace literals -{ +inline namespace literals { #if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS - constexpr auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg { return {s}; } +constexpr auto operator""_a(const wchar_t* s, size_t) + -> detail::udl_arg { + return {s}; +} #endif -} // namespace literals +} // namespace literals template -auto join(It begin, Sentinel end, wstring_view sep) -> join_view -{ - return {begin, end, sep}; +auto join(It begin, Sentinel end, wstring_view sep) + -> join_view { + return {begin, end, sep}; } template -auto join(Range&& range, wstring_view sep) -> join_view, detail::sentinel_t, wchar_t> -{ - return join(std::begin(range), std::end(range), sep); +auto join(Range&& range, wstring_view sep) + -> join_view, detail::sentinel_t, + wchar_t> { + return join(std::begin(range), std::end(range), sep); } template -auto join(std::initializer_list list, wstring_view sep) -> join_view -{ - return join(std::begin(list), std::end(list), sep); +auto join(std::initializer_list list, wstring_view sep) + -> join_view { + return join(std::begin(list), std::end(list), sep); } template ::value)> -auto vformat(basic_string_view format_str, basic_format_args>> args) -> std::basic_string -{ - auto buf = basic_memory_buffer(); - detail::vformat_to(buf, format_str, args); - return to_string(buf); +auto vformat(basic_string_view format_str, + basic_format_args>> args) + -> std::basic_string { + auto buf = basic_memory_buffer(); + detail::vformat_to(buf, format_str, args); + return to_string(buf); } template -auto format(wformat_string fmt, T&&... args) -> std::wstring -{ - return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); +auto format(wformat_string fmt, T&&... args) -> std::wstring { + return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } // Pass char_t as a default template parameter instead of using // std::basic_string> to reduce the symbol size. -template , FMT_ENABLE_IF(!std::is_same::value && !std::is_same::value)> -auto format(const S& format_str, T&&... args) -> std::basic_string -{ - return vformat(detail::to_string_view(format_str), fmt::make_format_args>(args...)); +template , + FMT_ENABLE_IF(!std::is_same::value && + !std::is_same::value)> +auto format(const S& format_str, T&&... args) -> std::basic_string { + return vformat(detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto vformat(const Locale& loc, const S& format_str, basic_format_args>> args) -> std::basic_string -{ - return detail::vformat(loc, detail::to_string_view(format_str), args); +template , + FMT_ENABLE_IF(detail::is_locale::value&& + detail::is_exotic_char::value)> +inline auto vformat( + const Locale& loc, const S& format_str, + basic_format_args>> args) + -> std::basic_string { + return detail::vformat(loc, detail::to_string_view(format_str), args); } -template , FMT_ENABLE_IF(detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto format(const Locale& loc, const S& format_str, T&&... args) -> std::basic_string -{ - return detail::vformat(loc, detail::to_string_view(format_str), fmt::make_format_args>(args...)); +template , + FMT_ENABLE_IF(detail::is_locale::value&& + detail::is_exotic_char::value)> +inline auto format(const Locale& loc, const S& format_str, T&&... args) + -> std::basic_string { + return detail::vformat(loc, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> -auto vformat_to(OutputIt out, const S& format_str, basic_format_args>> args) -> OutputIt -{ - auto&& buf = detail::get_buffer(out); - detail::vformat_to(buf, detail::to_string_view(format_str), args); - return detail::get_iterator(buf, out); +template , + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_exotic_char::value)> +auto vformat_to(OutputIt out, const S& format_str, + basic_format_args>> args) + -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, detail::to_string_view(format_str), args); + return detail::get_iterator(buf, out); } -template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> -inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt -{ - return vformat_to(out, detail::to_string_view(fmt), fmt::make_format_args>(args...)); +template , + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_exotic_char::value)> +inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { + return vformat_to(out, detail::to_string_view(fmt), + fmt::make_format_args>(args...)); } -template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_locale::value&& detail::is_exotic_char::value)> -inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str, basic_format_args>> args) -> OutputIt -{ - auto&& buf = detail::get_buffer(out); - vformat_to(buf, detail::to_string_view(format_str), args, detail::locale_ref(loc)); - return detail::get_iterator(buf, out); +template , + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_locale::value&& + detail::is_exotic_char::value)> +inline auto vformat_to( + OutputIt out, const Locale& loc, const S& format_str, + basic_format_args>> args) -> OutputIt { + auto&& buf = detail::get_buffer(out); + vformat_to(buf, detail::to_string_view(format_str), args, + detail::locale_ref(loc)); + return detail::get_iterator(buf, out); } -template , bool enable = detail::is_output_iterator::value && detail::is_locale::value && detail::is_exotic_char::value> -inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, T&&... args) -> typename std::enable_if::type -{ - return vformat_to(out, loc, detail::to_string_view(format_str), fmt::make_format_args>(args...)); +template , + bool enable = detail::is_output_iterator::value && + detail::is_locale::value && + detail::is_exotic_char::value> +inline auto format_to(OutputIt out, const Locale& loc, const S& format_str, + T&&... args) -> + typename std::enable_if::type { + return vformat_to(out, loc, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); } -template ::value&& detail::is_exotic_char::value)> -inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view format_str, basic_format_args>> args) -> format_to_n_result -{ - using traits = detail::fixed_buffer_traits; - auto buf = detail::iterator_buffer(out, n); - detail::vformat_to(buf, format_str, args); - return {buf.out(), buf.count()}; +template ::value&& + detail::is_exotic_char::value)> +inline auto vformat_to_n( + OutputIt out, size_t n, basic_string_view format_str, + basic_format_args>> args) + -> format_to_n_result { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer(out, n); + detail::vformat_to(buf, format_str, args); + return {buf.out(), buf.count()}; } -template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> -inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result -{ - return vformat_to_n(out, n, detail::to_string_view(fmt), fmt::make_format_args>(args...)); +template , + FMT_ENABLE_IF(detail::is_output_iterator::value&& + detail::is_exotic_char::value)> +inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) + -> format_to_n_result { + return vformat_to_n(out, n, detail::to_string_view(fmt), + fmt::make_format_args>(args...)); } -template , FMT_ENABLE_IF(detail::is_exotic_char::value)> -inline auto formatted_size(const S& fmt, T&&... args) -> size_t -{ - auto buf = detail::counting_buffer(); - detail::vformat_to(buf, detail::to_string_view(fmt), fmt::make_format_args>(args...)); - return buf.count(); +template , + FMT_ENABLE_IF(detail::is_exotic_char::value)> +inline auto formatted_size(const S& fmt, T&&... args) -> size_t { + auto buf = detail::counting_buffer(); + detail::vformat_to(buf, detail::to_string_view(fmt), + fmt::make_format_args>(args...)); + return buf.count(); } -inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) -{ - auto buf = wmemory_buffer(); - detail::vformat_to(buf, fmt, args); - buf.push_back(L'\0'); - if (std::fputws(buf.data(), f) == -1) - FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); +inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { + auto buf = wmemory_buffer(); + detail::vformat_to(buf, fmt, args); + buf.push_back(L'\0'); + if (std::fputws(buf.data(), f) == -1) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } -inline void vprint(wstring_view fmt, wformat_args args) { vprint(stdout, fmt, args); } +inline void vprint(wstring_view fmt, wformat_args args) { + vprint(stdout, fmt, args); +} template -void print(std::FILE* f, wformat_string fmt, T&&... args) -{ - return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...)); +void print(std::FILE* f, wformat_string fmt, T&&... args) { + return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...)); } -template -void print(wformat_string fmt, T&&... args) -{ - return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); +template void print(wformat_string fmt, T&&... args) { + return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); } template -void println(std::FILE* f, wformat_string fmt, T&&... args) -{ - return print(f, L"{}\n", fmt::format(fmt, std::forward(args)...)); +void println(std::FILE* f, wformat_string fmt, T&&... args) { + return print(f, L"{}\n", fmt::format(fmt, std::forward(args)...)); } -template -void println(wformat_string fmt, T&&... args) -{ - return print(L"{}\n", fmt::format(fmt, std::forward(args)...)); +template void println(wformat_string fmt, T&&... args) { + return print(L"{}\n", fmt::format(fmt, std::forward(args)...)); } /** Converts *value* to ``std::wstring`` using the default format for type *T*. */ -template -inline auto to_wstring(const T& value) -> std::wstring -{ - return format(FMT_STRING(L"{}"), value); +template inline auto to_wstring(const T& value) -> std::wstring { + return format(FMT_STRING(L"{}"), value); } FMT_END_EXPORT FMT_END_NAMESPACE -#endif // FMT_XCHAR_H_ +#endif // FMT_XCHAR_H_ diff --git a/lib/spdlog/fmt/chrono.h b/lib/spdlog/fmt/chrono.h index 4da092b8..a72a5bd6 100644 --- a/lib/spdlog/fmt/chrono.h +++ b/lib/spdlog/fmt/chrono.h @@ -10,14 +10,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/fmt/compile.h b/lib/spdlog/fmt/compile.h index 795e6a3d..3c9c25d8 100644 --- a/lib/spdlog/fmt/compile.h +++ b/lib/spdlog/fmt/compile.h @@ -10,14 +10,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/fmt/fmt.h b/lib/spdlog/fmt/fmt.h index 1da6a240..7fa6b093 100644 --- a/lib/spdlog/fmt/fmt.h +++ b/lib/spdlog/fmt/fmt.h @@ -11,21 +11,20 @@ // #include -#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use - // std::format -#include +#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format + #include #elif !defined(SPDLOG_FMT_EXTERNAL) -#if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) -#define FMT_HEADER_ONLY -#endif -#ifndef FMT_USE_WINDOWS_H -#define FMT_USE_WINDOWS_H 0 -#endif + #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) + #define FMT_HEADER_ONLY + #endif + #ifndef FMT_USE_WINDOWS_H + #define FMT_USE_WINDOWS_H 0 + #endif -#include -#include + #include + #include -#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib -#include -#include +#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib + #include + #include #endif diff --git a/lib/spdlog/fmt/ostr.h b/lib/spdlog/fmt/ostr.h index a9e50e1f..2b901055 100644 --- a/lib/spdlog/fmt/ostr.h +++ b/lib/spdlog/fmt/ostr.h @@ -10,14 +10,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/fmt/ranges.h b/lib/spdlog/fmt/ranges.h index 117a9e46..5bb91e9a 100644 --- a/lib/spdlog/fmt/ranges.h +++ b/lib/spdlog/fmt/ranges.h @@ -10,14 +10,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/fmt/std.h b/lib/spdlog/fmt/std.h index 4a3b828c..dabe6f69 100644 --- a/lib/spdlog/fmt/std.h +++ b/lib/spdlog/fmt/std.h @@ -11,14 +11,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/fmt/xchar.h b/lib/spdlog/fmt/xchar.h index 8ce17988..2525f058 100644 --- a/lib/spdlog/fmt/xchar.h +++ b/lib/spdlog/fmt/xchar.h @@ -10,14 +10,14 @@ #include #if !defined(SPDLOG_USE_STD_FORMAT) -#if !defined(SPDLOG_FMT_EXTERNAL) -#ifdef SPDLOG_HEADER_ONLY -#ifndef FMT_HEADER_ONLY -#define FMT_HEADER_ONLY -#endif -#endif -#include -#else -#include -#endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/lib/spdlog/formatter.h b/lib/spdlog/formatter.h index bf9e3fa8..4d482f82 100644 --- a/lib/spdlog/formatter.h +++ b/lib/spdlog/formatter.h @@ -6,13 +6,12 @@ #include #include -namespace spdlog -{ +namespace spdlog { - class formatter { - public: - virtual ~formatter() = default; - virtual void format(const details::log_msg& msg, memory_buf_t& dest) = 0; - virtual std::unique_ptr clone() const = 0; - }; -} // namespace spdlog +class formatter { +public: + virtual ~formatter() = default; + virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; + virtual std::unique_ptr clone() const = 0; +}; +} // namespace spdlog diff --git a/lib/spdlog/fwd.h b/lib/spdlog/fwd.h index cd6eab34..647b16bf 100644 --- a/lib/spdlog/fwd.h +++ b/lib/spdlog/fwd.h @@ -3,19 +3,16 @@ #pragma once -namespace spdlog -{ - class logger; - class formatter; +namespace spdlog { +class logger; +class formatter; - namespace sinks - { - class sink; - } +namespace sinks { +class sink; +} - namespace level - { - enum level_enum : int; - } +namespace level { +enum level_enum : int; +} -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/logger-inl.h b/lib/spdlog/logger-inl.h index a597358f..5218fe4c 100644 --- a/lib/spdlog/logger-inl.h +++ b/lib/spdlog/logger-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -13,187 +13,186 @@ #include -namespace spdlog -{ - - // public methods - SPDLOG_INLINE logger::logger(const logger& other) : name_(other.name_), sinks_(other.sinks_), level_(other.level_.load(std::memory_order_relaxed)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)), custom_err_handler_(other.custom_err_handler_), tracer_(other.tracer_) {} - - SPDLOG_INLINE logger::logger(logger&& other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)), sinks_(std::move(other.sinks_)), level_(other.level_.load(std::memory_order_relaxed)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)), custom_err_handler_(std::move(other.custom_err_handler_)), tracer_(std::move(other.tracer_)) {} - - SPDLOG_INLINE logger& logger::operator=(logger other) SPDLOG_NOEXCEPT - { - this->swap(other); - return *this; - } - - SPDLOG_INLINE void logger::swap(spdlog::logger& other) SPDLOG_NOEXCEPT - { - name_.swap(other.name_); - sinks_.swap(other.sinks_); - - // swap level_ - auto other_level = other.level_.load(); - auto my_level = level_.exchange(other_level); - other.level_.store(my_level); - - // swap flush level_ - other_level = other.flush_level_.load(); - my_level = flush_level_.exchange(other_level); - other.flush_level_.store(my_level); - - custom_err_handler_.swap(other.custom_err_handler_); - std::swap(tracer_, other.tracer_); - } - - SPDLOG_INLINE void swap(logger& a, logger& b) { a.swap(b); } - - SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); } - - SPDLOG_INLINE level::level_enum logger::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } - - SPDLOG_INLINE const std::string& logger::name() const { return name_; } - - // set formatting for the sinks in this logger. - // each sink will get a separate instance of the formatter object. - SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) - { - for (auto it = sinks_.begin(); it != sinks_.end(); ++it) - { - if (std::next(it) == sinks_.end()) - { - // last element - we can be move it. - (*it)->set_formatter(std::move(f)); - break; // to prevent clang-tidy warning - } - else - { - (*it)->set_formatter(f->clone()); - } +namespace spdlog { + +// public methods +SPDLOG_INLINE logger::logger(const logger &other) + : name_(other.name_), + sinks_(other.sinks_), + level_(other.level_.load(std::memory_order_relaxed)), + flush_level_(other.flush_level_.load(std::memory_order_relaxed)), + custom_err_handler_(other.custom_err_handler_), + tracer_(other.tracer_) {} + +SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT + : name_(std::move(other.name_)), + sinks_(std::move(other.sinks_)), + level_(other.level_.load(std::memory_order_relaxed)), + flush_level_(other.flush_level_.load(std::memory_order_relaxed)), + custom_err_handler_(std::move(other.custom_err_handler_)), + tracer_(std::move(other.tracer_)) + +{} + +SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT { + this->swap(other); + return *this; +} + +SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT { + name_.swap(other.name_); + sinks_.swap(other.sinks_); + + // swap level_ + auto other_level = other.level_.load(); + auto my_level = level_.exchange(other_level); + other.level_.store(my_level); + + // swap flush level_ + other_level = other.flush_level_.load(); + my_level = flush_level_.exchange(other_level); + other.flush_level_.store(my_level); + + custom_err_handler_.swap(other.custom_err_handler_); + std::swap(tracer_, other.tracer_); +} + +SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); } + +SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); } + +SPDLOG_INLINE level::level_enum logger::level() const { + return static_cast(level_.load(std::memory_order_relaxed)); +} + +SPDLOG_INLINE const std::string &logger::name() const { return name_; } + +// set formatting for the sinks in this logger. +// each sink will get a separate instance of the formatter object. +SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) { + for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { + if (std::next(it) == sinks_.end()) { + // last element - we can be move it. + (*it)->set_formatter(std::move(f)); + break; // to prevent clang-tidy warning + } else { + (*it)->set_formatter(f->clone()); } } +} - SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) - { - auto new_formatter = details::make_unique(std::move(pattern), time_type); - set_formatter(std::move(new_formatter)); - } +SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) { + auto new_formatter = details::make_unique(std::move(pattern), time_type); + set_formatter(std::move(new_formatter)); +} - // create new backtrace sink and move to it all our child sinks - SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); } +// create new backtrace sink and move to it all our child sinks +SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); } - // restore orig sinks and level and delete the backtrace sink - SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); } +// restore orig sinks and level and delete the backtrace sink +SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); } - SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); } +SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); } - // flush functions - SPDLOG_INLINE void logger::flush() { flush_(); } +// flush functions +SPDLOG_INLINE void logger::flush() { flush_(); } - SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } +SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } - SPDLOG_INLINE level::level_enum logger::flush_level() const { return static_cast(flush_level_.load(std::memory_order_relaxed)); } +SPDLOG_INLINE level::level_enum logger::flush_level() const { + return static_cast(flush_level_.load(std::memory_order_relaxed)); +} - // sinks - SPDLOG_INLINE const std::vector& logger::sinks() const { return sinks_; } +// sinks +SPDLOG_INLINE const std::vector &logger::sinks() const { return sinks_; } - SPDLOG_INLINE std::vector& logger::sinks() { return sinks_; } +SPDLOG_INLINE std::vector &logger::sinks() { return sinks_; } - // error handler - SPDLOG_INLINE void logger::set_error_handler(err_handler handler) { custom_err_handler_ = std::move(handler); } +// error handler +SPDLOG_INLINE void logger::set_error_handler(err_handler handler) { + custom_err_handler_ = std::move(handler); +} - // create new logger with same sinks and configuration. - SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) - { - auto cloned = std::make_shared(*this); - cloned->name_ = std::move(logger_name); - return cloned; - } +// create new logger with same sinks and configuration. +SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) { + auto cloned = std::make_shared(*this); + cloned->name_ = std::move(logger_name); + return cloned; +} - // protected methods - SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg& log_msg, bool log_enabled, bool traceback_enabled) - { - if (log_enabled) - { - sink_it_(log_msg); - } - if (traceback_enabled) - { - tracer_.push_back(log_msg); - } +// protected methods +SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, + bool log_enabled, + bool traceback_enabled) { + if (log_enabled) { + sink_it_(log_msg); } - - SPDLOG_INLINE void logger::sink_it_(const details::log_msg& msg) - { - for (auto& sink : sinks_) - { - if (sink->should_log(msg.level)) - { - SPDLOG_TRY { sink->log(msg); } - SPDLOG_LOGGER_CATCH(msg.source) - } - } - - if (should_flush_(msg)) - { - flush_(); - } + if (traceback_enabled) { + tracer_.push_back(log_msg); } +} - SPDLOG_INLINE void logger::flush_() - { - for (auto& sink : sinks_) - { - SPDLOG_TRY { sink->flush(); } - SPDLOG_LOGGER_CATCH(source_loc()) +SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) { + for (auto &sink : sinks_) { + if (sink->should_log(msg.level)) { + SPDLOG_TRY { sink->log(msg); } + SPDLOG_LOGGER_CATCH(msg.source) } } - SPDLOG_INLINE void logger::dump_backtrace_() - { - using details::log_msg; - if (tracer_.enabled() && !tracer_.empty()) - { - sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"}); - tracer_.foreach_pop([this](const log_msg& msg) { this->sink_it_(msg); }); - sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"}); - } + if (should_flush_(msg)) { + flush_(); } +} - SPDLOG_INLINE bool logger::should_flush_(const details::log_msg& msg) - { - auto flush_level = flush_level_.load(std::memory_order_relaxed); - return (msg.level >= flush_level) && (msg.level != level::off); +SPDLOG_INLINE void logger::flush_() { + for (auto &sink : sinks_) { + SPDLOG_TRY { sink->flush(); } + SPDLOG_LOGGER_CATCH(source_loc()) } - - SPDLOG_INLINE void logger::err_handler_(const std::string& msg) - { - if (custom_err_handler_) - { - custom_err_handler_(msg); +} + +SPDLOG_INLINE void logger::dump_backtrace_() { + using details::log_msg; + if (tracer_.enabled() && !tracer_.empty()) { + sink_it_( + log_msg{name(), level::info, "****************** Backtrace Start ******************"}); + tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); + sink_it_( + log_msg{name(), level::info, "****************** Backtrace End ********************"}); + } +} + +SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) { + auto flush_level = flush_level_.load(std::memory_order_relaxed); + return (msg.level >= flush_level) && (msg.level != level::off); +} + +SPDLOG_INLINE void logger::err_handler_(const std::string &msg) { + if (custom_err_handler_) { + custom_err_handler_(msg); + } else { + using std::chrono::system_clock; + static std::mutex mutex; + static std::chrono::system_clock::time_point last_report_time; + static size_t err_counter = 0; + std::lock_guard lk{mutex}; + auto now = system_clock::now(); + err_counter++; + if (now - last_report_time < std::chrono::seconds(1)) { + return; } - else - { - using std::chrono::system_clock; - static std::mutex mutex; - static std::chrono::system_clock::time_point last_report_time; - static size_t err_counter = 0; - std::lock_guard lk{mutex}; - auto now = system_clock::now(); - err_counter++; - if (now - last_report_time < std::chrono::seconds(1)) - { - return; - } - last_report_time = now; - auto tm_time = details::os::localtime(system_clock::to_time_t(now)); - char date_buf[64]; - std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); -#if defined(USING_R) && defined(R_R_H) // if in R environment - REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); + last_report_time = now; + auto tm_time = details::os::localtime(system_clock::to_time_t(now)); + char date_buf[64]; + std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); +#if defined(USING_R) && defined(R_R_H) // if in R environment + REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), + msg.c_str()); #else - std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); + std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, + name().c_str(), msg.c_str()); #endif - } } -} // namespace spdlog +} +} // namespace spdlog diff --git a/lib/spdlog/logger.h b/lib/spdlog/logger.h index 752b3cc6..f49bdc00 100644 --- a/lib/spdlog/logger.h +++ b/lib/spdlog/logger.h @@ -19,392 +19,361 @@ #include #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -#ifndef _WIN32 -#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows -#endif -#include + #ifndef _WIN32 + #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows + #endif + #include #endif #include #ifndef SPDLOG_NO_EXCEPTIONS -#define SPDLOG_LOGGER_CATCH(location) \ - catch (const std::exception& ex) \ - { \ - if (location.filename) \ - { \ - err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \ - } \ - else \ - { \ - err_handler_(ex.what()); \ - } \ - } \ - catch (...) \ - { \ - err_handler_("Rethrowing unknown exception in logger"); \ - throw; \ - } + #define SPDLOG_LOGGER_CATCH(location) \ + catch (const std::exception &ex) { \ + if (location.filename) { \ + err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \ + location.filename, location.line)); \ + } else { \ + err_handler_(ex.what()); \ + } \ + } \ + catch (...) { \ + err_handler_("Rethrowing unknown exception in logger"); \ + throw; \ + } #else -#define SPDLOG_LOGGER_CATCH(location) + #define SPDLOG_LOGGER_CATCH(location) #endif -namespace spdlog -{ +namespace spdlog { - class SPDLOG_API logger { - public: - // Empty logger - explicit logger(std::string name) : name_(std::move(name)), sinks_() {} +class SPDLOG_API logger { +public: + // Empty logger + explicit logger(std::string name) + : name_(std::move(name)), + sinks_() {} - // Logger with range on sinks - template - logger(std::string name, It begin, It end) : name_(std::move(name)), sinks_(begin, end) - { - } - - // Logger with single sink - logger(std::string name, sink_ptr single_sink) : logger(std::move(name), {std::move(single_sink)}) {} + // Logger with range on sinks + template + logger(std::string name, It begin, It end) + : name_(std::move(name)), + sinks_(begin, end) {} - // Logger with sinks init list - logger(std::string name, sinks_init_list sinks) : logger(std::move(name), sinks.begin(), sinks.end()) {} + // Logger with single sink + logger(std::string name, sink_ptr single_sink) + : logger(std::move(name), {std::move(single_sink)}) {} - virtual ~logger() = default; + // Logger with sinks init list + logger(std::string name, sinks_init_list sinks) + : logger(std::move(name), sinks.begin(), sinks.end()) {} - logger(const logger& other); - logger(logger&& other) SPDLOG_NOEXCEPT; - logger& operator=(logger other) SPDLOG_NOEXCEPT; - void swap(spdlog::logger& other) SPDLOG_NOEXCEPT; + virtual ~logger() = default; - template - void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args&&... args) - { - log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); - } + logger(const logger &other); + logger(logger &&other) SPDLOG_NOEXCEPT; + logger &operator=(logger other) SPDLOG_NOEXCEPT; + void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; - template - void log(level::level_enum lvl, format_string_t fmt, Args&&... args) - { - log(source_loc{}, lvl, fmt, std::forward(args)...); - } + template + void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args &&...args) { + log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); + } - template - void log(level::level_enum lvl, const T& msg) - { - log(source_loc{}, lvl, msg); - } + template + void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { + log(source_loc{}, lvl, fmt, std::forward(args)...); + } - // T cannot be statically converted to format string (including - // string_view/wstring_view) - template ::value, int>::type = 0> - void log(source_loc loc, level::level_enum lvl, const T& msg) - { - log(loc, lvl, "{}", msg); - } + template + void log(level::level_enum lvl, const T &msg) { + log(source_loc{}, lvl, msg); + } - void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } + // T cannot be statically converted to format string (including string_view/wstring_view) + template ::value, + int>::type = 0> + void log(source_loc loc, level::level_enum lvl, const T &msg) { + log(loc, lvl, "{}", msg); + } - details::log_msg log_msg(log_time, loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); + void log(log_clock::time_point log_time, + source_loc loc, + level::level_enum lvl, + string_view_t msg) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; } - void log(source_loc loc, level::level_enum lvl, string_view_t msg) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } + details::log_msg log_msg(log_time, loc, name_, lvl, msg); + log_it_(log_msg, log_enabled, traceback_enabled); + } - details::log_msg log_msg(loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); + void log(source_loc loc, level::level_enum lvl, string_view_t msg) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; } - void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); } + details::log_msg log_msg(loc, name_, lvl, msg); + log_it_(log_msg, log_enabled, traceback_enabled); + } - template - void trace(format_string_t fmt, Args&&... args) - { - log(level::trace, fmt, std::forward(args)...); - } + void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); } - template - void debug(format_string_t fmt, Args&&... args) - { - log(level::debug, fmt, std::forward(args)...); - } + template + void trace(format_string_t fmt, Args &&...args) { + log(level::trace, fmt, std::forward(args)...); + } - template - void info(format_string_t fmt, Args&&... args) - { - log(level::info, fmt, std::forward(args)...); - } + template + void debug(format_string_t fmt, Args &&...args) { + log(level::debug, fmt, std::forward(args)...); + } - template - void warn(format_string_t fmt, Args&&... args) - { - log(level::warn, fmt, std::forward(args)...); - } + template + void info(format_string_t fmt, Args &&...args) { + log(level::info, fmt, std::forward(args)...); + } - template - void error(format_string_t fmt, Args&&... args) - { - log(level::err, fmt, std::forward(args)...); - } + template + void warn(format_string_t fmt, Args &&...args) { + log(level::warn, fmt, std::forward(args)...); + } - template - void critical(format_string_t fmt, Args&&... args) - { - log(level::critical, fmt, std::forward(args)...); - } + template + void error(format_string_t fmt, Args &&...args) { + log(level::err, fmt, std::forward(args)...); + } -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args&&... args) - { - log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); - } + template + void critical(format_string_t fmt, Args &&...args) { + log(level::critical, fmt, std::forward(args)...); + } - template - void log(level::level_enum lvl, wformat_string_t fmt, Args&&... args) - { - log(source_loc{}, lvl, fmt, std::forward(args)...); - } +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT + template + void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args &&...args) { + log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); + } - void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } + template + void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { + log(source_loc{}, lvl, fmt, std::forward(args)...); + } - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); - details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); + void log(log_clock::time_point log_time, + source_loc loc, + level::level_enum lvl, + wstring_view_t msg) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; } - void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } + memory_buf_t buf; + details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); + details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); + void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; } - void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); } + memory_buf_t buf; + details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } - template - void trace(wformat_string_t fmt, Args&&... args) - { - log(level::trace, fmt, std::forward(args)...); - } + void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); } - template - void debug(wformat_string_t fmt, Args&&... args) - { - log(level::debug, fmt, std::forward(args)...); - } + template + void trace(wformat_string_t fmt, Args &&...args) { + log(level::trace, fmt, std::forward(args)...); + } - template - void info(wformat_string_t fmt, Args&&... args) - { - log(level::info, fmt, std::forward(args)...); - } + template + void debug(wformat_string_t fmt, Args &&...args) { + log(level::debug, fmt, std::forward(args)...); + } - template - void warn(wformat_string_t fmt, Args&&... args) - { - log(level::warn, fmt, std::forward(args)...); - } + template + void info(wformat_string_t fmt, Args &&...args) { + log(level::info, fmt, std::forward(args)...); + } - template - void error(wformat_string_t fmt, Args&&... args) - { - log(level::err, fmt, std::forward(args)...); - } + template + void warn(wformat_string_t fmt, Args &&...args) { + log(level::warn, fmt, std::forward(args)...); + } - template - void critical(wformat_string_t fmt, Args&&... args) - { - log(level::critical, fmt, std::forward(args)...); - } + template + void error(wformat_string_t fmt, Args &&...args) { + log(level::err, fmt, std::forward(args)...); + } + + template + void critical(wformat_string_t fmt, Args &&...args) { + log(level::critical, fmt, std::forward(args)...); + } #endif - template - void trace(const T& msg) - { - log(level::trace, msg); - } + template + void trace(const T &msg) { + log(level::trace, msg); + } - template - void debug(const T& msg) - { - log(level::debug, msg); - } + template + void debug(const T &msg) { + log(level::debug, msg); + } - template - void info(const T& msg) - { - log(level::info, msg); - } + template + void info(const T &msg) { + log(level::info, msg); + } - template - void warn(const T& msg) - { - log(level::warn, msg); - } + template + void warn(const T &msg) { + log(level::warn, msg); + } - template - void error(const T& msg) - { - log(level::err, msg); - } + template + void error(const T &msg) { + log(level::err, msg); + } - template - void critical(const T& msg) - { - log(level::critical, msg); - } + template + void critical(const T &msg) { + log(level::critical, msg); + } + + // return true logging is enabled for the given level. + bool should_log(level::level_enum msg_level) const { + return msg_level >= level_.load(std::memory_order_relaxed); + } + + // return true if backtrace logging is enabled. + bool should_backtrace() const { return tracer_.enabled(); } - // return true logging is enabled for the given level. - bool should_log(level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } - - // return true if backtrace logging is enabled. - bool should_backtrace() const { return tracer_.enabled(); } - - void set_level(level::level_enum log_level); - - level::level_enum level() const; - - const std::string& name() const; - - // set formatting for the sinks in this logger. - // each sink will get a separate instance of the formatter object. - void set_formatter(std::unique_ptr f); - - // set formatting for the sinks in this logger. - // equivalent to - // set_formatter(make_unique(pattern, time_type)) - // Note: each sink will get a new instance of a formatter object, replacing - // the old one. - void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); - - // backtrace support. - // efficiently store all debug/trace messages in a circular buffer until - // needed for debugging. - void enable_backtrace(size_t n_messages); - void disable_backtrace(); - void dump_backtrace(); - - // flush functions - void flush(); - void flush_on(level::level_enum log_level); - level::level_enum flush_level() const; - - // sinks - const std::vector& sinks() const; - - std::vector& sinks(); - - // error handler - void set_error_handler(err_handler); - - // create new logger with same sinks and configuration. - virtual std::shared_ptr clone(std::string logger_name); - - protected: - std::string name_; - std::vector sinks_; - spdlog::level_t level_{level::info}; - spdlog::level_t flush_level_{level::off}; - err_handler custom_err_handler_{nullptr}; - details::backtracer tracer_; - - // common implementation for after templated public api has been resolved - template - void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args&&... args) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } - SPDLOG_TRY - { - memory_buf_t buf; + void set_level(level::level_enum log_level); + + level::level_enum level() const; + + const std::string &name() const; + + // set formatting for the sinks in this logger. + // each sink will get a separate instance of the formatter object. + void set_formatter(std::unique_ptr f); + + // set formatting for the sinks in this logger. + // equivalent to + // set_formatter(make_unique(pattern, time_type)) + // Note: each sink will get a new instance of a formatter object, replacing the old one. + void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); + + // backtrace support. + // efficiently store all debug/trace messages in a circular buffer until needed for debugging. + void enable_backtrace(size_t n_messages); + void disable_backtrace(); + void dump_backtrace(); + + // flush functions + void flush(); + void flush_on(level::level_enum log_level); + level::level_enum flush_level() const; + + // sinks + const std::vector &sinks() const; + + std::vector &sinks(); + + // error handler + void set_error_handler(err_handler); + + // create new logger with same sinks and configuration. + virtual std::shared_ptr clone(std::string logger_name); + +protected: + std::string name_; + std::vector sinks_; + spdlog::level_t level_{level::info}; + spdlog::level_t flush_level_{level::off}; + err_handler custom_err_handler_{nullptr}; + details::backtracer tracer_; + + // common implementation for after templated public api has been resolved + template + void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; + } + SPDLOG_TRY { + memory_buf_t buf; #ifdef SPDLOG_USE_STD_FORMAT - fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); + fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); #else - fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...)); + fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...)); #endif - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - SPDLOG_LOGGER_CATCH(loc) + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); } + SPDLOG_LOGGER_CATCH(loc) + } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args&&... args) - { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { - return; - } - SPDLOG_TRY - { - // format to wmemory_buffer and convert to utf8 - wmemory_buf_t wbuf; - fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, fmt_lib::make_format_args(args...)); - - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - SPDLOG_LOGGER_CATCH(loc) + template + void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) { + return; } -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT + SPDLOG_TRY { + // format to wmemory_buffer and convert to utf8 + wmemory_buf_t wbuf; + fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, + fmt_lib::make_format_args(args...)); + + memory_buf_t buf; + details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } + SPDLOG_LOGGER_CATCH(loc) + } +#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - // log the given message (if the given log level is high enough), - // and save backtrace (if backtrace is enabled). - void log_it_(const details::log_msg& log_msg, bool log_enabled, bool traceback_enabled); - virtual void sink_it_(const details::log_msg& msg); - virtual void flush_(); - void dump_backtrace_(); - bool should_flush_(const details::log_msg& msg); + // log the given message (if the given log level is high enough), + // and save backtrace (if backtrace is enabled). + void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled); + virtual void sink_it_(const details::log_msg &msg); + virtual void flush_(); + void dump_backtrace_(); + bool should_flush_(const details::log_msg &msg); - // handle errors during logging. - // default handler prints the error to stderr at max rate of 1 message/sec. - void err_handler_(const std::string& msg); - }; + // handle errors during logging. + // default handler prints the error to stderr at max rate of 1 message/sec. + void err_handler_(const std::string &msg); +}; - void swap(logger& a, logger& b); +void swap(logger &a, logger &b); -} // namespace spdlog +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "logger-inl.h" + #include "logger-inl.h" #endif diff --git a/lib/spdlog/mdc.h b/lib/spdlog/mdc.h index e0c3391f..80b6f25c 100644 --- a/lib/spdlog/mdc.h +++ b/lib/spdlog/mdc.h @@ -4,7 +4,7 @@ #pragma once #if defined(SPDLOG_NO_TLS) -#error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined." + #error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined." #endif #include @@ -12,43 +12,39 @@ #include -// MDC is a simple map of key->string values stored in thread local storage -// whose content will be printed by the loggers. Note: Not supported in async -// mode (thread local storage - so the async thread pool have different copy). +// MDC is a simple map of key->string values stored in thread local storage whose content will be printed by the loggers. +// Note: Not supported in async mode (thread local storage - so the async thread pool have different copy). // // Usage example: // spdlog::mdc::put("mdc_key_1", "mdc_value_1"); -// spdlog::info("Hello, {}", "World!"); // => [2024-04-26 02:08:05.040] [info] -// [mdc_key_1:mdc_value_1] Hello, World! - -namespace spdlog -{ - class SPDLOG_API mdc { - public: - using mdc_map_t = std::map; - - static void put(const std::string& key, const std::string& value) { get_context()[key] = value; } - - static std::string get(const std::string& key) - { - auto& context = get_context(); - auto it = context.find(key); - if (it != context.end()) - { - return it->second; - } - return ""; +// spdlog::info("Hello, {}", "World!"); // => [2024-04-26 02:08:05.040] [info] [mdc_key_1:mdc_value_1] Hello, World! + +namespace spdlog { +class SPDLOG_API mdc { +public: + using mdc_map_t = std::map; + + static void put(const std::string &key, const std::string &value) { + get_context()[key] = value; + } + + static std::string get(const std::string &key) { + auto &context = get_context(); + auto it = context.find(key); + if (it != context.end()) { + return it->second; } + return ""; + } - static void remove(const std::string& key) { get_context().erase(key); } + static void remove(const std::string &key) { get_context().erase(key); } - static void clear() { get_context().clear(); } + static void clear() { get_context().clear(); } - static mdc_map_t& get_context() - { - static thread_local mdc_map_t context; - return context; - } - }; + static mdc_map_t &get_context() { + static thread_local mdc_map_t context; + return context; + } +}; -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/pattern_formatter-inl.h b/lib/spdlog/pattern_formatter-inl.h index 7ffe901e..b53d8051 100644 --- a/lib/spdlog/pattern_formatter-inl.h +++ b/lib/spdlog/pattern_formatter-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -12,7 +12,7 @@ #include #ifndef SPDLOG_NO_TLS -#include + #include #endif #include @@ -32,1240 +32,1240 @@ #include #include -namespace spdlog -{ - namespace details - { - - /////////////////////////////////////////////////////////////////////// - // name & level pattern appender - /////////////////////////////////////////////////////////////////////// - - class scoped_padder { - public: - scoped_padder(size_t wrapped_size, const padding_info& padinfo, memory_buf_t& dest) : padinfo_(padinfo), dest_(dest) - { - remaining_pad_ = static_cast(padinfo.width_) - static_cast(wrapped_size); - if (remaining_pad_ <= 0) - { - return; - } - - if (padinfo_.side_ == padding_info::pad_side::left) - { - pad_it(remaining_pad_); - remaining_pad_ = 0; - } - else if (padinfo_.side_ == padding_info::pad_side::center) - { - auto half_pad = remaining_pad_ / 2; - auto reminder = remaining_pad_ & 1; - pad_it(half_pad); - remaining_pad_ = half_pad + reminder; // for the right side - } - } - - template - static unsigned int count_digits(T n) - { - return fmt_helper::count_digits(n); - } - - ~scoped_padder() - { - if (remaining_pad_ >= 0) - { - pad_it(remaining_pad_); - } - else if (padinfo_.truncate_) - { - long new_size = static_cast(dest_.size()) + remaining_pad_; - dest_.resize(static_cast(new_size)); - } - } - - private: - void pad_it(long count) { fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast(count)), dest_); } - - const padding_info& padinfo_; - memory_buf_t& dest_; - long remaining_pad_; - string_view_t spaces_{" ", 64}; - }; - - struct null_scoped_padder { - null_scoped_padder(size_t /*wrapped_size*/, const padding_info& /*padinfo*/, memory_buf_t& /*dest*/) {} - - template - static unsigned int count_digits(T /* number */) - { - return 0; - } - }; - - template - class name_formatter final : public flag_formatter { - public: - explicit name_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - ScopedPadder p(msg.logger_name.size(), padinfo_, dest); - fmt_helper::append_string_view(msg.logger_name, dest); - } - }; - - // log level appender - template - class level_formatter final : public flag_formatter { - public: - explicit level_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - const string_view_t& level_name = level::to_string_view(msg.level); - ScopedPadder p(level_name.size(), padinfo_, dest); - fmt_helper::append_string_view(level_name, dest); - } - }; - - // short log level appender - template - class short_level_formatter final : public flag_formatter { - public: - explicit short_level_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - string_view_t level_name{level::to_short_c_str(msg.level)}; - ScopedPadder p(level_name.size(), padinfo_, dest); - fmt_helper::append_string_view(level_name, dest); - } - }; - - /////////////////////////////////////////////////////////////////////// - // Date time pattern appenders - /////////////////////////////////////////////////////////////////////// - - static const char* ampm(const tm& t) { return t.tm_hour >= 12 ? "PM" : "AM"; } - - static int to12h(const tm& t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; } - - // Abbreviated weekday name - static std::array days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}}; - - template - class a_formatter final : public flag_formatter { - public: - explicit a_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +namespace spdlog { +namespace details { - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - string_view_t field_value{days[static_cast(tm_time.tm_wday)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } - }; - - // Full weekday name - static std::array full_days{{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; - - template - class A_formatter : public flag_formatter { - public: - explicit A_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - string_view_t field_value{full_days[static_cast(tm_time.tm_wday)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } - }; - - // Abbreviated month - static const std::array months{{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}}; - - template - class b_formatter final : public flag_formatter { - public: - explicit b_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - string_view_t field_value{months[static_cast(tm_time.tm_mon)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } - }; - - // Full month name - static const std::array full_months{{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}}; - - template - class B_formatter final : public flag_formatter { - public: - explicit B_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - string_view_t field_value{full_months[static_cast(tm_time.tm_mon)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } - }; - - // Date and time representation (Thu Aug 23 15:35:46 2014) - template - class c_formatter final : public flag_formatter { - public: - explicit c_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 24; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::append_string_view(days[static_cast(tm_time.tm_wday)], dest); - dest.push_back(' '); - fmt_helper::append_string_view(months[static_cast(tm_time.tm_mon)], dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_mday, dest); - dest.push_back(' '); - // time - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } - }; - - // year - 2 digit - template - class C_formatter final : public flag_formatter { - public: - explicit C_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } - }; - - // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 - template - class D_formatter final : public flag_formatter { - public: - explicit D_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 10; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_mday, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } - }; - - // year - 4 digit - template - class Y_formatter final : public flag_formatter { - public: - explicit Y_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +/////////////////////////////////////////////////////////////////////// +// name & level pattern appender +/////////////////////////////////////////////////////////////////////// - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 4; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } - }; - - // month 1-12 - template - class m_formatter final : public flag_formatter { - public: - explicit m_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - } - }; - - // day of month 1-31 - template - class d_formatter final : public flag_formatter { - public: - explicit d_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_mday, dest); - } - }; - - // hours in 24 format 0-23 - template - class H_formatter final : public flag_formatter { - public: - explicit H_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_hour, dest); - } - }; - - // hours in 12 format 1-12 - template - class I_formatter final : public flag_formatter { - public: - explicit I_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(to12h(tm_time), dest); - } - }; - - // minutes 0-59 - template - class M_formatter final : public flag_formatter { - public: - explicit M_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_min, dest); - } - }; - - // seconds 0-59 - template - class S_formatter final : public flag_formatter { - public: - explicit S_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_sec, dest); - } - }; - - // milliseconds - template - class e_formatter final : public flag_formatter { - public: - explicit e_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - auto millis = fmt_helper::time_fraction(msg.time); - const size_t field_size = 3; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad3(static_cast(millis.count()), dest); - } - }; - - // microseconds - template - class f_formatter final : public flag_formatter { - public: - explicit f_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - auto micros = fmt_helper::time_fraction(msg.time); - - const size_t field_size = 6; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad6(static_cast(micros.count()), dest); - } - }; - - // nanoseconds - template - class F_formatter final : public flag_formatter { - public: - explicit F_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - auto ns = fmt_helper::time_fraction(msg.time); - const size_t field_size = 9; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad9(static_cast(ns.count()), dest); - } - }; - - // seconds since epoch - template - class E_formatter final : public flag_formatter { - public: - explicit E_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - const size_t field_size = 10; - ScopedPadder p(field_size, padinfo_, dest); - auto duration = msg.time.time_since_epoch(); - auto seconds = std::chrono::duration_cast(duration).count(); - fmt_helper::append_int(seconds, dest); - } - }; - - // AM/PM - template - class p_formatter final : public flag_formatter { - public: - explicit p_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +class scoped_padder { +public: + scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest) + : padinfo_(padinfo), + dest_(dest) { + remaining_pad_ = static_cast(padinfo.width_) - static_cast(wrapped_size); + if (remaining_pad_ <= 0) { + return; + } - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_string_view(ampm(tm_time), dest); - } - }; + if (padinfo_.side_ == padding_info::pad_side::left) { + pad_it(remaining_pad_); + remaining_pad_ = 0; + } else if (padinfo_.side_ == padding_info::pad_side::center) { + auto half_pad = remaining_pad_ / 2; + auto reminder = remaining_pad_ & 1; + pad_it(half_pad); + remaining_pad_ = half_pad + reminder; // for the right side + } + } - // 12 hour clock 02:55:02 pm - template - class r_formatter final : public flag_formatter { - public: - explicit r_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + template + static unsigned int count_digits(T n) { + return fmt_helper::count_digits(n); + } - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 11; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(to12h(tm_time), dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_string_view(ampm(tm_time), dest); - } - }; + ~scoped_padder() { + if (remaining_pad_ >= 0) { + pad_it(remaining_pad_); + } else if (padinfo_.truncate_) { + long new_size = static_cast(dest_.size()) + remaining_pad_; + dest_.resize(static_cast(new_size)); + } + } - // 24-hour HH:MM time, equivalent to %H:%M - template - class R_formatter final : public flag_formatter { - public: - explicit R_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +private: + void pad_it(long count) { + fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast(count)), + dest_); + } - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 5; - ScopedPadder p(field_size, padinfo_, dest); + const padding_info &padinfo_; + memory_buf_t &dest_; + long remaining_pad_; + string_view_t spaces_{" ", 64}; +}; - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - } - }; +struct null_scoped_padder { + null_scoped_padder(size_t /*wrapped_size*/, + const padding_info & /*padinfo*/, + memory_buf_t & /*dest*/) {} - // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S - template - class T_formatter final : public flag_formatter { - public: - explicit T_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + template + static unsigned int count_digits(T /* number */) { + return 0; + } +}; - void format(const details::log_msg&, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 8; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - } - }; +template +class name_formatter final : public flag_formatter { +public: + explicit name_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - // ISO 8601 offset from UTC in timezone (+-HH:MM) - template - class z_formatter final : public flag_formatter { - public: - explicit z_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + ScopedPadder p(msg.logger_name.size(), padinfo_, dest); + fmt_helper::append_string_view(msg.logger_name, dest); + } +}; + +// log level appender +template +class level_formatter final : public flag_formatter { +public: + explicit level_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + const string_view_t &level_name = level::to_string_view(msg.level); + ScopedPadder p(level_name.size(), padinfo_, dest); + fmt_helper::append_string_view(level_name, dest); + } +}; + +// short log level appender +template +class short_level_formatter final : public flag_formatter { +public: + explicit short_level_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + string_view_t level_name{level::to_short_c_str(msg.level)}; + ScopedPadder p(level_name.size(), padinfo_, dest); + fmt_helper::append_string_view(level_name, dest); + } +}; - z_formatter() = default; - z_formatter(const z_formatter&) = delete; - z_formatter& operator=(const z_formatter&) = delete; +/////////////////////////////////////////////////////////////////////// +// Date time pattern appenders +/////////////////////////////////////////////////////////////////////// - void format(const details::log_msg& msg, const std::tm& tm_time, memory_buf_t& dest) override - { - const size_t field_size = 6; - ScopedPadder p(field_size, padinfo_, dest); - - auto total_minutes = get_cached_offset(msg, tm_time); - bool is_negative = total_minutes < 0; - if (is_negative) - { - total_minutes = -total_minutes; - dest.push_back('-'); - } - else - { - dest.push_back('+'); - } +static const char *ampm(const tm &t) { return t.tm_hour >= 12 ? "PM" : "AM"; } - fmt_helper::pad2(total_minutes / 60, dest); // hours - dest.push_back(':'); - fmt_helper::pad2(total_minutes % 60, dest); // minutes - } +static int to12h(const tm &t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; } - private: - log_clock::time_point last_update_{std::chrono::seconds(0)}; - int offset_minutes_{0}; +// Abbreviated weekday name +static std::array days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}}; - int get_cached_offset(const log_msg& msg, const std::tm& tm_time) - { - // refresh every 10 seconds - if (msg.time - last_update_ >= std::chrono::seconds(10)) - { - offset_minutes_ = os::utc_minutes_offset(tm_time); - last_update_ = msg.time; - } - return offset_minutes_; - } - }; +template +class a_formatter final : public flag_formatter { +public: + explicit a_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - // Thread id - template - class t_formatter final : public flag_formatter { - public: - explicit t_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + string_view_t field_value{days[static_cast(tm_time.tm_wday)]}; + ScopedPadder p(field_value.size(), padinfo_, dest); + fmt_helper::append_string_view(field_value, dest); + } +}; + +// Full weekday name +static std::array full_days{ + {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; + +template +class A_formatter : public flag_formatter { +public: + explicit A_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + string_view_t field_value{full_days[static_cast(tm_time.tm_wday)]}; + ScopedPadder p(field_value.size(), padinfo_, dest); + fmt_helper::append_string_view(field_value, dest); + } +}; + +// Abbreviated month +static const std::array months{ + {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}}; + +template +class b_formatter final : public flag_formatter { +public: + explicit b_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + string_view_t field_value{months[static_cast(tm_time.tm_mon)]}; + ScopedPadder p(field_value.size(), padinfo_, dest); + fmt_helper::append_string_view(field_value, dest); + } +}; + +// Full month name +static const std::array full_months{{"January", "February", "March", "April", + "May", "June", "July", "August", "September", + "October", "November", "December"}}; + +template +class B_formatter final : public flag_formatter { +public: + explicit B_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + string_view_t field_value{full_months[static_cast(tm_time.tm_mon)]}; + ScopedPadder p(field_value.size(), padinfo_, dest); + fmt_helper::append_string_view(field_value, dest); + } +}; + +// Date and time representation (Thu Aug 23 15:35:46 2014) +template +class c_formatter final : public flag_formatter { +public: + explicit c_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 24; + ScopedPadder p(field_size, padinfo_, dest); + + fmt_helper::append_string_view(days[static_cast(tm_time.tm_wday)], dest); + dest.push_back(' '); + fmt_helper::append_string_view(months[static_cast(tm_time.tm_mon)], dest); + dest.push_back(' '); + fmt_helper::append_int(tm_time.tm_mday, dest); + dest.push_back(' '); + // time + + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + dest.push_back(' '); + fmt_helper::append_int(tm_time.tm_year + 1900, dest); + } +}; + +// year - 2 digit +template +class C_formatter final : public flag_formatter { +public: + explicit C_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_year % 100, dest); + } +}; + +// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 +template +class D_formatter final : public flag_formatter { +public: + explicit D_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 10; + ScopedPadder p(field_size, padinfo_, dest); + + fmt_helper::pad2(tm_time.tm_mon + 1, dest); + dest.push_back('/'); + fmt_helper::pad2(tm_time.tm_mday, dest); + dest.push_back('/'); + fmt_helper::pad2(tm_time.tm_year % 100, dest); + } +}; + +// year - 4 digit +template +class Y_formatter final : public flag_formatter { +public: + explicit Y_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 4; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::append_int(tm_time.tm_year + 1900, dest); + } +}; + +// month 1-12 +template +class m_formatter final : public flag_formatter { +public: + explicit m_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_mon + 1, dest); + } +}; + +// day of month 1-31 +template +class d_formatter final : public flag_formatter { +public: + explicit d_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_mday, dest); + } +}; + +// hours in 24 format 0-23 +template +class H_formatter final : public flag_formatter { +public: + explicit H_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_hour, dest); + } +}; + +// hours in 12 format 1-12 +template +class I_formatter final : public flag_formatter { +public: + explicit I_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(to12h(tm_time), dest); + } +}; + +// minutes 0-59 +template +class M_formatter final : public flag_formatter { +public: + explicit M_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_min, dest); + } +}; + +// seconds 0-59 +template +class S_formatter final : public flag_formatter { +public: + explicit S_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad2(tm_time.tm_sec, dest); + } +}; + +// milliseconds +template +class e_formatter final : public flag_formatter { +public: + explicit e_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + auto millis = fmt_helper::time_fraction(msg.time); + const size_t field_size = 3; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad3(static_cast(millis.count()), dest); + } +}; - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - const auto field_size = ScopedPadder::count_digits(msg.thread_id); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(msg.thread_id, dest); - } - }; +// microseconds +template +class f_formatter final : public flag_formatter { +public: + explicit f_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - // Current pid - template - class pid_formatter final : public flag_formatter { - public: - explicit pid_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + auto micros = fmt_helper::time_fraction(msg.time); - void format(const details::log_msg&, const std::tm&, memory_buf_t& dest) override - { - const auto pid = static_cast(details::os::pid()); - auto field_size = ScopedPadder::count_digits(pid); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(pid, dest); - } - }; - - template - class v_formatter final : public flag_formatter { - public: - explicit v_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + const size_t field_size = 6; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad6(static_cast(micros.count()), dest); + } +}; + +// nanoseconds +template +class F_formatter final : public flag_formatter { +public: + explicit F_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + auto ns = fmt_helper::time_fraction(msg.time); + const size_t field_size = 9; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::pad9(static_cast(ns.count()), dest); + } +}; + +// seconds since epoch +template +class E_formatter final : public flag_formatter { +public: + explicit E_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + const size_t field_size = 10; + ScopedPadder p(field_size, padinfo_, dest); + auto duration = msg.time.time_since_epoch(); + auto seconds = std::chrono::duration_cast(duration).count(); + fmt_helper::append_int(seconds, dest); + } +}; + +// AM/PM +template +class p_formatter final : public flag_formatter { +public: + explicit p_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 2; + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::append_string_view(ampm(tm_time), dest); + } +}; + +// 12 hour clock 02:55:02 pm +template +class r_formatter final : public flag_formatter { +public: + explicit r_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 11; + ScopedPadder p(field_size, padinfo_, dest); + + fmt_helper::pad2(to12h(tm_time), dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + dest.push_back(' '); + fmt_helper::append_string_view(ampm(tm_time), dest); + } +}; + +// 24-hour HH:MM time, equivalent to %H:%M +template +class R_formatter final : public flag_formatter { +public: + explicit R_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 5; + ScopedPadder p(field_size, padinfo_, dest); + + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + } +}; + +// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S +template +class T_formatter final : public flag_formatter { +public: + explicit T_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 8; + ScopedPadder p(field_size, padinfo_, dest); + + fmt_helper::pad2(tm_time.tm_hour, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, dest); + dest.push_back(':'); + fmt_helper::pad2(tm_time.tm_sec, dest); + } +}; + +// ISO 8601 offset from UTC in timezone (+-HH:MM) +template +class z_formatter final : public flag_formatter { +public: + explicit z_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + z_formatter() = default; + z_formatter(const z_formatter &) = delete; + z_formatter &operator=(const z_formatter &) = delete; + + void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { + const size_t field_size = 6; + ScopedPadder p(field_size, padinfo_, dest); + + auto total_minutes = get_cached_offset(msg, tm_time); + bool is_negative = total_minutes < 0; + if (is_negative) { + total_minutes = -total_minutes; + dest.push_back('-'); + } else { + dest.push_back('+'); + } - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - ScopedPadder p(msg.payload.size(), padinfo_, dest); - fmt_helper::append_string_view(msg.payload, dest); - } - }; + fmt_helper::pad2(total_minutes / 60, dest); // hours + dest.push_back(':'); + fmt_helper::pad2(total_minutes % 60, dest); // minutes + } - class ch_formatter final : public flag_formatter { - public: - explicit ch_formatter(char ch) : ch_(ch) {} +private: + log_clock::time_point last_update_{std::chrono::seconds(0)}; + int offset_minutes_{0}; - void format(const details::log_msg&, const std::tm&, memory_buf_t& dest) override { dest.push_back(ch_); } + int get_cached_offset(const log_msg &msg, const std::tm &tm_time) { + // refresh every 10 seconds + if (msg.time - last_update_ >= std::chrono::seconds(10)) { + offset_minutes_ = os::utc_minutes_offset(tm_time); + last_update_ = msg.time; + } + return offset_minutes_; + } +}; + +// Thread id +template +class t_formatter final : public flag_formatter { +public: + explicit t_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + const auto field_size = ScopedPadder::count_digits(msg.thread_id); + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::append_int(msg.thread_id, dest); + } +}; + +// Current pid +template +class pid_formatter final : public flag_formatter { +public: + explicit pid_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { + const auto pid = static_cast(details::os::pid()); + auto field_size = ScopedPadder::count_digits(pid); + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::append_int(pid, dest); + } +}; - private: - char ch_; - }; +template +class v_formatter final : public flag_formatter { +public: + explicit v_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - // aggregate user chars to display as is - class aggregate_formatter final : public flag_formatter { - public: - aggregate_formatter() = default; + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + ScopedPadder p(msg.payload.size(), padinfo_, dest); + fmt_helper::append_string_view(msg.payload, dest); + } +}; - void add_ch(char ch) { str_ += ch; } - void format(const details::log_msg&, const std::tm&, memory_buf_t& dest) override { fmt_helper::append_string_view(str_, dest); } +class ch_formatter final : public flag_formatter { +public: + explicit ch_formatter(char ch) + : ch_(ch) {} - private: - std::string str_; - }; + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { + dest.push_back(ch_); + } - // mark the color range. expect it to be in the form of "%^colored text%$" - class color_start_formatter final : public flag_formatter { - public: - explicit color_start_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +private: + char ch_; +}; - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override { msg.color_range_start = dest.size(); } - }; +// aggregate user chars to display as is +class aggregate_formatter final : public flag_formatter { +public: + aggregate_formatter() = default; - class color_stop_formatter final : public flag_formatter { - public: - explicit color_stop_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + void add_ch(char ch) { str_ += ch; } + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { + fmt_helper::append_string_view(str_, dest); + } - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override { msg.color_range_end = dest.size(); } - }; +private: + std::string str_; +}; - // print source location - template - class source_location_formatter final : public flag_formatter { - public: - explicit source_location_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +// mark the color range. expect it to be in the form of "%^colored text%$" +class color_start_formatter final : public flag_formatter { +public: + explicit color_start_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - if (msg.source.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + msg.color_range_start = dest.size(); + } +}; - size_t text_size; - if (padinfo_.enabled()) - { - // calc text size for padding based on "filename:line" - text_size = std::char_traits::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1; - } - else - { - text_size = 0; - } +class color_stop_formatter final : public flag_formatter { +public: + explicit color_stop_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.filename, dest); - dest.push_back(':'); - fmt_helper::append_int(msg.source.line, dest); - } - }; + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + msg.color_range_end = dest.size(); + } +}; + +// print source location +template +class source_location_formatter final : public flag_formatter { +public: + explicit source_location_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } - // print source filename - template - class source_filename_formatter final : public flag_formatter { - public: - explicit source_filename_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + size_t text_size; + if (padinfo_.enabled()) { + // calc text size for padding based on "filename:line" + text_size = std::char_traits::length(msg.source.filename) + + ScopedPadder::count_digits(msg.source.line) + 1; + } else { + text_size = 0; + } - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - if (msg.source.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } - size_t text_size = padinfo_.enabled() ? std::char_traits::length(msg.source.filename) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.filename, dest); - } - }; + ScopedPadder p(text_size, padinfo_, dest); + fmt_helper::append_string_view(msg.source.filename, dest); + dest.push_back(':'); + fmt_helper::append_int(msg.source.line, dest); + } +}; + +// print source filename +template +class source_filename_formatter final : public flag_formatter { +public: + explicit source_filename_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } + size_t text_size = + padinfo_.enabled() ? std::char_traits::length(msg.source.filename) : 0; + ScopedPadder p(text_size, padinfo_, dest); + fmt_helper::append_string_view(msg.source.filename, dest); + } +}; - template - class short_filename_formatter final : public flag_formatter { - public: - explicit short_filename_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +template +class short_filename_formatter final : public flag_formatter { +public: + explicit short_filename_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} #ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4127) // consider using 'if constexpr' instead -#endif // _MSC_VER - static const char* basename(const char* filename) - { - // if the size is 2 (1 character + null terminator) we can use the more - // efficient strrchr the branch will be elided by optimizations - if (sizeof(os::folder_seps) == 2) - { - const char* rv = std::strrchr(filename, os::folder_seps[0]); - return rv != nullptr ? rv + 1 : filename; - } - else - { - const std::reverse_iterator begin(filename + std::strlen(filename)); - const std::reverse_iterator end(filename); - - const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), std::end(os::folder_seps) - 1); - return it != end ? it.base() : filename; - } - } + #pragma warning(push) + #pragma warning(disable : 4127) // consider using 'if constexpr' instead +#endif // _MSC_VER + static const char *basename(const char *filename) { + // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr + // the branch will be elided by optimizations + if (sizeof(os::folder_seps) == 2) { + const char *rv = std::strrchr(filename, os::folder_seps[0]); + return rv != nullptr ? rv + 1 : filename; + } else { + const std::reverse_iterator begin(filename + std::strlen(filename)); + const std::reverse_iterator end(filename); + + const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), + std::end(os::folder_seps) - 1); + return it != end ? it.base() : filename; + } + } #ifdef _MSC_VER -#pragma warning(pop) -#endif // _MSC_VER - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - if (msg.source.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } - auto filename = basename(msg.source.filename); - size_t text_size = padinfo_.enabled() ? std::char_traits::length(filename) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(filename, dest); - } - }; - - template - class source_linenum_formatter final : public flag_formatter { - public: - explicit source_linenum_formatter(padding_info padinfo) : flag_formatter(padinfo) {} - - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - if (msg.source.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } - - auto field_size = ScopedPadder::count_digits(msg.source.line); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(msg.source.line, dest); - } - }; - - // print source funcname - template - class source_funcname_formatter final : public flag_formatter { - public: - explicit source_funcname_formatter(padding_info padinfo) : flag_formatter(padinfo) {} + #pragma warning(pop) +#endif // _MSC_VER - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - if (msg.source.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } - size_t text_size = padinfo_.enabled() ? std::char_traits::length(msg.source.funcname) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.funcname, dest); - } - }; + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } + auto filename = basename(msg.source.filename); + size_t text_size = padinfo_.enabled() ? std::char_traits::length(filename) : 0; + ScopedPadder p(text_size, padinfo_, dest); + fmt_helper::append_string_view(filename, dest); + } +}; - // print elapsed time since last message - template - class elapsed_formatter final : public flag_formatter { - public: - using DurationUnits = Units; +template +class source_linenum_formatter final : public flag_formatter { +public: + explicit source_linenum_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - explicit elapsed_formatter(padding_info padinfo) : flag_formatter(padinfo), last_message_time_(log_clock::now()) {} + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } - void format(const details::log_msg& msg, const std::tm&, memory_buf_t& dest) override - { - auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero()); - auto delta_units = std::chrono::duration_cast(delta); - last_message_time_ = msg.time; - auto delta_count = static_cast(delta_units.count()); - auto n_digits = static_cast(ScopedPadder::count_digits(delta_count)); - ScopedPadder p(n_digits, padinfo_, dest); - fmt_helper::append_int(delta_count, dest); - } + auto field_size = ScopedPadder::count_digits(msg.source.line); + ScopedPadder p(field_size, padinfo_, dest); + fmt_helper::append_int(msg.source.line, dest); + } +}; + +// print source funcname +template +class source_funcname_formatter final : public flag_formatter { +public: + explicit source_funcname_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } + size_t text_size = + padinfo_.enabled() ? std::char_traits::length(msg.source.funcname) : 0; + ScopedPadder p(text_size, padinfo_, dest); + fmt_helper::append_string_view(msg.source.funcname, dest); + } +}; + +// print elapsed time since last message +template +class elapsed_formatter final : public flag_formatter { +public: + using DurationUnits = Units; + + explicit elapsed_formatter(padding_info padinfo) + : flag_formatter(padinfo), + last_message_time_(log_clock::now()) {} + + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero()); + auto delta_units = std::chrono::duration_cast(delta); + last_message_time_ = msg.time; + auto delta_count = static_cast(delta_units.count()); + auto n_digits = static_cast(ScopedPadder::count_digits(delta_count)); + ScopedPadder p(n_digits, padinfo_, dest); + fmt_helper::append_int(delta_count, dest); + } - private: - log_clock::time_point last_message_time_; - }; +private: + log_clock::time_point last_message_time_; +}; // Class for formatting Mapped Diagnostic Context (MDC) in log messages. -// Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] -// some message +// Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message #ifndef SPDLOG_NO_TLS - template - class mdc_formatter : public flag_formatter { - public: - explicit mdc_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +template +class mdc_formatter : public flag_formatter { +public: + explicit mdc_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} + + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { + auto &mdc_map = mdc::get_context(); + if (mdc_map.empty()) { + ScopedPadder p(0, padinfo_, dest); + return; + } else { + format_mdc(mdc_map, dest); + } + } - void format(const details::log_msg&, const std::tm&, memory_buf_t& dest) override - { - auto& mdc_map = mdc::get_context(); - if (mdc_map.empty()) - { - ScopedPadder p(0, padinfo_, dest); - return; - } - else - { - format_mdc(mdc_map, dest); - } + void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) { + auto last_element = --mdc_map.end(); + for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) { + auto &pair = *it; + const auto &key = pair.first; + const auto &value = pair.second; + size_t content_size = key.size() + value.size() + 1; // 1 for ':' + + if (it != last_element) { + content_size++; // 1 for ' ' } - void format_mdc(const mdc::mdc_map_t& mdc_map, memory_buf_t& dest) - { - auto last_element = --mdc_map.end(); - for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) - { - auto& pair = *it; - const auto& key = pair.first; - const auto& value = pair.second; - size_t content_size = key.size() + value.size() + 1; // 1 for ':' - - if (it != last_element) - { - content_size++; // 1 for ' ' - } - - ScopedPadder p(content_size, padinfo_, dest); - fmt_helper::append_string_view(key, dest); - fmt_helper::append_string_view(":", dest); - fmt_helper::append_string_view(value, dest); - if (it != last_element) - { - fmt_helper::append_string_view(" ", dest); - } - } + ScopedPadder p(content_size, padinfo_, dest); + fmt_helper::append_string_view(key, dest); + fmt_helper::append_string_view(":", dest); + fmt_helper::append_string_view(value, dest); + if (it != last_element) { + fmt_helper::append_string_view(" ", dest); } - }; + } + } +}; #endif - // Full info formatter - // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v - class full_formatter final : public flag_formatter { - public: - explicit full_formatter(padding_info padinfo) : flag_formatter(padinfo) {} +// Full info formatter +// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v +class full_formatter final : public flag_formatter { +public: + explicit full_formatter(padding_info padinfo) + : flag_formatter(padinfo) {} - void format(const details::log_msg& msg, const std::tm& tm_time, memory_buf_t& dest) override - { - using std::chrono::duration_cast; - using std::chrono::milliseconds; - using std::chrono::seconds; + void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { + using std::chrono::duration_cast; + using std::chrono::milliseconds; + using std::chrono::seconds; - // cache the date/time part for the next second. - auto duration = msg.time.time_since_epoch(); - auto secs = duration_cast(duration); + // cache the date/time part for the next second. + auto duration = msg.time.time_since_epoch(); + auto secs = duration_cast(duration); - if (cache_timestamp_ != secs || cached_datetime_.size() == 0) - { - cached_datetime_.clear(); - cached_datetime_.push_back('['); - fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); - cached_datetime_.push_back('-'); + if (cache_timestamp_ != secs || cached_datetime_.size() == 0) { + cached_datetime_.clear(); + cached_datetime_.push_back('['); + fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); + cached_datetime_.push_back('-'); - fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); - cached_datetime_.push_back('-'); + fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); + cached_datetime_.push_back('-'); - fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); - cached_datetime_.push_back(' '); + fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); + cached_datetime_.push_back(' '); - fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); - cached_datetime_.push_back(':'); + fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); + cached_datetime_.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, cached_datetime_); - cached_datetime_.push_back(':'); + fmt_helper::pad2(tm_time.tm_min, cached_datetime_); + cached_datetime_.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); - cached_datetime_.push_back('.'); + fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); + cached_datetime_.push_back('.'); - cache_timestamp_ = secs; - } - dest.append(cached_datetime_.begin(), cached_datetime_.end()); - - auto millis = fmt_helper::time_fraction(msg.time); - fmt_helper::pad3(static_cast(millis.count()), dest); - dest.push_back(']'); - dest.push_back(' '); - - // append logger name if exists - if (msg.logger_name.size() > 0) - { - dest.push_back('['); - fmt_helper::append_string_view(msg.logger_name, dest); - dest.push_back(']'); - dest.push_back(' '); - } + cache_timestamp_ = secs; + } + dest.append(cached_datetime_.begin(), cached_datetime_.end()); + + auto millis = fmt_helper::time_fraction(msg.time); + fmt_helper::pad3(static_cast(millis.count()), dest); + dest.push_back(']'); + dest.push_back(' '); + + // append logger name if exists + if (msg.logger_name.size() > 0) { + dest.push_back('['); + fmt_helper::append_string_view(msg.logger_name, dest); + dest.push_back(']'); + dest.push_back(' '); + } - dest.push_back('['); - // wrap the level name with color - msg.color_range_start = dest.size(); - // fmt_helper::append_string_view(level::to_c_str(msg.level), dest); - fmt_helper::append_string_view(level::to_string_view(msg.level), dest); - msg.color_range_end = dest.size(); - dest.push_back(']'); - dest.push_back(' '); - - // add source location if present - if (!msg.source.empty()) - { - dest.push_back('['); - const char* filename = details::short_filename_formatter::basename(msg.source.filename); - fmt_helper::append_string_view(filename, dest); - dest.push_back(':'); - fmt_helper::append_int(msg.source.line, dest); - dest.push_back(']'); - dest.push_back(' '); - } + dest.push_back('['); + // wrap the level name with color + msg.color_range_start = dest.size(); + // fmt_helper::append_string_view(level::to_c_str(msg.level), dest); + fmt_helper::append_string_view(level::to_string_view(msg.level), dest); + msg.color_range_end = dest.size(); + dest.push_back(']'); + dest.push_back(' '); + + // add source location if present + if (!msg.source.empty()) { + dest.push_back('['); + const char *filename = + details::short_filename_formatter::basename( + msg.source.filename); + fmt_helper::append_string_view(filename, dest); + dest.push_back(':'); + fmt_helper::append_int(msg.source.line, dest); + dest.push_back(']'); + dest.push_back(' '); + } #ifndef SPDLOG_NO_TLS - // add mdc if present - auto& mdc_map = mdc::get_context(); - if (!mdc_map.empty()) - { - dest.push_back('['); - mdc_formatter_.format_mdc(mdc_map, dest); - dest.push_back(']'); - dest.push_back(' '); - } + // add mdc if present + auto &mdc_map = mdc::get_context(); + if (!mdc_map.empty()) { + dest.push_back('['); + mdc_formatter_.format_mdc(mdc_map, dest); + dest.push_back(']'); + dest.push_back(' '); + } #endif - // fmt_helper::append_string_view(msg.msg(), dest); - fmt_helper::append_string_view(msg.payload, dest); - } + // fmt_helper::append_string_view(msg.msg(), dest); + fmt_helper::append_string_view(msg.payload, dest); + } - private: - std::chrono::seconds cache_timestamp_{0}; - memory_buf_t cached_datetime_; +private: + std::chrono::seconds cache_timestamp_{0}; + memory_buf_t cached_datetime_; #ifndef SPDLOG_NO_TLS - mdc_formatter mdc_formatter_{padding_info {}}; + mdc_formatter mdc_formatter_{padding_info{}}; #endif - }; - - } // namespace details - - SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags) : pattern_(std::move(pattern)), eol_(std::move(eol)), pattern_time_type_(time_type), need_localtime_(false), last_log_secs_(0), custom_handlers_(std::move(custom_user_flags)) - { - std::memset(&cached_tm_, 0, sizeof(cached_tm_)); - compile_pattern_(pattern_); - } - // use by default full formatter for if pattern is not given - SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) : pattern_("%+"), eol_(std::move(eol)), pattern_time_type_(time_type), need_localtime_(true), last_log_secs_(0) - { - std::memset(&cached_tm_, 0, sizeof(cached_tm_)); - formatters_.push_back(details::make_unique(details::padding_info{})); +}; + +} // namespace details + +SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, + pattern_time_type time_type, + std::string eol, + custom_flags custom_user_flags) + : pattern_(std::move(pattern)), + eol_(std::move(eol)), + pattern_time_type_(time_type), + need_localtime_(false), + last_log_secs_(0), + custom_handlers_(std::move(custom_user_flags)) { + std::memset(&cached_tm_, 0, sizeof(cached_tm_)); + compile_pattern_(pattern_); +} + +// use by default full formatter for if pattern is not given +SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) + : pattern_("%+"), + eol_(std::move(eol)), + pattern_time_type_(time_type), + need_localtime_(true), + last_log_secs_(0) { + std::memset(&cached_tm_, 0, sizeof(cached_tm_)); + formatters_.push_back(details::make_unique(details::padding_info{})); +} + +SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const { + custom_flags cloned_custom_formatters; + for (auto &it : custom_handlers_) { + cloned_custom_formatters[it.first] = it.second->clone(); } - - SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const - { - custom_flags cloned_custom_formatters; - for (auto& it : custom_handlers_) - { - cloned_custom_formatters[it.first] = it.second->clone(); - } - auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters)); - cloned->need_localtime(need_localtime_); + auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_, + std::move(cloned_custom_formatters)); + cloned->need_localtime(need_localtime_); #if defined(__GNUC__) && __GNUC__ < 5 - return std::move(cloned); + return std::move(cloned); #else - return cloned; + return cloned; #endif - } - - SPDLOG_INLINE void pattern_formatter::format(const details::log_msg& msg, memory_buf_t& dest) - { - if (need_localtime_) - { - const auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); - if (secs != last_log_secs_) - { - cached_tm_ = get_time_(msg); - last_log_secs_ = secs; - } - } - - for (auto& f : formatters_) - { - f->format(msg, cached_tm_, dest); +} + +SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) { + if (need_localtime_) { + const auto secs = + std::chrono::duration_cast(msg.time.time_since_epoch()); + if (secs != last_log_secs_) { + cached_tm_ = get_time_(msg); + last_log_secs_ = secs; } - // write eol - details::fmt_helper::append_string_view(eol_, dest); } - SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) - { - pattern_ = std::move(pattern); - need_localtime_ = false; - compile_pattern_(pattern_); + for (auto &f : formatters_) { + f->format(msg, cached_tm_, dest); } + // write eol + details::fmt_helper::append_string_view(eol_, dest); +} - SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } +SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) { + pattern_ = std::move(pattern); + need_localtime_ = false; + compile_pattern_(pattern_); +} - SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg& msg) - { - if (pattern_time_type_ == 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)); - } +SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } - template - SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) - { - // process custom flags - auto it = custom_handlers_.find(flag); - if (it != custom_handlers_.end()) - { - auto custom_handler = it->second->clone(); - custom_handler->set_padding_info(padding); - formatters_.push_back(std::move(custom_handler)); - return; - } +SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) { + if (pattern_time_type_ == 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)); +} + +template +SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { + // process custom flags + auto it = custom_handlers_.find(flag); + if (it != custom_handlers_.end()) { + auto custom_handler = it->second->clone(); + custom_handler->set_padding_info(padding); + formatters_.push_back(std::move(custom_handler)); + return; + } - // process built-in flags - switch (flag) - { - case ('+'): // default formatter + // process built-in flags + switch (flag) { + case ('+'): // default formatter formatters_.push_back(details::make_unique(padding)); need_localtime_ = true; break; - case 'n': // logger name + case 'n': // logger name formatters_.push_back(details::make_unique>(padding)); break; - case 'l': // level + case 'l': // level formatters_.push_back(details::make_unique>(padding)); break; - case 'L': // short level - formatters_.push_back(details::make_unique>(padding)); + case 'L': // short level + formatters_.push_back( + details::make_unique>(padding)); break; - case ('t'): // thread id + case ('t'): // thread id formatters_.push_back(details::make_unique>(padding)); break; - case ('v'): // the message text + case ('v'): // the message text formatters_.push_back(details::make_unique>(padding)); break; - case ('a'): // weekday + case ('a'): // weekday formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('A'): // short weekday + case ('A'): // short weekday formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('b'): - case ('h'): // month + case ('h'): // month formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('B'): // short month + case ('B'): // short month formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('c'): // datetime + case ('c'): // datetime formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('C'): // year 2 digits + case ('C'): // year 2 digits formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('Y'): // year 4 digits + case ('Y'): // year 4 digits formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('D'): - case ('x'): // datetime MM/DD/YY + case ('x'): // datetime MM/DD/YY formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('m'): // month 1-12 + case ('m'): // month 1-12 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('d'): // day of month 1-31 + case ('d'): // day of month 1-31 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('H'): // hours 24 + case ('H'): // hours 24 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('I'): // hours 12 + case ('I'): // hours 12 formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('M'): // minutes + case ('M'): // minutes formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('S'): // seconds + case ('S'): // seconds formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('e'): // milliseconds + case ('e'): // milliseconds formatters_.push_back(details::make_unique>(padding)); break; - case ('f'): // microseconds + case ('f'): // microseconds formatters_.push_back(details::make_unique>(padding)); break; - case ('F'): // nanoseconds + case ('F'): // nanoseconds formatters_.push_back(details::make_unique>(padding)); break; - case ('E'): // seconds since epoch + case ('E'): // seconds since epoch formatters_.push_back(details::make_unique>(padding)); break; - case ('p'): // am/pm + case ('p'): // am/pm formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('r'): // 12 hour clock 02:55:02 pm + case ('r'): // 12 hour clock 02:55:02 pm formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('R'): // 24-hour HH:MM time + case ('R'): // 24-hour HH:MM time formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; case ('T'): - case ('X'): // ISO 8601 time format (HH:MM:SS) + case ('X'): // ISO 8601 time format (HH:MM:SS) formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('z'): // timezone + case ('z'): // timezone formatters_.push_back(details::make_unique>(padding)); need_localtime_ = true; break; - case ('P'): // pid + case ('P'): // pid formatters_.push_back(details::make_unique>(padding)); break; - case ('^'): // color range start + case ('^'): // color range start formatters_.push_back(details::make_unique(padding)); break; - case ('$'): // color range end + case ('$'): // color range end formatters_.push_back(details::make_unique(padding)); break; - case ('@'): // source location (filename:filenumber) - formatters_.push_back(details::make_unique>(padding)); + case ('@'): // source location (filename:filenumber) + formatters_.push_back( + details::make_unique>(padding)); break; - case ('s'): // short source filename - without directory name - formatters_.push_back(details::make_unique>(padding)); + case ('s'): // short source filename - without directory name + formatters_.push_back( + details::make_unique>(padding)); break; - case ('g'): // full source filename - formatters_.push_back(details::make_unique>(padding)); + case ('g'): // full source filename + formatters_.push_back( + details::make_unique>(padding)); break; - case ('#'): // source line number - formatters_.push_back(details::make_unique>(padding)); + case ('#'): // source line number + formatters_.push_back( + details::make_unique>(padding)); break; - case ('!'): // source funcname - formatters_.push_back(details::make_unique>(padding)); + case ('!'): // source funcname + formatters_.push_back( + details::make_unique>(padding)); break; - case ('%'): // % char + case ('%'): // % char formatters_.push_back(details::make_unique('%')); break; - case ('u'): // elapsed time since last log message in nanos - formatters_.push_back(details::make_unique>(padding)); + case ('u'): // elapsed time since last log message in nanos + formatters_.push_back( + details::make_unique>( + padding)); break; - case ('i'): // elapsed time since last log message in micros - formatters_.push_back(details::make_unique>(padding)); + case ('i'): // elapsed time since last log message in micros + formatters_.push_back( + details::make_unique>( + padding)); break; - case ('o'): // elapsed time since last log message in millis - formatters_.push_back(details::make_unique>(padding)); + case ('o'): // elapsed time since last log message in millis + formatters_.push_back( + details::make_unique>( + padding)); break; - case ('O'): // elapsed time since last log message in seconds - formatters_.push_back(details::make_unique>(padding)); + case ('O'): // elapsed time since last log message in seconds + formatters_.push_back( + details::make_unique>( + padding)); break; -#ifndef SPDLOG_NO_TLS // mdc formatter requires TLS support +#ifndef SPDLOG_NO_TLS // mdc formatter requires TLS support case ('&'): formatters_.push_back(details::make_unique>(padding)); break; #endif - default: // Unknown flag appears as is + default: // Unknown flag appears as is auto unknown_flag = details::make_unique(); - if (!padding.truncate_) - { + if (!padding.truncate_) { unknown_flag->add_ch('%'); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } - // fix issue #1617 (prev char was '!' and should have been treated as - // funcname flag instead of truncating flag) spdlog::set_pattern("[%10!] - // %v") => "[ main] some message" spdlog::set_pattern("[%3!!] %v") => - // "[mai] some message" - else - { + // fix issue #1617 (prev char was '!' and should have been treated as funcname flag + // instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some + // message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message" + else { padding.truncate_ = false; - formatters_.push_back(details::make_unique>(padding)); + formatters_.push_back( + details::make_unique>(padding)); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } break; - } + } +} + +// Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) +// Advance the given it pass the end of the padding spec found (if any) +// Return padding. +SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_( + std::string::const_iterator &it, std::string::const_iterator end) { + using details::padding_info; + using details::scoped_padder; + const size_t max_width = 64; + if (it == end) { + return padding_info{}; } - // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) - // Advance the given it pass the end of the padding spec found (if any) - // Return padding. - SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator& it, std::string::const_iterator end) - { - using details::padding_info; - using details::scoped_padder; - const size_t max_width = 64; - if (it == end) - { - return padding_info{}; - } - - padding_info::pad_side side; - switch (*it) - { + padding_info::pad_side side; + switch (*it) { case '-': side = padding_info::pad_side::right; ++it; @@ -1277,78 +1277,62 @@ namespace spdlog default: side = details::padding_info::pad_side::left; break; - } - - if (it == end || !std::isdigit(static_cast(*it))) - { - return padding_info{}; // no padding if no digit found here - } + } - auto width = static_cast(*it) - '0'; - for (++it; it != end && std::isdigit(static_cast(*it)); ++it) - { - auto digit = static_cast(*it) - '0'; - width = width * 10 + digit; - } + if (it == end || !std::isdigit(static_cast(*it))) { + return padding_info{}; // no padding if no digit found here + } - // search for the optional truncate marker '!' - bool truncate; - if (it != end && *it == '!') - { - truncate = true; - ++it; - } - else - { - truncate = false; - } - return details::padding_info{std::min(width, max_width), side, truncate}; + auto width = static_cast(*it) - '0'; + for (++it; it != end && std::isdigit(static_cast(*it)); ++it) { + auto digit = static_cast(*it) - '0'; + width = width * 10 + digit; } - SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string& pattern) - { - auto end = pattern.end(); - std::unique_ptr user_chars; - formatters_.clear(); - for (auto it = pattern.begin(); it != end; ++it) - { - if (*it == '%') + // search for the optional truncate marker '!' + bool truncate; + if (it != end && *it == '!') { + truncate = true; + ++it; + } else { + truncate = false; + } + return details::padding_info{std::min(width, max_width), side, truncate}; +} + +SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) { + auto end = pattern.end(); + std::unique_ptr user_chars; + formatters_.clear(); + for (auto it = pattern.begin(); it != end; ++it) { + if (*it == '%') { + if (user_chars) // append user chars found so far { - if (user_chars) // append user chars found so far - { - formatters_.push_back(std::move(user_chars)); - } - - auto padding = handle_padspec_(++it, end); - - if (it != end) - { - if (padding.enabled()) - { - handle_flag_(*it, padding); - } - else - { - handle_flag_(*it, padding); - } - } - else - { - break; - } + formatters_.push_back(std::move(user_chars)); } - else // chars not following the % sign should be displayed as is - { - if (!user_chars) - { - user_chars = details::make_unique(); + + auto padding = handle_padspec_(++it, end); + + if (it != end) { + if (padding.enabled()) { + handle_flag_(*it, padding); + } else { + handle_flag_(*it, padding); } - user_chars->add_ch(*it); + } else { + break; } - } - if (user_chars) // append raw chars found so far + } else // chars not following the % sign should be displayed as is { - formatters_.push_back(std::move(user_chars)); + if (!user_chars) { + user_chars = details::make_unique(); + } + user_chars->add_ch(*it); } } -} // namespace spdlog + if (user_chars) // append raw chars found so far + { + formatters_.push_back(std::move(user_chars)); + } +} +} // namespace spdlog diff --git a/lib/spdlog/pattern_formatter.h b/lib/spdlog/pattern_formatter.h index ebd856ff..ececd673 100644 --- a/lib/spdlog/pattern_formatter.h +++ b/lib/spdlog/pattern_formatter.h @@ -16,92 +16,103 @@ #include #include -namespace spdlog -{ - namespace details - { - - // padding information. - struct padding_info { - enum class pad_side { left, right, center }; - - padding_info() = default; - padding_info(size_t width, padding_info::pad_side side, bool truncate) : width_(width), side_(side), truncate_(truncate), enabled_(true) {} - - bool enabled() const { return enabled_; } - size_t width_ = 0; - pad_side side_ = pad_side::left; - bool truncate_ = false; - bool enabled_ = false; - }; - - class SPDLOG_API flag_formatter { - public: - explicit flag_formatter(padding_info padinfo) : padinfo_(padinfo) {} - flag_formatter() = default; - virtual ~flag_formatter() = default; - virtual void format(const details::log_msg& msg, const std::tm& tm_time, memory_buf_t& dest) = 0; - - protected: - padding_info padinfo_; - }; - - } // namespace details - - class SPDLOG_API custom_flag_formatter : public details::flag_formatter { - public: - virtual std::unique_ptr clone() const = 0; - - void set_padding_info(const details::padding_info& padding) { flag_formatter::padinfo_ = padding; } - }; - - class SPDLOG_API pattern_formatter final : public formatter { - public: - using custom_flags = std::unordered_map>; - - explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags()); - - // use default pattern is not given - explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol); - - pattern_formatter(const pattern_formatter& other) = delete; - pattern_formatter& operator=(const pattern_formatter& other) = delete; - - std::unique_ptr clone() const override; - void format(const details::log_msg& msg, memory_buf_t& dest) override; - - template - pattern_formatter& add_flag(char flag, Args&&... args) - { - custom_handlers_[flag] = details::make_unique(std::forward(args)...); - return *this; - } - void set_pattern(std::string pattern); - void need_localtime(bool need = true); - - private: - std::string pattern_; - std::string eol_; - pattern_time_type pattern_time_type_; - bool need_localtime_; - std::tm cached_tm_; - std::chrono::seconds last_log_secs_; - std::vector> formatters_; - custom_flags custom_handlers_; - - std::tm get_time_(const details::log_msg& msg); - template - void handle_flag_(char flag, details::padding_info padding); - - // Extract given pad spec (e.g. %8X) - // Advance the given it pass the end of the padding spec found (if any) - // Return padding. - static details::padding_info handle_padspec_(std::string::const_iterator& it, std::string::const_iterator end); - - void compile_pattern_(const std::string& pattern); - }; -} // namespace spdlog +namespace spdlog { +namespace details { + +// padding information. +struct padding_info { + enum class pad_side { left, right, center }; + + padding_info() = default; + padding_info(size_t width, padding_info::pad_side side, bool truncate) + : width_(width), + side_(side), + truncate_(truncate), + enabled_(true) {} + + bool enabled() const { return enabled_; } + size_t width_ = 0; + pad_side side_ = pad_side::left; + bool truncate_ = false; + bool enabled_ = false; +}; + +class SPDLOG_API flag_formatter { +public: + explicit flag_formatter(padding_info padinfo) + : padinfo_(padinfo) {} + flag_formatter() = default; + virtual ~flag_formatter() = default; + virtual void format(const details::log_msg &msg, + const std::tm &tm_time, + memory_buf_t &dest) = 0; + +protected: + padding_info padinfo_; +}; + +} // namespace details + +class SPDLOG_API custom_flag_formatter : public details::flag_formatter { +public: + virtual std::unique_ptr clone() const = 0; + + void set_padding_info(const details::padding_info &padding) { + flag_formatter::padinfo_ = padding; + } +}; + +class SPDLOG_API pattern_formatter final : public formatter { +public: + using custom_flags = std::unordered_map>; + + explicit pattern_formatter(std::string pattern, + pattern_time_type time_type = pattern_time_type::local, + std::string eol = spdlog::details::os::default_eol, + custom_flags custom_user_flags = custom_flags()); + + // use default pattern is not given + explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, + std::string eol = spdlog::details::os::default_eol); + + pattern_formatter(const pattern_formatter &other) = delete; + pattern_formatter &operator=(const pattern_formatter &other) = delete; + + std::unique_ptr clone() const override; + void format(const details::log_msg &msg, memory_buf_t &dest) override; + + template + pattern_formatter &add_flag(char flag, Args &&...args) { + custom_handlers_[flag] = details::make_unique(std::forward(args)...); + return *this; + } + void set_pattern(std::string pattern); + void need_localtime(bool need = true); + +private: + std::string pattern_; + std::string eol_; + pattern_time_type pattern_time_type_; + bool need_localtime_; + std::tm cached_tm_; + std::chrono::seconds last_log_secs_; + std::vector> formatters_; + custom_flags custom_handlers_; + + std::tm get_time_(const details::log_msg &msg); + template + void handle_flag_(char flag, details::padding_info padding); + + // Extract given pad spec (e.g. %8X) + // Advance the given it pass the end of the padding spec found (if any) + // Return padding. + static details::padding_info handle_padspec_(std::string::const_iterator &it, + std::string::const_iterator end); + + void compile_pattern_(const std::string &pattern); +}; +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "pattern_formatter-inl.h" + #include "pattern_formatter-inl.h" #endif diff --git a/lib/spdlog/sinks/android_sink.h b/lib/spdlog/sinks/android_sink.h index c20face9..4435a560 100644 --- a/lib/spdlog/sinks/android_sink.h +++ b/lib/spdlog/sinks/android_sink.h @@ -5,143 +5,133 @@ #ifdef __ANDROID__ -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#if !defined(SPDLOG_ANDROID_RETRIES) -#define SPDLOG_ANDROID_RETRIES 2 -#endif - -namespace spdlog -{ - namespace sinks - { - - /* - * Android sink - * (logging using __android_log_write or __android_log_buf_write depending on - * the specified BufferID) - */ - template - class android_sink final : public base_sink { - public: - explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) : tag_(std::move(tag)), use_raw_msg_(use_raw_msg) {} - - protected: - void sink_it_(const details::log_msg& msg) override - { - const android_LogPriority priority = convert_to_android_(msg.level); - memory_buf_t formatted; - if (use_raw_msg_) - { - details::fmt_helper::append_string_view(msg.payload, formatted); - } - else - { - base_sink::formatter_->format(msg, formatted); - } - formatted.push_back('\0'); - const char* msg_output = formatted.data(); - - // See system/core/liblog/logger_write.c for explanation of return value - int ret = android_log(priority, tag_.c_str(), msg_output); - if (ret == -EPERM) - { - return; // !__android_log_is_loggable - } - int retry_count = 0; - while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) - { - details::os::sleep_for_millis(5); - ret = android_log(priority, tag_.c_str(), msg_output); - retry_count++; - } - - if (ret < 0) - { - throw_spdlog_ex("logging to Android failed", ret); - } - } - - void flush_() override {} - - private: - // There might be liblog versions used, that do not support - // __android_log_buf_write. So we only compile and link against - // __android_log_buf_write, if user explicitly provides a non-default log - // buffer. Otherwise, when using the default log buffer, always log via - // __android_log_write. - template - typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char* tag, const char* text) - { - return __android_log_write(prio, tag, text); - } - - template - typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char* tag, const char* text) - { - return __android_log_buf_write(ID, prio, tag, text); - } - - static android_LogPriority convert_to_android_(spdlog::level::level_enum level) - { - switch (level) - { - case spdlog::level::trace: - return ANDROID_LOG_VERBOSE; - case spdlog::level::debug: - return ANDROID_LOG_DEBUG; - case spdlog::level::info: - return ANDROID_LOG_INFO; - case spdlog::level::warn: - return ANDROID_LOG_WARN; - case spdlog::level::err: - return ANDROID_LOG_ERROR; - case spdlog::level::critical: - return ANDROID_LOG_FATAL; - default: - return ANDROID_LOG_DEFAULT; - } - } - - std::string tag_; - bool use_raw_msg_; - }; - - using android_sink_mt = android_sink; - using android_sink_st = android_sink; - - template - using android_sink_buf_mt = android_sink; - template - using android_sink_buf_st = android_sink; - - } // namespace sinks - - // Create and register android syslog logger - - template - inline std::shared_ptr android_logger_mt(const std::string& logger_name, const std::string& tag = "spdlog") - { - return Factory::template create(logger_name, tag); + #include + #include + #include + #include + #include + + #include + #include + #include + #include + #include + #include + + #if !defined(SPDLOG_ANDROID_RETRIES) + #define SPDLOG_ANDROID_RETRIES 2 + #endif + +namespace spdlog { +namespace sinks { + +/* + * Android sink + * (logging using __android_log_write or __android_log_buf_write depending on the specified + * BufferID) + */ +template +class android_sink final : public base_sink { +public: + explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) + : tag_(std::move(tag)), + use_raw_msg_(use_raw_msg) {} + +protected: + void sink_it_(const details::log_msg &msg) override { + const android_LogPriority priority = convert_to_android_(msg.level); + memory_buf_t formatted; + if (use_raw_msg_) { + details::fmt_helper::append_string_view(msg.payload, formatted); + } else { + base_sink::formatter_->format(msg, formatted); + } + formatted.push_back('\0'); + const char *msg_output = formatted.data(); + + // See system/core/liblog/logger_write.c for explanation of return value + int ret = android_log(priority, tag_.c_str(), msg_output); + if (ret == -EPERM) { + return; // !__android_log_is_loggable + } + int retry_count = 0; + while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) { + details::os::sleep_for_millis(5); + ret = android_log(priority, tag_.c_str(), msg_output); + retry_count++; + } + + if (ret < 0) { + throw_spdlog_ex("logging to Android failed", ret); + } } - template - inline std::shared_ptr android_logger_st(const std::string& logger_name, const std::string& tag = "spdlog") - { - return Factory::template create(logger_name, tag); + void flush_() override {} + +private: + // There might be liblog versions used, that do not support __android_log_buf_write. So we only + // compile and link against + // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, + // when using the default log buffer, always log via __android_log_write. + template + typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( + int prio, const char *tag, const char *text) { + return __android_log_write(prio, tag, text); } -} // namespace spdlog + template + typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( + int prio, const char *tag, const char *text) { + return __android_log_buf_write(ID, prio, tag, text); + } + + static android_LogPriority convert_to_android_(spdlog::level::level_enum level) { + switch (level) { + case spdlog::level::trace: + return ANDROID_LOG_VERBOSE; + case spdlog::level::debug: + return ANDROID_LOG_DEBUG; + case spdlog::level::info: + return ANDROID_LOG_INFO; + case spdlog::level::warn: + return ANDROID_LOG_WARN; + case spdlog::level::err: + return ANDROID_LOG_ERROR; + case spdlog::level::critical: + return ANDROID_LOG_FATAL; + default: + return ANDROID_LOG_DEFAULT; + } + } + + std::string tag_; + bool use_raw_msg_; +}; + +using android_sink_mt = android_sink; +using android_sink_st = android_sink; + +template +using android_sink_buf_mt = android_sink; +template +using android_sink_buf_st = android_sink; + +} // namespace sinks + +// Create and register android syslog logger + +template +inline std::shared_ptr android_logger_mt(const std::string &logger_name, + const std::string &tag = "spdlog") { + return Factory::template create(logger_name, tag); +} + +template +inline std::shared_ptr android_logger_st(const std::string &logger_name, + const std::string &tag = "spdlog") { + return Factory::template create(logger_name, tag); +} + +} // namespace spdlog -#endif // __ANDROID__ +#endif // __ANDROID__ diff --git a/lib/spdlog/sinks/ansicolor_sink-inl.h b/lib/spdlog/sinks/ansicolor_sink-inl.h index ffe9dce6..2194f67b 100644 --- a/lib/spdlog/sinks/ansicolor_sink-inl.h +++ b/lib/spdlog/sinks/ansicolor_sink-inl.h @@ -4,141 +4,132 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog +namespace spdlog { +namespace sinks { + +template +SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) + : target_file_(target_file), + mutex_(ConsoleMutex::mutex()), + formatter_(details::make_unique()) + { - namespace sinks + set_color_mode(mode); + colors_.at(level::trace) = to_string_(white); + colors_.at(level::debug) = to_string_(cyan); + colors_.at(level::info) = to_string_(green); + colors_.at(level::warn) = to_string_(yellow_bold); + colors_.at(level::err) = to_string_(red_bold); + colors_.at(level::critical) = to_string_(bold_on_red); + colors_.at(level::off) = to_string_(reset); +} + +template +SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, + string_view_t color) { + std::lock_guard lock(mutex_); + colors_.at(static_cast(color_level)) = to_string_(color); +} + +template +SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) { + // Wrap the originally formatted message in color codes. + // If color is not supported in the terminal, log as is instead. + std::lock_guard lock(mutex_); + msg.color_range_start = 0; + msg.color_range_end = 0; + memory_buf_t formatted; + formatter_->format(msg, formatted); + if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { + // before color range + print_range_(formatted, 0, msg.color_range_start); + // in color range + print_ccode_(colors_.at(static_cast(msg.level))); + print_range_(formatted, msg.color_range_start, msg.color_range_end); + print_ccode_(reset); + // after color range + print_range_(formatted, msg.color_range_end, formatted.size()); + } else // no color { - - template - SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE* target_file, color_mode mode) : target_file_(target_file), mutex_(ConsoleMutex::mutex()), formatter_(details::make_unique()) - - { - set_color_mode(mode); - colors_.at(level::trace) = to_string_(white); - colors_.at(level::debug) = to_string_(cyan); - colors_.at(level::info) = to_string_(green); - colors_.at(level::warn) = to_string_(yellow_bold); - colors_.at(level::err) = to_string_(red_bold); - colors_.at(level::critical) = to_string_(bold_on_red); - colors_.at(level::off) = to_string_(reset); - } - - template - SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) - { - std::lock_guard lock(mutex_); - colors_.at(static_cast(color_level)) = to_string_(color); - } - - template - SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg& msg) - { - // Wrap the originally formatted message in color codes. - // If color is not supported in the terminal, log as is instead. - std::lock_guard lock(mutex_); - msg.color_range_start = 0; - msg.color_range_end = 0; - memory_buf_t formatted; - formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) - { - // before color range - print_range_(formatted, 0, msg.color_range_start); - // in color range - print_ccode_(colors_.at(static_cast(msg.level))); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - print_ccode_(reset); - // after color range - print_range_(formatted, msg.color_range_end, formatted.size()); - } - else // no color - { - print_range_(formatted, 0, formatted.size()); - } - fflush(target_file_); - } - - template - SPDLOG_INLINE void ansicolor_sink::flush() - { - std::lock_guard lock(mutex_); - fflush(target_file_); - } - - template - SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string& pattern) - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - template - SPDLOG_INLINE void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - - template - SPDLOG_INLINE bool ansicolor_sink::should_color() - { - return should_do_colors_; - } - - template - SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) - { - switch (mode) - { - case color_mode::always: - should_do_colors_ = true; - return; - case color_mode::automatic: - should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal(); - return; - case color_mode::never: - should_do_colors_ = false; - return; - default: - should_do_colors_ = false; - } - } - - template - SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t& color_code) - { - fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); - } - - template - SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t& formatted, size_t start, size_t end) - { - fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); - } - - template - SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t& sv) - { - return std::string(sv.data(), sv.size()); - } - - // ansicolor_stdout_sink - template - SPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) : ansicolor_sink(stdout, mode) - { - } - - // ansicolor_stderr_sink - template - SPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) : ansicolor_sink(stderr, mode) - { - } - - } // namespace sinks -} // namespace spdlog + print_range_(formatted, 0, formatted.size()); + } + fflush(target_file_); +} + +template +SPDLOG_INLINE void ansicolor_sink::flush() { + std::lock_guard lock(mutex_); + fflush(target_file_); +} + +template +SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); +} + +template +SPDLOG_INLINE void ansicolor_sink::set_formatter( + std::unique_ptr sink_formatter) { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); +} + +template +SPDLOG_INLINE bool ansicolor_sink::should_color() { + return should_do_colors_; +} + +template +SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) { + switch (mode) { + case color_mode::always: + should_do_colors_ = true; + return; + case color_mode::automatic: + should_do_colors_ = + details::os::in_terminal(target_file_) && details::os::is_color_terminal(); + return; + case color_mode::never: + should_do_colors_ = false; + return; + default: + should_do_colors_ = false; + } +} + +template +SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t &color_code) { + fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); +} + +template +SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted, + size_t start, + size_t end) { + fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); +} + +template +SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) { + return std::string(sv.data(), sv.size()); +} + +// ansicolor_stdout_sink +template +SPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) + : ansicolor_sink(stdout, mode) {} + +// ansicolor_stderr_sink +template +SPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) + : ansicolor_sink(stderr, mode) {} + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/ansicolor_sink.h b/lib/spdlog/sinks/ansicolor_sink.h index 78292164..d0dadd75 100644 --- a/lib/spdlog/sinks/ansicolor_sink.h +++ b/lib/spdlog/sinks/ansicolor_sink.h @@ -11,107 +11,105 @@ #include #include -namespace spdlog -{ - namespace sinks - { - - /** - * This sink prefixes the output with an ANSI escape sequence color code - * depending on the severity - * of the message. - * If no color terminal detected, omit the escape codes. - */ - - template - class ansicolor_sink : public sink { - public: - using mutex_t = typename ConsoleMutex::mutex_t; - ansicolor_sink(FILE* target_file, color_mode mode); - ~ansicolor_sink() override = default; - - ansicolor_sink(const ansicolor_sink& other) = delete; - ansicolor_sink(ansicolor_sink&& other) = delete; - - ansicolor_sink& operator=(const ansicolor_sink& other) = delete; - ansicolor_sink& operator=(ansicolor_sink&& other) = delete; - - void set_color(level::level_enum color_level, string_view_t color); - void set_color_mode(color_mode mode); - bool should_color(); - - void log(const details::log_msg& msg) override; - void flush() override; - void set_pattern(const std::string& pattern) final override; - void set_formatter(std::unique_ptr sink_formatter) override; - - // Formatting codes - const string_view_t reset = "\033[m"; - const string_view_t bold = "\033[1m"; - const string_view_t dark = "\033[2m"; - const string_view_t underline = "\033[4m"; - const string_view_t blink = "\033[5m"; - const string_view_t reverse = "\033[7m"; - const string_view_t concealed = "\033[8m"; - const string_view_t clear_line = "\033[K"; - - // Foreground colors - const string_view_t black = "\033[30m"; - const string_view_t red = "\033[31m"; - const string_view_t green = "\033[32m"; - const string_view_t yellow = "\033[33m"; - const string_view_t blue = "\033[34m"; - const string_view_t magenta = "\033[35m"; - const string_view_t cyan = "\033[36m"; - const string_view_t white = "\033[37m"; - - /// Background colors - const string_view_t on_black = "\033[40m"; - const string_view_t on_red = "\033[41m"; - const string_view_t on_green = "\033[42m"; - const string_view_t on_yellow = "\033[43m"; - const string_view_t on_blue = "\033[44m"; - const string_view_t on_magenta = "\033[45m"; - const string_view_t on_cyan = "\033[46m"; - const string_view_t on_white = "\033[47m"; - - /// Bold colors - const string_view_t yellow_bold = "\033[33m\033[1m"; - const string_view_t red_bold = "\033[31m\033[1m"; - const string_view_t bold_on_red = "\033[1m\033[41m"; - - private: - FILE* target_file_; - mutex_t& mutex_; - bool should_do_colors_; - std::unique_ptr formatter_; - std::array colors_; - void print_ccode_(const string_view_t& color_code); - void print_range_(const memory_buf_t& formatted, size_t start, size_t end); - static std::string to_string_(const string_view_t& sv); - }; - - template - class ansicolor_stdout_sink : public ansicolor_sink { - public: - explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); - }; - - template - class ansicolor_stderr_sink : public ansicolor_sink { - public: - explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); - }; - - using ansicolor_stdout_sink_mt = ansicolor_stdout_sink; - using ansicolor_stdout_sink_st = ansicolor_stdout_sink; - - using ansicolor_stderr_sink_mt = ansicolor_stderr_sink; - using ansicolor_stderr_sink_st = ansicolor_stderr_sink; - - } // namespace sinks -} // namespace spdlog +namespace spdlog { +namespace sinks { + +/** + * This sink prefixes the output with an ANSI escape sequence color code + * depending on the severity + * of the message. + * If no color terminal detected, omit the escape codes. + */ + +template +class ansicolor_sink : public sink { +public: + using mutex_t = typename ConsoleMutex::mutex_t; + ansicolor_sink(FILE *target_file, color_mode mode); + ~ansicolor_sink() override = default; + + ansicolor_sink(const ansicolor_sink &other) = delete; + ansicolor_sink(ansicolor_sink &&other) = delete; + + ansicolor_sink &operator=(const ansicolor_sink &other) = delete; + ansicolor_sink &operator=(ansicolor_sink &&other) = delete; + + void set_color(level::level_enum color_level, string_view_t color); + void set_color_mode(color_mode mode); + bool should_color(); + + void log(const details::log_msg &msg) override; + void flush() override; + void set_pattern(const std::string &pattern) final override; + void set_formatter(std::unique_ptr sink_formatter) override; + + // Formatting codes + const string_view_t reset = "\033[m"; + const string_view_t bold = "\033[1m"; + const string_view_t dark = "\033[2m"; + const string_view_t underline = "\033[4m"; + const string_view_t blink = "\033[5m"; + const string_view_t reverse = "\033[7m"; + const string_view_t concealed = "\033[8m"; + const string_view_t clear_line = "\033[K"; + + // Foreground colors + const string_view_t black = "\033[30m"; + const string_view_t red = "\033[31m"; + const string_view_t green = "\033[32m"; + const string_view_t yellow = "\033[33m"; + const string_view_t blue = "\033[34m"; + const string_view_t magenta = "\033[35m"; + const string_view_t cyan = "\033[36m"; + const string_view_t white = "\033[37m"; + + /// Background colors + const string_view_t on_black = "\033[40m"; + const string_view_t on_red = "\033[41m"; + const string_view_t on_green = "\033[42m"; + const string_view_t on_yellow = "\033[43m"; + const string_view_t on_blue = "\033[44m"; + const string_view_t on_magenta = "\033[45m"; + const string_view_t on_cyan = "\033[46m"; + const string_view_t on_white = "\033[47m"; + + /// Bold colors + const string_view_t yellow_bold = "\033[33m\033[1m"; + const string_view_t red_bold = "\033[31m\033[1m"; + const string_view_t bold_on_red = "\033[1m\033[41m"; + +private: + FILE *target_file_; + mutex_t &mutex_; + bool should_do_colors_; + std::unique_ptr formatter_; + std::array colors_; + void print_ccode_(const string_view_t &color_code); + void print_range_(const memory_buf_t &formatted, size_t start, size_t end); + static std::string to_string_(const string_view_t &sv); +}; + +template +class ansicolor_stdout_sink : public ansicolor_sink { +public: + explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); +}; + +template +class ansicolor_stderr_sink : public ansicolor_sink { +public: + explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); +}; + +using ansicolor_stdout_sink_mt = ansicolor_stdout_sink; +using ansicolor_stdout_sink_st = ansicolor_stdout_sink; + +using ansicolor_stderr_sink_mt = ansicolor_stderr_sink; +using ansicolor_stderr_sink_st = ansicolor_stderr_sink; + +} // namespace sinks +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "ansicolor_sink-inl.h" + #include "ansicolor_sink-inl.h" #endif diff --git a/lib/spdlog/sinks/base_sink-inl.h b/lib/spdlog/sinks/base_sink-inl.h index c4028f95..ada161bc 100644 --- a/lib/spdlog/sinks/base_sink-inl.h +++ b/lib/spdlog/sinks/base_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -14,51 +14,46 @@ #include template -SPDLOG_INLINE spdlog::sinks::base_sink::base_sink() : formatter_{details::make_unique()} -{ -} +SPDLOG_INLINE spdlog::sinks::base_sink::base_sink() + : formatter_{details::make_unique()} {} template -SPDLOG_INLINE spdlog::sinks::base_sink::base_sink(std::unique_ptr formatter) : formatter_{std::move(formatter)} -{ -} +SPDLOG_INLINE spdlog::sinks::base_sink::base_sink( + std::unique_ptr formatter) + : formatter_{std::move(formatter)} {} template -void SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg& msg) -{ +void SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); sink_it_(msg); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::flush() -{ +void SPDLOG_INLINE spdlog::sinks::base_sink::flush() { std::lock_guard lock(mutex_); flush_(); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern(const std::string& pattern) -{ +void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); set_pattern_(pattern); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) -{ +void SPDLOG_INLINE +spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); set_formatter_(std::move(sink_formatter)); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern_(const std::string& pattern) -{ +void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) { set_formatter_(details::make_unique(pattern)); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) -{ +void SPDLOG_INLINE +spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) { formatter_ = std::move(sink_formatter); } diff --git a/lib/spdlog/sinks/base_sink.h b/lib/spdlog/sinks/base_sink.h index c43eea79..1b4bb068 100644 --- a/lib/spdlog/sinks/base_sink.h +++ b/lib/spdlog/sinks/base_sink.h @@ -13,41 +13,39 @@ #include #include -namespace spdlog -{ - namespace sinks - { - template - class SPDLOG_API base_sink : public sink { - public: - base_sink(); - explicit base_sink(std::unique_ptr formatter); - ~base_sink() override = default; - - base_sink(const base_sink&) = delete; - base_sink(base_sink&&) = delete; - - base_sink& operator=(const base_sink&) = delete; - base_sink& operator=(base_sink&&) = delete; - - void log(const details::log_msg& msg) final override; - void flush() final override; - void set_pattern(const std::string& pattern) final override; - void set_formatter(std::unique_ptr sink_formatter) final override; - - protected: - // sink formatter - std::unique_ptr formatter_; - Mutex mutex_; - - virtual void sink_it_(const details::log_msg& msg) = 0; - virtual void flush_() = 0; - virtual void set_pattern_(const std::string& pattern); - virtual void set_formatter_(std::unique_ptr sink_formatter); - }; - } // namespace sinks -} // namespace spdlog +namespace spdlog { +namespace sinks { +template +class SPDLOG_API base_sink : public sink { +public: + base_sink(); + explicit base_sink(std::unique_ptr formatter); + ~base_sink() override = default; + + base_sink(const base_sink &) = delete; + base_sink(base_sink &&) = delete; + + base_sink &operator=(const base_sink &) = delete; + base_sink &operator=(base_sink &&) = delete; + + void log(const details::log_msg &msg) final override; + void flush() final override; + void set_pattern(const std::string &pattern) final override; + void set_formatter(std::unique_ptr sink_formatter) final override; + +protected: + // sink formatter + std::unique_ptr formatter_; + Mutex mutex_; + + virtual void sink_it_(const details::log_msg &msg) = 0; + virtual void flush_() = 0; + virtual void set_pattern_(const std::string &pattern); + virtual void set_formatter_(std::unique_ptr sink_formatter); +}; +} // namespace sinks +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "base_sink-inl.h" + #include "base_sink-inl.h" #endif diff --git a/lib/spdlog/sinks/basic_file_sink-inl.h b/lib/spdlog/sinks/basic_file_sink-inl.h index c6b48d28..f7c1abf7 100644 --- a/lib/spdlog/sinks/basic_file_sink-inl.h +++ b/lib/spdlog/sinks/basic_file_sink-inl.h @@ -4,42 +4,39 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog -{ - namespace sinks - { - - template - SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t& filename, bool truncate, const file_event_handlers& event_handlers) : file_helper_{event_handlers} - { - file_helper_.open(filename, truncate); - } - - template - SPDLOG_INLINE const filename_t& basic_file_sink::filename() const - { - return file_helper_.filename(); - } - - template - SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg& msg) - { - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - file_helper_.write(formatted); - } - - template - SPDLOG_INLINE void basic_file_sink::flush_() - { - file_helper_.flush(); - } - - } // namespace sinks -} // namespace spdlog +namespace spdlog { +namespace sinks { + +template +SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename, + bool truncate, + const file_event_handlers &event_handlers) + : file_helper_{event_handlers} { + file_helper_.open(filename, truncate); +} + +template +SPDLOG_INLINE const filename_t &basic_file_sink::filename() const { + return file_helper_.filename(); +} + +template +SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) { + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + file_helper_.write(formatted); +} + +template +SPDLOG_INLINE void basic_file_sink::flush_() { + file_helper_.flush(); +} + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/basic_file_sink.h b/lib/spdlog/sinks/basic_file_sink.h index 91e78055..699caa14 100644 --- a/lib/spdlog/sinks/basic_file_sink.h +++ b/lib/spdlog/sinks/basic_file_sink.h @@ -11,49 +11,55 @@ #include #include -namespace spdlog -{ - namespace sinks - { - /* - * Trivial file sink with single file as target - */ - template - class basic_file_sink final : public base_sink { - public: - explicit basic_file_sink(const filename_t& filename, bool truncate = false, const file_event_handlers& event_handlers = {}); - const filename_t& filename() const; - - protected: - void sink_it_(const details::log_msg& msg) override; - void flush_() override; - - private: - details::file_helper file_helper_; - }; - - using basic_file_sink_mt = basic_file_sink; - using basic_file_sink_st = basic_file_sink; - - } // namespace sinks - - // - // factory functions - // - template - inline std::shared_ptr basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, truncate, event_handlers); - } - - template - inline std::shared_ptr basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, truncate, event_handlers); - } - -} // namespace spdlog +namespace spdlog { +namespace sinks { +/* + * Trivial file sink with single file as target + */ +template +class basic_file_sink final : public base_sink { +public: + explicit basic_file_sink(const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}); + const filename_t &filename() const; + +protected: + void sink_it_(const details::log_msg &msg) override; + void flush_() override; + +private: + details::file_helper file_helper_; +}; + +using basic_file_sink_mt = basic_file_sink; +using basic_file_sink_st = basic_file_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr basic_logger_mt(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, + event_handlers); +} + +template +inline std::shared_ptr basic_logger_st(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, + event_handlers); +} + +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "basic_file_sink-inl.h" + #include "basic_file_sink-inl.h" #endif diff --git a/lib/spdlog/sinks/callback_sink.h b/lib/spdlog/sinks/callback_sink.h index dc3a5544..5f8b6bc4 100644 --- a/lib/spdlog/sinks/callback_sink.h +++ b/lib/spdlog/sinks/callback_sink.h @@ -10,48 +10,47 @@ #include #include -namespace spdlog -{ - - // callbacks type - typedef std::function custom_log_callback; - - namespace sinks - { - /* - * Trivial callback sink, gets a callback function and calls it on each log - */ - template - class callback_sink final : public base_sink { - public: - explicit callback_sink(const custom_log_callback& callback) : callback_{callback} {} - - protected: - void sink_it_(const details::log_msg& msg) override { callback_(msg); } - void flush_() override {} - - private: - custom_log_callback callback_; - }; - - using callback_sink_mt = callback_sink; - using callback_sink_st = callback_sink; - - } // namespace sinks - - // - // factory functions - // - template - inline std::shared_ptr callback_logger_mt(const std::string& logger_name, const custom_log_callback& callback) - { - return Factory::template create(logger_name, callback); - } - - template - inline std::shared_ptr callback_logger_st(const std::string& logger_name, const custom_log_callback& callback) - { - return Factory::template create(logger_name, callback); - } - -} // namespace spdlog +namespace spdlog { + +// callbacks type +typedef std::function custom_log_callback; + +namespace sinks { +/* + * Trivial callback sink, gets a callback function and calls it on each log + */ +template +class callback_sink final : public base_sink { +public: + explicit callback_sink(const custom_log_callback &callback) + : callback_{callback} {} + +protected: + void sink_it_(const details::log_msg &msg) override { callback_(msg); } + void flush_() override{} + +private: + custom_log_callback callback_; +}; + +using callback_sink_mt = callback_sink; +using callback_sink_st = callback_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr callback_logger_mt(const std::string &logger_name, + const custom_log_callback &callback) { + return Factory::template create(logger_name, callback); +} + +template +inline std::shared_ptr callback_logger_st(const std::string &logger_name, + const custom_log_callback &callback) { + return Factory::template create(logger_name, callback); +} + +} // namespace spdlog diff --git a/lib/spdlog/sinks/daily_file_sink.h b/lib/spdlog/sinks/daily_file_sink.h index f83e25b5..884145fd 100644 --- a/lib/spdlog/sinks/daily_file_sink.h +++ b/lib/spdlog/sinks/daily_file_sink.h @@ -20,214 +20,236 @@ #include #include -namespace spdlog -{ - namespace sinks - { - - /* - * Generator of daily log file names in format basename.YYYY-MM-DD.ext - */ - struct daily_filename_calculator { - // Create filename for the form basename.YYYY-MM-DD - static filename_t calc_filename(const filename_t& filename, const tm& now_tm) - { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); - } - }; - - /* - * Generator of daily log file names with strftime format. - * Usages: - * auto sink = - * std::make_shared("myapp-%Y-%m-%d:%H:%M:%S.log", - * hour, minute);" auto logger = spdlog::daily_logger_format_mt("loggername, - * "myapp-%Y-%m-%d:%X.log", hour, minute)" - * - */ - struct daily_filename_format_calculator { - static filename_t calc_filename(const filename_t& file_path, const tm& now_tm) - { +namespace spdlog { +namespace sinks { + +/* + * Generator of daily log file names in format basename.YYYY-MM-DD.ext + */ +struct daily_filename_calculator { + // Create filename for the form basename.YYYY-MM-DD + static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { + filename_t basename, ext; + std::tie(basename, ext) = details::file_helper::split_by_extension(filename); + return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), + basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, + ext); + } +}; + +/* + * Generator of daily log file names with strftime format. + * Usages: + * auto sink = + * std::make_shared("myapp-%Y-%m-%d:%H:%M:%S.log", hour, + * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", + * hour, minute)" + * + */ +struct daily_filename_format_calculator { + static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - std::wstringstream stream; + std::wstringstream stream; #else - std::stringstream stream; + std::stringstream stream; #endif - stream << std::put_time(&now_tm, file_path.c_str()); - return stream.str(); - } - }; - - /* - * Rotating file sink based on date. - * If truncate != false , the created file will be truncated. - * If max_files > 0, retain only the last max_files and delete previous. - * If max_files > 0, retain only the last max_files and delete previous. - * Note that old log files from previous executions will not be deleted by this - * class, rotation and deletion is only applied while the program is running. - */ - template - class daily_file_sink final : public base_sink { - public: - // create daily file sink which rotates on given time - daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) : base_filename_(std::move(base_filename)), rotation_h_(rotation_hour), rotation_m_(rotation_minute), file_helper_{event_handlers}, truncate_(truncate), max_files_(max_files), filenames_q_() - { - if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) - { - throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); - } - - auto now = log_clock::now(); - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - - if (max_files_ > 0) - { - init_filenames_q_(); - } - } - - filename_t filename() - { - std::lock_guard lock(base_sink::mutex_); - return file_helper_.filename(); - } + stream << std::put_time(&now_tm, file_path.c_str()); + return stream.str(); + } +}; + +/* + * Rotating file sink based on date. + * If truncate != false , the created file will be truncated. + * If max_files > 0, retain only the last max_files and delete previous. + * If max_files > 0, retain only the last max_files and delete previous. + * Note that old log files from previous executions will not be deleted by this class, + * rotation and deletion is only applied while the program is running. + */ +template +class daily_file_sink final : public base_sink { +public: + // create daily file sink which rotates on given time + daily_file_sink(filename_t base_filename, + int rotation_hour, + int rotation_minute, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) + : base_filename_(std::move(base_filename)), + rotation_h_(rotation_hour), + rotation_m_(rotation_minute), + file_helper_{event_handlers}, + truncate_(truncate), + max_files_(max_files), + filenames_q_() { + if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || + rotation_minute > 59) { + throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); + } + + auto now = log_clock::now(); + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); + file_helper_.open(filename, truncate_); + rotation_tp_ = next_rotation_tp_(); + + if (max_files_ > 0) { + init_filenames_q_(); + } + } - protected: - void sink_it_(const details::log_msg& msg) override - { - auto time = msg.time; - bool should_rotate = time >= rotation_tp_; - if (should_rotate) - { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - } - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - file_helper_.write(formatted); - - // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) - { - delete_old_(); - } - } + filename_t filename() { + std::lock_guard lock(base_sink::mutex_); + return file_helper_.filename(); + } - void flush_() override { file_helper_.flush(); } - - private: - void init_filenames_q_() - { - using details::os::path_exists; - - filenames_q_ = details::circular_q(static_cast(max_files_)); - std::vector filenames; - auto now = log_clock::now(); - while (filenames.size() < max_files_) - { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) - { - break; - } - filenames.emplace_back(filename); - now -= std::chrono::hours(24); - } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) - { - filenames_q_.push_back(std::move(*iter)); - } - } +protected: + void sink_it_(const details::log_msg &msg) override { + auto time = msg.time; + bool should_rotate = time >= rotation_tp_; + if (should_rotate) { + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); + file_helper_.open(filename, truncate_); + rotation_tp_ = next_rotation_tp_(); + } + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + file_helper_.write(formatted); + + // Do the cleaning only at the end because it might throw on failure. + if (should_rotate && max_files_ > 0) { + delete_old_(); + } + } - tm now_tm(log_clock::time_point tp) - { - time_t tnow = log_clock::to_time_t(tp); - return spdlog::details::os::localtime(tnow); - } + void flush_() override { file_helper_.flush(); } - log_clock::time_point next_rotation_tp_() - { - auto now = log_clock::now(); - tm date = now_tm(now); - date.tm_hour = rotation_h_; - date.tm_min = rotation_m_; - date.tm_sec = 0; - auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) - { - return rotation_time; - } - return {rotation_time + std::chrono::hours(24)}; - } +private: + void init_filenames_q_() { + using details::os::path_exists; - // Delete the file N rotations ago. - // Throw spdlog_ex on failure to delete the old file. - void delete_old_() - { - using details::os::filename_to_str; - using details::os::remove_if_exists; - - filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) - { - auto old_filename = std::move(filenames_q_.front()); - filenames_q_.pop_front(); - bool ok = remove_if_exists(old_filename) == 0; - if (!ok) - { - filenames_q_.push_back(std::move(current_file)); - throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno); - } - } - filenames_q_.push_back(std::move(current_file)); + filenames_q_ = details::circular_q(static_cast(max_files_)); + std::vector filenames; + auto now = log_clock::now(); + while (filenames.size() < max_files_) { + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); + if (!path_exists(filename)) { + break; } - - filename_t base_filename_; - int rotation_h_; - int rotation_m_; - log_clock::time_point rotation_tp_; - details::file_helper file_helper_; - bool truncate_; - uint16_t max_files_; - details::circular_q filenames_q_; - }; - - using daily_file_sink_mt = daily_file_sink; - using daily_file_sink_st = daily_file_sink; - using daily_file_format_sink_mt = daily_file_sink; - using daily_file_format_sink_st = daily_file_sink; - - } // namespace sinks - - // - // factory functions - // - template - inline std::shared_ptr daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); + filenames.emplace_back(filename); + now -= std::chrono::hours(24); + } + for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { + filenames_q_.push_back(std::move(*iter)); + } } - template - inline std::shared_ptr daily_logger_format_mt(const std::string& logger_name, const filename_t& filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); + tm now_tm(log_clock::time_point tp) { + time_t tnow = log_clock::to_time_t(tp); + return spdlog::details::os::localtime(tnow); } - template - inline std::shared_ptr daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); + log_clock::time_point next_rotation_tp_() { + auto now = log_clock::now(); + tm date = now_tm(now); + date.tm_hour = rotation_h_; + date.tm_min = rotation_m_; + date.tm_sec = 0; + auto rotation_time = log_clock::from_time_t(std::mktime(&date)); + if (rotation_time > now) { + return rotation_time; + } + return {rotation_time + std::chrono::hours(24)}; } - template - inline std::shared_ptr daily_logger_format_st(const std::string& logger_name, const filename_t& filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, hour, minute, truncate, max_files, event_handlers); + // Delete the file N rotations ago. + // Throw spdlog_ex on failure to delete the old file. + void delete_old_() { + using details::os::filename_to_str; + using details::os::remove_if_exists; + + filename_t current_file = file_helper_.filename(); + if (filenames_q_.full()) { + auto old_filename = std::move(filenames_q_.front()); + filenames_q_.pop_front(); + bool ok = remove_if_exists(old_filename) == 0; + if (!ok) { + filenames_q_.push_back(std::move(current_file)); + throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), + errno); + } + } + filenames_q_.push_back(std::move(current_file)); } -} // namespace spdlog + + filename_t base_filename_; + int rotation_h_; + int rotation_m_; + log_clock::time_point rotation_tp_; + details::file_helper file_helper_; + bool truncate_; + uint16_t max_files_; + details::circular_q filenames_q_; +}; + +using daily_file_sink_mt = daily_file_sink; +using daily_file_sink_st = daily_file_sink; +using daily_file_format_sink_mt = daily_file_sink; +using daily_file_format_sink_st = + daily_file_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr daily_logger_mt(const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, hour, minute, + truncate, max_files, event_handlers); +} + +template +inline std::shared_ptr daily_logger_format_mt( + const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create( + logger_name, filename, hour, minute, truncate, max_files, event_handlers); +} + +template +inline std::shared_ptr daily_logger_st(const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, hour, minute, + truncate, max_files, event_handlers); +} + +template +inline std::shared_ptr daily_logger_format_st( + const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create( + logger_name, filename, hour, minute, truncate, max_files, event_handlers); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/dist_sink.h b/lib/spdlog/sinks/dist_sink.h index 25db751d..69c4971c 100644 --- a/lib/spdlog/sinks/dist_sink.h +++ b/lib/spdlog/sinks/dist_sink.h @@ -3,10 +3,10 @@ #pragma once +#include "base_sink.h" #include #include #include -#include "base_sink.h" #include #include @@ -16,75 +16,66 @@ // Distribution sink (mux). Stores a vector of sinks which get called when log // is called -namespace spdlog -{ - namespace sinks - { - - template - class dist_sink : public base_sink { - public: - dist_sink() = default; - explicit dist_sink(std::vector> sinks) : sinks_(sinks) {} - - dist_sink(const dist_sink&) = delete; - dist_sink& operator=(const dist_sink&) = delete; - - void add_sink(std::shared_ptr sub_sink) - { - std::lock_guard lock(base_sink::mutex_); - sinks_.push_back(sub_sink); - } - - void remove_sink(std::shared_ptr sub_sink) - { - std::lock_guard lock(base_sink::mutex_); - sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); - } - - void set_sinks(std::vector> sinks) - { - std::lock_guard lock(base_sink::mutex_); - sinks_ = std::move(sinks); +namespace spdlog { +namespace sinks { + +template +class dist_sink : public base_sink { +public: + dist_sink() = default; + explicit dist_sink(std::vector> sinks) + : sinks_(sinks) {} + + dist_sink(const dist_sink &) = delete; + dist_sink &operator=(const dist_sink &) = delete; + + void add_sink(std::shared_ptr sub_sink) { + std::lock_guard lock(base_sink::mutex_); + sinks_.push_back(sub_sink); + } + + void remove_sink(std::shared_ptr sub_sink) { + std::lock_guard lock(base_sink::mutex_); + sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); + } + + void set_sinks(std::vector> sinks) { + std::lock_guard lock(base_sink::mutex_); + sinks_ = std::move(sinks); + } + + std::vector> &sinks() { return sinks_; } + +protected: + void sink_it_(const details::log_msg &msg) override { + for (auto &sub_sink : sinks_) { + if (sub_sink->should_log(msg.level)) { + sub_sink->log(msg); } - - std::vector>& sinks() { return sinks_; } - - protected: - void sink_it_(const details::log_msg& msg) override - { - for (auto& sub_sink : sinks_) - { - if (sub_sink->should_log(msg.level)) - { - sub_sink->log(msg); - } - } - } - - void flush_() override - { - for (auto& sub_sink : sinks_) - { - sub_sink->flush(); - } - } - - void set_pattern_(const std::string& pattern) override { set_formatter_(details::make_unique(pattern)); } - - void set_formatter_(std::unique_ptr sink_formatter) override - { - base_sink::formatter_ = std::move(sink_formatter); - for (auto& sub_sink : sinks_) - { - sub_sink->set_formatter(base_sink::formatter_->clone()); - } - } - std::vector> sinks_; - }; - - using dist_sink_mt = dist_sink; - using dist_sink_st = dist_sink; - - } // namespace sinks -} // namespace spdlog + } + } + + void flush_() override { + for (auto &sub_sink : sinks_) { + sub_sink->flush(); + } + } + + void set_pattern_(const std::string &pattern) override { + set_formatter_(details::make_unique(pattern)); + } + + void set_formatter_(std::unique_ptr sink_formatter) override { + base_sink::formatter_ = std::move(sink_formatter); + for (auto &sub_sink : sinks_) { + sub_sink->set_formatter(base_sink::formatter_->clone()); + } + } + std::vector> sinks_; +}; + +using dist_sink_mt = dist_sink; +using dist_sink_st = dist_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/dup_filter_sink.h b/lib/spdlog/sinks/dup_filter_sink.h index a317c088..1498142c 100644 --- a/lib/spdlog/sinks/dup_filter_sink.h +++ b/lib/spdlog/sinks/dup_filter_sink.h @@ -3,9 +3,9 @@ #pragma once +#include "dist_sink.h" #include #include -#include "dist_sink.h" #include #include @@ -13,18 +13,15 @@ #include // Duplicate message removal sink. -// Skip the message if previous one is identical and less than -// "max_skip_duration" have passed +// Skip the message if previous one is identical and less than "max_skip_duration" have passed // // Example: // // #include // // int main() { -// auto dup_filter = -// std::make_shared(std::chrono::seconds(5), -// level::info); -// dup_filter->add_sink(std::make_shared()); +// auto dup_filter = std::make_shared(std::chrono::seconds(5), +// level::info); dup_filter->add_sink(std::make_shared()); // spdlog::logger l("logger", dup_filter); // l.info("Hello"); // l.info("Hello"); @@ -34,66 +31,62 @@ // // Will produce: // [2019-06-25 17:50:56.511] [logger] [info] Hello -// [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate -// messages.. [2019-06-25 17:50:56.512] [logger] [info] Different Hello - -namespace spdlog -{ - namespace sinks - { - template - class dup_filter_sink : public dist_sink { - public: - template - explicit dup_filter_sink(std::chrono::duration max_skip_duration, level::level_enum notification_level = level::info) : max_skip_duration_{max_skip_duration}, log_level_{notification_level} - { - } +// [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages.. +// [2019-06-25 17:50:56.512] [logger] [info] Different Hello - protected: - std::chrono::microseconds max_skip_duration_; - log_clock::time_point last_msg_time_; - std::string last_msg_payload_; - size_t skip_counter_ = 0; - level::level_enum log_level_; +namespace spdlog { +namespace sinks { +template +class dup_filter_sink : public dist_sink { +public: + template + explicit dup_filter_sink(std::chrono::duration max_skip_duration, + level::level_enum notification_level = level::info) + : max_skip_duration_{max_skip_duration}, + log_level_{notification_level} {} - void sink_it_(const details::log_msg& msg) override - { - bool filtered = filter_(msg); - if (!filtered) - { - skip_counter_ += 1; - return; - } +protected: + std::chrono::microseconds max_skip_duration_; + log_clock::time_point last_msg_time_; + std::string last_msg_payload_; + size_t skip_counter_ = 0; + level::level_enum log_level_; - // log the "skipped.." message - if (skip_counter_ > 0) - { - char buf[64]; - auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast(skip_counter_)); - if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) - { - details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, string_view_t{buf, static_cast(msg_size)}}; - dist_sink::sink_it_(skipped_msg); - } - } + void sink_it_(const details::log_msg &msg) override { + bool filtered = filter_(msg); + if (!filtered) { + skip_counter_ += 1; + return; + } - // log current message - dist_sink::sink_it_(msg); - last_msg_time_ = msg.time; - skip_counter_ = 0; - last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size()); + // log the "skipped.." message + if (skip_counter_ > 0) { + char buf[64]; + auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", + static_cast(skip_counter_)); + if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) { + details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, + string_view_t{buf, static_cast(msg_size)}}; + dist_sink::sink_it_(skipped_msg); } + } - // return whether the log msg should be displayed (true) or skipped (false) - bool filter_(const details::log_msg& msg) - { - auto filter_duration = msg.time - last_msg_time_; - return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_); - } - }; + // log current message + dist_sink::sink_it_(msg); + last_msg_time_ = msg.time; + skip_counter_ = 0; + last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size()); + } + + // return whether the log msg should be displayed (true) or skipped (false) + bool filter_(const details::log_msg &msg) { + auto filter_duration = msg.time - last_msg_time_; + return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_); + } +}; - using dup_filter_sink_mt = dup_filter_sink; - using dup_filter_sink_st = dup_filter_sink; +using dup_filter_sink_mt = dup_filter_sink; +using dup_filter_sink_st = dup_filter_sink; - } // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/hourly_file_sink.h b/lib/spdlog/sinks/hourly_file_sink.h index 3e20b7af..3e618725 100644 --- a/lib/spdlog/sinks/hourly_file_sink.h +++ b/lib/spdlog/sinks/hourly_file_sink.h @@ -18,177 +18,176 @@ #include #include -namespace spdlog -{ - namespace sinks - { - - /* - * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext - */ - struct hourly_filename_calculator { - // Create filename for the form basename.YYYY-MM-DD-H - static filename_t calc_filename(const filename_t& filename, const tm& now_tm) - { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, now_tm.tm_hour, ext); - } - }; - - /* - * Rotating file sink based on time. - * If truncate != false , the created file will be truncated. - * If max_files > 0, retain only the last max_files and delete previous. - * Note that old log files from previous executions will not be deleted by this - * class, rotation and deletion is only applied while the program is running. - */ - template - class hourly_file_sink final : public base_sink { - public: - // create hourly file sink which rotates on given time - hourly_file_sink(filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) : base_filename_(std::move(base_filename)), file_helper_{event_handlers}, truncate_(truncate), max_files_(max_files), filenames_q_() - { - auto now = log_clock::now(); - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - file_helper_.open(filename, truncate_); - remove_init_file_ = file_helper_.size() == 0; - rotation_tp_ = next_rotation_tp_(); - - if (max_files_ > 0) - { - init_filenames_q_(); - } - } +namespace spdlog { +namespace sinks { + +/* + * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext + */ +struct hourly_filename_calculator { + // Create filename for the form basename.YYYY-MM-DD-H + static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { + filename_t basename, ext; + std::tie(basename, ext) = details::file_helper::split_by_extension(filename); + return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, + now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, + now_tm.tm_hour, ext); + } +}; + +/* + * Rotating file sink based on time. + * If truncate != false , the created file will be truncated. + * If max_files > 0, retain only the last max_files and delete previous. + * Note that old log files from previous executions will not be deleted by this class, + * rotation and deletion is only applied while the program is running. + */ +template +class hourly_file_sink final : public base_sink { +public: + // create hourly file sink which rotates on given time + hourly_file_sink(filename_t base_filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) + : base_filename_(std::move(base_filename)), + file_helper_{event_handlers}, + truncate_(truncate), + max_files_(max_files), + filenames_q_() { + auto now = log_clock::now(); + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); + file_helper_.open(filename, truncate_); + remove_init_file_ = file_helper_.size() == 0; + rotation_tp_ = next_rotation_tp_(); + + if (max_files_ > 0) { + init_filenames_q_(); + } + } - filename_t filename() - { - std::lock_guard lock(base_sink::mutex_); - return file_helper_.filename(); - } + filename_t filename() { + std::lock_guard lock(base_sink::mutex_); + return file_helper_.filename(); + } - protected: - void sink_it_(const details::log_msg& msg) override - { - auto time = msg.time; - bool should_rotate = time >= rotation_tp_; - if (should_rotate) - { - if (remove_init_file_) - { - file_helper_.close(); - details::os::remove(file_helper_.filename()); - } - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - } - remove_init_file_ = false; - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - file_helper_.write(formatted); - - // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) - { - delete_old_(); - } +protected: + void sink_it_(const details::log_msg &msg) override { + auto time = msg.time; + bool should_rotate = time >= rotation_tp_; + if (should_rotate) { + if (remove_init_file_) { + file_helper_.close(); + details::os::remove(file_helper_.filename()); } + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); + file_helper_.open(filename, truncate_); + rotation_tp_ = next_rotation_tp_(); + } + remove_init_file_ = false; + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + file_helper_.write(formatted); + + // Do the cleaning only at the end because it might throw on failure. + if (should_rotate && max_files_ > 0) { + delete_old_(); + } + } - void flush_() override { file_helper_.flush(); } - - private: - void init_filenames_q_() - { - using details::os::path_exists; - - filenames_q_ = details::circular_q(static_cast(max_files_)); - std::vector filenames; - auto now = log_clock::now(); - while (filenames.size() < max_files_) - { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) - { - break; - } - filenames.emplace_back(filename); - now -= std::chrono::hours(1); - } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) - { - filenames_q_.push_back(std::move(*iter)); - } - } + void flush_() override { file_helper_.flush(); } - tm now_tm(log_clock::time_point tp) - { - time_t tnow = log_clock::to_time_t(tp); - return spdlog::details::os::localtime(tnow); - } +private: + void init_filenames_q_() { + using details::os::path_exists; - log_clock::time_point next_rotation_tp_() - { - auto now = log_clock::now(); - tm date = now_tm(now); - date.tm_min = 0; - date.tm_sec = 0; - auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) - { - return rotation_time; - } - return {rotation_time + std::chrono::hours(1)}; + filenames_q_ = details::circular_q(static_cast(max_files_)); + std::vector filenames; + auto now = log_clock::now(); + while (filenames.size() < max_files_) { + auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); + if (!path_exists(filename)) { + break; } + filenames.emplace_back(filename); + now -= std::chrono::hours(1); + } + for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { + filenames_q_.push_back(std::move(*iter)); + } + } - // Delete the file N rotations ago. - // Throw spdlog_ex on failure to delete the old file. - void delete_old_() - { - using details::os::filename_to_str; - using details::os::remove_if_exists; - - filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) - { - auto old_filename = std::move(filenames_q_.front()); - filenames_q_.pop_front(); - bool ok = remove_if_exists(old_filename) == 0; - if (!ok) - { - filenames_q_.push_back(std::move(current_file)); - SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno)); - } - } - filenames_q_.push_back(std::move(current_file)); - } + tm now_tm(log_clock::time_point tp) { + time_t tnow = log_clock::to_time_t(tp); + return spdlog::details::os::localtime(tnow); + } - filename_t base_filename_; - log_clock::time_point rotation_tp_; - details::file_helper file_helper_; - bool truncate_; - uint16_t max_files_; - details::circular_q filenames_q_; - bool remove_init_file_; - }; - - using hourly_file_sink_mt = hourly_file_sink; - using hourly_file_sink_st = hourly_file_sink; - - } // namespace sinks - - // - // factory functions - // - template - inline std::shared_ptr hourly_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); + log_clock::time_point next_rotation_tp_() { + auto now = log_clock::now(); + tm date = now_tm(now); + date.tm_min = 0; + date.tm_sec = 0; + auto rotation_time = log_clock::from_time_t(std::mktime(&date)); + if (rotation_time > now) { + return rotation_time; + } + return {rotation_time + std::chrono::hours(1)}; } - template - inline std::shared_ptr hourly_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); + // Delete the file N rotations ago. + // Throw spdlog_ex on failure to delete the old file. + void delete_old_() { + using details::os::filename_to_str; + using details::os::remove_if_exists; + + filename_t current_file = file_helper_.filename(); + if (filenames_q_.full()) { + auto old_filename = std::move(filenames_q_.front()); + filenames_q_.pop_front(); + bool ok = remove_if_exists(old_filename) == 0; + if (!ok) { + filenames_q_.push_back(std::move(current_file)); + SPDLOG_THROW(spdlog_ex( + "Failed removing hourly file " + filename_to_str(old_filename), errno)); + } + } + filenames_q_.push_back(std::move(current_file)); } -} // namespace spdlog + + filename_t base_filename_; + log_clock::time_point rotation_tp_; + details::file_helper file_helper_; + bool truncate_; + uint16_t max_files_; + details::circular_q filenames_q_; + bool remove_init_file_; +}; + +using hourly_file_sink_mt = hourly_file_sink; +using hourly_file_sink_st = hourly_file_sink; + +} // namespace sinks + +// +// factory functions +// +template +inline std::shared_ptr hourly_logger_mt(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, + max_files, event_handlers); +} + +template +inline std::shared_ptr hourly_logger_st(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, + max_files, event_handlers); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/kafka_sink.h b/lib/spdlog/sinks/kafka_sink.h index d811fac5..91e98786 100644 --- a/lib/spdlog/sinks/kafka_sink.h +++ b/lib/spdlog/sinks/kafka_sink.h @@ -10,110 +10,110 @@ // https://github.com/confluentinc/librdkafka // -#include -#include #include "spdlog/async.h" #include "spdlog/details/log_msg.h" #include "spdlog/details/null_mutex.h" #include "spdlog/details/synchronous_factory.h" #include "spdlog/sinks/base_sink.h" +#include +#include // kafka header #include -namespace spdlog -{ - namespace sinks - { - - struct kafka_sink_config { - std::string server_addr; - std::string produce_topic; - int32_t flush_timeout_ms = 1000; - - kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) : server_addr{std::move(addr)}, produce_topic{std::move(topic)}, flush_timeout_ms(flush_timeout_ms) {} - }; - - template - class kafka_sink : public base_sink { - public: - kafka_sink(kafka_sink_config config) : config_{std::move(config)} - { - try - { - std::string errstr; - conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL)); - RdKafka::Conf::ConfResult confRes = conf_->set("bootstrap.servers", config_.server_addr, errstr); - if (confRes != RdKafka::Conf::CONF_OK) - { - throw_spdlog_ex(fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr)); - } - - tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC)); - if (tconf_ == nullptr) - { - throw_spdlog_ex(fmt_lib::format("create topic config failed")); - } - - producer_.reset(RdKafka::Producer::create(conf_.get(), errstr)); - if (producer_ == nullptr) - { - throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr)); - } - topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, tconf_.get(), errstr)); - if (topic_ == nullptr) - { - throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr)); - } - } - catch (const std::exception& e) - { - throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what())); - } +namespace spdlog { +namespace sinks { + +struct kafka_sink_config { + std::string server_addr; + std::string produce_topic; + int32_t flush_timeout_ms = 1000; + + kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) + : server_addr{std::move(addr)}, + produce_topic{std::move(topic)}, + flush_timeout_ms(flush_timeout_ms) {} +}; + +template +class kafka_sink : public base_sink { +public: + kafka_sink(kafka_sink_config config) + : config_{std::move(config)} { + try { + std::string errstr; + conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL)); + RdKafka::Conf::ConfResult confRes = + conf_->set("bootstrap.servers", config_.server_addr, errstr); + if (confRes != RdKafka::Conf::CONF_OK) { + throw_spdlog_ex( + fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr)); } - ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); } - - protected: - void sink_it_(const details::log_msg& msg) override { producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void*)msg.payload.data(), msg.payload.size(), NULL, NULL); } - - void flush_() override { producer_->flush(config_.flush_timeout_ms); } - - private: - kafka_sink_config config_; - std::unique_ptr producer_ = nullptr; - std::unique_ptr conf_ = nullptr; - std::unique_ptr tconf_ = nullptr; - std::unique_ptr topic_ = nullptr; - }; - - using kafka_sink_mt = kafka_sink; - using kafka_sink_st = kafka_sink; - - } // namespace sinks - - template - inline std::shared_ptr kafka_logger_mt(const std::string& logger_name, spdlog::sinks::kafka_sink_config config) - { - return Factory::template create(logger_name, config); - } + tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC)); + if (tconf_ == nullptr) { + throw_spdlog_ex(fmt_lib::format("create topic config failed")); + } - template - inline std::shared_ptr kafka_logger_st(const std::string& logger_name, spdlog::sinks::kafka_sink_config config) - { - return Factory::template create(logger_name, config); + producer_.reset(RdKafka::Producer::create(conf_.get(), errstr)); + if (producer_ == nullptr) { + throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr)); + } + topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, + tconf_.get(), errstr)); + if (topic_ == nullptr) { + throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr)); + } + } catch (const std::exception &e) { + throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what())); + } } - template - inline std::shared_ptr kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) - { - return Factory::template create(logger_name, config); - } + ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); } - template - inline std::shared_ptr kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config) - { - return Factory::template create(logger_name, config); +protected: + void sink_it_(const details::log_msg &msg) override { + producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, + (void *)msg.payload.data(), msg.payload.size(), NULL, NULL); } -} // namespace spdlog + void flush_() override { producer_->flush(config_.flush_timeout_ms); } + +private: + kafka_sink_config config_; + std::unique_ptr producer_ = nullptr; + std::unique_ptr conf_ = nullptr; + std::unique_ptr tconf_ = nullptr; + std::unique_ptr topic_ = nullptr; +}; + +using kafka_sink_mt = kafka_sink; +using kafka_sink_st = kafka_sink; + +} // namespace sinks + +template +inline std::shared_ptr kafka_logger_mt(const std::string &logger_name, + spdlog::sinks::kafka_sink_config config) { + return Factory::template create(logger_name, config); +} + +template +inline std::shared_ptr kafka_logger_st(const std::string &logger_name, + spdlog::sinks::kafka_sink_config config) { + return Factory::template create(logger_name, config); +} + +template +inline std::shared_ptr kafka_logger_async_mt( + std::string logger_name, spdlog::sinks::kafka_sink_config config) { + return Factory::template create(logger_name, config); +} + +template +inline std::shared_ptr kafka_logger_async_st( + std::string logger_name, spdlog::sinks::kafka_sink_config config) { + return Factory::template create(logger_name, config); +} + +} // namespace spdlog diff --git a/lib/spdlog/sinks/mongo_sink.h b/lib/spdlog/sinks/mongo_sink.h index 36b8a7ad..c5b38ab9 100644 --- a/lib/spdlog/sinks/mongo_sink.h +++ b/lib/spdlog/sinks/mongo_sink.h @@ -10,10 +10,10 @@ // http://mongocxx.org/mongocxx-v3/installation/ // -#include #include "spdlog/common.h" #include "spdlog/details/log_msg.h" #include "spdlog/sinks/base_sink.h" +#include #include #include @@ -23,75 +23,86 @@ #include #include -namespace spdlog -{ - namespace sinks - { - template - class mongo_sink : public base_sink { - public: - mongo_sink(const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017") - try : mongo_sink(std::make_shared(), db_name, collection_name, uri) - { - } - catch (const std::exception& e) - { - throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); - } - - mongo_sink(std::shared_ptr instance, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017") : instance_(std::move(instance)), db_name_(db_name), coll_name_(collection_name) - { - try - { - client_ = spdlog::details::make_unique(mongocxx::uri{uri}); - } - catch (const std::exception& e) - { - throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); - } - } - - ~mongo_sink() { flush_(); } - - protected: - void sink_it_(const details::log_msg& msg) override - { - using bsoncxx::builder::stream::document; - using bsoncxx::builder::stream::finalize; - - if (client_ != nullptr) - { - auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data() << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end()) << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id" << static_cast(msg.thread_id) << finalize; - client_->database(db_name_).collection(coll_name_).insert_one(doc.view()); - } - } - - void flush_() override {} - - private: - std::shared_ptr instance_; - std::string db_name_; - std::string coll_name_; - std::unique_ptr client_ = nullptr; - }; - -#include -#include "spdlog/details/null_mutex.h" - using mongo_sink_mt = mongo_sink; - using mongo_sink_st = mongo_sink; - - } // namespace sinks +namespace spdlog { +namespace sinks { +template +class mongo_sink : public base_sink { +public: + mongo_sink(const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") try + : mongo_sink(std::make_shared(), db_name, collection_name, uri) { + } catch (const std::exception &e) { + throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); + } - template - inline std::shared_ptr mongo_logger_mt(const std::string& logger_name, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017") - { - return Factory::template create(logger_name, db_name, collection_name, uri); + mongo_sink(std::shared_ptr instance, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") + : instance_(std::move(instance)), + db_name_(db_name), + coll_name_(collection_name) { + try { + client_ = spdlog::details::make_unique(mongocxx::uri{uri}); + } catch (const std::exception &e) { + throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); + } } - template - inline std::shared_ptr mongo_logger_st(const std::string& logger_name, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017") - { - return Factory::template create(logger_name, db_name, collection_name, uri); + ~mongo_sink() { flush_(); } + +protected: + void sink_it_(const details::log_msg &msg) override { + using bsoncxx::builder::stream::document; + using bsoncxx::builder::stream::finalize; + + if (client_ != nullptr) { + auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" + << level::to_string_view(msg.level).data() << "level_num" + << msg.level << "message" + << std::string(msg.payload.begin(), msg.payload.end()) + << "logger_name" + << std::string(msg.logger_name.begin(), msg.logger_name.end()) + << "thread_id" << static_cast(msg.thread_id) << finalize; + client_->database(db_name_).collection(coll_name_).insert_one(doc.view()); + } } -} // namespace spdlog + void flush_() override {} + +private: + std::shared_ptr instance_; + std::string db_name_; + std::string coll_name_; + std::unique_ptr client_ = nullptr; +}; + +#include "spdlog/details/null_mutex.h" +#include +using mongo_sink_mt = mongo_sink; +using mongo_sink_st = mongo_sink; + +} // namespace sinks + +template +inline std::shared_ptr mongo_logger_mt( + const std::string &logger_name, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") { + return Factory::template create(logger_name, db_name, collection_name, + uri); +} + +template +inline std::shared_ptr mongo_logger_st( + const std::string &logger_name, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") { + return Factory::template create(logger_name, db_name, collection_name, + uri); +} + +} // namespace spdlog diff --git a/lib/spdlog/sinks/msvc_sink.h b/lib/spdlog/sinks/msvc_sink.h index 36240e2f..c28d6ebd 100644 --- a/lib/spdlog/sinks/msvc_sink.h +++ b/lib/spdlog/sinks/msvc_sink.h @@ -5,67 +5,64 @@ #if defined(_WIN32) -#include -#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -#include -#endif -#include + #include + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #include + #endif + #include -#include -#include + #include + #include -// Avoid including windows.h (https://stackoverflow.com/a/30741042) -#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t* lpOutputString); -#else -extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char* lpOutputString); -#endif + // Avoid including windows.h (https://stackoverflow.com/a/30741042) + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) +extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); + #else +extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); + #endif extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); -namespace spdlog -{ - namespace sinks - { - /* - * MSVC sink (logging using OutputDebugStringA) - */ - template - class msvc_sink : public base_sink { - public: - msvc_sink() = default; - msvc_sink(bool check_debugger_present) : check_debugger_present_{check_debugger_present} {} +namespace spdlog { +namespace sinks { +/* + * MSVC sink (logging using OutputDebugStringA) + */ +template +class msvc_sink : public base_sink { +public: + msvc_sink() = default; + msvc_sink(bool check_debugger_present) + : check_debugger_present_{check_debugger_present} {} - protected: - void sink_it_(const details::log_msg& msg) override - { - if (check_debugger_present_ && !IsDebuggerPresent()) - { - return; - } - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - formatted.push_back('\0'); // add a null terminator for OutputDebugString -#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - wmemory_buf_t wformatted; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); - OutputDebugStringW(wformatted.data()); -#else - OutputDebugStringA(formatted.data()); -#endif - } +protected: + void sink_it_(const details::log_msg &msg) override { + if (check_debugger_present_ && !IsDebuggerPresent()) { + return; + } + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + formatted.push_back('\0'); // add a null terminator for OutputDebugString + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + wmemory_buf_t wformatted; + details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); + OutputDebugStringW(wformatted.data()); + #else + OutputDebugStringA(formatted.data()); + #endif + } - void flush_() override {} + void flush_() override {} - bool check_debugger_present_ = true; - }; + bool check_debugger_present_ = true; +}; - using msvc_sink_mt = msvc_sink; - using msvc_sink_st = msvc_sink; +using msvc_sink_mt = msvc_sink; +using msvc_sink_st = msvc_sink; - using windebug_sink_mt = msvc_sink_mt; - using windebug_sink_st = msvc_sink_st; +using windebug_sink_mt = msvc_sink_mt; +using windebug_sink_st = msvc_sink_st; - } // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog #endif diff --git a/lib/spdlog/sinks/null_sink.h b/lib/spdlog/sinks/null_sink.h index 46d5d22a..c51247fe 100644 --- a/lib/spdlog/sinks/null_sink.h +++ b/lib/spdlog/sinks/null_sink.h @@ -9,37 +9,33 @@ #include -namespace spdlog -{ - namespace sinks - { - - template - class null_sink : public base_sink { - protected: - void sink_it_(const details::log_msg&) override {} - void flush_() override {} - }; - - using null_sink_mt = null_sink; - using null_sink_st = null_sink; - - } // namespace sinks - - template - inline std::shared_ptr null_logger_mt(const std::string& logger_name) - { - auto null_logger = Factory::template create(logger_name); - null_logger->set_level(level::off); - return null_logger; - } - - template - inline std::shared_ptr null_logger_st(const std::string& logger_name) - { - auto null_logger = Factory::template create(logger_name); - null_logger->set_level(level::off); - return null_logger; - } - -} // namespace spdlog +namespace spdlog { +namespace sinks { + +template +class null_sink : public base_sink { +protected: + void sink_it_(const details::log_msg &) override {} + void flush_() override {} +}; + +using null_sink_mt = null_sink; +using null_sink_st = null_sink; + +} // namespace sinks + +template +inline std::shared_ptr null_logger_mt(const std::string &logger_name) { + auto null_logger = Factory::template create(logger_name); + null_logger->set_level(level::off); + return null_logger; +} + +template +inline std::shared_ptr null_logger_st(const std::string &logger_name) { + auto null_logger = Factory::template create(logger_name); + null_logger->set_level(level::off); + return null_logger; +} + +} // namespace spdlog diff --git a/lib/spdlog/sinks/ostream_sink.h b/lib/spdlog/sinks/ostream_sink.h index a8aa0893..6af9dd09 100644 --- a/lib/spdlog/sinks/ostream_sink.h +++ b/lib/spdlog/sinks/ostream_sink.h @@ -9,37 +9,35 @@ #include #include -namespace spdlog -{ - namespace sinks - { - template - class ostream_sink final : 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; - - protected: - void sink_it_(const details::log_msg& msg) override - { - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - ostream_.write(formatted.data(), static_cast(formatted.size())); - if (force_flush_) - { - ostream_.flush(); - } - } - - void flush_() override { ostream_.flush(); } - - std::ostream& ostream_; - bool force_flush_; - }; - - using ostream_sink_mt = ostream_sink; - using ostream_sink_st = ostream_sink; - - } // namespace sinks -} // namespace spdlog +namespace spdlog { +namespace sinks { +template +class ostream_sink final : 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; + +protected: + void sink_it_(const details::log_msg &msg) override { + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + ostream_.write(formatted.data(), static_cast(formatted.size())); + if (force_flush_) { + ostream_.flush(); + } + } + + void flush_() override { ostream_.flush(); } + + std::ostream &ostream_; + bool force_flush_; +}; + +using ostream_sink_mt = ostream_sink; +using ostream_sink_st = ostream_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/qt_sinks.h b/lib/spdlog/sinks/qt_sinks.h index e5b44837..d319e847 100644 --- a/lib/spdlog/sinks/qt_sinks.h +++ b/lib/spdlog/sinks/qt_sinks.h @@ -8,15 +8,15 @@ // etc) Building and using requires Qt library. // // Warning: the qt_sink won't be notified if the target widget is destroyed. -// If the widget's lifetime can be shorter than the logger's one, you should -// provide some permanent QObject, and then use a standard signal/slot. +// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent +// QObject, and then use a standard signal/slot. // -#include #include "spdlog/common.h" #include "spdlog/details/log_msg.h" #include "spdlog/details/synchronous_factory.h" #include "spdlog/sinks/base_sink.h" +#include #include #include @@ -24,264 +24,281 @@ // // qt_sink class // -namespace spdlog -{ - namespace sinks - { - template - class qt_sink : public base_sink { - public: - qt_sink(QObject* qt_object, std::string meta_method) : qt_object_(qt_object), meta_method_(std::move(meta_method)) - { - if (!qt_object_) - { - throw_spdlog_ex("qt_sink: qt_object is null"); - } - } +namespace spdlog { +namespace sinks { +template +class qt_sink : public base_sink { +public: + qt_sink(QObject *qt_object, std::string meta_method) + : qt_object_(qt_object), + meta_method_(std::move(meta_method)) { + if (!qt_object_) { + throw_spdlog_ex("qt_sink: qt_object is null"); + } + } - ~qt_sink() { flush_(); } + ~qt_sink() { flush_(); } - protected: - void sink_it_(const details::log_msg& msg) override - { - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - const string_view_t str = string_view_t(formatted.data(), formatted.size()); - QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection, Q_ARG(QString, QString::fromUtf8(str.data(), static_cast(str.size())).trimmed())); - } +protected: + void sink_it_(const details::log_msg &msg) override { + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + const string_view_t str = string_view_t(formatted.data(), formatted.size()); + QMetaObject::invokeMethod( + qt_object_, meta_method_.c_str(), Qt::AutoConnection, + Q_ARG(QString, QString::fromUtf8(str.data(), static_cast(str.size())).trimmed())); + } - void flush_() override {} - - private: - QObject* qt_object_ = nullptr; - std::string meta_method_; - }; - - // Qt color sink to QTextEdit. - // Color location is determined by the sink log pattern like in the rest of - // spdlog sinks. Colors can be modified if needed using sink->set_color(level, - // qtTextCharFormat). max_lines is the maximum number of lines that the sink - // will hold before removing the oldest lines. By default, only ascii (latin1) - // is supported by this sink. Set is_utf8 to true if utf8 support is needed. - template - class qt_color_sink : public base_sink { - public: - qt_color_sink(QTextEdit* qt_text_edit, int max_lines, bool dark_colors = false, bool is_utf8 = false) : qt_text_edit_(qt_text_edit), max_lines_(max_lines), is_utf8_(is_utf8) - { - if (!qt_text_edit_) - { - throw_spdlog_ex("qt_color_text_sink: text_edit is null"); - } - - default_color_ = qt_text_edit_->currentCharFormat(); - // set colors - QTextCharFormat format; - // trace - format.setForeground(dark_colors ? Qt::darkGray : Qt::gray); - colors_.at(level::trace) = format; - // debug - format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan); - colors_.at(level::debug) = format; - // info - format.setForeground(dark_colors ? Qt::darkGreen : Qt::green); - colors_.at(level::info) = format; - // warn - format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow); - colors_.at(level::warn) = format; - // err - format.setForeground(Qt::red); - colors_.at(level::err) = format; - // critical - format.setForeground(Qt::white); - format.setBackground(Qt::red); - colors_.at(level::critical) = format; - } + void flush_() override {} + +private: + QObject *qt_object_ = nullptr; + std::string meta_method_; +}; + +// Qt color sink to QTextEdit. +// Color location is determined by the sink log pattern like in the rest of spdlog sinks. +// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat). +// max_lines is the maximum number of lines that the sink will hold before removing the oldest +// lines. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8 +// support is needed. +template +class qt_color_sink : public base_sink { +public: + qt_color_sink(QTextEdit *qt_text_edit, + int max_lines, + bool dark_colors = false, + bool is_utf8 = false) + : qt_text_edit_(qt_text_edit), + max_lines_(max_lines), + is_utf8_(is_utf8) { + if (!qt_text_edit_) { + throw_spdlog_ex("qt_color_text_sink: text_edit is null"); + } + + default_color_ = qt_text_edit_->currentCharFormat(); + // set colors + QTextCharFormat format; + // trace + format.setForeground(dark_colors ? Qt::darkGray : Qt::gray); + colors_.at(level::trace) = format; + // debug + format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan); + colors_.at(level::debug) = format; + // info + format.setForeground(dark_colors ? Qt::darkGreen : Qt::green); + colors_.at(level::info) = format; + // warn + format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow); + colors_.at(level::warn) = format; + // err + format.setForeground(Qt::red); + colors_.at(level::err) = format; + // critical + format.setForeground(Qt::white); + format.setBackground(Qt::red); + colors_.at(level::critical) = format; + } - ~qt_color_sink() { flush_(); } + ~qt_color_sink() { flush_(); } - void set_default_color(QTextCharFormat format) - { - // std::lock_guard lock(base_sink::mutex_); - default_color_ = format; - } + void set_default_color(QTextCharFormat format) { + // std::lock_guard lock(base_sink::mutex_); + default_color_ = format; + } - void set_level_color(level::level_enum color_level, QTextCharFormat format) - { - // std::lock_guard lock(base_sink::mutex_); - colors_.at(static_cast(color_level)) = format; - } + void set_level_color(level::level_enum color_level, QTextCharFormat format) { + // std::lock_guard lock(base_sink::mutex_); + colors_.at(static_cast(color_level)) = format; + } - QTextCharFormat& get_level_color(level::level_enum color_level) - { - std::lock_guard lock(base_sink::mutex_); - return colors_.at(static_cast(color_level)); - } + QTextCharFormat &get_level_color(level::level_enum color_level) { + std::lock_guard lock(base_sink::mutex_); + return colors_.at(static_cast(color_level)); + } - QTextCharFormat& get_default_color() - { - std::lock_guard lock(base_sink::mutex_); - return default_color_; - } + QTextCharFormat &get_default_color() { + std::lock_guard lock(base_sink::mutex_); + return default_color_; + } - protected: - struct invoke_params { - invoke_params(int max_lines, QTextEdit* q_text_edit, QString payload, QTextCharFormat default_color, QTextCharFormat level_color, int color_range_start, int color_range_end) : max_lines(max_lines), q_text_edit(q_text_edit), payload(std::move(payload)), default_color(default_color), level_color(level_color), color_range_start(color_range_start), color_range_end(color_range_end) {} - int max_lines; - QTextEdit* q_text_edit; - QString payload; - QTextCharFormat default_color; - QTextCharFormat level_color; - int color_range_start; - int color_range_end; - }; - - void sink_it_(const details::log_msg& msg) override - { - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - - const string_view_t str = string_view_t(formatted.data(), formatted.size()); - // apply the color to the color range in the formatted message. - QString payload; - int color_range_start = static_cast(msg.color_range_start); - int color_range_end = static_cast(msg.color_range_end); - if (is_utf8_) - { - payload = QString::fromUtf8(str.data(), static_cast(str.size())); - // convert color ranges from byte index to character index. - if (msg.color_range_start < msg.color_range_end) - { - color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size(); - color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size(); - } - } - else - { - payload = QString::fromLatin1(str.data(), static_cast(str.size())); - } - - invoke_params params{max_lines_, // max lines - qt_text_edit_, // text edit to append to - std::move(payload), // text to append - default_color_, // default color - colors_.at(msg.level), // color to apply - color_range_start, // color range start - color_range_end}; // color range end - - QMetaObject::invokeMethod(qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); +protected: + struct invoke_params { + invoke_params(int max_lines, + QTextEdit *q_text_edit, + QString payload, + QTextCharFormat default_color, + QTextCharFormat level_color, + int color_range_start, + int color_range_end) + : max_lines(max_lines), + q_text_edit(q_text_edit), + payload(std::move(payload)), + default_color(default_color), + level_color(level_color), + color_range_start(color_range_start), + color_range_end(color_range_end) {} + int max_lines; + QTextEdit *q_text_edit; + QString payload; + QTextCharFormat default_color; + QTextCharFormat level_color; + int color_range_start; + int color_range_end; + }; + + void sink_it_(const details::log_msg &msg) override { + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + + const string_view_t str = string_view_t(formatted.data(), formatted.size()); + // apply the color to the color range in the formatted message. + QString payload; + int color_range_start = static_cast(msg.color_range_start); + int color_range_end = static_cast(msg.color_range_end); + if (is_utf8_) { + payload = QString::fromUtf8(str.data(), static_cast(str.size())); + // convert color ranges from byte index to character index. + if (msg.color_range_start < msg.color_range_end) { + color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size(); + color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size(); } + } else { + payload = QString::fromLatin1(str.data(), static_cast(str.size())); + } + + invoke_params params{max_lines_, // max lines + qt_text_edit_, // text edit to append to + std::move(payload), // text to append + default_color_, // default color + colors_.at(msg.level), // color to apply + color_range_start, // color range start + color_range_end}; // color range end + + QMetaObject::invokeMethod( + qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); + } - void flush_() override {} - - // Add colored text to the text edit widget. This method is invoked in the GUI - // thread. It is a static method to ensure that it is handled correctly even - // if the sink is destroyed prematurely before it is invoked. - - static void invoke_method_(invoke_params params) - { - auto* document = params.q_text_edit->document(); - QTextCursor cursor(document); - - // remove first blocks if number of blocks exceeds max_lines - while (document->blockCount() > params.max_lines) - { - cursor.select(QTextCursor::BlockUnderCursor); - cursor.removeSelectedText(); - cursor.deleteChar(); // delete the newline after the block - } - - cursor.movePosition(QTextCursor::End); - cursor.setCharFormat(params.default_color); - - // if color range not specified or not not valid, just append the text with - // default color - if (params.color_range_end <= params.color_range_start) - { - cursor.insertText(params.payload); - return; - } - - // insert the text before the color range - cursor.insertText(params.payload.left(params.color_range_start)); - - // insert the colorized text - cursor.setCharFormat(params.level_color); - cursor.insertText(params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start)); - - // insert the text after the color range with default format - cursor.setCharFormat(params.default_color); - cursor.insertText(params.payload.mid(params.color_range_end)); - } + void flush_() override {} - QTextEdit* qt_text_edit_; - int max_lines_; - bool is_utf8_; - QTextCharFormat default_color_; - std::array colors_; - }; + // Add colored text to the text edit widget. This method is invoked in the GUI thread. + // It is a static method to ensure that it is handled correctly even if the sink is destroyed + // prematurely before it is invoked. -#include -#include "spdlog/details/null_mutex.h" + static void invoke_method_(invoke_params params) { + auto *document = params.q_text_edit->document(); + QTextCursor cursor(document); - using qt_sink_mt = qt_sink; - using qt_sink_st = qt_sink; - using qt_color_sink_mt = qt_color_sink; - using qt_color_sink_st = qt_color_sink; - } // namespace sinks - - // - // Factory functions - // - - // log to QTextEdit - template - inline std::shared_ptr qt_logger_mt(const std::string& logger_name, QTextEdit* qt_object, const std::string& meta_method = "append") - { - return Factory::template create(logger_name, qt_object, meta_method); - } + // remove first blocks if number of blocks exceeds max_lines + while (document->blockCount() > params.max_lines) { + cursor.select(QTextCursor::BlockUnderCursor); + cursor.removeSelectedText(); + cursor.deleteChar(); // delete the newline after the block + } - template - inline std::shared_ptr qt_logger_st(const std::string& logger_name, QTextEdit* qt_object, const std::string& meta_method = "append") - { - return Factory::template create(logger_name, qt_object, meta_method); - } + cursor.movePosition(QTextCursor::End); + cursor.setCharFormat(params.default_color); - // log to QPlainTextEdit - template - inline std::shared_ptr qt_logger_mt(const std::string& logger_name, QPlainTextEdit* qt_object, const std::string& meta_method = "appendPlainText") - { - return Factory::template create(logger_name, qt_object, meta_method); - } + // if color range not specified or not not valid, just append the text with default color + if (params.color_range_end <= params.color_range_start) { + cursor.insertText(params.payload); + return; + } - template - inline std::shared_ptr qt_logger_st(const std::string& logger_name, QPlainTextEdit* qt_object, const std::string& meta_method = "appendPlainText") - { - return Factory::template create(logger_name, qt_object, meta_method); - } - // log to QObject - template - inline std::shared_ptr qt_logger_mt(const std::string& logger_name, QObject* qt_object, const std::string& meta_method) - { - return Factory::template create(logger_name, qt_object, meta_method); - } + // insert the text before the color range + cursor.insertText(params.payload.left(params.color_range_start)); - template - inline std::shared_ptr qt_logger_st(const std::string& logger_name, QObject* qt_object, const std::string& meta_method) - { - return Factory::template create(logger_name, qt_object, meta_method); - } + // insert the colorized text + cursor.setCharFormat(params.level_color); + cursor.insertText(params.payload.mid(params.color_range_start, + params.color_range_end - params.color_range_start)); - // log to QTextEdit with colorized output - template - inline std::shared_ptr qt_color_logger_mt(const std::string& logger_name, QTextEdit* qt_text_edit, int max_lines, bool is_utf8 = false) - { - return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); + // insert the text after the color range with default format + cursor.setCharFormat(params.default_color); + cursor.insertText(params.payload.mid(params.color_range_end)); } - template - inline std::shared_ptr qt_color_logger_st(const std::string& logger_name, QTextEdit* qt_text_edit, int max_lines, bool is_utf8 = false) - { - return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); - } + QTextEdit *qt_text_edit_; + int max_lines_; + bool is_utf8_; + QTextCharFormat default_color_; + std::array colors_; +}; + +#include "spdlog/details/null_mutex.h" +#include + +using qt_sink_mt = qt_sink; +using qt_sink_st = qt_sink; +using qt_color_sink_mt = qt_color_sink; +using qt_color_sink_st = qt_color_sink; +} // namespace sinks + +// +// Factory functions +// -} // namespace spdlog +// log to QTextEdit +template +inline std::shared_ptr qt_logger_mt(const std::string &logger_name, + QTextEdit *qt_object, + const std::string &meta_method = "append") { + return Factory::template create(logger_name, qt_object, meta_method); +} + +template +inline std::shared_ptr qt_logger_st(const std::string &logger_name, + QTextEdit *qt_object, + const std::string &meta_method = "append") { + return Factory::template create(logger_name, qt_object, meta_method); +} + +// log to QPlainTextEdit +template +inline std::shared_ptr qt_logger_mt(const std::string &logger_name, + QPlainTextEdit *qt_object, + const std::string &meta_method = "appendPlainText") { + return Factory::template create(logger_name, qt_object, meta_method); +} + +template +inline std::shared_ptr qt_logger_st(const std::string &logger_name, + QPlainTextEdit *qt_object, + const std::string &meta_method = "appendPlainText") { + return Factory::template create(logger_name, qt_object, meta_method); +} +// log to QObject +template +inline std::shared_ptr qt_logger_mt(const std::string &logger_name, + QObject *qt_object, + const std::string &meta_method) { + return Factory::template create(logger_name, qt_object, meta_method); +} + +template +inline std::shared_ptr qt_logger_st(const std::string &logger_name, + QObject *qt_object, + const std::string &meta_method) { + return Factory::template create(logger_name, qt_object, meta_method); +} + +// log to QTextEdit with colorized output +template +inline std::shared_ptr qt_color_logger_mt(const std::string &logger_name, + QTextEdit *qt_text_edit, + int max_lines, + bool is_utf8 = false) { + return Factory::template create(logger_name, qt_text_edit, max_lines, + false, is_utf8); +} + +template +inline std::shared_ptr qt_color_logger_st(const std::string &logger_name, + QTextEdit *qt_text_edit, + int max_lines, + bool is_utf8 = false) { + return Factory::template create(logger_name, qt_text_edit, max_lines, + false, is_utf8); +} + +} // namespace spdlog diff --git a/lib/spdlog/sinks/ringbuffer_sink.h b/lib/spdlog/sinks/ringbuffer_sink.h index 3559a570..6156c6a5 100644 --- a/lib/spdlog/sinks/ringbuffer_sink.h +++ b/lib/spdlog/sinks/ringbuffer_sink.h @@ -12,59 +12,56 @@ #include #include -namespace spdlog -{ - namespace sinks - { - /* - * Ring buffer sink - */ - template - class ringbuffer_sink final : public base_sink { - public: - explicit ringbuffer_sink(size_t n_items) : q_{n_items} {} +namespace spdlog { +namespace sinks { +/* + * Ring buffer sink + */ +template +class ringbuffer_sink final : public base_sink { +public: + explicit ringbuffer_sink(size_t n_items) + : q_{n_items} {} - std::vector last_raw(size_t lim = 0) - { - std::lock_guard lock(base_sink::mutex_); - auto items_available = q_.size(); - auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; - std::vector ret; - ret.reserve(n_items); - for (size_t i = (items_available - n_items); i < items_available; i++) - { - ret.push_back(q_.at(i)); - } - return ret; - } + std::vector last_raw(size_t lim = 0) { + std::lock_guard lock(base_sink::mutex_); + auto items_available = q_.size(); + auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; + std::vector ret; + ret.reserve(n_items); + for (size_t i = (items_available - n_items); i < items_available; i++) { + ret.push_back(q_.at(i)); + } + return ret; + } - std::vector last_formatted(size_t lim = 0) - { - std::lock_guard lock(base_sink::mutex_); - auto items_available = q_.size(); - auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; - std::vector ret; - ret.reserve(n_items); - for (size_t i = (items_available - n_items); i < items_available; i++) - { - memory_buf_t formatted; - base_sink::formatter_->format(q_.at(i), formatted); - ret.push_back(SPDLOG_BUF_TO_STRING(formatted)); - } - return ret; - } + std::vector last_formatted(size_t lim = 0) { + std::lock_guard lock(base_sink::mutex_); + auto items_available = q_.size(); + auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; + std::vector ret; + ret.reserve(n_items); + for (size_t i = (items_available - n_items); i < items_available; i++) { + memory_buf_t formatted; + base_sink::formatter_->format(q_.at(i), formatted); + ret.push_back(SPDLOG_BUF_TO_STRING(formatted)); + } + return ret; + } - protected: - void sink_it_(const details::log_msg& msg) override { q_.push_back(details::log_msg_buffer{msg}); } - void flush_() override {} +protected: + void sink_it_(const details::log_msg &msg) override { + q_.push_back(details::log_msg_buffer{msg}); + } + void flush_() override {} - private: - details::circular_q q_; - }; +private: + details::circular_q q_; +}; - using ringbuffer_sink_mt = ringbuffer_sink; - using ringbuffer_sink_st = ringbuffer_sink; +using ringbuffer_sink_mt = ringbuffer_sink; +using ringbuffer_sink_st = ringbuffer_sink; - } // namespace sinks +} // namespace sinks -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/sinks/rotating_file_sink-inl.h b/lib/spdlog/sinks/rotating_file_sink-inl.h index 56535b31..bf9351eb 100644 --- a/lib/spdlog/sinks/rotating_file_sink-inl.h +++ b/lib/spdlog/sinks/rotating_file_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -20,133 +20,125 @@ #include #include -namespace spdlog -{ - namespace sinks - { - - template - SPDLOG_INLINE rotating_file_sink::rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers& event_handlers) : base_filename_(std::move(base_filename)), max_size_(max_size), max_files_(max_files), file_helper_{event_handlers} - { - if (max_size == 0) - { - throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero"); - } - - if (max_files > 200000) - { - throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); - } - file_helper_.open(calc_filename(base_filename_, 0)); - current_size_ = file_helper_.size(); // expensive. called only once - if (rotate_on_open && current_size_ > 0) - { - rotate_(); - current_size_ = 0; - } - } - - // calc filename according to index and file extension if exists. - // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". - template - SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t& filename, std::size_t index) - { - if (index == 0u) - { - return filename; - } - - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext); - } - - template - SPDLOG_INLINE filename_t rotating_file_sink::filename() - { - std::lock_guard lock(base_sink::mutex_); - return file_helper_.filename(); +namespace spdlog { +namespace sinks { + +template +SPDLOG_INLINE rotating_file_sink::rotating_file_sink( + filename_t base_filename, + std::size_t max_size, + std::size_t max_files, + bool rotate_on_open, + const file_event_handlers &event_handlers) + : base_filename_(std::move(base_filename)), + max_size_(max_size), + max_files_(max_files), + file_helper_{event_handlers} { + if (max_size == 0) { + throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero"); + } + + if (max_files > 200000) { + throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); + } + file_helper_.open(calc_filename(base_filename_, 0)); + current_size_ = file_helper_.size(); // expensive. called only once + if (rotate_on_open && current_size_ > 0) { + rotate_(); + current_size_ = 0; + } +} + +// calc filename according to index and file extension if exists. +// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". +template +SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename, + std::size_t index) { + if (index == 0u) { + return filename; + } + + filename_t basename, ext; + std::tie(basename, ext) = details::file_helper::split_by_extension(filename); + return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext); +} + +template +SPDLOG_INLINE filename_t rotating_file_sink::filename() { + std::lock_guard lock(base_sink::mutex_); + return file_helper_.filename(); +} + +template +SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) { + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + auto new_size = current_size_ + formatted.size(); + + // rotate if the new estimated file size exceeds max size. + // rotate only if the real size > 0 to better deal with full disk (see issue #2261). + // we only check the real size when new_size > max_size_ because it is relatively expensive. + if (new_size > max_size_) { + file_helper_.flush(); + if (file_helper_.size() > 0) { + rotate_(); + new_size = formatted.size(); } - - template - SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg& msg) - { - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - auto new_size = current_size_ + formatted.size(); - - // rotate if the new estimated file size exceeds max size. - // rotate only if the real size > 0 to better deal with full disk (see issue - // #2261). we only check the real size when new_size > max_size_ because it is - // relatively expensive. - if (new_size > max_size_) - { - file_helper_.flush(); - if (file_helper_.size() > 0) - { - rotate_(); - new_size = formatted.size(); - } - } - file_helper_.write(formatted); - current_size_ = new_size; - } - - template - SPDLOG_INLINE void rotating_file_sink::flush_() - { - file_helper_.flush(); + } + file_helper_.write(formatted); + current_size_ = new_size; +} + +template +SPDLOG_INLINE void rotating_file_sink::flush_() { + file_helper_.flush(); +} + +// Rotate files: +// log.txt -> log.1.txt +// log.1.txt -> log.2.txt +// log.2.txt -> log.3.txt +// log.3.txt -> delete +template +SPDLOG_INLINE void rotating_file_sink::rotate_() { + using details::os::filename_to_str; + using details::os::path_exists; + + file_helper_.close(); + for (auto i = max_files_; i > 0; --i) { + filename_t src = calc_filename(base_filename_, i - 1); + if (!path_exists(src)) { + continue; } - - // Rotate files: - // log.txt -> log.1.txt - // log.1.txt -> log.2.txt - // log.2.txt -> log.3.txt - // log.3.txt -> delete - template - SPDLOG_INLINE void rotating_file_sink::rotate_() - { - using details::os::filename_to_str; - using details::os::path_exists; - - file_helper_.close(); - for (auto i = max_files_; i > 0; --i) - { - filename_t src = calc_filename(base_filename_, i - 1); - if (!path_exists(src)) - { - continue; - } - filename_t target = calc_filename(base_filename_, i); - - if (!rename_file_(src, target)) - { - // if failed try again after a small delay. - // this is a workaround to a windows issue, where very high rotation - // rates can cause the rename to fail with permission denied (because of - // antivirus?). - details::os::sleep_for_millis(100); - if (!rename_file_(src, target)) - { - file_helper_.reopen(true); // truncate the log file anyway to prevent it - // to grow beyond its limit! - current_size_ = 0; - throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); - } - } + filename_t target = calc_filename(base_filename_, i); + + if (!rename_file_(src, target)) { + // if failed try again after a small delay. + // this is a workaround to a windows issue, where very high rotation + // rates can cause the rename to fail with permission denied (because of antivirus?). + details::os::sleep_for_millis(100); + if (!rename_file_(src, target)) { + file_helper_.reopen( + true); // truncate the log file anyway to prevent it to grow beyond its limit! + current_size_ = 0; + throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + + " to " + filename_to_str(target), + errno); } - file_helper_.reopen(true); } - - // delete the target if exists, and rename the src file to target - // return true on success, false otherwise. - template - SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t& src_filename, const filename_t& target_filename) - { - // try to delete the target file in case it already exists. - (void)details::os::remove(target_filename); - return details::os::rename(src_filename, target_filename) == 0; - } - - } // namespace sinks -} // namespace spdlog + } + file_helper_.reopen(true); +} + +// delete the target if exists, and rename the src file to target +// return true on success, false otherwise. +template +SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename, + const filename_t &target_filename) { + // try to delete the target file in case it already exists. + (void)details::os::remove(target_filename); + return details::os::rename(src_filename, target_filename) == 0; +} + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/rotating_file_sink.h b/lib/spdlog/sinks/rotating_file_sink.h index c9b8f23a..cd43d349 100644 --- a/lib/spdlog/sinks/rotating_file_sink.h +++ b/lib/spdlog/sinks/rotating_file_sink.h @@ -12,66 +12,78 @@ #include #include -namespace spdlog -{ - namespace sinks - { +namespace spdlog { +namespace sinks { - // - // Rotating file sink based on size - // - template - class rotating_file_sink final : public base_sink { - public: - rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}); - static filename_t calc_filename(const filename_t& filename, std::size_t index); - filename_t filename(); +// +// Rotating file sink based on size +// +template +class rotating_file_sink final : public base_sink { +public: + rotating_file_sink(filename_t base_filename, + std::size_t max_size, + std::size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}); + static filename_t calc_filename(const filename_t &filename, std::size_t index); + filename_t filename(); - protected: - void sink_it_(const details::log_msg& msg) override; - void flush_() override; +protected: + void sink_it_(const details::log_msg &msg) override; + void flush_() override; - private: - // Rotate files: - // log.txt -> log.1.txt - // log.1.txt -> log.2.txt - // log.2.txt -> log.3.txt - // log.3.txt -> delete - void rotate_(); +private: + // Rotate files: + // log.txt -> log.1.txt + // log.1.txt -> log.2.txt + // log.2.txt -> log.3.txt + // log.3.txt -> delete + void rotate_(); - // delete the target if exists, and rename the src file to target - // return true on success, false otherwise. - bool rename_file_(const filename_t& src_filename, const filename_t& target_filename); + // delete the target if exists, and rename the src file to target + // return true on success, false otherwise. + bool rename_file_(const filename_t &src_filename, const filename_t &target_filename); - filename_t base_filename_; - std::size_t max_size_; - std::size_t max_files_; - std::size_t current_size_; - details::file_helper file_helper_; - }; + filename_t base_filename_; + std::size_t max_size_; + std::size_t max_files_; + std::size_t current_size_; + details::file_helper file_helper_; +}; - using rotating_file_sink_mt = rotating_file_sink; - using rotating_file_sink_st = rotating_file_sink; +using rotating_file_sink_mt = rotating_file_sink; +using rotating_file_sink_st = rotating_file_sink; - } // namespace sinks +} // namespace sinks - // - // factory functions - // +// +// factory functions +// - template - inline std::shared_ptr rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); - } +template +inline std::shared_ptr rotating_logger_mt(const std::string &logger_name, + const filename_t &filename, + size_t max_file_size, + size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create( + logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); +} - template - inline std::shared_ptr rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}) - { - return Factory::template create(logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); - } -} // namespace spdlog +template +inline std::shared_ptr rotating_logger_st(const std::string &logger_name, + const filename_t &filename, + size_t max_file_size, + size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create( + logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); +} +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "rotating_file_sink-inl.h" + #include "rotating_file_sink-inl.h" #endif diff --git a/lib/spdlog/sinks/sink-inl.h b/lib/spdlog/sinks/sink-inl.h index 637ea5b7..e4b27140 100644 --- a/lib/spdlog/sinks/sink-inl.h +++ b/lib/spdlog/sinks/sink-inl.h @@ -4,13 +4,19 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include -SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } +SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { + return msg_level >= level_.load(std::memory_order_relaxed); +} -SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { level_.store(log_level, std::memory_order_relaxed); } +SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { + level_.store(log_level, std::memory_order_relaxed); +} -SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } +SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { + return static_cast(level_.load(std::memory_order_relaxed)); +} diff --git a/lib/spdlog/sinks/sink.h b/lib/spdlog/sinks/sink.h index f81e6d1d..58506853 100644 --- a/lib/spdlog/sinks/sink.h +++ b/lib/spdlog/sinks/sink.h @@ -6,31 +6,29 @@ #include #include -namespace spdlog -{ - - namespace sinks - { - class SPDLOG_API sink { - public: - virtual ~sink() = default; - virtual void log(const details::log_msg& msg) = 0; - virtual void flush() = 0; - virtual void set_pattern(const std::string& pattern) = 0; - virtual void set_formatter(std::unique_ptr sink_formatter) = 0; - - void set_level(level::level_enum log_level); - level::level_enum level() const; - bool should_log(level::level_enum msg_level) const; - - protected: - // sink log level - default is all - level_t level_{level::trace}; - }; - - } // namespace sinks -} // namespace spdlog +namespace spdlog { + +namespace sinks { +class SPDLOG_API sink { +public: + virtual ~sink() = default; + virtual void log(const details::log_msg &msg) = 0; + virtual void flush() = 0; + virtual void set_pattern(const std::string &pattern) = 0; + virtual void set_formatter(std::unique_ptr sink_formatter) = 0; + + void set_level(level::level_enum log_level); + level::level_enum level() const; + bool should_log(level::level_enum msg_level) const; + +protected: + // sink log level - default is all + level_t level_{level::trace}; +}; + +} // namespace sinks +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "sink-inl.h" + #include "sink-inl.h" #endif diff --git a/lib/spdlog/sinks/stdout_color_sinks-inl.h b/lib/spdlog/sinks/stdout_color_sinks-inl.h index 438642e6..166e3861 100644 --- a/lib/spdlog/sinks/stdout_color_sinks-inl.h +++ b/lib/spdlog/sinks/stdout_color_sinks-inl.h @@ -4,36 +4,35 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog -{ - - template - SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string& logger_name, color_mode mode) - { - return Factory::template create(logger_name, mode); - } - - template - SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string& logger_name, color_mode mode) - { - return Factory::template create(logger_name, mode); - } - - template - SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string& logger_name, color_mode mode) - { - return Factory::template create(logger_name, mode); - } - - template - SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string& logger_name, color_mode mode) - { - return Factory::template create(logger_name, mode); - } -} // namespace spdlog +namespace spdlog { + +template +SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name, + color_mode mode) { + return Factory::template create(logger_name, mode); +} + +template +SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name, + color_mode mode) { + return Factory::template create(logger_name, mode); +} + +template +SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name, + color_mode mode) { + return Factory::template create(logger_name, mode); +} + +template +SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name, + color_mode mode) { + return Factory::template create(logger_name, mode); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/stdout_color_sinks.h b/lib/spdlog/sinks/stdout_color_sinks.h index 351eb9c7..72991fe0 100644 --- a/lib/spdlog/sinks/stdout_color_sinks.h +++ b/lib/spdlog/sinks/stdout_color_sinks.h @@ -4,44 +4,46 @@ #pragma once #ifdef _WIN32 -#include + #include #else -#include + #include #endif #include -namespace spdlog -{ - namespace sinks - { +namespace spdlog { +namespace sinks { #ifdef _WIN32 - using stdout_color_sink_mt = wincolor_stdout_sink_mt; - using stdout_color_sink_st = wincolor_stdout_sink_st; - using stderr_color_sink_mt = wincolor_stderr_sink_mt; - using stderr_color_sink_st = wincolor_stderr_sink_st; +using stdout_color_sink_mt = wincolor_stdout_sink_mt; +using stdout_color_sink_st = wincolor_stdout_sink_st; +using stderr_color_sink_mt = wincolor_stderr_sink_mt; +using stderr_color_sink_st = wincolor_stderr_sink_st; #else - using stdout_color_sink_mt = ansicolor_stdout_sink_mt; - using stdout_color_sink_st = ansicolor_stdout_sink_st; - using stderr_color_sink_mt = ansicolor_stderr_sink_mt; - using stderr_color_sink_st = ansicolor_stderr_sink_st; +using stdout_color_sink_mt = ansicolor_stdout_sink_mt; +using stdout_color_sink_st = ansicolor_stdout_sink_st; +using stderr_color_sink_mt = ansicolor_stderr_sink_mt; +using stderr_color_sink_st = ansicolor_stderr_sink_st; #endif - } // namespace sinks +} // namespace sinks - template - std::shared_ptr stdout_color_mt(const std::string& logger_name, color_mode mode = color_mode::automatic); +template +std::shared_ptr stdout_color_mt(const std::string &logger_name, + color_mode mode = color_mode::automatic); - template - std::shared_ptr stdout_color_st(const std::string& logger_name, color_mode mode = color_mode::automatic); +template +std::shared_ptr stdout_color_st(const std::string &logger_name, + color_mode mode = color_mode::automatic); - template - std::shared_ptr stderr_color_mt(const std::string& logger_name, color_mode mode = color_mode::automatic); +template +std::shared_ptr stderr_color_mt(const std::string &logger_name, + color_mode mode = color_mode::automatic); - template - std::shared_ptr stderr_color_st(const std::string& logger_name, color_mode mode = color_mode::automatic); +template +std::shared_ptr stderr_color_st(const std::string &logger_name, + color_mode mode = color_mode::automatic); -} // namespace spdlog +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "stdout_color_sinks-inl.h" + #include "stdout_color_sinks-inl.h" #endif diff --git a/lib/spdlog/sinks/stdout_sinks-inl.h b/lib/spdlog/sinks/stdout_sinks-inl.h index 3271134d..f98244db 100644 --- a/lib/spdlog/sinks/stdout_sinks-inl.h +++ b/lib/spdlog/sinks/stdout_sinks-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -12,127 +12,115 @@ #include #ifdef _WIN32 -// under windows using fwrite to non-binary stream results in \r\r\n (see issue -// #1675) so instead we use ::FileWrite -#include + // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) + // so instead we use ::FileWrite + #include -#ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp -#include // WriteFile (..) -#endif + #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp + #include // WriteFile (..) + #endif -#include // _get_osfhandle(..) -#include // _fileno(..) -#endif // WIN32 + #include // _get_osfhandle(..) + #include // _fileno(..) +#endif // WIN32 -namespace spdlog -{ +namespace spdlog { - namespace sinks - { +namespace sinks { - template - SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE* file) : mutex_(ConsoleMutex::mutex()), file_(file), formatter_(details::make_unique()) - { -#ifdef _WIN32 - // get windows handle from the FILE* object - - handle_ = reinterpret_cast(::_get_osfhandle(::_fileno(file_))); - - // don't throw to support cases where no console is attached, - // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). - // throw only if non stdout/stderr target is requested (probably regular file - // and not console). - if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) - { - throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); - } -#endif // WIN32 - } - - template - SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg& msg) - { +template +SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) + : mutex_(ConsoleMutex::mutex()), + file_(file), + formatter_(details::make_unique()) { #ifdef _WIN32 - if (handle_ == INVALID_HANDLE_VALUE) - { - return; - } - std::lock_guard lock(mutex_); - memory_buf_t formatted; - formatter_->format(msg, formatted); - auto size = static_cast(formatted.size()); - DWORD bytes_written = 0; - bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; - if (!ok) - { - throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); - } -#else - std::lock_guard lock(mutex_); - memory_buf_t formatted; - formatter_->format(msg, formatted); - ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); -#endif // WIN32 - ::fflush(file_); // flush every line to terminal - } - - template - SPDLOG_INLINE void stdout_sink_base::flush() - { - std::lock_guard lock(mutex_); - fflush(file_); - } - - template - SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string& pattern) - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - template - SPDLOG_INLINE void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - - // stdout sink - template - SPDLOG_INLINE stdout_sink::stdout_sink() : stdout_sink_base(stdout) - { - } - - // stderr sink - template - SPDLOG_INLINE stderr_sink::stderr_sink() : stdout_sink_base(stderr) - { - } - - } // namespace sinks - - // factory methods - template - SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string& logger_name) - { - return Factory::template create(logger_name); - } + // get windows handle from the FILE* object - template - SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string& logger_name) - { - return Factory::template create(logger_name); - } + handle_ = reinterpret_cast(::_get_osfhandle(::_fileno(file_))); - template - SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string& logger_name) - { - return Factory::template create(logger_name); + // don't throw to support cases where no console is attached, + // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). + // throw only if non stdout/stderr target is requested (probably regular file and not console). + if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { + throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); } +#endif // WIN32 +} - template - SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string& logger_name) - { - return Factory::template create(logger_name); +template +SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) { +#ifdef _WIN32 + if (handle_ == INVALID_HANDLE_VALUE) { + return; } -} // namespace spdlog + std::lock_guard lock(mutex_); + memory_buf_t formatted; + formatter_->format(msg, formatted); + auto size = static_cast(formatted.size()); + DWORD bytes_written = 0; + bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; + if (!ok) { + throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + + std::to_string(::GetLastError())); + } +#else + std::lock_guard lock(mutex_); + memory_buf_t formatted; + formatter_->format(msg, formatted); + ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); +#endif // WIN32 + ::fflush(file_); // flush every line to terminal +} + +template +SPDLOG_INLINE void stdout_sink_base::flush() { + std::lock_guard lock(mutex_); + fflush(file_); +} + +template +SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); +} + +template +SPDLOG_INLINE void stdout_sink_base::set_formatter( + std::unique_ptr sink_formatter) { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); +} + +// stdout sink +template +SPDLOG_INLINE stdout_sink::stdout_sink() + : stdout_sink_base(stdout) {} + +// stderr sink +template +SPDLOG_INLINE stderr_sink::stderr_sink() + : stdout_sink_base(stderr) {} + +} // namespace sinks + +// factory methods +template +SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) { + return Factory::template create(logger_name); +} + +template +SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) { + return Factory::template create(logger_name); +} + +template +SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) { + return Factory::template create(logger_name); +} + +template +SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) { + return Factory::template create(logger_name); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/stdout_sinks.h b/lib/spdlog/sinks/stdout_sinks.h index 32bc44a0..6ef09968 100644 --- a/lib/spdlog/sinks/stdout_sinks.h +++ b/lib/spdlog/sinks/stdout_sinks.h @@ -9,78 +9,76 @@ #include #ifdef _WIN32 -#include + #include #endif -namespace spdlog -{ +namespace spdlog { - namespace sinks - { +namespace sinks { - template - class stdout_sink_base : public sink { - public: - using mutex_t = typename ConsoleMutex::mutex_t; - explicit stdout_sink_base(FILE* file); - ~stdout_sink_base() override = default; +template +class stdout_sink_base : public sink { +public: + using mutex_t = typename ConsoleMutex::mutex_t; + explicit stdout_sink_base(FILE *file); + ~stdout_sink_base() override = default; - stdout_sink_base(const stdout_sink_base& other) = delete; - stdout_sink_base(stdout_sink_base&& other) = delete; + stdout_sink_base(const stdout_sink_base &other) = delete; + stdout_sink_base(stdout_sink_base &&other) = delete; - stdout_sink_base& operator=(const stdout_sink_base& other) = delete; - stdout_sink_base& operator=(stdout_sink_base&& other) = delete; + stdout_sink_base &operator=(const stdout_sink_base &other) = delete; + stdout_sink_base &operator=(stdout_sink_base &&other) = delete; - void log(const details::log_msg& msg) override; - void flush() override; - void set_pattern(const std::string& pattern) override; + void log(const details::log_msg &msg) override; + void flush() override; + void set_pattern(const std::string &pattern) override; - void set_formatter(std::unique_ptr sink_formatter) override; + void set_formatter(std::unique_ptr sink_formatter) override; - protected: - mutex_t& mutex_; - FILE* file_; - std::unique_ptr formatter_; +protected: + mutex_t &mutex_; + FILE *file_; + std::unique_ptr formatter_; #ifdef _WIN32 - HANDLE handle_; -#endif // WIN32 - }; + HANDLE handle_; +#endif // WIN32 +}; - template - class stdout_sink : public stdout_sink_base { - public: - stdout_sink(); - }; +template +class stdout_sink : public stdout_sink_base { +public: + stdout_sink(); +}; - template - class stderr_sink : public stdout_sink_base { - public: - stderr_sink(); - }; +template +class stderr_sink : public stdout_sink_base { +public: + stderr_sink(); +}; - using stdout_sink_mt = stdout_sink; - using stdout_sink_st = stdout_sink; +using stdout_sink_mt = stdout_sink; +using stdout_sink_st = stdout_sink; - using stderr_sink_mt = stderr_sink; - using stderr_sink_st = stderr_sink; +using stderr_sink_mt = stderr_sink; +using stderr_sink_st = stderr_sink; - } // namespace sinks +} // namespace sinks - // factory methods - template - std::shared_ptr stdout_logger_mt(const std::string& logger_name); +// factory methods +template +std::shared_ptr stdout_logger_mt(const std::string &logger_name); - template - std::shared_ptr stdout_logger_st(const std::string& logger_name); +template +std::shared_ptr stdout_logger_st(const std::string &logger_name); - template - std::shared_ptr stderr_logger_mt(const std::string& logger_name); +template +std::shared_ptr stderr_logger_mt(const std::string &logger_name); - template - std::shared_ptr stderr_logger_st(const std::string& logger_name); +template +std::shared_ptr stderr_logger_st(const std::string &logger_name); -} // namespace spdlog +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "stdout_sinks-inl.h" + #include "stdout_sinks-inl.h" #endif diff --git a/lib/spdlog/sinks/syslog_sink.h b/lib/spdlog/sinks/syslog_sink.h index f0d18d50..913d41be 100644 --- a/lib/spdlog/sinks/syslog_sink.h +++ b/lib/spdlog/sinks/syslog_sink.h @@ -11,91 +11,94 @@ #include #include -namespace spdlog -{ - namespace sinks - { - /** - * Sink that write to syslog using the `syscall()` library call. - */ - template - class syslog_sink : public base_sink { - public: - syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) : - enable_formatting_{enable_formatting}, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}}, - ident_{std::move(ident)} - { - // set ident to be program name if empty - ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); - } - - ~syslog_sink() override { ::closelog(); } - - syslog_sink(const syslog_sink&) = delete; - syslog_sink& operator=(const syslog_sink&) = delete; - - protected: - void sink_it_(const details::log_msg& msg) override - { - string_view_t payload; - memory_buf_t formatted; - if (enable_formatting_) - { - base_sink::formatter_->format(msg, formatted); - payload = string_view_t(formatted.data(), formatted.size()); - } - else - { - payload = msg.payload; - } - - size_t length = payload.size(); - // limit to max int - if (length > static_cast(std::numeric_limits::max())) - { - length = static_cast(std::numeric_limits::max()); - } - - ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast(length), payload.data()); - } - - void flush_() override {} - bool enable_formatting_ = false; - - // - // Simply maps spdlog's log level to syslog priority level. - // - virtual int syslog_prio_from_level(const details::log_msg& msg) const { return syslog_levels_.at(static_cast(msg.level)); } - - using levels_array = std::array; - levels_array syslog_levels_; - - private: - // must store the ident because the man says openlog might use the pointer as - // is and not a string copy - const std::string ident_; - }; - - using syslog_sink_mt = syslog_sink; - using syslog_sink_st = syslog_sink; - } // namespace sinks - - // Create and register a syslog logger - template - inline std::shared_ptr syslog_logger_mt(const std::string& logger_name, const std::string& syslog_ident = "", int syslog_option = 0, int syslog_facility = LOG_USER, bool enable_formatting = false) - { - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); +namespace spdlog { +namespace sinks { +/** + * Sink that write to syslog using the `syscall()` library call. + */ +template +class syslog_sink : public base_sink { +public: + syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) + : enable_formatting_{enable_formatting}, + syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, + /* spdlog::level::debug */ LOG_DEBUG, + /* spdlog::level::info */ LOG_INFO, + /* spdlog::level::warn */ LOG_WARNING, + /* spdlog::level::err */ LOG_ERR, + /* spdlog::level::critical */ LOG_CRIT, + /* spdlog::level::off */ LOG_INFO}}, + ident_{std::move(ident)} { + // set ident to be program name if empty + ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); } - template - inline std::shared_ptr syslog_logger_st(const std::string& logger_name, const std::string& syslog_ident = "", int syslog_option = 0, int syslog_facility = LOG_USER, bool enable_formatting = false) - { - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); + ~syslog_sink() override { ::closelog(); } + + syslog_sink(const syslog_sink &) = delete; + syslog_sink &operator=(const syslog_sink &) = delete; + +protected: + void sink_it_(const details::log_msg &msg) override { + string_view_t payload; + memory_buf_t formatted; + if (enable_formatting_) { + base_sink::formatter_->format(msg, formatted); + payload = string_view_t(formatted.data(), formatted.size()); + } else { + payload = msg.payload; + } + + size_t length = payload.size(); + // limit to max int + if (length > static_cast(std::numeric_limits::max())) { + length = static_cast(std::numeric_limits::max()); + } + + ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast(length), payload.data()); } -} // namespace spdlog + + void flush_() override {} + bool enable_formatting_ = false; + + // + // Simply maps spdlog's log level to syslog priority level. + // + virtual int syslog_prio_from_level(const details::log_msg &msg) const { + return syslog_levels_.at(static_cast(msg.level)); + } + + using levels_array = std::array; + levels_array syslog_levels_; + +private: + // must store the ident because the man says openlog might use the pointer as + // is and not a string copy + const std::string ident_; +}; + +using syslog_sink_mt = syslog_sink; +using syslog_sink_st = syslog_sink; +} // namespace sinks + +// Create and register a syslog logger +template +inline std::shared_ptr syslog_logger_mt(const std::string &logger_name, + const std::string &syslog_ident = "", + int syslog_option = 0, + int syslog_facility = LOG_USER, + bool enable_formatting = false) { + return Factory::template create(logger_name, syslog_ident, syslog_option, + syslog_facility, enable_formatting); +} + +template +inline std::shared_ptr syslog_logger_st(const std::string &logger_name, + const std::string &syslog_ident = "", + int syslog_option = 0, + int syslog_facility = LOG_USER, + bool enable_formatting = false) { + return Factory::template create(logger_name, syslog_ident, syslog_option, + syslog_facility, enable_formatting); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/systemd_sink.h b/lib/spdlog/sinks/systemd_sink.h index 947fc6d8..d2cd55f2 100644 --- a/lib/spdlog/sinks/systemd_sink.h +++ b/lib/spdlog/sinks/systemd_sink.h @@ -10,112 +10,112 @@ #include #ifndef SD_JOURNAL_SUPPRESS_LOCATION -#define SD_JOURNAL_SUPPRESS_LOCATION + #define SD_JOURNAL_SUPPRESS_LOCATION #endif #include -namespace spdlog -{ - namespace sinks - { - - /** - * Sink that write to systemd journal using the `sd_journal_send()` library - * call. - */ - template - class systemd_sink : public base_sink { - public: - systemd_sink(std::string ident = "", bool enable_formatting = false) : - ident_{std::move(ident)}, enable_formatting_{enable_formatting}, syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}} - { - } - - ~systemd_sink() override {} - - systemd_sink(const systemd_sink&) = delete; - systemd_sink& operator=(const systemd_sink&) = delete; - - protected: - const std::string ident_; - bool enable_formatting_ = false; - using levels_array = std::array; - levels_array syslog_levels_; - - void sink_it_(const details::log_msg& msg) override - { - int err; - string_view_t payload; - memory_buf_t formatted; - if (enable_formatting_) - { - base_sink::formatter_->format(msg, formatted); - payload = string_view_t(formatted.data(), formatted.size()); - } - else - { - payload = msg.payload; - } - - size_t length = payload.size(); - // limit to max int - if (length > static_cast(std::numeric_limits::max())) - { - length = static_cast(std::numeric_limits::max()); - } - - const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; - - // Do not send source location if not available - if (msg.source.empty()) - { - // Note: function call inside '()' to avoid macro expansion - err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), +namespace spdlog { +namespace sinks { + +/** + * Sink that write to systemd journal using the `sd_journal_send()` library call. + */ +template +class systemd_sink : public base_sink { +public: + systemd_sink(std::string ident = "", bool enable_formatting = false) + : ident_{std::move(ident)}, + enable_formatting_{enable_formatting}, + syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, + /* spdlog::level::debug */ LOG_DEBUG, + /* spdlog::level::info */ LOG_INFO, + /* spdlog::level::warn */ LOG_WARNING, + /* spdlog::level::err */ LOG_ERR, + /* spdlog::level::critical */ LOG_CRIT, + /* spdlog::level::off */ LOG_INFO}} {} + + ~systemd_sink() override {} + + systemd_sink(const systemd_sink &) = delete; + systemd_sink &operator=(const systemd_sink &) = delete; + +protected: + const std::string ident_; + bool enable_formatting_ = false; + using levels_array = std::array; + levels_array syslog_levels_; + + void sink_it_(const details::log_msg &msg) override { + int err; + string_view_t payload; + memory_buf_t formatted; + if (enable_formatting_) { + base_sink::formatter_->format(msg, formatted); + payload = string_view_t(formatted.data(), formatted.size()); + } else { + payload = msg.payload; + } + + size_t length = payload.size(); + // limit to max int + if (length > static_cast(std::numeric_limits::max())) { + length = static_cast(std::numeric_limits::max()); + } + + const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; + + // Do not send source location if not available + if (msg.source.empty()) { + // Note: function call inside '()' to avoid macro expansion + err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), + "PRIORITY=%d", syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", msg.thread_id, + "TID=%zu", msg.thread_id, #endif - "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), nullptr); - } - else - { - err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), + "SYSLOG_IDENTIFIER=%.*s", + static_cast(syslog_identifier.size()), + syslog_identifier.data(), nullptr); + } else { + err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), + "PRIORITY=%d", syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", msg.thread_id, + "TID=%zu", msg.thread_id, #endif - "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr); - } - - if (err) - { - throw_spdlog_ex("Failed writing to systemd", errno); - } - } - - int syslog_level(level::level_enum l) { return syslog_levels_.at(static_cast(l)); } - - void flush_() override {} - }; - - using systemd_sink_mt = systemd_sink; - using systemd_sink_st = systemd_sink; - } // namespace sinks - - // Create and register a syslog logger - template - inline std::shared_ptr systemd_logger_mt(const std::string& logger_name, const std::string& ident = "", bool enable_formatting = false) - { - return Factory::template create(logger_name, ident, enable_formatting); + "SYSLOG_IDENTIFIER=%.*s", + static_cast(syslog_identifier.size()), + syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, + "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", + msg.source.funcname, nullptr); + } + + if (err) { + throw_spdlog_ex("Failed writing to systemd", errno); + } } - template - inline std::shared_ptr systemd_logger_st(const std::string& logger_name, const std::string& ident = "", bool enable_formatting = false) - { - return Factory::template create(logger_name, ident, enable_formatting); + int syslog_level(level::level_enum l) { + return syslog_levels_.at(static_cast(l)); } -} // namespace spdlog + + void flush_() override {} +}; + +using systemd_sink_mt = systemd_sink; +using systemd_sink_st = systemd_sink; +} // namespace sinks + +// Create and register a syslog logger +template +inline std::shared_ptr systemd_logger_mt(const std::string &logger_name, + const std::string &ident = "", + bool enable_formatting = false) { + return Factory::template create(logger_name, ident, enable_formatting); +} + +template +inline std::shared_ptr systemd_logger_st(const std::string &logger_name, + const std::string &ident = "", + bool enable_formatting = false) { + return Factory::template create(logger_name, ident, enable_formatting); +} +} // namespace spdlog diff --git a/lib/spdlog/sinks/tcp_sink.h b/lib/spdlog/sinks/tcp_sink.h index 740cb091..25349645 100644 --- a/lib/spdlog/sinks/tcp_sink.h +++ b/lib/spdlog/sinks/tcp_sink.h @@ -7,9 +7,9 @@ #include #include #ifdef _WIN32 -#include + #include #else -#include + #include #endif #include @@ -22,57 +22,54 @@ // Simple tcp client sink // Connects to remote address and send the formatted log. // Will attempt to reconnect if connection drops. -// If more complicated behaviour is needed (i.e get responses), you can inherit -// it and override the sink_it_ method. +// If more complicated behaviour is needed (i.e get responses), you can inherit it and override the +// sink_it_ method. -namespace spdlog -{ - namespace sinks - { +namespace spdlog { +namespace sinks { - struct tcp_sink_config { - std::string server_host; - int server_port; - bool lazy_connect = false; // if true connect on first log call instead of on construction +struct tcp_sink_config { + std::string server_host; + int server_port; + bool lazy_connect = false; // if true connect on first log call instead of on construction - tcp_sink_config(std::string host, int port) : server_host{std::move(host)}, server_port{port} {} - }; + tcp_sink_config(std::string host, int port) + : server_host{std::move(host)}, + server_port{port} {} +}; - template - class tcp_sink : public spdlog::sinks::base_sink { - public: - // connect to tcp host/port or throw if failed - // host can be hostname or ip address +template +class tcp_sink : public spdlog::sinks::base_sink { +public: + // connect to tcp host/port or throw if failed + // host can be hostname or ip address - explicit tcp_sink(tcp_sink_config sink_config) : config_{std::move(sink_config)} - { - if (!config_.lazy_connect) - { - this->client_.connect(config_.server_host, config_.server_port); - } - } + explicit tcp_sink(tcp_sink_config sink_config) + : config_{std::move(sink_config)} { + if (!config_.lazy_connect) { + this->client_.connect(config_.server_host, config_.server_port); + } + } - ~tcp_sink() override = default; + ~tcp_sink() override = default; - protected: - void sink_it_(const spdlog::details::log_msg& msg) override - { - spdlog::memory_buf_t formatted; - spdlog::sinks::base_sink::formatter_->format(msg, formatted); - if (!client_.is_connected()) - { - client_.connect(config_.server_host, config_.server_port); - } - client_.send(formatted.data(), formatted.size()); - } +protected: + void sink_it_(const spdlog::details::log_msg &msg) override { + spdlog::memory_buf_t formatted; + spdlog::sinks::base_sink::formatter_->format(msg, formatted); + if (!client_.is_connected()) { + client_.connect(config_.server_host, config_.server_port); + } + client_.send(formatted.data(), formatted.size()); + } - void flush_() override {} - tcp_sink_config config_; - details::tcp_client client_; - }; + void flush_() override {} + tcp_sink_config config_; + details::tcp_client client_; +}; - using tcp_sink_mt = tcp_sink; - using tcp_sink_st = tcp_sink; +using tcp_sink_mt = tcp_sink; +using tcp_sink_st = tcp_sink; - } // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/udp_sink.h b/lib/spdlog/sinks/udp_sink.h index 7625e14a..4bff0fd2 100644 --- a/lib/spdlog/sinks/udp_sink.h +++ b/lib/spdlog/sinks/udp_sink.h @@ -7,9 +7,9 @@ #include #include #ifdef _WIN32 -#include + #include #else -#include + #include #endif #include @@ -20,50 +20,50 @@ // Simple udp client sink // Sends formatted log via udp -namespace spdlog -{ - namespace sinks - { +namespace spdlog { +namespace sinks { - struct udp_sink_config { - std::string server_host; - uint16_t server_port; +struct udp_sink_config { + std::string server_host; + uint16_t server_port; - udp_sink_config(std::string host, uint16_t port) : server_host{std::move(host)}, server_port{port} {} - }; + udp_sink_config(std::string host, uint16_t port) + : server_host{std::move(host)}, + server_port{port} {} +}; - template - class udp_sink : public spdlog::sinks::base_sink { - public: - // host can be hostname or ip address - explicit udp_sink(udp_sink_config sink_config) : client_{sink_config.server_host, sink_config.server_port} {} +template +class udp_sink : public spdlog::sinks::base_sink { +public: + // host can be hostname or ip address + explicit udp_sink(udp_sink_config sink_config) + : client_{sink_config.server_host, sink_config.server_port} {} - ~udp_sink() override = default; + ~udp_sink() override = default; - protected: - void sink_it_(const spdlog::details::log_msg& msg) override - { - spdlog::memory_buf_t formatted; - spdlog::sinks::base_sink::formatter_->format(msg, formatted); - client_.send(formatted.data(), formatted.size()); - } +protected: + void sink_it_(const spdlog::details::log_msg &msg) override { + spdlog::memory_buf_t formatted; + spdlog::sinks::base_sink::formatter_->format(msg, formatted); + client_.send(formatted.data(), formatted.size()); + } - void flush_() override {} - details::udp_client client_; - }; + void flush_() override {} + details::udp_client client_; +}; - using udp_sink_mt = udp_sink; - using udp_sink_st = udp_sink; +using udp_sink_mt = udp_sink; +using udp_sink_st = udp_sink; - } // namespace sinks +} // namespace sinks - // - // factory functions - // - template - inline std::shared_ptr udp_logger_mt(const std::string& logger_name, sinks::udp_sink_config skin_config) - { - return Factory::template create(logger_name, skin_config); - } +// +// factory functions +// +template +inline std::shared_ptr udp_logger_mt(const std::string &logger_name, + sinks::udp_sink_config skin_config) { + return Factory::template create(logger_name, skin_config); +} -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/sinks/win_eventlog_sink.h b/lib/spdlog/sinks/win_eventlog_sink.h index c9c4fa53..2c9b582d 100644 --- a/lib/spdlog/sinks/win_eventlog_sink.h +++ b/lib/spdlog/sinks/win_eventlog_sink.h @@ -1,22 +1,20 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -// Writing to Windows Event Log requires the registry entries below to be -// present, with the following modifications: -// 1. should be replaced with your log name (e.g. your application -// name) -// 2. should be replaced with the specific source name and the key -// should be duplicated for +// Writing to Windows Event Log requires the registry entries below to be present, with the +// following modifications: +// 1. should be replaced with your log name (e.g. your application name) +// 2. should be replaced with the specific source name and the key should be +// duplicated for // each source used in the application // -// Since typically modifications of this kind require elevation, it's better to -// do it as a part of setup procedure. The snippet below uses mscoree.dll as the -// message file as it exists on most of the Windows systems anyway and happens -// to contain the needed resource. +// Since typically modifications of this kind require elevation, it's better to do it as a part of +// setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of +// the Windows systems anyway and happens to contain the needed resource. // // You can also specify a custom message file if needed. -// Please refer to Event Log functions descriptions in MSDN for more details on -// custom message files. +// Please refer to Event Log functions descriptions in MSDN for more details on custom message +// files. /*--------------------------------------------------------------------------------------- @@ -45,235 +43,218 @@ Windows Registry Editor Version 5.00 #include #include -namespace spdlog -{ - namespace sinks - { - - namespace win_eventlog - { - - namespace internal - { - - struct local_alloc_t { - HLOCAL hlocal_; - - SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} - - local_alloc_t(local_alloc_t const&) = delete; - local_alloc_t& operator=(local_alloc_t const&) = delete; - - ~local_alloc_t() SPDLOG_NOEXCEPT - { - if (hlocal_) - { - LocalFree(hlocal_); - } - } - }; - - /** Windows error */ - struct win32_error : public spdlog_ex { - /** Formats an error report line: "user-message: error-code (system message)" - */ - static std::string format(std::string const& user_message, DWORD error_code = GetLastError()) - { - std::string system_message; - - local_alloc_t format_message_result{}; - auto format_message_succeeded = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr); - - if (format_message_succeeded && format_message_result.hlocal_) - { - system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); - } - - return fmt_lib::format("{}: {}{}", user_message, error_code, system_message); - } - - explicit win32_error(std::string const& func_name, DWORD error = GetLastError()) : spdlog_ex(format(func_name, error)) {} - }; - - /** Wrapper for security identifiers (SID) on Windows */ - struct sid_t { - std::vector buffer_; - - public: - sid_t() {} - - /** creates a wrapped SID copy */ - static sid_t duplicate_sid(PSID psid) - { - if (!::IsValidSid(psid)) - { - throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); - } - - auto const sid_length{::GetLengthSid(psid)}; - - sid_t result; - result.buffer_.resize(sid_length); - if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) - { - SPDLOG_THROW(win32_error("CopySid")); - } - - return result; - } - - /** Retrieves pointer to the internal buffer contents as SID* */ - SID* as_sid() const { return buffer_.empty() ? nullptr : (SID*)buffer_.data(); } - - /** Get SID for the current user */ - static sid_t get_current_user_sid() - { - /* create and init RAII holder for process token */ - struct process_token_t { - HANDLE token_handle_ = INVALID_HANDLE_VALUE; - explicit process_token_t(HANDLE process) - { - if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) - { - SPDLOG_THROW(win32_error("OpenProcessToken")); - } - } - - ~process_token_t() { ::CloseHandle(token_handle_); } - - } current_process_token(::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no - // leak here! - - // Get the required size, this is expected to fail with - // ERROR_INSUFFICIENT_BUFFER and return the token size - DWORD tusize = 0; - if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) - { - SPDLOG_THROW(win32_error("GetTokenInformation should fail")); - } - - // get user token - std::vector buffer(static_cast(tusize)); - if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, &tusize)) - { - SPDLOG_THROW(win32_error("GetTokenInformation")); - } - - // create a wrapper of the SID data as stored in the user token - return sid_t::duplicate_sid(((TOKEN_USER*)buffer.data())->User.Sid); - } - }; - - struct eventlog { - static WORD get_event_type(details::log_msg const& msg) - { - switch (msg.level) - { - case level::trace: - case level::debug: - return EVENTLOG_SUCCESS; - - case level::info: - return EVENTLOG_INFORMATION_TYPE; - - case level::warn: - return EVENTLOG_WARNING_TYPE; - - case level::err: - case level::critical: - case level::off: - return EVENTLOG_ERROR_TYPE; - - default: - return EVENTLOG_INFORMATION_TYPE; - } - } - - static WORD get_event_category(details::log_msg const& msg) { return (WORD)msg.level; } - }; - - } // namespace internal - - /* - * Windows Event Log sink - */ - template - class win_eventlog_sink : public base_sink { - private: - HANDLE hEventLog_{NULL}; - internal::sid_t current_user_sid_; - std::string source_; - DWORD event_id_; - - HANDLE event_log_handle() - { - if (!hEventLog_) - { - hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); - if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) - { - SPDLOG_THROW(internal::win32_error("RegisterEventSource")); - } - } - - return hEventLog_; - } +namespace spdlog { +namespace sinks { - protected: - void sink_it_(const details::log_msg& msg) override - { - using namespace internal; +namespace win_eventlog { - bool succeeded; - memory_buf_t formatted; - base_sink::formatter_->format(msg, formatted); - formatted.push_back('\0'); +namespace internal { -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - wmemory_buf_t buf; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); +struct local_alloc_t { + HLOCAL hlocal_; - LPCWSTR lp_wstr = buf.data(); - succeeded = static_cast(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); -#else - LPCSTR lp_str = formatted.data(); - succeeded = static_cast(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); -#endif + SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} - if (!succeeded) - { - SPDLOG_THROW(win32_error("ReportEvent")); - } - } + local_alloc_t(local_alloc_t const &) = delete; + local_alloc_t &operator=(local_alloc_t const &) = delete; - void flush_() override {} - - public: - win_eventlog_sink(std::string const& source, DWORD event_id = 1000 /* according to mscoree.dll */) : source_(source), event_id_(event_id) - { - try - { - current_user_sid_ = internal::sid_t::get_current_user_sid(); - } - catch (...) - { - // get_current_user_sid() is unlikely to fail and if it does, we can still - // proceed without current_user_sid but in the event log the record will - // have no user name - } - } + ~local_alloc_t() SPDLOG_NOEXCEPT { + if (hlocal_) { + LocalFree(hlocal_); + } + } +}; + +/** Windows error */ +struct win32_error : public spdlog_ex { + /** Formats an error report line: "user-message: error-code (system message)" */ + static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) { + std::string system_message; + + local_alloc_t format_message_result{}; + auto format_message_succeeded = + ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPSTR)&format_message_result.hlocal_, 0, nullptr); + + if (format_message_succeeded && format_message_result.hlocal_) { + system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); + } + + return fmt_lib::format("{}: {}{}", user_message, error_code, system_message); + } + + explicit win32_error(std::string const &func_name, DWORD error = GetLastError()) + : spdlog_ex(format(func_name, error)) {} +}; - ~win_eventlog_sink() - { - if (hEventLog_) - DeregisterEventSource(hEventLog_); +/** Wrapper for security identifiers (SID) on Windows */ +struct sid_t { + std::vector buffer_; + +public: + sid_t() {} + + /** creates a wrapped SID copy */ + static sid_t duplicate_sid(PSID psid) { + if (!::IsValidSid(psid)) { + throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); + } + + auto const sid_length{::GetLengthSid(psid)}; + + sid_t result; + result.buffer_.resize(sid_length); + if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) { + SPDLOG_THROW(win32_error("CopySid")); + } + + return result; + } + + /** Retrieves pointer to the internal buffer contents as SID* */ + SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); } + + /** Get SID for the current user */ + static sid_t get_current_user_sid() { + /* create and init RAII holder for process token */ + struct process_token_t { + HANDLE token_handle_ = INVALID_HANDLE_VALUE; + explicit process_token_t(HANDLE process) { + if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) { + SPDLOG_THROW(win32_error("OpenProcessToken")); } - }; + } + + ~process_token_t() { ::CloseHandle(token_handle_); } + + } current_process_token( + ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! + + // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return + // the token size + DWORD tusize = 0; + if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, + &tusize)) { + SPDLOG_THROW(win32_error("GetTokenInformation should fail")); + } + + // get user token + std::vector buffer(static_cast(tusize)); + if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, + (LPVOID)buffer.data(), tusize, &tusize)) { + SPDLOG_THROW(win32_error("GetTokenInformation")); + } + + // create a wrapper of the SID data as stored in the user token + return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid); + } +}; + +struct eventlog { + static WORD get_event_type(details::log_msg const &msg) { + switch (msg.level) { + case level::trace: + case level::debug: + return EVENTLOG_SUCCESS; + + case level::info: + return EVENTLOG_INFORMATION_TYPE; + + case level::warn: + return EVENTLOG_WARNING_TYPE; + + case level::err: + case level::critical: + case level::off: + return EVENTLOG_ERROR_TYPE; + + default: + return EVENTLOG_INFORMATION_TYPE; + } + } + + static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; } +}; + +} // namespace internal + +/* + * Windows Event Log sink + */ +template +class win_eventlog_sink : public base_sink { +private: + HANDLE hEventLog_{NULL}; + internal::sid_t current_user_sid_; + std::string source_; + DWORD event_id_; + + HANDLE event_log_handle() { + if (!hEventLog_) { + hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); + if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) { + SPDLOG_THROW(internal::win32_error("RegisterEventSource")); + } + } + + return hEventLog_; + } + +protected: + void sink_it_(const details::log_msg &msg) override { + using namespace internal; + + bool succeeded; + memory_buf_t formatted; + base_sink::formatter_->format(msg, formatted); + formatted.push_back('\0'); - } // namespace win_eventlog +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT + wmemory_buf_t buf; + details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); - using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink; - using win_eventlog_sink_st = win_eventlog::win_eventlog_sink; + LPCWSTR lp_wstr = buf.data(); + succeeded = static_cast(::ReportEventW( + event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), + event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); +#else + LPCSTR lp_str = formatted.data(); + succeeded = static_cast(::ReportEventA( + event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), + event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); +#endif - } // namespace sinks -} // namespace spdlog + if (!succeeded) { + SPDLOG_THROW(win32_error("ReportEvent")); + } + } + + void flush_() override {} + +public: + win_eventlog_sink(std::string const &source, + DWORD event_id = 1000 /* according to mscoree.dll */) + : source_(source), + event_id_(event_id) { + try { + current_user_sid_ = internal::sid_t::get_current_user_sid(); + } catch (...) { + // get_current_user_sid() is unlikely to fail and if it does, we can still proceed + // without current_user_sid but in the event log the record will have no user name + } + } + + ~win_eventlog_sink() { + if (hEventLog_) DeregisterEventSource(hEventLog_); + } +}; + +} // namespace win_eventlog + +using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink; +using win_eventlog_sink_st = win_eventlog::win_eventlog_sink; + +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/wincolor_sink-inl.h b/lib/spdlog/sinks/wincolor_sink-inl.h index 51bc6025..696db566 100644 --- a/lib/spdlog/sinks/wincolor_sink-inl.h +++ b/lib/spdlog/sinks/wincolor_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include @@ -13,169 +13,160 @@ #include #include -namespace spdlog -{ - namespace sinks +namespace spdlog { +namespace sinks { +template +SPDLOG_INLINE wincolor_sink::wincolor_sink(void *out_handle, color_mode mode) + : out_handle_(out_handle), + mutex_(ConsoleMutex::mutex()), + formatter_(details::make_unique()) { + set_color_mode_impl(mode); + // set level colors + colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white + colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan + colors_[level::info] = FOREGROUND_GREEN; // green + colors_[level::warn] = + FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow + colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red + colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | + FOREGROUND_BLUE | + FOREGROUND_INTENSITY; // intense white on red background + colors_[level::off] = 0; +} + +template +SPDLOG_INLINE wincolor_sink::~wincolor_sink() { + this->flush(); +} + +// change the color for the given level +template +void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, + std::uint16_t color) { + std::lock_guard lock(mutex_); + colors_[static_cast(level)] = color; +} + +template +void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) { + if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) { + return; + } + + std::lock_guard lock(mutex_); + msg.color_range_start = 0; + msg.color_range_end = 0; + memory_buf_t formatted; + formatter_->format(msg, formatted); + if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { + // before color range + print_range_(formatted, 0, msg.color_range_start); + // in color range + auto orig_attribs = + static_cast(set_foreground_color_(colors_[static_cast(msg.level)])); + print_range_(formatted, msg.color_range_start, msg.color_range_end); + // reset to orig colors + ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs); + print_range_(formatted, msg.color_range_end, formatted.size()); + } else // print without colors if color range is invalid (or color is disabled) { - template - SPDLOG_INLINE wincolor_sink::wincolor_sink(void* out_handle, color_mode mode) : out_handle_(out_handle), mutex_(ConsoleMutex::mutex()), formatter_(details::make_unique()) - { - set_color_mode_impl(mode); - // set level colors - colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white - colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan - colors_[level::info] = FOREGROUND_GREEN; // green - colors_[level::warn] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow - colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red - colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background - colors_[level::off] = 0; - } - - template - SPDLOG_INLINE wincolor_sink::~wincolor_sink() - { - this->flush(); - } - - // change the color for the given level - template - void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, std::uint16_t color) - { - std::lock_guard lock(mutex_); - colors_[static_cast(level)] = color; - } - - template - void SPDLOG_INLINE wincolor_sink::log(const details::log_msg& msg) - { - if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) - { - return; - } - - std::lock_guard lock(mutex_); - msg.color_range_start = 0; - msg.color_range_end = 0; - memory_buf_t formatted; - formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) - { - // before color range - print_range_(formatted, 0, msg.color_range_start); - // in color range - auto orig_attribs = static_cast(set_foreground_color_(colors_[static_cast(msg.level)])); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - // reset to orig colors - ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs); - print_range_(formatted, msg.color_range_end, formatted.size()); - } - else // print without colors if color range is invalid (or color is - // disabled) - { - write_to_file_(formatted); - } - } - - template - void SPDLOG_INLINE wincolor_sink::flush() - { - // windows console always flushed? - } - - template - void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string& pattern) - { - std::lock_guard lock(mutex_); - formatter_ = std::unique_ptr(new pattern_formatter(pattern)); - } - - template - void SPDLOG_INLINE wincolor_sink::set_formatter(std::unique_ptr sink_formatter) - { - std::lock_guard lock(mutex_); - formatter_ = std::move(sink_formatter); - } - - template - void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) - { - std::lock_guard lock(mutex_); - set_color_mode_impl(mode); - } - - template - void SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) - { - if (mode == color_mode::automatic) - { - // should do colors only if out_handle_ points to actual console. - DWORD console_mode; - bool in_console = ::GetConsoleMode(static_cast(out_handle_), &console_mode) != 0; - should_do_colors_ = in_console; - } - else - { - should_do_colors_ = mode == color_mode::always ? true : false; - } - } - - // set foreground color and return the orig console attributes (for resetting - // later) - template - std::uint16_t SPDLOG_INLINE wincolor_sink::set_foreground_color_(std::uint16_t attribs) - { - CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; - if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) - { - // just return white if failed getting console info - return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; - } - - // change only the foreground bits (lowest 4 bits) - auto new_attribs = static_cast(attribs) | (orig_buffer_info.wAttributes & 0xfff0); - auto ignored = ::SetConsoleTextAttribute(static_cast(out_handle_), static_cast(new_attribs)); - (void)(ignored); - return static_cast(orig_buffer_info.wAttributes); // return orig attribs - } - - // print a range of formatted message to console - template - void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t& formatted, size_t start, size_t end) - { - if (end > start) - { + write_to_file_(formatted); + } +} + +template +void SPDLOG_INLINE wincolor_sink::flush() { + // windows console always flushed? +} + +template +void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) { + std::lock_guard lock(mutex_); + formatter_ = std::unique_ptr(new pattern_formatter(pattern)); +} + +template +void SPDLOG_INLINE +wincolor_sink::set_formatter(std::unique_ptr sink_formatter) { + std::lock_guard lock(mutex_); + formatter_ = std::move(sink_formatter); +} + +template +void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) { + std::lock_guard lock(mutex_); + set_color_mode_impl(mode); +} + +template +void SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) { + if (mode == color_mode::automatic) { + // should do colors only if out_handle_ points to actual console. + DWORD console_mode; + bool in_console = ::GetConsoleMode(static_cast(out_handle_), &console_mode) != 0; + should_do_colors_ = in_console; + } else { + should_do_colors_ = mode == color_mode::always ? true : false; + } +} + +// set foreground color and return the orig console attributes (for resetting later) +template +std::uint16_t SPDLOG_INLINE +wincolor_sink::set_foreground_color_(std::uint16_t attribs) { + CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; + if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) { + // just return white if failed getting console info + return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; + } + + // change only the foreground bits (lowest 4 bits) + auto new_attribs = static_cast(attribs) | (orig_buffer_info.wAttributes & 0xfff0); + auto ignored = + ::SetConsoleTextAttribute(static_cast(out_handle_), static_cast(new_attribs)); + (void)(ignored); + return static_cast(orig_buffer_info.wAttributes); // return orig attribs +} + +// print a range of formatted message to console +template +void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted, + size_t start, + size_t end) { + if (end > start) { #if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE) - wmemory_buf_t wformatted; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start), wformatted); - auto size = static_cast(wformatted.size()); - auto ignored = ::WriteConsoleW(static_cast(out_handle_), wformatted.data(), size, nullptr, nullptr); + wmemory_buf_t wformatted; + details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start), + wformatted); + auto size = static_cast(wformatted.size()); + auto ignored = ::WriteConsoleW(static_cast(out_handle_), wformatted.data(), size, + nullptr, nullptr); #else - auto size = static_cast(end - start); - auto ignored = ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start, size, nullptr, nullptr); + auto size = static_cast(end - start); + auto ignored = ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start, + size, nullptr, nullptr); #endif - (void)(ignored); - } - } - - template - void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t& formatted) - { - auto size = static_cast(formatted.size()); - DWORD bytes_written = 0; - auto ignored = ::WriteFile(static_cast(out_handle_), formatted.data(), size, &bytes_written, nullptr); - (void)(ignored); - } - - // wincolor_stdout_sink - template - SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) - { - } - - // wincolor_stderr_sink - template - SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) - { - } - } // namespace sinks -} // namespace spdlog + (void)(ignored); + } +} + +template +void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) { + auto size = static_cast(formatted.size()); + DWORD bytes_written = 0; + auto ignored = ::WriteFile(static_cast(out_handle_), formatted.data(), size, + &bytes_written, nullptr); + (void)(ignored); +} + +// wincolor_stdout_sink +template +SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) + : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {} + +// wincolor_stderr_sink +template +SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) + : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} +} // namespace sinks +} // namespace spdlog diff --git a/lib/spdlog/sinks/wincolor_sink.h b/lib/spdlog/sinks/wincolor_sink.h index 26324612..8ba594cc 100644 --- a/lib/spdlog/sinks/wincolor_sink.h +++ b/lib/spdlog/sinks/wincolor_sink.h @@ -14,72 +14,69 @@ #include #include -namespace spdlog -{ - namespace sinks - { - /* - * Windows color console sink. Uses WriteConsoleA to write to the console with - * colors - */ - template - class wincolor_sink : public sink { - public: - wincolor_sink(void* out_handle, color_mode mode); - ~wincolor_sink() override; - - 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, std::uint16_t color); - void log(const details::log_msg& msg) final override; - void flush() final override; - void set_pattern(const std::string& pattern) override final; - void set_formatter(std::unique_ptr sink_formatter) override final; - void set_color_mode(color_mode mode); - - protected: - using mutex_t = typename ConsoleMutex::mutex_t; - void* out_handle_; - mutex_t& mutex_; - bool should_do_colors_; - std::unique_ptr formatter_; - std::array colors_; - - // set foreground color and return the orig console attributes (for resetting - // later) - std::uint16_t set_foreground_color_(std::uint16_t attribs); - - // print a range of formatted message to console - void print_range_(const memory_buf_t& formatted, size_t start, size_t end); - - // in case we are redirected to file (not in console mode) - void write_to_file_(const memory_buf_t& formatted); - - void set_color_mode_impl(color_mode mode); - }; - - template - class wincolor_stdout_sink : public wincolor_sink { - public: - explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); - }; - - template - class wincolor_stderr_sink : public wincolor_sink { - public: - explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); - }; - - using wincolor_stdout_sink_mt = wincolor_stdout_sink; - using wincolor_stdout_sink_st = wincolor_stdout_sink; - - using wincolor_stderr_sink_mt = wincolor_stderr_sink; - using wincolor_stderr_sink_st = wincolor_stderr_sink; - } // namespace sinks -} // namespace spdlog +namespace spdlog { +namespace sinks { +/* + * Windows color console sink. Uses WriteConsoleA to write to the console with + * colors + */ +template +class wincolor_sink : public sink { +public: + wincolor_sink(void *out_handle, color_mode mode); + ~wincolor_sink() override; + + 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, std::uint16_t color); + void log(const details::log_msg &msg) final override; + void flush() final override; + void set_pattern(const std::string &pattern) override final; + void set_formatter(std::unique_ptr sink_formatter) override final; + void set_color_mode(color_mode mode); + +protected: + using mutex_t = typename ConsoleMutex::mutex_t; + void *out_handle_; + mutex_t &mutex_; + bool should_do_colors_; + std::unique_ptr formatter_; + std::array colors_; + + // set foreground color and return the orig console attributes (for resetting later) + std::uint16_t set_foreground_color_(std::uint16_t attribs); + + // print a range of formatted message to console + void print_range_(const memory_buf_t &formatted, size_t start, size_t end); + + // in case we are redirected to file (not in console mode) + void write_to_file_(const memory_buf_t &formatted); + + void set_color_mode_impl(color_mode mode); +}; + +template +class wincolor_stdout_sink : public wincolor_sink { +public: + explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); +}; + +template +class wincolor_stderr_sink : public wincolor_sink { +public: + explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); +}; + +using wincolor_stdout_sink_mt = wincolor_stdout_sink; +using wincolor_stdout_sink_st = wincolor_stdout_sink; + +using wincolor_stderr_sink_mt = wincolor_stderr_sink; +using wincolor_stderr_sink_st = wincolor_stderr_sink; +} // namespace sinks +} // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -#include "wincolor_sink-inl.h" + #include "wincolor_sink-inl.h" #endif diff --git a/lib/spdlog/spdlog-inl.h b/lib/spdlog/spdlog-inl.h index 02e3f414..97c36222 100644 --- a/lib/spdlog/spdlog-inl.h +++ b/lib/spdlog/spdlog-inl.h @@ -4,57 +4,89 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -#include + #include #endif #include #include -namespace spdlog -{ +namespace spdlog { - SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } +SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { + details::registry::instance().initialize_logger(std::move(logger)); +} - SPDLOG_INLINE std::shared_ptr get(const std::string& name) { return details::registry::instance().get(name); } +SPDLOG_INLINE std::shared_ptr get(const std::string &name) { + return details::registry::instance().get(name); +} - SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) { details::registry::instance().set_formatter(std::move(formatter)); } +SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) { + details::registry::instance().set_formatter(std::move(formatter)); +} - SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } +SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { + set_formatter( + std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); +} - SPDLOG_INLINE void enable_backtrace(size_t n_messages) { details::registry::instance().enable_backtrace(n_messages); } +SPDLOG_INLINE void enable_backtrace(size_t n_messages) { + details::registry::instance().enable_backtrace(n_messages); +} - SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } +SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } - SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } +SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } - SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } +SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } - SPDLOG_INLINE bool should_log(level::level_enum log_level) { return default_logger_raw()->should_log(log_level); } +SPDLOG_INLINE bool should_log(level::level_enum log_level) { + return default_logger_raw()->should_log(log_level); +} - SPDLOG_INLINE void set_level(level::level_enum log_level) { details::registry::instance().set_level(log_level); } +SPDLOG_INLINE void set_level(level::level_enum log_level) { + details::registry::instance().set_level(log_level); +} - SPDLOG_INLINE void flush_on(level::level_enum log_level) { details::registry::instance().flush_on(log_level); } +SPDLOG_INLINE void flush_on(level::level_enum log_level) { + details::registry::instance().flush_on(log_level); +} - SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string& msg)) { details::registry::instance().set_error_handler(handler); } +SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) { + details::registry::instance().set_error_handler(handler); +} - SPDLOG_INLINE void register_logger(std::shared_ptr logger) { details::registry::instance().register_logger(std::move(logger)); } +SPDLOG_INLINE void register_logger(std::shared_ptr logger) { + details::registry::instance().register_logger(std::move(logger)); +} - SPDLOG_INLINE void apply_all(const std::function)>& fun) { details::registry::instance().apply_all(fun); } +SPDLOG_INLINE void apply_all(const std::function)> &fun) { + details::registry::instance().apply_all(fun); +} - SPDLOG_INLINE void drop(const std::string& name) { details::registry::instance().drop(name); } +SPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); } - SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } +SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } - SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } +SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } - SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { details::registry::instance().set_automatic_registration(automatic_registration); } +SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { + details::registry::instance().set_automatic_registration(automatic_registration); +} - SPDLOG_INLINE std::shared_ptr default_logger() { return details::registry::instance().default_logger(); } +SPDLOG_INLINE std::shared_ptr default_logger() { + return details::registry::instance().default_logger(); +} - SPDLOG_INLINE spdlog::logger* default_logger_raw() { return details::registry::instance().get_default_raw(); } +SPDLOG_INLINE spdlog::logger *default_logger_raw() { + return details::registry::instance().get_default_raw(); +} - SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) { details::registry::instance().set_default_logger(std::move(default_logger)); } +SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) { + details::registry::instance().set_default_logger(std::move(default_logger)); +} - SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) { details::registry::instance().apply_logger_env_levels(std::move(logger)); } +SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) { + details::registry::instance().apply_logger_env_levels(std::move(logger)); +} -} // namespace spdlog +} // namespace spdlog diff --git a/lib/spdlog/spdlog.h b/lib/spdlog/spdlog.h index 7b0b2f85..a8afbcec 100644 --- a/lib/spdlog/spdlog.h +++ b/lib/spdlog/spdlog.h @@ -20,278 +20,255 @@ #include #include -namespace spdlog -{ - - using default_factory = synchronous_factory; - - // Create and register a logger with a templated sink type - // The logger's level, formatter and flush level will be set according the - // global settings. - // - // Example: - // spdlog::create("logger_name", "dailylog_filename", 11, - // 59); - template - inline std::shared_ptr create(std::string logger_name, SinkArgs&&... sink_args) - { - return default_factory::create(std::move(logger_name), std::forward(sink_args)...); - } - - // Initialize and register a logger, - // formatter and flush level will be set according the global settings. - // - // Useful for initializing manually created loggers with the global settings. - // - // Example: - // auto mylogger = std::make_shared("mylogger", ...); - // spdlog::initialize_logger(mylogger); - SPDLOG_API void initialize_logger(std::shared_ptr logger); - - // Return an existing logger or nullptr if a logger with such name doesn't - // exist. - // example: spdlog::get("my_logger")->info("hello {}", "world"); - SPDLOG_API std::shared_ptr get(const std::string& name); - - // Set global formatter. Each sink in each logger will get a clone of this - // object - SPDLOG_API void set_formatter(std::unique_ptr formatter); - - // Set global format string. - // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); - SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); - - // enable global backtrace support - SPDLOG_API void enable_backtrace(size_t n_messages); - - // disable global backtrace support - SPDLOG_API void disable_backtrace(); - - // call dump backtrace on default logger - SPDLOG_API void dump_backtrace(); - - // Get global logging level - SPDLOG_API level::level_enum get_level(); - - // Set global logging level - SPDLOG_API void set_level(level::level_enum log_level); - - // Determine whether the default logger should log messages with a certain level - SPDLOG_API bool should_log(level::level_enum lvl); - - // Set global flush level - SPDLOG_API void flush_on(level::level_enum log_level); - - // Start/Restart a periodic flusher thread - // Warning: Use only if all your loggers are thread safe! - template - inline void flush_every(std::chrono::duration interval) - { - details::registry::instance().flush_every(interval); - } - - // Set global error handler - SPDLOG_API void set_error_handler(void (*handler)(const std::string& msg)); - - // Register the given logger with the given name - SPDLOG_API void register_logger(std::shared_ptr logger); - - // Apply a user defined function on all registered loggers - // Example: - // spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); - SPDLOG_API void apply_all(const std::function)>& fun); - - // Drop the reference to the given logger - SPDLOG_API void drop(const std::string& name); - - // Drop all references from the registry - SPDLOG_API void drop_all(); - - // stop any running threads started by spdlog and clean registry loggers - SPDLOG_API void shutdown(); - - // Automatic registration of loggers when using spdlog::create() or - // spdlog::create_async - SPDLOG_API void set_automatic_registration(bool automatic_registration); - - // API for using default logger (stdout_color_mt), - // e.g: spdlog::info("Message {}", 1); - // - // The default logger object can be accessed using the spdlog::default_logger(): - // For example, to add another sink to it: - // spdlog::default_logger()->sinks().push_back(some_sink); - // - // The default logger can replaced using spdlog::set_default_logger(new_logger). - // For example, to replace it with a file logger. - // - // IMPORTANT: - // The default API is thread safe (for _mt loggers), but: - // set_default_logger() *should not* be used concurrently with the default API. - // e.g do not call set_default_logger() from one thread while calling - // spdlog::info() from another. - - SPDLOG_API std::shared_ptr default_logger(); - - SPDLOG_API spdlog::logger* default_logger_raw(); - - SPDLOG_API void set_default_logger(std::shared_ptr default_logger); - - // Initialize logger level based on environment configs. - // - // Useful for applying SPDLOG_LEVEL to manually created loggers. - // - // Example: - // auto mylogger = std::make_shared("mylogger", ...); - // spdlog::apply_logger_env_levels(mylogger); - SPDLOG_API void apply_logger_env_levels(std::shared_ptr logger); - - template - inline void log(source_loc source, level::level_enum lvl, format_string_t fmt, Args&&... args) - { - default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); - } - - template - inline void log(level::level_enum lvl, format_string_t fmt, Args&&... args) - { - default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); - } - - template - inline void trace(format_string_t fmt, Args&&... args) - { - default_logger_raw()->trace(fmt, std::forward(args)...); - } - - template - inline void debug(format_string_t fmt, Args&&... args) - { - default_logger_raw()->debug(fmt, std::forward(args)...); - } - - template - inline void info(format_string_t fmt, Args&&... args) - { - default_logger_raw()->info(fmt, std::forward(args)...); - } - - template - inline void warn(format_string_t fmt, Args&&... args) - { - default_logger_raw()->warn(fmt, std::forward(args)...); - } - - template - inline void error(format_string_t fmt, Args&&... args) - { - default_logger_raw()->error(fmt, std::forward(args)...); - } - - template - inline void critical(format_string_t fmt, Args&&... args) - { - default_logger_raw()->critical(fmt, std::forward(args)...); - } - - template - inline void log(source_loc source, level::level_enum lvl, const T& msg) - { - default_logger_raw()->log(source, lvl, msg); - } - - template - inline void log(level::level_enum lvl, const T& msg) - { - default_logger_raw()->log(lvl, msg); - } +namespace spdlog { + +using default_factory = synchronous_factory; + +// Create and register a logger with a templated sink type +// The logger's level, formatter and flush level will be set according the +// global settings. +// +// Example: +// spdlog::create("logger_name", "dailylog_filename", 11, 59); +template +inline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) { + return default_factory::create(std::move(logger_name), + std::forward(sink_args)...); +} + +// Initialize and register a logger, +// formatter and flush level will be set according the global settings. +// +// Useful for initializing manually created loggers with the global settings. +// +// Example: +// auto mylogger = std::make_shared("mylogger", ...); +// spdlog::initialize_logger(mylogger); +SPDLOG_API void initialize_logger(std::shared_ptr logger); + +// Return an existing logger or nullptr if a logger with such name doesn't +// exist. +// example: spdlog::get("my_logger")->info("hello {}", "world"); +SPDLOG_API std::shared_ptr get(const std::string &name); + +// Set global formatter. Each sink in each logger will get a clone of this object +SPDLOG_API void set_formatter(std::unique_ptr formatter); + +// Set global format string. +// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); +SPDLOG_API void set_pattern(std::string pattern, + pattern_time_type time_type = pattern_time_type::local); + +// enable global backtrace support +SPDLOG_API void enable_backtrace(size_t n_messages); + +// disable global backtrace support +SPDLOG_API void disable_backtrace(); + +// call dump backtrace on default logger +SPDLOG_API void dump_backtrace(); + +// Get global logging level +SPDLOG_API level::level_enum get_level(); + +// Set global logging level +SPDLOG_API void set_level(level::level_enum log_level); + +// Determine whether the default logger should log messages with a certain level +SPDLOG_API bool should_log(level::level_enum lvl); + +// Set global flush level +SPDLOG_API void flush_on(level::level_enum log_level); + +// Start/Restart a periodic flusher thread +// Warning: Use only if all your loggers are thread safe! +template +inline void flush_every(std::chrono::duration interval) { + details::registry::instance().flush_every(interval); +} + +// Set global error handler +SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); + +// Register the given logger with the given name +SPDLOG_API void register_logger(std::shared_ptr logger); + +// Apply a user defined function on all registered loggers +// Example: +// spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); +SPDLOG_API void apply_all(const std::function)> &fun); + +// Drop the reference to the given logger +SPDLOG_API void drop(const std::string &name); + +// Drop all references from the registry +SPDLOG_API void drop_all(); + +// stop any running threads started by spdlog and clean registry loggers +SPDLOG_API void shutdown(); + +// Automatic registration of loggers when using spdlog::create() or spdlog::create_async +SPDLOG_API void set_automatic_registration(bool automatic_registration); + +// API for using default logger (stdout_color_mt), +// e.g: spdlog::info("Message {}", 1); +// +// The default logger object can be accessed using the spdlog::default_logger(): +// For example, to add another sink to it: +// spdlog::default_logger()->sinks().push_back(some_sink); +// +// The default logger can replaced using spdlog::set_default_logger(new_logger). +// For example, to replace it with a file logger. +// +// IMPORTANT: +// The default API is thread safe (for _mt loggers), but: +// set_default_logger() *should not* be used concurrently with the default API. +// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. + +SPDLOG_API std::shared_ptr default_logger(); + +SPDLOG_API spdlog::logger *default_logger_raw(); + +SPDLOG_API void set_default_logger(std::shared_ptr default_logger); + +// Initialize logger level based on environment configs. +// +// Useful for applying SPDLOG_LEVEL to manually created loggers. +// +// Example: +// auto mylogger = std::make_shared("mylogger", ...); +// spdlog::apply_logger_env_levels(mylogger); +SPDLOG_API void apply_logger_env_levels(std::shared_ptr logger); + +template +inline void log(source_loc source, + level::level_enum lvl, + format_string_t fmt, + Args &&...args) { + default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); +} + +template +inline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { + default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); +} + +template +inline void trace(format_string_t fmt, Args &&...args) { + default_logger_raw()->trace(fmt, std::forward(args)...); +} + +template +inline void debug(format_string_t fmt, Args &&...args) { + default_logger_raw()->debug(fmt, std::forward(args)...); +} + +template +inline void info(format_string_t fmt, Args &&...args) { + default_logger_raw()->info(fmt, std::forward(args)...); +} + +template +inline void warn(format_string_t fmt, Args &&...args) { + default_logger_raw()->warn(fmt, std::forward(args)...); +} + +template +inline void error(format_string_t fmt, Args &&...args) { + default_logger_raw()->error(fmt, std::forward(args)...); +} + +template +inline void critical(format_string_t fmt, Args &&...args) { + default_logger_raw()->critical(fmt, std::forward(args)...); +} + +template +inline void log(source_loc source, level::level_enum lvl, const T &msg) { + default_logger_raw()->log(source, lvl, msg); +} + +template +inline void log(level::level_enum lvl, const T &msg) { + default_logger_raw()->log(lvl, msg); +} #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - inline void log(source_loc source, level::level_enum lvl, wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); - } - - template - inline void log(level::level_enum lvl, wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); - } - - template - inline void trace(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->trace(fmt, std::forward(args)...); - } - - template - inline void debug(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->debug(fmt, std::forward(args)...); - } - - template - inline void info(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->info(fmt, std::forward(args)...); - } - - template - inline void warn(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->warn(fmt, std::forward(args)...); - } - - template - inline void error(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->error(fmt, std::forward(args)...); - } - - template - inline void critical(wformat_string_t fmt, Args&&... args) - { - default_logger_raw()->critical(fmt, std::forward(args)...); - } +template +inline void log(source_loc source, + level::level_enum lvl, + wformat_string_t fmt, + Args &&...args) { + default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); +} + +template +inline void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { + default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); +} + +template +inline void trace(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->trace(fmt, std::forward(args)...); +} + +template +inline void debug(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->debug(fmt, std::forward(args)...); +} + +template +inline void info(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->info(fmt, std::forward(args)...); +} + +template +inline void warn(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->warn(fmt, std::forward(args)...); +} + +template +inline void error(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->error(fmt, std::forward(args)...); +} + +template +inline void critical(wformat_string_t fmt, Args &&...args) { + default_logger_raw()->critical(fmt, std::forward(args)...); +} #endif - template - inline void trace(const T& msg) - { - default_logger_raw()->trace(msg); - } - - template - inline void debug(const T& msg) - { - default_logger_raw()->debug(msg); - } - - template - inline void info(const T& msg) - { - default_logger_raw()->info(msg); - } - - template - inline void warn(const T& msg) - { - default_logger_raw()->warn(msg); - } - - template - inline void error(const T& msg) - { - default_logger_raw()->error(msg); - } - - template - inline void critical(const T& msg) - { - default_logger_raw()->critical(msg); - } - -} // namespace spdlog +template +inline void trace(const T &msg) { + default_logger_raw()->trace(msg); +} + +template +inline void debug(const T &msg) { + default_logger_raw()->debug(msg); +} + +template +inline void info(const T &msg) { + default_logger_raw()->info(msg); +} + +template +inline void warn(const T &msg) { + default_logger_raw()->warn(msg); +} + +template +inline void error(const T &msg) { + default_logger_raw()->error(msg); +} + +template +inline void critical(const T &msg) { + default_logger_raw()->critical(msg); +} + +} // namespace spdlog // // enable/disable log calls at compile time according to global level. @@ -307,61 +284,69 @@ namespace spdlog // #ifndef SPDLOG_NO_SOURCE_LOC -#define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) + #define SPDLOG_LOGGER_CALL(logger, level, ...) \ + (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) #else -#define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) + #define SPDLOG_LOGGER_CALL(logger, level, ...) \ + (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE -#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) -#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_TRACE(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) + #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 -#define SPDLOG_TRACE(...) (void)0 + #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 + #define SPDLOG_TRACE(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG -#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) -#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_DEBUG(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) + #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 -#define SPDLOG_DEBUG(...) (void)0 + #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 + #define SPDLOG_DEBUG(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO -#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) -#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_INFO(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) + #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_INFO(logger, ...) (void)0 -#define SPDLOG_INFO(...) (void)0 + #define SPDLOG_LOGGER_INFO(logger, ...) (void)0 + #define SPDLOG_INFO(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN -#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) -#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_WARN(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) + #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_WARN(logger, ...) (void)0 -#define SPDLOG_WARN(...) (void)0 + #define SPDLOG_LOGGER_WARN(logger, ...) (void)0 + #define SPDLOG_WARN(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR -#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) -#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_ERROR(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) + #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 -#define SPDLOG_ERROR(...) (void)0 + #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 + #define SPDLOG_ERROR(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL -#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) -#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_CRITICAL(logger, ...) \ + SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) + #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) #else -#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 -#define SPDLOG_CRITICAL(...) (void)0 + #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 + #define SPDLOG_CRITICAL(...) (void)0 #endif #ifdef SPDLOG_HEADER_ONLY -#include "spdlog-inl.h" + #include "spdlog-inl.h" #endif -#endif // SPDLOG_H +#endif // SPDLOG_H diff --git a/lib/spdlog/stopwatch.h b/lib/spdlog/stopwatch.h index 0261834a..54ab3d3b 100644 --- a/lib/spdlog/stopwatch.h +++ b/lib/spdlog/stopwatch.h @@ -13,53 +13,54 @@ // // spdlog::stopwatch sw; // ... -// spdlog::debug("Elapsed: {} seconds", sw); => "Elapsed 0.005116733 -// seconds" spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 -// seconds" +// spdlog::debug("Elapsed: {} seconds", sw); => "Elapsed 0.005116733 seconds" +// spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 seconds" // // -// If other units are needed (e.g. millis instead of double), include -// "fmt/chrono.h" and use "duration_cast<..>(sw.elapsed())": +// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use +// "duration_cast<..>(sw.elapsed())": // // #include //.. // using std::chrono::duration_cast; // using std::chrono::milliseconds; -// spdlog::info("Elapsed {}", duration_cast(sw.elapsed())); => -// "Elapsed 5ms" +// spdlog::info("Elapsed {}", duration_cast(sw.elapsed())); => "Elapsed 5ms" -namespace spdlog -{ - class stopwatch { - using clock = std::chrono::steady_clock; - std::chrono::time_point start_tp_; +namespace spdlog { +class stopwatch { + using clock = std::chrono::steady_clock; + std::chrono::time_point start_tp_; - public: - stopwatch() : start_tp_{clock::now()} {} +public: + stopwatch() + : start_tp_{clock::now()} {} - std::chrono::duration elapsed() const { return std::chrono::duration(clock::now() - start_tp_); } + std::chrono::duration elapsed() const { + return std::chrono::duration(clock::now() - start_tp_); + } - std::chrono::milliseconds elapsed_ms() const { return std::chrono::duration_cast(clock::now() - start_tp_); } + std::chrono::milliseconds elapsed_ms() const { + return std::chrono::duration_cast(clock::now() - start_tp_); + } - void reset() { start_tp_ = clock::now(); } - }; -} // namespace spdlog + void reset() { start_tp_ = clock::now(); } +}; +} // namespace spdlog // Support for fmt formatting (e.g. "{:012.9}" or just "{}") namespace #ifdef SPDLOG_USE_STD_FORMAT -std + std #else -fmt + fmt #endif { - template <> - struct formatter : formatter { - template - auto format(const spdlog::stopwatch& sw, FormatContext& ctx) const -> decltype(ctx.out()) - { - return formatter::format(sw.elapsed().count(), ctx); - } - }; -} // namespace std +template <> +struct formatter : formatter { + template + auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) { + return formatter::format(sw.elapsed().count(), ctx); + } +}; +} // namespace std diff --git a/lib/spdlog/tweakme.h b/lib/spdlog/tweakme.h index a446c242..922f2e85 100644 --- a/lib/spdlog/tweakme.h +++ b/lib/spdlog/tweakme.h @@ -102,8 +102,8 @@ /////////////////////////////////////////////////////////////////////////////// // Uncomment to customize level names (e.g. "MY 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" } /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// @@ -115,16 +115,14 @@ /////////////////////////////////////////////////////////////////////////////// // Uncomment to disable default logger creation. -// This might save some (very) small initialization time if no default logger is -// needed. +// This might save some (very) small initialization time if no default logger is needed. // // #define SPDLOG_DISABLE_DEFAULT_LOGGER /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Uncomment and set to compile time level with zero cost (default is INFO). -// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty -// statements if not enabled +// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty statements if not enabled // // #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO /////////////////////////////////////////////////////////////////////////////// diff --git a/lib/speex/arch.h b/lib/speex/arch.h index d490911d..ff7fc553 100644 --- a/lib/speex/arch.h +++ b/lib/speex/arch.h @@ -66,19 +66,20 @@ #error "Don't you think enabling fixed-point is a good thing to do if you want to debug that?" #endif + #endif #ifndef OUTSIDE_SPEEX #include "speex/speexdsp_types.h" #endif -#define ABS(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute integer value. */ -#define ABS16(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute 16-bit value. */ -#define MIN16(a, b) ((a) < (b) ? (a) : (b)) /**< Maximum 16-bit value. */ -#define MAX16(a, b) ((a) > (b) ? (a) : (b)) /**< Maximum 16-bit value. */ -#define ABS32(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute 32-bit value. */ -#define MIN32(a, b) ((a) < (b) ? (a) : (b)) /**< Maximum 32-bit value. */ -#define MAX32(a, b) ((a) > (b) ? (a) : (b)) /**< Maximum 32-bit value. */ +#define ABS(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute integer value. */ +#define ABS16(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute 16-bit value. */ +#define MIN16(a,b) ((a) < (b) ? (a) : (b)) /**< Maximum 16-bit value. */ +#define MAX16(a,b) ((a) > (b) ? (a) : (b)) /**< Maximum 16-bit value. */ +#define ABS32(x) ((x) < 0 ? (-(x)) : (x)) /**< Absolute 32-bit value. */ +#define MIN32(a,b) ((a) < (b) ? (a) : (b)) /**< Maximum 32-bit value. */ +#define MAX32(a,b) ((a) > (b) ? (a) : (b)) /**< Maximum 32-bit value. */ #ifdef FIXED_POINT @@ -91,17 +92,17 @@ typedef spx_word32_t spx_sig_t; #define Q15ONE 32767 -#define LPC_SCALING 8192 -#define SIG_SCALING 16384 -#define LSP_SCALING 8192. +#define LPC_SCALING 8192 +#define SIG_SCALING 16384 +#define LSP_SCALING 8192. #define GAMMA_SCALING 32768. #define GAIN_SCALING 64 #define GAIN_SCALING_1 0.015625 -#define LPC_SHIFT 13 -#define LSP_SHIFT 13 -#define SIG_SHIFT 14 -#define GAIN_SHIFT 6 +#define LPC_SHIFT 13 +#define LSP_SHIFT 13 +#define SIG_SHIFT 14 +#define GAIN_SHIFT 6 #define WORD2INT(x) ((x) < -32767 ? -32768 : ((x) > 32766 ? 32767 : (x))) @@ -110,6 +111,7 @@ typedef spx_word32_t spx_sig_t; #define VERY_LARGE16 ((spx_word16_t)32767) #define Q15_ONE ((spx_word16_t)32767) + #ifdef FIXED_DEBUG #include "fixed_debug.h" #else @@ -126,6 +128,7 @@ typedef spx_word32_t spx_sig_t; #endif + #else typedef float spx_mem_t; @@ -136,74 +139,77 @@ typedef float spx_word16_t; typedef float spx_word32_t; #define Q15ONE 1.0f -#define LPC_SCALING 1.f -#define SIG_SCALING 1.f -#define LSP_SCALING 1.f +#define LPC_SCALING 1.f +#define SIG_SCALING 1.f +#define LSP_SCALING 1.f #define GAMMA_SCALING 1.f #define GAIN_SCALING 1.f #define GAIN_SCALING_1 1.f + #define VERY_SMALL 1e-15f #define VERY_LARGE32 1e15f #define VERY_LARGE16 1e15f #define Q15_ONE ((spx_word16_t)1.f) -#define QCONST16(x, bits) (x) -#define QCONST32(x, bits) (x) +#define QCONST16(x,bits) (x) +#define QCONST32(x,bits) (x) #define NEG16(x) (-(x)) #define NEG32(x) (-(x)) #define EXTRACT16(x) (x) #define EXTEND32(x) (x) -#define SHR16(a, shift) (a) -#define SHL16(a, shift) (a) -#define SHR32(a, shift) (a) -#define SHL32(a, shift) (a) -#define PSHR16(a, shift) (a) -#define PSHR32(a, shift) (a) -#define VSHR32(a, shift) (a) -#define SATURATE16(x, a) (x) -#define SATURATE32(x, a) (x) -#define SATURATE32PSHR(x, shift, a) (x) - -#define PSHR(a, shift) (a) -#define SHR(a, shift) (a) -#define SHL(a, shift) (a) -#define SATURATE(x, a) (x) - -#define ADD16(a, b) ((a) + (b)) -#define SUB16(a, b) ((a) - (b)) -#define ADD32(a, b) ((a) + (b)) -#define SUB32(a, b) ((a) - (b)) -#define MULT16_16_16(a, b) ((a) * (b)) -#define MULT16_32_32(a, b) ((a) * (b)) -#define MULT16_16(a, b) ((spx_word32_t)(a) * (spx_word32_t)(b)) -#define MAC16_16(c, a, b) ((c) + (spx_word32_t)(a) * (spx_word32_t)(b)) - -#define MULT16_32_Q15(a, b) ((a) * (b)) -#define MULT16_32_P15(a, b) ((a) * (b)) - -#define MAC16_32_Q15(c, a, b) ((c) + (a) * (b)) - -#define MAC16_16_Q11(c, a, b) ((c) + (a) * (b)) -#define MAC16_16_Q13(c, a, b) ((c) + (a) * (b)) -#define MAC16_16_P13(c, a, b) ((c) + (a) * (b)) -#define MULT16_16_Q11_32(a, b) ((a) * (b)) -#define MULT16_16_Q13(a, b) ((a) * (b)) -#define MULT16_16_Q14(a, b) ((a) * (b)) -#define MULT16_16_Q15(a, b) ((a) * (b)) -#define MULT16_16_P15(a, b) ((a) * (b)) -#define MULT16_16_P13(a, b) ((a) * (b)) -#define MULT16_16_P14(a, b) ((a) * (b)) - -#define DIV32_16(a, b) (((spx_word32_t)(a)) / (spx_word16_t)(b)) -#define PDIV32_16(a, b) (((spx_word32_t)(a)) / (spx_word16_t)(b)) -#define DIV32(a, b) (((spx_word32_t)(a)) / (spx_word32_t)(b)) -#define PDIV32(a, b) (((spx_word32_t)(a)) / (spx_word32_t)(b)) - -#define WORD2INT(x) ((x) < -32767.5f ? -32768 : ((x) > 32766.5f ? 32767 : (spx_int16_t)floor(.5 + (x)))) +#define SHR16(a,shift) (a) +#define SHL16(a,shift) (a) +#define SHR32(a,shift) (a) +#define SHL32(a,shift) (a) +#define PSHR16(a,shift) (a) +#define PSHR32(a,shift) (a) +#define VSHR32(a,shift) (a) +#define SATURATE16(x,a) (x) +#define SATURATE32(x,a) (x) +#define SATURATE32PSHR(x,shift,a) (x) + +#define PSHR(a,shift) (a) +#define SHR(a,shift) (a) +#define SHL(a,shift) (a) +#define SATURATE(x,a) (x) + +#define ADD16(a,b) ((a)+(b)) +#define SUB16(a,b) ((a)-(b)) +#define ADD32(a,b) ((a)+(b)) +#define SUB32(a,b) ((a)-(b)) +#define MULT16_16_16(a,b) ((a)*(b)) +#define MULT16_32_32(a,b) ((a)*(b)) +#define MULT16_16(a,b) ((spx_word32_t)(a)*(spx_word32_t)(b)) +#define MAC16_16(c,a,b) ((c)+(spx_word32_t)(a)*(spx_word32_t)(b)) + +#define MULT16_32_Q15(a,b) ((a)*(b)) +#define MULT16_32_P15(a,b) ((a)*(b)) + +#define MAC16_32_Q15(c,a,b) ((c)+(a)*(b)) + +#define MAC16_16_Q11(c,a,b) ((c)+(a)*(b)) +#define MAC16_16_Q13(c,a,b) ((c)+(a)*(b)) +#define MAC16_16_P13(c,a,b) ((c)+(a)*(b)) +#define MULT16_16_Q11_32(a,b) ((a)*(b)) +#define MULT16_16_Q13(a,b) ((a)*(b)) +#define MULT16_16_Q14(a,b) ((a)*(b)) +#define MULT16_16_Q15(a,b) ((a)*(b)) +#define MULT16_16_P15(a,b) ((a)*(b)) +#define MULT16_16_P13(a,b) ((a)*(b)) +#define MULT16_16_P14(a,b) ((a)*(b)) + +#define DIV32_16(a,b) (((spx_word32_t)(a))/(spx_word16_t)(b)) +#define PDIV32_16(a,b) (((spx_word32_t)(a))/(spx_word16_t)(b)) +#define DIV32(a,b) (((spx_word32_t)(a))/(spx_word32_t)(b)) +#define PDIV32(a,b) (((spx_word32_t)(a))/(spx_word32_t)(b)) + +#define WORD2INT(x) ((x) < -32767.5f ? -32768 : \ + ((x) > 32766.5f ? 32767 : (spx_int16_t)floor(.5 + (x)))) #endif + #if defined(CONFIG_TI_C54X) || defined(CONFIG_TI_C55X) /* 2 on TI C5x DSP */ @@ -219,8 +225,10 @@ typedef float spx_word32_t; #endif + #ifdef FIXED_DEBUG extern long long spx_mips; #endif + #endif diff --git a/lib/speex/speex_resampler.c b/lib/speex/speex_resampler.c index 0271a5d5..1e9c99c5 100644 --- a/lib/speex/speex_resampler.c +++ b/lib/speex/speex_resampler.c @@ -33,10 +33,10 @@ /* The design goals of this code are: - - Very fast algorithm - - SIMD-friendly algorithm - - Low memory requirement - - Good *perceptual* quality (and not best SNR) + - Very fast algorithm + - SIMD-friendly algorithm + - Low memory requirement + - Good *perceptual* quality (and not best SNR) Warning: This resampler is relatively new. Although I think I got rid of all the major bugs and I don't expect the API to change anymore, there @@ -71,24 +71,24 @@ static void speex_free(void* ptr) { free(ptr); } #ifndef EXPORT #define EXPORT #endif -#include "arch.h" #include "speex_resampler.h" +#include "arch.h" #else /* OUTSIDE_SPEEX */ +#include "speex/speex_resampler.h" #include "arch.h" #include "os_support.h" -#include "speex/speex_resampler.h" #endif /* OUTSIDE_SPEEX */ -#include #include +#include #ifndef M_PI #define M_PI 3.14159265358979323846 #endif -#define IMAX(a, b) ((a) > (b) ? (a) : (b)) -#define IMIN(a, b) ((a) < (b) ? (a) : (b)) +#define IMAX(a,b) ((a) > (b) ? (a) : (b)) +#define IMIN(a,b) ((a) < (b) ? (a) : (b)) #ifndef NULL #define NULL 0 @@ -113,9 +113,11 @@ static void speex_free(void* ptr) { free(ptr); } #define FIXED_STACK_ALLOC 1024 #endif -typedef int (*resampler_basic_func)(SpeexResamplerState*, spx_uint32_t, const spx_word16_t*, spx_uint32_t*, spx_word16_t*, spx_uint32_t*); +typedef int (*resampler_basic_func)(SpeexResamplerState*, spx_uint32_t, const spx_word16_t*, spx_uint32_t*, + spx_word16_t*, spx_uint32_t*); -struct SpeexResamplerState_ { +struct SpeexResamplerState_ +{ spx_uint32_t in_rate; spx_uint32_t out_rate; spx_uint32_t num_rate; @@ -147,8 +149,20 @@ struct SpeexResamplerState_ { int out_stride; }; -static const double kaiser12_table[68] = {0.99859849, 1.00000000, 0.99859849, 0.99440475, 0.98745105, 0.97779076, 0.96549770, 0.95066529, 0.93340547, 0.91384741, 0.89213598, 0.86843014, 0.84290116, 0.81573067, 0.78710866, 0.75723148, 0.72629970, 0.69451601, 0.66208321, 0.62920216, 0.59606986, 0.56287762, 0.52980938, 0.49704014, 0.46473455, 0.43304576, 0.40211431, 0.37206735, 0.34301800, 0.31506490, 0.28829195, 0.26276832, 0.23854851, 0.21567274, - 0.19416736, 0.17404546, 0.15530766, 0.13794294, 0.12192957, 0.10723616, 0.09382272, 0.08164178, 0.07063950, 0.06075685, 0.05193064, 0.04409466, 0.03718069, 0.03111947, 0.02584161, 0.02127838, 0.01736250, 0.01402878, 0.01121463, 0.00886058, 0.00691064, 0.00531256, 0.00401805, 0.00298291, 0.00216702, 0.00153438, 0.00105297, 0.00069463, 0.00043489, 0.00025272, 0.00013031, 0.0000527734, 0.00001000, 0.00000000}; +static const double kaiser12_table[68] = { + 0.99859849, 1.00000000, 0.99859849, 0.99440475, 0.98745105, 0.97779076, + 0.96549770, 0.95066529, 0.93340547, 0.91384741, 0.89213598, 0.86843014, + 0.84290116, 0.81573067, 0.78710866, 0.75723148, 0.72629970, 0.69451601, + 0.66208321, 0.62920216, 0.59606986, 0.56287762, 0.52980938, 0.49704014, + 0.46473455, 0.43304576, 0.40211431, 0.37206735, 0.34301800, 0.31506490, + 0.28829195, 0.26276832, 0.23854851, 0.21567274, 0.19416736, 0.17404546, + 0.15530766, 0.13794294, 0.12192957, 0.10723616, 0.09382272, 0.08164178, + 0.07063950, 0.06075685, 0.05193064, 0.04409466, 0.03718069, 0.03111947, + 0.02584161, 0.02127838, 0.01736250, 0.01402878, 0.01121463, 0.00886058, + 0.00691064, 0.00531256, 0.00401805, 0.00298291, 0.00216702, 0.00153438, + 0.00105297, 0.00069463, 0.00043489, 0.00025272, 0.00013031, 0.0000527734, + 0.00001000, 0.00000000 +}; /* static const double kaiser12_table[36] = { 0.99440475, 1.00000000, 0.99440475, 0.97779076, 0.95066529, 0.91384741, @@ -158,13 +172,35 @@ static const double kaiser12_table[36] = { 0.03111947, 0.02127838, 0.01402878, 0.00886058, 0.00531256, 0.00298291, 0.00153438, 0.00069463, 0.00025272, 0.0000527734, 0.00000500, 0.00000000}; */ -static const double kaiser10_table[36] = {0.99537781, 1.00000000, 0.99537781, 0.98162644, 0.95908712, 0.92831446, 0.89005583, 0.84522401, 0.79486424, 0.74011713, 0.68217934, 0.62226347, 0.56155915, 0.50119680, 0.44221549, 0.38553619, 0.33194107, 0.28205962, 0.23636152, 0.19515633, 0.15859932, 0.12670280, 0.09935205, 0.07632451, 0.05731132, 0.04193980, 0.02979584, 0.02044510, 0.01345224, 0.00839739, 0.00488951, 0.00257636, 0.00115101, 0.00035515, 0.00000000, 0.00000000}; +static const double kaiser10_table[36] = { + 0.99537781, 1.00000000, 0.99537781, 0.98162644, 0.95908712, 0.92831446, + 0.89005583, 0.84522401, 0.79486424, 0.74011713, 0.68217934, 0.62226347, + 0.56155915, 0.50119680, 0.44221549, 0.38553619, 0.33194107, 0.28205962, + 0.23636152, 0.19515633, 0.15859932, 0.12670280, 0.09935205, 0.07632451, + 0.05731132, 0.04193980, 0.02979584, 0.02044510, 0.01345224, 0.00839739, + 0.00488951, 0.00257636, 0.00115101, 0.00035515, 0.00000000, 0.00000000 +}; -static const double kaiser8_table[36] = {0.99635258, 1.00000000, 0.99635258, 0.98548012, 0.96759014, 0.94302200, 0.91223751, 0.87580811, 0.83439927, 0.78875245, 0.73966538, 0.68797126, 0.63451750, 0.58014482, 0.52566725, 0.47185369, 0.41941150, 0.36897272, 0.32108304, 0.27619388, 0.23465776, 0.19672670, 0.16255380, 0.13219758, 0.10562887, 0.08273982, 0.06335451, 0.04724088, 0.03412321, 0.02369490, 0.01563093, 0.00959968, 0.00527363, 0.00233883, 0.00050000, 0.00000000}; +static const double kaiser8_table[36] = { + 0.99635258, 1.00000000, 0.99635258, 0.98548012, 0.96759014, 0.94302200, + 0.91223751, 0.87580811, 0.83439927, 0.78875245, 0.73966538, 0.68797126, + 0.63451750, 0.58014482, 0.52566725, 0.47185369, 0.41941150, 0.36897272, + 0.32108304, 0.27619388, 0.23465776, 0.19672670, 0.16255380, 0.13219758, + 0.10562887, 0.08273982, 0.06335451, 0.04724088, 0.03412321, 0.02369490, + 0.01563093, 0.00959968, 0.00527363, 0.00233883, 0.00050000, 0.00000000 +}; -static const double kaiser6_table[36] = {0.99733006, 1.00000000, 0.99733006, 0.98935595, 0.97618418, 0.95799003, 0.93501423, 0.90755855, 0.87598009, 0.84068475, 0.80211977, 0.76076565, 0.71712752, 0.67172623, 0.62508937, 0.57774224, 0.53019925, 0.48295561, 0.43647969, 0.39120616, 0.34752997, 0.30580127, 0.26632152, 0.22934058, 0.19505503, 0.16360756, 0.13508755, 0.10953262, 0.08693120, 0.06722600, 0.05031820, 0.03607231, 0.02432151, 0.01487334, 0.00752000, 0.00000000}; +static const double kaiser6_table[36] = { + 0.99733006, 1.00000000, 0.99733006, 0.98935595, 0.97618418, 0.95799003, + 0.93501423, 0.90755855, 0.87598009, 0.84068475, 0.80211977, 0.76076565, + 0.71712752, 0.67172623, 0.62508937, 0.57774224, 0.53019925, 0.48295561, + 0.43647969, 0.39120616, 0.34752997, 0.30580127, 0.26632152, 0.22934058, + 0.19505503, 0.16360756, 0.13508755, 0.10953262, 0.08693120, 0.06722600, + 0.05031820, 0.03607231, 0.02432151, 0.01487334, 0.00752000, 0.00000000 +}; -struct FuncDef { +struct FuncDef +{ const double* table; int oversample; }; @@ -178,7 +214,8 @@ static const struct FuncDef kaiser8_funcdef = {kaiser8_table, 32}; static const struct FuncDef kaiser6_funcdef = {kaiser6_table, 32}; #define KAISER6 (&kaiser6_funcdef) -struct QualityMapping { +struct QualityMapping +{ int base_length; int oversample; float downsample_bandwidth; @@ -186,36 +223,28 @@ struct QualityMapping { const struct FuncDef* window_func; }; + /* This table maps conversion quality to internal parameters. There are two reasons that explain why the up-sampling bandwidth is larger than the down-sampling bandwidth: 1) When up-sampling, we can assume that the spectrum is already attenuated - close to the Nyquist rate (from an A/D or a previous resampling - filter) 2) Any aliasing that occurs very close to the Nyquist rate will be - masked by the sinusoids/noise just below the Nyquist rate (guaranteed only - for up-sampling). + close to the Nyquist rate (from an A/D or a previous resampling filter) + 2) Any aliasing that occurs very close to the Nyquist rate will be masked + by the sinusoids/noise just below the Nyquist rate (guaranteed only for + up-sampling). */ static const struct QualityMapping quality_map[11] = { -{8, 4, 0.830f, 0.860f, KAISER6}, /* Q0 */ -{16, 4, 0.850f, 0.880f, KAISER6}, /* Q1 */ -{32, 4, 0.882f, 0.910f, KAISER6}, -/* Q2 */ /* 82.3% cutoff ( ~60 dB stop) 6 */ -{48, 8, 0.895f, 0.917f, KAISER8}, -/* Q3 */ /* 84.9% cutoff ( ~80 dB stop) 8 */ -{64, 8, 0.921f, 0.940f, KAISER8}, -/* Q4 */ /* 88.7% cutoff ( ~80 dB stop) 8 */ -{80, 16, 0.922f, 0.940f, KAISER10}, -/* Q5 */ /* 89.1% cutoff (~100 dB stop) 10 */ -{96, 16, 0.940f, 0.945f, KAISER10}, -/* Q6 */ /* 91.5% cutoff (~100 dB stop) 10 */ -{128, 16, 0.950f, 0.950f, KAISER10}, -/* Q7 */ /* 93.1% cutoff (~100 dB stop) 10 */ -{160, 16, 0.960f, 0.960f, KAISER10}, -/* Q8 */ /* 94.5% cutoff (~100 dB stop) 10 */ -{192, 32, 0.968f, 0.968f, KAISER12}, -/* Q9 */ /* 95.5% cutoff (~100 dB stop) 10 */ -{256, 32, 0.975f, 0.975f, KAISER12}, -/* Q10 */ /* 96.6% cutoff (~100 dB stop) 10 */ + {8, 4, 0.830f, 0.860f, KAISER6}, /* Q0 */ + {16, 4, 0.850f, 0.880f, KAISER6}, /* Q1 */ + {32, 4, 0.882f, 0.910f, KAISER6}, /* Q2 */ /* 82.3% cutoff ( ~60 dB stop) 6 */ + {48, 8, 0.895f, 0.917f, KAISER8}, /* Q3 */ /* 84.9% cutoff ( ~80 dB stop) 8 */ + {64, 8, 0.921f, 0.940f, KAISER8}, /* Q4 */ /* 88.7% cutoff ( ~80 dB stop) 8 */ + {80, 16, 0.922f, 0.940f, KAISER10}, /* Q5 */ /* 89.1% cutoff (~100 dB stop) 10 */ + {96, 16, 0.940f, 0.945f, KAISER10}, /* Q6 */ /* 91.5% cutoff (~100 dB stop) 10 */ + {128, 16, 0.950f, 0.950f, KAISER10}, /* Q7 */ /* 93.1% cutoff (~100 dB stop) 10 */ + {160, 16, 0.960f, 0.960f, KAISER10}, /* Q8 */ /* 94.5% cutoff (~100 dB stop) 10 */ + {192, 32, 0.968f, 0.968f, KAISER12}, /* Q9 */ /* 95.5% cutoff (~100 dB stop) 10 */ + {256, 32, 0.975f, 0.975f, KAISER12}, /* Q10 */ /* 96.6% cutoff (~100 dB stop) 10 */ }; /*8,24,40,56,80,104,128,160,200,256,320*/ static double compute_func(float x, const struct FuncDef* func) @@ -235,7 +264,8 @@ static double compute_func(float x, const struct FuncDef* func) interp[1] = 1.f - interp[3] - interp[2] - interp[0]; /*sum = frac*accum[1] + (1-frac)*accum[2];*/ - return interp[0] * func->table[ind] + interp[1] * func->table[ind + 1] + interp[2] * func->table[ind + 2] + interp[3] * func->table[ind + 3]; + return interp[0] * func->table[ind] + interp[1] * func->table[ind + 1] + interp[2] * func->table[ind + 2] + interp[ + 3] * func->table[ind + 3]; } #if 0 @@ -250,22 +280,19 @@ int main(int argc, char** argv) { #endif #ifdef FIXED_POINT -/* The slow way of computing a sinc for the table. Should improve that some day - */ -static spx_word16_t sinc(float cutoff, float x, int N, const struct FuncDef* window_func) -{ - /*fprintf (stderr, "%f ", x);*/ - float xx = x * cutoff; - if (fabs(x) < 1e-6f) - return WORD2INT(32768. * cutoff); - else if (fabs(x) > .5f * N) - return 0; - /*FIXME: Can it really be any slower than this? */ - return WORD2INT(32768. * cutoff * sin(M_PI * xx) / (M_PI * xx) * compute_func(fabs(2. * x / N), window_func)); +/* The slow way of computing a sinc for the table. Should improve that some day */ +static spx_word16_t sinc(float cutoff, float x, int N, const struct FuncDef* window_func) { + /*fprintf (stderr, "%f ", x);*/ + float xx = x * cutoff; + if (fabs(x) < 1e-6f) + return WORD2INT(32768. * cutoff); + else if (fabs(x) > .5f * N) + return 0; + /*FIXME: Can it really be any slower than this? */ + return WORD2INT(32768. * cutoff * sin(M_PI * xx) / (M_PI * xx) * compute_func(fabs(2. * x / N), window_func)); } #else -/* The slow way of computing a sinc for the table. Should improve that some day - */ +/* The slow way of computing a sinc for the table. Should improve that some day */ static spx_word16_t sinc(float cutoff, float x, int N, const struct FuncDef* window_func) { /*fprintf (stderr, "%f ", x);*/ @@ -280,26 +307,25 @@ static spx_word16_t sinc(float cutoff, float x, int N, const struct FuncDef* win #endif #ifdef FIXED_POINT -static void cubic_coef(spx_word16_t x, spx_word16_t interp[4]) -{ - /* Compute interpolation coefficients. I'm not sure whether this corresponds - to cubic interpolation but I know it's MMSE-optimal on a sinc */ - spx_word16_t x2, x3; - x2 = MULT16_16_P15(x, x); - x3 = MULT16_16_P15(x, x2); - interp[0] = PSHR32(MULT16_16(QCONST16(-0.16667f, 15), x) + MULT16_16(QCONST16(0.16667f, 15), x3), 15); - interp[1] = EXTRACT16(EXTEND32(x) + SHR32(SUB32(EXTEND32(x2), EXTEND32(x3)), 1)); - interp[3] = PSHR32(MULT16_16(QCONST16(-0.33333f, 15), x) + MULT16_16(QCONST16(.5f, 15), x2) - MULT16_16(QCONST16(0.16667f, 15), x3), 15); - /* Just to make sure we don't have rounding problems */ - interp[2] = Q15_ONE - interp[0] - interp[1] - interp[3]; - if (interp[2] < 32767) - interp[2] += 1; +static void cubic_coef(spx_word16_t x, spx_word16_t interp[4]) { + /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation + but I know it's MMSE-optimal on a sinc */ + spx_word16_t x2, x3; + x2 = MULT16_16_P15(x, x); + x3 = MULT16_16_P15(x, x2); + interp[0] = PSHR32(MULT16_16(QCONST16(-0.16667f, 15), x) + MULT16_16(QCONST16(0.16667f, 15), x3), 15); + interp[1] = EXTRACT16(EXTEND32(x) + SHR32(SUB32(EXTEND32(x2), EXTEND32(x3)), 1)); + interp[3] = PSHR32(MULT16_16(QCONST16(-0.33333f, 15), x) + MULT16_16(QCONST16(.5f, 15), x2) - MULT16_16(QCONST16(0.16667f, 15), x3), 15); + /* Just to make sure we don't have rounding problems */ + interp[2] = Q15_ONE - interp[0] - interp[1] - interp[3]; + if (interp[2] < 32767) + interp[2] += 1; } #else static void cubic_coef(spx_word16_t frac, spx_word16_t interp[4]) { - /* Compute interpolation coefficients. I'm not sure whether this corresponds - to cubic interpolation but I know it's MMSE-optimal on a sinc */ + /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation + but I know it's MMSE-optimal on a sinc */ interp[0] = -0.16667f * frac + 0.16667f * frac * frac * frac; interp[1] = frac + 0.5f * frac * frac - 0.5f * frac * frac * frac; /*interp[2] = 1.f - 0.5f*frac - frac*frac + 0.5f*frac*frac*frac;*/ @@ -309,7 +335,8 @@ static void cubic_coef(spx_word16_t frac, spx_word16_t interp[4]) } #endif -static int resampler_basic_direct_single(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) +static int resampler_basic_direct_single(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, + spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) { const int N = st->filt_len; int out_sample = 0; @@ -330,13 +357,13 @@ static int resampler_basic_direct_single(SpeexResamplerState* st, spx_uint32_t c #ifndef OVERRIDE_INNER_PRODUCT_SINGLE int j; sum = 0; - for (j = 0; j < N; j++) - sum += MULT16_16(sinct[j], iptr[j]); + for (j = 0; j < N; j++) sum += MULT16_16(sinct[j], iptr[j]); /* This code is slower on most DSPs which have only 2 accumulators. - Plus this this forces truncation to 32 bits and you lose the HW guard - bits. I think we can trust the compiler and let it vectorize and/or - unroll itself. spx_word32_t accum[4] = {0,0,0,0}; for(j=0;jfilt_len; int out_sample = 0; @@ -399,7 +426,7 @@ static int resampler_basic_direct_double(SpeexResamplerState* st, spx_uint32_t c } sum = accum[0] + accum[1] + accum[2] + accum[3]; #else - sum = inner_product_double(sinct, iptr, N); + sum = inner_product_double(sinct, iptr, N); #endif out[out_stride * out_sample++] = PSHR32(sum, 15); @@ -418,7 +445,9 @@ static int resampler_basic_direct_double(SpeexResamplerState* st, spx_uint32_t c } #endif -static int resampler_basic_interpolate_single(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) +static int resampler_basic_interpolate_single(SpeexResamplerState* st, spx_uint32_t channel_index, + const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, + spx_uint32_t* out_len) { const int N = st->filt_len; int out_sample = 0; @@ -436,12 +465,13 @@ static int resampler_basic_interpolate_single(SpeexResamplerState* st, spx_uint3 const int offset = samp_frac_num * st->oversample / st->den_rate; #ifdef FIXED_POINT - const spx_word16_t frac = PDIV32(SHL32((samp_frac_num * st->oversample) % st->den_rate, 15), st->den_rate); + const spx_word16_t frac = PDIV32(SHL32((samp_frac_num * st->oversample) % st->den_rate, 15), st->den_rate); #else const spx_word16_t frac = ((float)((samp_frac_num * st->oversample) % st->den_rate)) / st->den_rate; #endif spx_word16_t interp[4]; + #ifndef OVERRIDE_INTERPOLATE_PRODUCT_SINGLE int j; spx_word32_t accum[4] = {0, 0, 0, 0}; @@ -456,11 +486,12 @@ static int resampler_basic_interpolate_single(SpeexResamplerState* st, spx_uint3 } cubic_coef(frac, interp); - sum = MULT16_32_Q15(interp[0], accum[0]) + MULT16_32_Q15(interp[1], accum[1]) + MULT16_32_Q15(interp[2], accum[2]) + MULT16_32_Q15(interp[3], accum[3]); + sum = MULT16_32_Q15(interp[0], accum[0]) + MULT16_32_Q15(interp[1], accum[1]) + + MULT16_32_Q15(interp[2], accum[2]) + MULT16_32_Q15(interp[3], accum[3]); sum = SATURATE32PSHR(sum, 15, 32767); #else - cubic_coef(frac, interp); - sum = interpolate_product_single(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp); + cubic_coef(frac, interp); + sum = interpolate_product_single(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp); #endif out[out_stride * out_sample++] = sum; @@ -480,9 +511,10 @@ static int resampler_basic_interpolate_single(SpeexResamplerState* st, spx_uint3 #ifdef FIXED_POINT #else -/* This is the same as the previous function, except with a double-precision - * accumulator */ -static int resampler_basic_interpolate_double(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) +/* This is the same as the previous function, except with a double-precision accumulator */ +static int resampler_basic_interpolate_double(SpeexResamplerState* st, spx_uint32_t channel_index, + const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, + spx_uint32_t* out_len) { const int N = st->filt_len; int out_sample = 0; @@ -500,12 +532,13 @@ static int resampler_basic_interpolate_double(SpeexResamplerState* st, spx_uint3 const int offset = samp_frac_num * st->oversample / st->den_rate; #ifdef FIXED_POINT - const spx_word16_t frac = PDIV32(SHL32((samp_frac_num * st->oversample) % st->den_rate, 15), st->den_rate); + const spx_word16_t frac = PDIV32(SHL32((samp_frac_num * st->oversample) % st->den_rate, 15), st->den_rate); #else const spx_word16_t frac = ((float)((samp_frac_num * st->oversample) % st->den_rate)) / st->den_rate; #endif spx_word16_t interp[4]; + #ifndef OVERRIDE_INTERPOLATE_PRODUCT_DOUBLE int j; double accum[4] = {0, 0, 0, 0}; @@ -520,10 +553,11 @@ static int resampler_basic_interpolate_double(SpeexResamplerState* st, spx_uint3 } cubic_coef(frac, interp); - sum = MULT16_32_Q15(interp[0], accum[0]) + MULT16_32_Q15(interp[1], accum[1]) + MULT16_32_Q15(interp[2], accum[2]) + MULT16_32_Q15(interp[3], accum[3]); + sum = MULT16_32_Q15(interp[0], accum[0]) + MULT16_32_Q15(interp[1], accum[1]) + + MULT16_32_Q15(interp[2], accum[2]) + MULT16_32_Q15(interp[3], accum[3]); #else - cubic_coef(frac, interp); - sum = interpolate_product_double(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp); + cubic_coef(frac, interp); + sum = interpolate_product_double(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp); #endif out[out_stride * out_sample++] = PSHR32(sum, 15); @@ -546,7 +580,8 @@ static int resampler_basic_interpolate_double(SpeexResamplerState* st, spx_uint3 for the filter could not be allocated. The expected numbers of input and output samples are still processed so that callers failing to check error codes are not surprised, possibly getting into infinite loops. */ -static int resampler_basic_zero(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) +static int resampler_basic_zero(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_word16_t* in, + spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) { int out_sample = 0; int last_sample = st->last_sample[channel_index]; @@ -578,9 +613,9 @@ static int multiply_frac(spx_uint32_t* result, spx_uint32_t value, spx_uint32_t { spx_uint32_t major = value / den; spx_uint32_t remain = value % den; - /* TODO: Could use 64 bits operation to check for overflow. But only - * guaranteed in C99+ */ - if (remain > UINT32_MAX / num || major > UINT32_MAX / num || major * num > UINT32_MAX - remain * num / den) + /* TODO: Could use 64 bits operation to check for overflow. But only guaranteed in C99+ */ + if (remain > UINT32_MAX / num || major > UINT32_MAX / num + || major * num > UINT32_MAX - remain * num / den) return RESAMPLER_ERR_OVERFLOW; *result = remain * num / den + major * num; return RESAMPLER_ERR_SUCCESS; @@ -625,12 +660,13 @@ static int update_filter(SpeexResamplerState* st) } #ifdef RESAMPLE_FULL_SINC_TABLE - use_direct = 1; - if (INT_MAX / sizeof(spx_word16_t) / st->den_rate < st->filt_len) - goto fail; + use_direct = 1; + if (INT_MAX / sizeof(spx_word16_t) / st->den_rate < st->filt_len) + goto fail; #else /* Choose the resampling type that requires the least amount of memory */ - use_direct = st->filt_len * st->den_rate <= st->filt_len * st->oversample + 8 && INT_MAX / sizeof(spx_word16_t) / st->den_rate >= st->filt_len; + use_direct = st->filt_len * st->den_rate <= st->filt_len * st->oversample + 8 + && INT_MAX / sizeof(spx_word16_t) / st->den_rate >= st->filt_len; #endif if (use_direct) { @@ -645,7 +681,8 @@ static int update_filter(SpeexResamplerState* st) } if (st->sinc_table_length < min_sinc_table_length) { - spx_word16_t* sinc_table = (spx_word16_t*)speex_realloc(st->sinc_table, min_sinc_table_length * sizeof(spx_word16_t)); + spx_word16_t* sinc_table = (spx_word16_t*)speex_realloc(st->sinc_table, + min_sinc_table_length * sizeof(spx_word16_t)); if (!sinc_table) goto fail; @@ -660,35 +697,36 @@ static int update_filter(SpeexResamplerState* st) spx_int32_t j; for (j = 0; j < st->filt_len; j++) { - st->sinc_table[i * st->filt_len + j] = sinc(st->cutoff, ((j - (spx_int32_t)st->filt_len / 2 + 1) - ((float)i) / st->den_rate), st->filt_len, quality_map[st->quality].window_func); + st->sinc_table[i * st->filt_len + j] = sinc( + st->cutoff, ((j - (spx_int32_t)st->filt_len / 2 + 1) - ((float)i) / st->den_rate), st->filt_len, + quality_map[st->quality].window_func); } } #ifdef FIXED_POINT - st->resampler_ptr = resampler_basic_direct_single; + st->resampler_ptr = resampler_basic_direct_single; #else if (st->quality > 8) st->resampler_ptr = resampler_basic_direct_double; else st->resampler_ptr = resampler_basic_direct_single; #endif - /*fprintf (stderr, "resampler uses direct sinc table and normalised cutoff - * %f\n", cutoff);*/ + /*fprintf (stderr, "resampler uses direct sinc table and normalised cutoff %f\n", cutoff);*/ } else { spx_int32_t i; for (i = -4; i < (spx_int32_t)(st->oversample * st->filt_len + 4); i++) - st->sinc_table[i + 4] = sinc(st->cutoff, (i / (float)st->oversample - st->filt_len / 2), st->filt_len, quality_map[st->quality].window_func); + st->sinc_table[i + 4] = sinc(st->cutoff, (i / (float)st->oversample - st->filt_len / 2), st->filt_len, + quality_map[st->quality].window_func); #ifdef FIXED_POINT - st->resampler_ptr = resampler_basic_interpolate_single; + st->resampler_ptr = resampler_basic_interpolate_single; #else if (st->quality > 8) st->resampler_ptr = resampler_basic_interpolate_double; else st->resampler_ptr = resampler_basic_interpolate_single; #endif - /*fprintf (stderr, "resampler uses interpolated sinc table and normalised - * cutoff %f\n", cutoff);*/ + /*fprintf (stderr, "resampler uses interpolated sinc table and normalised cutoff %f\n", cutoff);*/ } /* Here's the place where we update the filter memory to take into account @@ -729,8 +767,7 @@ static int update_filter(SpeexResamplerState* st) { /* Try and remove the magic samples as if nothing had happened */ - /* FIXME: This is wrong but for now we need it to avoid going over the - * array bounds */ + /* FIXME: This is wrong but for now we need it to avoid going over the array bounds */ olen = old_length + 2 * st->magic_samples[i]; for (j = old_length - 1 + st->magic_samples[i]; j--;) st->mem[i * st->mem_alloc_size + j + st->magic_samples[i]] = st->mem[i * old_alloc_size + j]; @@ -740,11 +777,11 @@ static int update_filter(SpeexResamplerState* st) } if (st->filt_len > olen) { - /* If the new filter length is still bigger than the "augmented" length - */ + /* If the new filter length is still bigger than the "augmented" length */ /* Copy data going backward */ for (j = 0; j < olen - 1; j++) - st->mem[i * st->mem_alloc_size + (st->filt_len - 2 - j)] = st->mem[i * st->mem_alloc_size + (olen - 2 - j)]; + st->mem[i * st->mem_alloc_size + (st->filt_len - 2 - j)] = st->mem[i * st->mem_alloc_size + (olen - + 2 - j)]; /* Then put zeros for lack of anything better */ for (; j < st->filt_len - 1; j++) st->mem[i * st->mem_alloc_size + (st->filt_len - 2 - j)] = 0; @@ -763,9 +800,8 @@ static int update_filter(SpeexResamplerState* st) else if (st->filt_len < old_length) { spx_uint32_t i; - /* Reduce filter length, this a bit tricky. We need to store some of the - memory as "magic" samples so they can be used directly as input the next - time(s) */ + /* Reduce filter length, this a bit tricky. We need to store some of the memory as "magic" + samples so they can be used directly as input the next time(s) */ for (i = 0; i < st->nb_channels; i++) { spx_uint32_t j; @@ -789,9 +825,15 @@ static int update_filter(SpeexResamplerState* st) return RESAMPLER_ERR_ALLOC_FAILED; } -EXPORT SpeexResamplerState* speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int* err) { return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality, err); } +EXPORT SpeexResamplerState* speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, + int quality, int* err) +{ + return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality, err); +} -EXPORT SpeexResamplerState* speex_resampler_init_frac(spx_uint32_t nb_channels, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int* err) +EXPORT SpeexResamplerState* speex_resampler_init_frac(spx_uint32_t nb_channels, spx_uint32_t ratio_num, + spx_uint32_t ratio_den, spx_uint32_t in_rate, + spx_uint32_t out_rate, int quality, int* err) { SpeexResamplerState* st; int filter_err; @@ -872,7 +914,8 @@ EXPORT void speex_resampler_destroy(SpeexResamplerState* st) speex_free(st); } -static int speex_resampler_process_native(SpeexResamplerState* st, spx_uint32_t channel_index, spx_uint32_t* in_len, spx_word16_t* out, spx_uint32_t* out_len) +static int speex_resampler_process_native(SpeexResamplerState* st, spx_uint32_t channel_index, spx_uint32_t* in_len, + spx_word16_t* out, spx_uint32_t* out_len) { int j = 0; const int N = st->filt_len; @@ -898,7 +941,8 @@ static int speex_resampler_process_native(SpeexResamplerState* st, spx_uint32_t return RESAMPLER_ERR_SUCCESS; } -static int speex_resampler_magic(SpeexResamplerState* st, spx_uint32_t channel_index, spx_word16_t** out, spx_uint32_t out_len) +static int speex_resampler_magic(SpeexResamplerState* st, spx_uint32_t channel_index, spx_word16_t** out, + spx_uint32_t out_len) { spx_uint32_t tmp_in_len = st->magic_samples[channel_index]; spx_word16_t* mem = st->mem + channel_index * st->mem_alloc_size; @@ -908,8 +952,7 @@ static int speex_resampler_magic(SpeexResamplerState* st, spx_uint32_t channel_i st->magic_samples[channel_index] -= tmp_in_len; - /* If we couldn't process all "magic" input samples, save the rest for next - * time */ + /* If we couldn't process all "magic" input samples, save the rest for next time */ if (st->magic_samples[channel_index]) { spx_uint32_t i; @@ -923,7 +966,8 @@ static int speex_resampler_magic(SpeexResamplerState* st, spx_uint32_t channel_i #ifdef FIXED_POINT EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_int16_t* in, spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len) #else -EXPORT int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t channel_index, const float* in, spx_uint32_t* in_len, float* out, spx_uint32_t* out_len) +EXPORT int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t channel_index, const float* in, + spx_uint32_t* in_len, float* out, spx_uint32_t* out_len) #endif { int j; @@ -969,7 +1013,8 @@ EXPORT int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t c #ifdef FIXED_POINT EXPORT int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t channel_index, const float* in, spx_uint32_t* in_len, float* out, spx_uint32_t* out_len) #else -EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_int16_t* in, spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len) +EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_int16_t* in, + spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len) #endif { int j; @@ -980,8 +1025,8 @@ EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t cha spx_word16_t* x = st->mem + channel_index * st->mem_alloc_size; const spx_uint32_t xlen = st->mem_alloc_size - (st->filt_len - 1); #ifdef VAR_ARRAYS - const unsigned int ylen = (olen < FIXED_STACK_ALLOC) ? olen : FIXED_STACK_ALLOC; - spx_word16_t ystack[ylen]; + const unsigned int ylen = (olen < FIXED_STACK_ALLOC) ? olen : FIXED_STACK_ALLOC; + spx_word16_t ystack[ylen]; #else const unsigned int ylen = FIXED_STACK_ALLOC; spx_word16_t ystack[FIXED_STACK_ALLOC]; @@ -1008,7 +1053,7 @@ EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t cha { for (j = 0; j < ichunk; ++j) #ifdef FIXED_POINT - x[j + st->filt_len - 1] = WORD2INT(in[j * istride_save]); + x[j + st->filt_len - 1] = WORD2INT(in[j * istride_save]); #else x[j + st->filt_len - 1] = in[j * istride_save]; #endif @@ -1029,7 +1074,7 @@ EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t cha for (j = 0; j < ochunk + omagic; ++j) #ifdef FIXED_POINT - out[j * ostride_save] = ystack[j]; + out[j * ostride_save] = ystack[j]; #else out[j * ostride_save] = WORD2INT(ystack[j]); #endif @@ -1047,7 +1092,8 @@ EXPORT int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t cha return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS; } -EXPORT int speex_resampler_process_interleaved_float(SpeexResamplerState* st, const float* in, spx_uint32_t* in_len, float* out, spx_uint32_t* out_len) +EXPORT int speex_resampler_process_interleaved_float(SpeexResamplerState* st, const float* in, spx_uint32_t* in_len, + float* out, spx_uint32_t* out_len) { spx_uint32_t i; int istride_save, ostride_save; @@ -1070,7 +1116,8 @@ EXPORT int speex_resampler_process_interleaved_float(SpeexResamplerState* st, co return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS; } -EXPORT int speex_resampler_process_interleaved_int(SpeexResamplerState* st, const spx_int16_t* in, spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len) +EXPORT int speex_resampler_process_interleaved_int(SpeexResamplerState* st, const spx_int16_t* in, spx_uint32_t* in_len, + spx_int16_t* out, spx_uint32_t* out_len) { spx_uint32_t i; int istride_save, ostride_save; @@ -1093,7 +1140,10 @@ EXPORT int speex_resampler_process_interleaved_int(SpeexResamplerState* st, cons return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS; } -EXPORT int speex_resampler_set_rate(SpeexResamplerState* st, spx_uint32_t in_rate, spx_uint32_t out_rate) { return speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate); } +EXPORT int speex_resampler_set_rate(SpeexResamplerState* st, spx_uint32_t in_rate, spx_uint32_t out_rate) +{ + return speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate); +} EXPORT void speex_resampler_get_rate(SpeexResamplerState* st, spx_uint32_t* in_rate, spx_uint32_t* out_rate) { @@ -1113,7 +1163,8 @@ static inline spx_uint32_t compute_gcd(spx_uint32_t a, spx_uint32_t b) return a; } -EXPORT int speex_resampler_set_rate_frac(SpeexResamplerState* st, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate) +EXPORT int speex_resampler_set_rate_frac(SpeexResamplerState* st, spx_uint32_t ratio_num, spx_uint32_t ratio_den, + spx_uint32_t in_rate, spx_uint32_t out_rate) { spx_uint32_t fact; spx_uint32_t old_den; @@ -1140,7 +1191,8 @@ EXPORT int speex_resampler_set_rate_frac(SpeexResamplerState* st, spx_uint32_t r { for (i = 0; i < st->nb_channels; i++) { - if (multiply_frac(&st->samp_frac_num[i], st->samp_frac_num[i], st->den_rate, old_den) != RESAMPLER_ERR_SUCCESS) + if (multiply_frac(&st->samp_frac_num[i], st->samp_frac_num[i], st->den_rate, old_den) != + RESAMPLER_ERR_SUCCESS) return RESAMPLER_ERR_OVERFLOW; /* Safety net */ if (st->samp_frac_num[i] >= st->den_rate) @@ -1171,19 +1223,40 @@ EXPORT int speex_resampler_set_quality(SpeexResamplerState* st, int quality) return RESAMPLER_ERR_SUCCESS; } -EXPORT void speex_resampler_get_quality(SpeexResamplerState* st, int* quality) { *quality = st->quality; } +EXPORT void speex_resampler_get_quality(SpeexResamplerState* st, int* quality) +{ + *quality = st->quality; +} -EXPORT void speex_resampler_set_input_stride(SpeexResamplerState* st, spx_uint32_t stride) { st->in_stride = stride; } +EXPORT void speex_resampler_set_input_stride(SpeexResamplerState* st, spx_uint32_t stride) +{ + st->in_stride = stride; +} -EXPORT void speex_resampler_get_input_stride(SpeexResamplerState* st, spx_uint32_t* stride) { *stride = st->in_stride; } +EXPORT void speex_resampler_get_input_stride(SpeexResamplerState* st, spx_uint32_t* stride) +{ + *stride = st->in_stride; +} -EXPORT void speex_resampler_set_output_stride(SpeexResamplerState* st, spx_uint32_t stride) { st->out_stride = stride; } +EXPORT void speex_resampler_set_output_stride(SpeexResamplerState* st, spx_uint32_t stride) +{ + st->out_stride = stride; +} -EXPORT void speex_resampler_get_output_stride(SpeexResamplerState* st, spx_uint32_t* stride) { *stride = st->out_stride; } +EXPORT void speex_resampler_get_output_stride(SpeexResamplerState* st, spx_uint32_t* stride) +{ + *stride = st->out_stride; +} -EXPORT int speex_resampler_get_input_latency(SpeexResamplerState* st) { return st->filt_len / 2; } +EXPORT int speex_resampler_get_input_latency(SpeexResamplerState* st) +{ + return st->filt_len / 2; +} -EXPORT int speex_resampler_get_output_latency(SpeexResamplerState* st) { return ((st->filt_len / 2) * st->den_rate + (st->num_rate >> 1)) / st->num_rate; } +EXPORT int speex_resampler_get_output_latency(SpeexResamplerState* st) +{ + return ((st->filt_len / 2) * st->den_rate + (st->num_rate >> 1)) / st->num_rate; +} EXPORT int speex_resampler_skip_zeros(SpeexResamplerState* st) { diff --git a/lib/speex/speex_resampler.h b/lib/speex/speex_resampler.h index f818e371..6651f987 100644 --- a/lib/speex/speex_resampler.h +++ b/lib/speex/speex_resampler.h @@ -4,9 +4,9 @@ Resampling code The design goals of this code are: - - Very fast algorithm - - Low memory requirement - - Good *perceptual* quality (and not best SNR) + - Very fast algorithm + - Low memory requirement + - Good *perceptual* quality (and not best SNR) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are @@ -35,6 +35,7 @@ POSSIBILITY OF SUCH DAMAGE. */ + #ifndef SPEEX_RESAMPLER_H #define SPEEX_RESAMPLER_H @@ -44,8 +45,8 @@ /********* WARNING: MENTAL SANITY ENDS HERE *************/ -/* If the resampler is defined outside of Speex, we change the symbol names so - that there won't be any clash if linking with Speex later on. */ +/* If the resampler is defined outside of Speex, we change the symbol names so that + there won't be any clash if linking with Speex later on. */ /* #define RANDOM_PREFIX your software name here */ #define RANDOM_PREFIX MUPEN @@ -53,31 +54,31 @@ #error "Please define RANDOM_PREFIX (above) to something specific to your project to prevent symbol name clashes" #endif -#define CAT_PREFIX2(a, b) a##b -#define CAT_PREFIX(a, b) CAT_PREFIX2(a, b) - -#define speex_resampler_init CAT_PREFIX(RANDOM_PREFIX, _resampler_init) -#define speex_resampler_init_frac CAT_PREFIX(RANDOM_PREFIX, _resampler_init_frac) -#define speex_resampler_destroy CAT_PREFIX(RANDOM_PREFIX, _resampler_destroy) -#define speex_resampler_process_float CAT_PREFIX(RANDOM_PREFIX, _resampler_process_float) -#define speex_resampler_process_int CAT_PREFIX(RANDOM_PREFIX, _resampler_process_int) -#define speex_resampler_process_interleaved_float CAT_PREFIX(RANDOM_PREFIX, _resampler_process_interleaved_float) -#define speex_resampler_process_interleaved_int CAT_PREFIX(RANDOM_PREFIX, _resampler_process_interleaved_int) -#define speex_resampler_set_rate CAT_PREFIX(RANDOM_PREFIX, _resampler_set_rate) -#define speex_resampler_get_rate CAT_PREFIX(RANDOM_PREFIX, _resampler_get_rate) -#define speex_resampler_set_rate_frac CAT_PREFIX(RANDOM_PREFIX, _resampler_set_rate_frac) -#define speex_resampler_get_ratio CAT_PREFIX(RANDOM_PREFIX, _resampler_get_ratio) -#define speex_resampler_set_quality CAT_PREFIX(RANDOM_PREFIX, _resampler_set_quality) -#define speex_resampler_get_quality CAT_PREFIX(RANDOM_PREFIX, _resampler_get_quality) -#define speex_resampler_set_input_stride CAT_PREFIX(RANDOM_PREFIX, _resampler_set_input_stride) -#define speex_resampler_get_input_stride CAT_PREFIX(RANDOM_PREFIX, _resampler_get_input_stride) -#define speex_resampler_set_output_stride CAT_PREFIX(RANDOM_PREFIX, _resampler_set_output_stride) -#define speex_resampler_get_output_stride CAT_PREFIX(RANDOM_PREFIX, _resampler_get_output_stride) -#define speex_resampler_get_input_latency CAT_PREFIX(RANDOM_PREFIX, _resampler_get_input_latency) -#define speex_resampler_get_output_latency CAT_PREFIX(RANDOM_PREFIX, _resampler_get_output_latency) -#define speex_resampler_skip_zeros CAT_PREFIX(RANDOM_PREFIX, _resampler_skip_zeros) -#define speex_resampler_reset_mem CAT_PREFIX(RANDOM_PREFIX, _resampler_reset_mem) -#define speex_resampler_strerror CAT_PREFIX(RANDOM_PREFIX, _resampler_strerror) +#define CAT_PREFIX2(a,b) a ## b +#define CAT_PREFIX(a,b) CAT_PREFIX2(a, b) + +#define speex_resampler_init CAT_PREFIX(RANDOM_PREFIX,_resampler_init) +#define speex_resampler_init_frac CAT_PREFIX(RANDOM_PREFIX,_resampler_init_frac) +#define speex_resampler_destroy CAT_PREFIX(RANDOM_PREFIX,_resampler_destroy) +#define speex_resampler_process_float CAT_PREFIX(RANDOM_PREFIX,_resampler_process_float) +#define speex_resampler_process_int CAT_PREFIX(RANDOM_PREFIX,_resampler_process_int) +#define speex_resampler_process_interleaved_float CAT_PREFIX(RANDOM_PREFIX,_resampler_process_interleaved_float) +#define speex_resampler_process_interleaved_int CAT_PREFIX(RANDOM_PREFIX,_resampler_process_interleaved_int) +#define speex_resampler_set_rate CAT_PREFIX(RANDOM_PREFIX,_resampler_set_rate) +#define speex_resampler_get_rate CAT_PREFIX(RANDOM_PREFIX,_resampler_get_rate) +#define speex_resampler_set_rate_frac CAT_PREFIX(RANDOM_PREFIX,_resampler_set_rate_frac) +#define speex_resampler_get_ratio CAT_PREFIX(RANDOM_PREFIX,_resampler_get_ratio) +#define speex_resampler_set_quality CAT_PREFIX(RANDOM_PREFIX,_resampler_set_quality) +#define speex_resampler_get_quality CAT_PREFIX(RANDOM_PREFIX,_resampler_get_quality) +#define speex_resampler_set_input_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_set_input_stride) +#define speex_resampler_get_input_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_get_input_stride) +#define speex_resampler_set_output_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_set_output_stride) +#define speex_resampler_get_output_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_get_output_stride) +#define speex_resampler_get_input_latency CAT_PREFIX(RANDOM_PREFIX,_resampler_get_input_latency) +#define speex_resampler_get_output_latency CAT_PREFIX(RANDOM_PREFIX,_resampler_get_output_latency) +#define speex_resampler_skip_zeros CAT_PREFIX(RANDOM_PREFIX,_resampler_skip_zeros) +#define speex_resampler_reset_mem CAT_PREFIX(RANDOM_PREFIX,_resampler_reset_mem) +#define speex_resampler_strerror CAT_PREFIX(RANDOM_PREFIX,_resampler_strerror) #define spx_int16_t short #define spx_int32_t int @@ -102,15 +103,16 @@ extern "C" { #define SPEEX_RESAMPLER_QUALITY_VOIP 3 #define SPEEX_RESAMPLER_QUALITY_DESKTOP 5 -enum { - RESAMPLER_ERR_SUCCESS = 0, - RESAMPLER_ERR_ALLOC_FAILED = 1, - RESAMPLER_ERR_BAD_STATE = 2, - RESAMPLER_ERR_INVALID_ARG = 3, - RESAMPLER_ERR_PTR_OVERLAP = 4, - RESAMPLER_ERR_OVERFLOW = 5, +enum +{ + RESAMPLER_ERR_SUCCESS = 0, + RESAMPLER_ERR_ALLOC_FAILED = 1, + RESAMPLER_ERR_BAD_STATE = 2, + RESAMPLER_ERR_INVALID_ARG = 3, + RESAMPLER_ERR_PTR_OVERLAP = 4, + RESAMPLER_ERR_OVERFLOW = 5, - RESAMPLER_ERR_MAX_ERROR + RESAMPLER_ERR_MAX_ERROR }; struct SpeexResamplerState_; @@ -125,7 +127,11 @@ typedef struct SpeexResamplerState_ SpeexResamplerState; * @return Newly created resampler state * @retval NULL Error: not enough memory */ -SpeexResamplerState* speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int* err); +SpeexResamplerState* speex_resampler_init(spx_uint32_t nb_channels, + spx_uint32_t in_rate, + spx_uint32_t out_rate, + int quality, + int* err); /** Create a new resampler with fractional input/output rates. The sampling * rate ratio is an arbitrary rational number with both the numerator and @@ -140,7 +146,13 @@ SpeexResamplerState* speex_resampler_init(spx_uint32_t nb_channels, spx_uint32_t * @return Newly created resampler state * @retval NULL Error: not enough memory */ -SpeexResamplerState* speex_resampler_init_frac(spx_uint32_t nb_channels, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int* err); +SpeexResamplerState* speex_resampler_init_frac(spx_uint32_t nb_channels, + spx_uint32_t ratio_num, + spx_uint32_t ratio_den, + spx_uint32_t in_rate, + spx_uint32_t out_rate, + int quality, + int* err); /** Destroy a resampler state. * @param st Resampler state @@ -155,10 +167,14 @@ void speex_resampler_destroy(SpeexResamplerState* st); * @param in_len Number of input samples in the input buffer. Returns the * number of samples processed * @param out Output buffer - * @param out_len Size of the output buffer. Returns the number of samples - * written + * @param out_len Size of the output buffer. Returns the number of samples written */ -int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t channel_index, const float* in, spx_uint32_t* in_len, float* out, spx_uint32_t* out_len); +int speex_resampler_process_float(SpeexResamplerState* st, + spx_uint32_t channel_index, + const float* in, + spx_uint32_t* in_len, + float* out, + spx_uint32_t* out_len); /** Resample an int array. The input and output buffers must *not* overlap. * @param st Resampler state @@ -168,48 +184,62 @@ int speex_resampler_process_float(SpeexResamplerState* st, spx_uint32_t channel_ * @param in_len Number of input samples in the input buffer. Returns the number * of samples processed * @param out Output buffer - * @param out_len Size of the output buffer. Returns the number of samples - * written + * @param out_len Size of the output buffer. Returns the number of samples written */ -int speex_resampler_process_int(SpeexResamplerState* st, spx_uint32_t channel_index, const spx_int16_t* in, spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len); - -/** Resample an interleaved float array. The input and output buffers must *not* - * overlap. +int speex_resampler_process_int(SpeexResamplerState* st, + spx_uint32_t channel_index, + const spx_int16_t* in, + spx_uint32_t* in_len, + spx_int16_t* out, + spx_uint32_t* out_len); + +/** Resample an interleaved float array. The input and output buffers must *not* overlap. * @param st Resampler state * @param in Input buffer * @param in_len Number of input samples in the input buffer. Returns the number * of samples processed. This is all per-channel. * @param out Output buffer - * @param out_len Size of the output buffer. Returns the number of samples - * written. This is all per-channel. + * @param out_len Size of the output buffer. Returns the number of samples written. + * This is all per-channel. */ -int speex_resampler_process_interleaved_float(SpeexResamplerState* st, const float* in, spx_uint32_t* in_len, float* out, spx_uint32_t* out_len); +int speex_resampler_process_interleaved_float(SpeexResamplerState* st, + const float* in, + spx_uint32_t* in_len, + float* out, + spx_uint32_t* out_len); -/** Resample an interleaved int array. The input and output buffers must *not* - * overlap. +/** Resample an interleaved int array. The input and output buffers must *not* overlap. * @param st Resampler state * @param in Input buffer * @param in_len Number of input samples in the input buffer. Returns the number * of samples processed. This is all per-channel. * @param out Output buffer - * @param out_len Size of the output buffer. Returns the number of samples - * written. This is all per-channel. + * @param out_len Size of the output buffer. Returns the number of samples written. + * This is all per-channel. */ -int speex_resampler_process_interleaved_int(SpeexResamplerState* st, const spx_int16_t* in, spx_uint32_t* in_len, spx_int16_t* out, spx_uint32_t* out_len); +int speex_resampler_process_interleaved_int(SpeexResamplerState* st, + const spx_int16_t* in, + spx_uint32_t* in_len, + spx_int16_t* out, + spx_uint32_t* out_len); /** Set (change) the input/output sampling rates (integer value). * @param st Resampler state * @param in_rate Input sampling rate (integer number of Hz). * @param out_rate Output sampling rate (integer number of Hz). */ -int speex_resampler_set_rate(SpeexResamplerState* st, spx_uint32_t in_rate, spx_uint32_t out_rate); +int speex_resampler_set_rate(SpeexResamplerState* st, + spx_uint32_t in_rate, + spx_uint32_t out_rate); /** Get the current input/output sampling rates (integer value). * @param st Resampler state * @param in_rate Input sampling rate (integer number of Hz) copied. * @param out_rate Output sampling rate (integer number of Hz) copied. */ -void speex_resampler_get_rate(SpeexResamplerState* st, spx_uint32_t* in_rate, spx_uint32_t* out_rate); +void speex_resampler_get_rate(SpeexResamplerState* st, + spx_uint32_t* in_rate, + spx_uint32_t* out_rate); /** Set (change) the input/output sampling rates and resampling ratio * (fractional values in Hz supported). @@ -219,7 +249,11 @@ void speex_resampler_get_rate(SpeexResamplerState* st, spx_uint32_t* in_rate, sp * @param in_rate Input sampling rate rounded to the nearest integer (in Hz). * @param out_rate Output sampling rate rounded to the nearest integer (in Hz). */ -int speex_resampler_set_rate_frac(SpeexResamplerState* st, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate); +int speex_resampler_set_rate_frac(SpeexResamplerState* st, + spx_uint32_t ratio_num, + spx_uint32_t ratio_den, + spx_uint32_t in_rate, + spx_uint32_t out_rate); /** Get the current resampling ratio. This will be reduced to the least * common denominator. @@ -227,45 +261,53 @@ int speex_resampler_set_rate_frac(SpeexResamplerState* st, spx_uint32_t ratio_nu * @param ratio_num Numerator of the sampling rate ratio copied * @param ratio_den Denominator of the sampling rate ratio copied */ -void speex_resampler_get_ratio(SpeexResamplerState* st, spx_uint32_t* ratio_num, spx_uint32_t* ratio_den); +void speex_resampler_get_ratio(SpeexResamplerState* st, + spx_uint32_t* ratio_num, + spx_uint32_t* ratio_den); /** Set (change) the conversion quality. * @param st Resampler state * @param quality Resampling quality between 0 and 10, where 0 has poor * quality and 10 has very high quality. */ -int speex_resampler_set_quality(SpeexResamplerState* st, int quality); +int speex_resampler_set_quality(SpeexResamplerState* st, + int quality); /** Get the conversion quality. * @param st Resampler state * @param quality Resampling quality between 0 and 10, where 0 has poor * quality and 10 has very high quality. */ -void speex_resampler_get_quality(SpeexResamplerState* st, int* quality); +void speex_resampler_get_quality(SpeexResamplerState* st, + int* quality); /** Set (change) the input stride. * @param st Resampler state * @param stride Input stride */ -void speex_resampler_set_input_stride(SpeexResamplerState* st, spx_uint32_t stride); +void speex_resampler_set_input_stride(SpeexResamplerState* st, + spx_uint32_t stride); /** Get the input stride. * @param st Resampler state * @param stride Input stride copied */ -void speex_resampler_get_input_stride(SpeexResamplerState* st, spx_uint32_t* stride); +void speex_resampler_get_input_stride(SpeexResamplerState* st, + spx_uint32_t* stride); /** Set (change) the output stride. * @param st Resampler state * @param stride Output stride */ -void speex_resampler_set_output_stride(SpeexResamplerState* st, spx_uint32_t stride); +void speex_resampler_set_output_stride(SpeexResamplerState* st, + spx_uint32_t stride); /** Get the output stride. * @param st Resampler state copied * @param stride Output stride */ -void speex_resampler_get_output_stride(SpeexResamplerState* st, spx_uint32_t* stride); +void speex_resampler_get_output_stride(SpeexResamplerState* st, + spx_uint32_t* stride); /** Get the latency introduced by the resampler measured in input samples. * @param st Resampler state diff --git a/lib/xxhash/xxh64.h b/lib/xxhash/xxh64.h index f200af04..760f4d89 100644 --- a/lib/xxhash/xxh64.h +++ b/lib/xxhash/xxh64.h @@ -26,32 +26,74 @@ #include struct xxh64 { - static constexpr uint64_t hash(const char* p, uint64_t len, uint64_t seed) { return finalize((len >= 32 ? h32bytes(p, len, seed) : seed + PRIME5) + len, p + (len & ~0x1F), len & 0x1F); } - + static constexpr uint64_t hash (const char *p, uint64_t len, uint64_t seed) { + return finalize ((len >= 32 ? h32bytes (p, len, seed) : seed + PRIME5) + len, p + (len & ~0x1F), len & 0x1F); + } private: static constexpr uint64_t PRIME1 = 11400714785074694791ULL; static constexpr uint64_t PRIME2 = 14029467366897019727ULL; - static constexpr uint64_t PRIME3 = 1609587929392839161ULL; - static constexpr uint64_t PRIME4 = 9650029242287828579ULL; - static constexpr uint64_t PRIME5 = 2870177450012600261ULL; + static constexpr uint64_t PRIME3 = 1609587929392839161ULL; + static constexpr uint64_t PRIME4 = 9650029242287828579ULL; + static constexpr uint64_t PRIME5 = 2870177450012600261ULL; - static constexpr uint64_t rotl(uint64_t x, int r) { return ((x << r) | (x >> (64 - r))); } - static constexpr uint64_t mix1(const uint64_t h, const uint64_t prime, int rshift) { return (h ^ (h >> rshift)) * prime; } - static constexpr uint64_t mix2(const uint64_t p, const uint64_t v = 0) { return rotl(v + p * PRIME2, 31) * PRIME1; } - static constexpr uint64_t mix3(const uint64_t h, const uint64_t v) { return (h ^ mix2(v)) * PRIME1 + PRIME4; } + static constexpr uint64_t rotl (uint64_t x, int r) { + return ((x << r) | (x >> (64 - r))); + } + static constexpr uint64_t mix1 (const uint64_t h, const uint64_t prime, int rshift) { + return (h ^ (h >> rshift)) * prime; + } + static constexpr uint64_t mix2 (const uint64_t p, const uint64_t v = 0) { + return rotl (v + p * PRIME2, 31) * PRIME1; + } + static constexpr uint64_t mix3 (const uint64_t h, const uint64_t v) { + return (h ^ mix2 (v)) * PRIME1 + PRIME4; + } #ifdef XXH64_BIG_ENDIAN - static constexpr uint32_t endian32(const char* v) { return uint32_t(uint8_t(v[3])) | (uint32_t(uint8_t(v[2])) << 8) | (uint32_t(uint8_t(v[1])) << 16) | (uint32_t(uint8_t(v[0])) << 24); } - static constexpr uint64_t endian64(const char* v) { return uint64_t(uint8_t(v[7])) | (uint64_t(uint8_t(v[6])) << 8) | (uint64_t(uint8_t(v[5])) << 16) | (uint64_t(uint8_t(v[4])) << 24) | (uint64_t(uint8_t(v[3])) << 32) | (uint64_t(uint8_t(v[2])) << 40) | (uint64_t(uint8_t(v[1])) << 48) | (uint64_t(uint8_t(v[0])) << 56); } + static constexpr uint32_t endian32 (const char *v) { + return uint32_t(uint8_t(v[3]))|(uint32_t(uint8_t(v[2]))<<8) + |(uint32_t(uint8_t(v[1]))<<16)|(uint32_t(uint8_t(v[0]))<<24); + } + static constexpr uint64_t endian64 (const char *v) + { + return uint64_t(uint8_t(v[7]))|(uint64_t(uint8_t(v[6]))<<8) + |(uint64_t(uint8_t(v[5]))<<16)|(uint64_t(uint8_t(v[4]))<<24) + |(uint64_t(uint8_t(v[3]))<<32)|(uint64_t(uint8_t(v[2]))<<40) + |(uint64_t(uint8_t(v[1]))<<48)|(uint64_t(uint8_t(v[0]))<<56); + } #else - static constexpr uint32_t endian32(const char* v) { return uint32_t(uint8_t(v[0])) | (uint32_t(uint8_t(v[1])) << 8) | (uint32_t(uint8_t(v[2])) << 16) | (uint32_t(uint8_t(v[3])) << 24); } - static constexpr uint64_t endian64(const char* v) { return uint64_t(uint8_t(v[0])) | (uint64_t(uint8_t(v[1])) << 8) | (uint64_t(uint8_t(v[2])) << 16) | (uint64_t(uint8_t(v[3])) << 24) | (uint64_t(uint8_t(v[4])) << 32) | (uint64_t(uint8_t(v[5])) << 40) | (uint64_t(uint8_t(v[6])) << 48) | (uint64_t(uint8_t(v[7])) << 56); } + static constexpr uint32_t endian32 (const char *v) { + return uint32_t(uint8_t(v[0]))|(uint32_t(uint8_t(v[1]))<<8) + |(uint32_t(uint8_t(v[2]))<<16)|(uint32_t(uint8_t(v[3]))<<24); + } + static constexpr uint64_t endian64 (const char *v) { + return uint64_t(uint8_t(v[0]))|(uint64_t(uint8_t(v[1]))<<8) + |(uint64_t(uint8_t(v[2]))<<16)|(uint64_t(uint8_t(v[3]))<<24) + |(uint64_t(uint8_t(v[4]))<<32)|(uint64_t(uint8_t(v[5]))<<40) + |(uint64_t(uint8_t(v[6]))<<48)|(uint64_t(uint8_t(v[7]))<<56); + } #endif - static constexpr uint64_t fetch64(const char* p, const uint64_t v = 0) { return mix2(endian64(p), v); } - static constexpr uint64_t fetch32(const char* p) { return uint64_t(endian32(p)) * PRIME1; } - static constexpr uint64_t fetch8(const char* p) { return uint8_t(*p) * PRIME5; } - static constexpr uint64_t finalize(const uint64_t h, const char* p, uint64_t len) { return (len >= 8) ? (finalize(rotl(h ^ fetch64(p), 27) * PRIME1 + PRIME4, p + 8, len - 8)) : ((len >= 4) ? (finalize(rotl(h ^ fetch32(p), 23) * PRIME2 + PRIME3, p + 4, len - 4)) : ((len > 0) ? (finalize(rotl(h ^ fetch8(p), 11) * PRIME1, p + 1, len - 1)) : (mix1(mix1(mix1(h, PRIME2, 33), PRIME3, 29), 1, 32)))); } - static constexpr uint64_t h32bytes(const char* p, uint64_t len, const uint64_t v1, const uint64_t v2, const uint64_t v3, const uint64_t v4) { return (len >= 32) ? h32bytes(p + 32, len - 32, fetch64(p, v1), fetch64(p + 8, v2), fetch64(p + 16, v3), fetch64(p + 24, v4)) : mix3(mix3(mix3(mix3(rotl(v1, 1) + rotl(v2, 7) + rotl(v3, 12) + rotl(v4, 18), v1), v2), v3), v4); } - static constexpr uint64_t h32bytes(const char* p, uint64_t len, const uint64_t seed) { return h32bytes(p, len, seed + PRIME1 + PRIME2, seed + PRIME2, seed, seed - PRIME1); } + static constexpr uint64_t fetch64 (const char *p, const uint64_t v = 0) { + return mix2 (endian64 (p), v); + } + static constexpr uint64_t fetch32 (const char *p) { + return uint64_t (endian32 (p)) * PRIME1; + } + static constexpr uint64_t fetch8 (const char *p) { + return uint8_t (*p) * PRIME5; + } + static constexpr uint64_t finalize (const uint64_t h, const char *p, uint64_t len) { + return (len >= 8) ? (finalize (rotl (h ^ fetch64 (p), 27) * PRIME1 + PRIME4, p + 8, len - 8)) : + ((len >= 4) ? (finalize (rotl (h ^ fetch32 (p), 23) * PRIME2 + PRIME3, p + 4, len - 4)) : + ((len > 0) ? (finalize (rotl (h ^ fetch8 (p), 11) * PRIME1, p + 1, len - 1)) : + (mix1 (mix1 (mix1 (h, PRIME2, 33), PRIME3, 29), 1, 32)))); + } + static constexpr uint64_t h32bytes (const char *p, uint64_t len, const uint64_t v1,const uint64_t v2, const uint64_t v3, const uint64_t v4) { + return (len >= 32) ? h32bytes (p + 32, len - 32, fetch64 (p, v1), fetch64 (p + 8, v2), fetch64 (p + 16, v3), fetch64 (p + 24, v4)) : + mix3 (mix3 (mix3 (mix3 (rotl (v1, 1) + rotl (v2, 7) + rotl (v3, 12) + rotl (v4, 18), v1), v2), v3), v4); + } + static constexpr uint64_t h32bytes (const char *p, uint64_t len, const uint64_t seed) { + return h32bytes (p, len, seed + PRIME1 + PRIME2, seed + PRIME2, seed, seed - PRIME1); + } }; #endif /* !defined XXH64_HPP */ diff --git a/lib/zlib-x64/zconf.h b/lib/zlib-x64/zconf.h index 8a629f5d..99368623 100644 --- a/lib/zlib-x64/zconf.h +++ b/lib/zlib-x64/zconf.h @@ -16,180 +16,180 @@ * Even better than compiling with -DZ_PREFIX would be to use configure to set * this permanently in zconf.h using "./configure --zprefix". */ -#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ -#define Z_PREFIX_SET +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET /* all linked symbols and init macros */ -#define _dist_code z__dist_code -#define _length_code z__length_code -#define _tr_align z__tr_align -#define _tr_flush_bits z__tr_flush_bits -#define _tr_flush_block z__tr_flush_block -#define _tr_init z__tr_init -#define _tr_stored_block z__tr_stored_block -#define _tr_tally z__tr_tally -#define adler32 z_adler32 -#define adler32_combine z_adler32_combine -#define adler32_combine64 z_adler32_combine64 -#define adler32_z z_adler32_z -#ifndef Z_SOLO -#define compress z_compress -#define compress2 z_compress2 -#define compressBound z_compressBound -#endif -#define crc32 z_crc32 -#define crc32_combine z_crc32_combine -#define crc32_combine64 z_crc32_combine64 -#define crc32_combine_gen z_crc32_combine_gen -#define crc32_combine_gen64 z_crc32_combine_gen64 -#define crc32_combine_op z_crc32_combine_op -#define crc32_z z_crc32_z -#define deflate z_deflate -#define deflateBound z_deflateBound -#define deflateCopy z_deflateCopy -#define deflateEnd z_deflateEnd -#define deflateGetDictionary z_deflateGetDictionary -#define deflateInit z_deflateInit -#define deflateInit2 z_deflateInit2 -#define deflateInit2_ z_deflateInit2_ -#define deflateInit_ z_deflateInit_ -#define deflateParams z_deflateParams -#define deflatePending z_deflatePending -#define deflatePrime z_deflatePrime -#define deflateReset z_deflateReset -#define deflateResetKeep z_deflateResetKeep -#define deflateSetDictionary z_deflateSetDictionary -#define deflateSetHeader z_deflateSetHeader -#define deflateTune z_deflateTune -#define deflate_copyright z_deflate_copyright -#define get_crc_table z_get_crc_table -#ifndef Z_SOLO -#define gz_error z_gz_error -#define gz_intmax z_gz_intmax -#define gz_strwinerror z_gz_strwinerror -#define gzbuffer z_gzbuffer -#define gzclearerr z_gzclearerr -#define gzclose z_gzclose -#define gzclose_r z_gzclose_r -#define gzclose_w z_gzclose_w -#define gzdirect z_gzdirect -#define gzdopen z_gzdopen -#define gzeof z_gzeof -#define gzerror z_gzerror -#define gzflush z_gzflush -#define gzfread z_gzfread -#define gzfwrite z_gzfwrite -#define gzgetc z_gzgetc -#define gzgetc_ z_gzgetc_ -#define gzgets z_gzgets -#define gzoffset z_gzoffset -#define gzoffset64 z_gzoffset64 -#define gzopen z_gzopen -#define gzopen64 z_gzopen64 -#ifdef _WIN32 -#define gzopen_w z_gzopen_w -#endif -#define gzprintf z_gzprintf -#define gzputc z_gzputc -#define gzputs z_gzputs -#define gzread z_gzread -#define gzrewind z_gzrewind -#define gzseek z_gzseek -#define gzseek64 z_gzseek64 -#define gzsetparams z_gzsetparams -#define gztell z_gztell -#define gztell64 z_gztell64 -#define gzungetc z_gzungetc -#define gzvprintf z_gzvprintf -#define gzwrite z_gzwrite -#endif -#define inflate z_inflate -#define inflateBack z_inflateBack -#define inflateBackEnd z_inflateBackEnd -#define inflateBackInit z_inflateBackInit -#define inflateBackInit_ z_inflateBackInit_ -#define inflateCodesUsed z_inflateCodesUsed -#define inflateCopy z_inflateCopy -#define inflateEnd z_inflateEnd -#define inflateGetDictionary z_inflateGetDictionary -#define inflateGetHeader z_inflateGetHeader -#define inflateInit z_inflateInit -#define inflateInit2 z_inflateInit2 -#define inflateInit2_ z_inflateInit2_ -#define inflateInit_ z_inflateInit_ -#define inflateMark z_inflateMark -#define inflatePrime z_inflatePrime -#define inflateReset z_inflateReset -#define inflateReset2 z_inflateReset2 -#define inflateResetKeep z_inflateResetKeep -#define inflateSetDictionary z_inflateSetDictionary -#define inflateSync z_inflateSync -#define inflateSyncPoint z_inflateSyncPoint -#define inflateUndermine z_inflateUndermine -#define inflateValidate z_inflateValidate -#define inflate_copyright z_inflate_copyright -#define inflate_fast z_inflate_fast -#define inflate_table z_inflate_table -#ifndef Z_SOLO -#define uncompress z_uncompress -#define uncompress2 z_uncompress2 -#endif -#define zError z_zError -#ifndef Z_SOLO -#define zcalloc z_zcalloc -#define zcfree z_zcfree -#endif -#define zlibCompileFlags z_zlibCompileFlags -#define zlibVersion z_zlibVersion +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# define adler32_z z_adler32_z +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define crc32_combine_gen z_crc32_combine_gen +# define crc32_combine_gen64 z_crc32_combine_gen64 +# define crc32_combine_op z_crc32_combine_op +# define crc32_z z_crc32_z +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateGetDictionary z_deflateGetDictionary +# define deflateInit z_deflateInit +# define deflateInit2 z_deflateInit2 +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzfread z_gzfread +# define gzfwrite z_gzfwrite +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzvprintf z_gzvprintf +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit z_inflateBackInit +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCodesUsed z_inflateCodesUsed +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetDictionary z_inflateGetDictionary +# define inflateGetHeader z_inflateGetHeader +# define inflateInit z_inflateInit +# define inflateInit2 z_inflateInit2 +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateResetKeep z_inflateResetKeep +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateValidate z_inflateValidate +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# define uncompress2 z_uncompress2 +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion /* all zlib typedefs in zlib.h and zconf.h */ -#define Byte z_Byte -#define Bytef z_Bytef -#define alloc_func z_alloc_func -#define charf z_charf -#define free_func z_free_func -#ifndef Z_SOLO -#define gzFile z_gzFile -#endif -#define gz_header z_gz_header -#define gz_headerp z_gz_headerp -#define in_func z_in_func -#define intf z_intf -#define out_func z_out_func -#define uInt z_uInt -#define uIntf z_uIntf -#define uLong z_uLong -#define uLongf z_uLongf -#define voidp z_voidp -#define voidpc z_voidpc -#define voidpf z_voidpf +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf /* all zlib structs in zlib.h and zconf.h */ -#define gz_header_s z_gz_header_s -#define internal_state z_internal_state +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state #endif #if defined(__MSDOS__) && !defined(MSDOS) -#define MSDOS +# define MSDOS #endif #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) -#define OS2 +# define OS2 #endif #if defined(_WINDOWS) && !defined(WINDOWS) -#define WINDOWS +# define WINDOWS #endif #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) -#ifndef WIN32 -#define WIN32 -#endif +# ifndef WIN32 +# define WIN32 +# endif #endif #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) -#if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) -#ifndef SYS16BIT -#define SYS16BIT -#endif -#endif +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif #endif /* @@ -197,77 +197,77 @@ * than 64k bytes at a time (needed on systems with 16-bit int). */ #ifdef SYS16BIT -#define MAXSEG_64K +# define MAXSEG_64K #endif #ifdef MSDOS -#define UNALIGNED_OK +# define UNALIGNED_OK #endif #ifdef __STDC_VERSION__ -#ifndef STDC -#define STDC -#endif -#if __STDC_VERSION__ >= 199901L -#ifndef STDC99 -#define STDC99 -#endif -#endif +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif #endif #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) -#define STDC +# define STDC #endif -#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ -#define STDC +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC #endif #ifndef STDC -#ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ -#define const /* note: need a more gentle solution here */ -#endif +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif #endif #if defined(ZLIB_CONST) && !defined(z_const) -#define z_const const +# define z_const const #else -#define z_const +# define z_const #endif #ifdef Z_SOLO -#ifdef _WIN64 -typedef unsigned long long z_size_t; +# ifdef _WIN64 + typedef unsigned long long z_size_t; +# else + typedef unsigned long z_size_t; +# endif #else -typedef unsigned long z_size_t; -#endif -#else -#define z_longlong long long -#if defined(NO_SIZE_T) -typedef unsigned NO_SIZE_T z_size_t; -#elif defined(STDC) -#include -typedef size_t z_size_t; -#else -typedef unsigned long z_size_t; -#endif -#undef z_longlong +# define z_longlong long long +# if defined(NO_SIZE_T) + typedef unsigned NO_SIZE_T z_size_t; +# elif defined(STDC) +# include + typedef size_t z_size_t; +# else + typedef unsigned long z_size_t; +# endif +# undef z_longlong #endif /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL -#ifdef MAXSEG_64K -#define MAX_MEM_LEVEL 8 -#else -#define MAX_MEM_LEVEL 9 -#endif +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif #endif /* Maximum value for windowBits in deflateInit2 and inflateInit2. @@ -276,7 +276,7 @@ typedef unsigned long z_size_t; * gzip.) */ #ifndef MAX_WBITS -#define MAX_WBITS 15 /* 32K LZ77 window */ +# define MAX_WBITS 15 /* 32K LZ77 window */ #endif /* The memory requirements for deflate are (in bytes): @@ -292,14 +292,14 @@ typedef unsigned long z_size_t; for small objects. */ -/* Type declarations */ + /* Type declarations */ #ifndef OF /* function prototypes */ -#ifdef STDC -#define OF(args) args -#else -#define OF(args) () -#endif +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif #endif /* The following definitions for FAR are needed only for MSDOS mixed @@ -309,164 +309,164 @@ typedef unsigned long z_size_t; * just define FAR to be empty. */ #ifdef SYS16BIT -#if defined(M_I86SM) || defined(M_I86MM) -/* MSC small or medium model */ -#define SMALL_MEDIUM -#ifdef _MSC_VER -#define FAR _far -#else -#define FAR far -#endif -#endif -#if (defined(__SMALL__) || defined(__MEDIUM__)) -/* Turbo C small or medium model */ -#define SMALL_MEDIUM -#ifdef __BORLANDC__ -#define FAR _far -#else -#define FAR far -#endif -#endif +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif #endif #if defined(WINDOWS) || defined(WIN32) -/* If building or using zlib as a DLL, define ZLIB_DLL. - * This is not mandatory, but it offers a little performance increase. - */ -#if 0 -#if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) -#ifdef ZLIB_INTERNAL -#define ZEXTERN extern __declspec(dllexport) -#else -#define ZEXTERN extern __declspec(dllimport) -#endif -#endif -#endif /* ZLIB_DLL */ -/* If building or using zlib with the WINAPI/WINAPIV calling convention, - * define ZLIB_WINAPI. - * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. - */ -#ifdef ZLIB_WINAPI -#ifdef FAR -#undef FAR -#endif -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#include -/* No need for _export, use ZLIB.DEF instead. */ -/* For complete Windows compatibility, use WINAPI, not __stdcall. */ -#define ZEXPORT WINAPI -#ifdef WIN32 -#define ZEXPORTVA WINAPIV -#else -#define ZEXPORTVA FAR CDECL -#endif -#endif -#endif - -#if defined(__BEOS__) -#if 0 -#ifdef ZLIB_INTERNAL -#define ZEXPORT __declspec(dllexport) -#define ZEXPORTVA __declspec(dllexport) -#else -#define ZEXPORT __declspec(dllimport) -#define ZEXPORTVA __declspec(dllimport) -#endif -#endif + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# if 0 +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# if 0 +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif #endif #ifndef ZEXTERN -#define ZEXTERN extern +# define ZEXTERN extern #endif #ifndef ZEXPORT -#define ZEXPORT +# define ZEXPORT #endif #ifndef ZEXPORTVA -#define ZEXPORTVA +# define ZEXPORTVA #endif #ifndef FAR -#define FAR +# define FAR #endif #if !defined(__MACTYPES__) -typedef unsigned char Byte; /* 8 bits */ +typedef unsigned char Byte; /* 8 bits */ #endif -typedef unsigned int uInt; /* 16 bits or more */ -typedef unsigned long uLong; /* 32 bits or more */ +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ #ifdef SMALL_MEDIUM -/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ -#define Bytef Byte FAR + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR #else -typedef Byte FAR Bytef; + typedef Byte FAR Bytef; #endif -typedef char FAR charf; -typedef int FAR intf; -typedef uInt FAR uIntf; +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC -typedef void const* voidpc; -typedef void FAR* voidpf; -typedef void* voidp; + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; #else -typedef Byte const* voidpc; -typedef Byte FAR* voidpf; -typedef Byte* voidp; + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; #endif #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) -#include -#if (UINT_MAX == 0xffffffffUL) -#define Z_U4 unsigned -#elif (ULONG_MAX == 0xffffffffUL) -#define Z_U4 unsigned long -#elif (USHRT_MAX == 0xffffffffUL) -#define Z_U4 unsigned short -#endif +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif #endif #ifdef Z_U4 -typedef Z_U4 z_crc_t; + typedef Z_U4 z_crc_t; #else -typedef unsigned long z_crc_t; + typedef unsigned long z_crc_t; #endif -#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ -#if ~(~HAVE_UNISTD_H + 0) == 0 && ~(~HAVE_UNISTD_H + 1) == 1 -#define Z_HAVE_UNISTD_H -#elif HAVE_UNISTD_H != 0 -#define Z_HAVE_UNISTD_H -#endif +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# if ~(~HAVE_UNISTD_H + 0) == 0 && ~(~HAVE_UNISTD_H + 1) == 1 +# define Z_HAVE_UNISTD_H +# elif HAVE_UNISTD_H != 0 +# define Z_HAVE_UNISTD_H +# endif #endif -#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ -#if ~(~HAVE_STDARG_H + 0) == 0 && ~(~HAVE_STDARG_H + 1) == 1 -#define Z_HAVE_STDARG_H -#elif HAVE_STDARG_H != 0 -#define Z_HAVE_STDARG_H -#endif +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# if ~(~HAVE_STDARG_H + 0) == 0 && ~(~HAVE_STDARG_H + 1) == 1 +# define Z_HAVE_STDARG_H +# elif HAVE_STDARG_H != 0 +# define Z_HAVE_STDARG_H +# endif #endif #ifdef STDC -#ifndef Z_SOLO -#include /* for off_t */ -#endif +# ifndef Z_SOLO +# include /* for off_t */ +# endif #endif #if defined(STDC) || defined(Z_HAVE_STDARG_H) -#ifndef Z_SOLO -#include /* for va_list */ -#endif +# ifndef Z_SOLO +# include /* for va_list */ +# endif #endif #ifdef _WIN32 -#ifndef Z_SOLO -#include /* for wchar_t */ -#endif +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif #endif /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and @@ -476,78 +476,78 @@ typedef unsigned long z_crc_t; * equivalently requesting no 64-bit operations */ #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 -#undef _LARGEFILE64_SOURCE +# undef _LARGEFILE64_SOURCE #endif #ifndef Z_HAVE_UNISTD_H -#ifdef __WATCOMC__ -#define Z_HAVE_UNISTD_H -#endif +# ifdef __WATCOMC__ +# define Z_HAVE_UNISTD_H +# endif #endif #ifndef Z_HAVE_UNISTD_H -#if defined(_LARGEFILE64_SOURCE) && !defined(_WIN32) -#define Z_HAVE_UNISTD_H -#endif +# if defined(_LARGEFILE64_SOURCE) && !defined(_WIN32) +# define Z_HAVE_UNISTD_H +# endif #endif #ifndef Z_SOLO -#if defined(Z_HAVE_UNISTD_H) -#include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ -#ifdef VMS -#include /* for off_t */ -#endif -#ifndef z_off_t -#define z_off_t off_t -#endif -#endif +# if defined(Z_HAVE_UNISTD_H) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif #endif -#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE - 0 -#define Z_LFS64 +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 #endif #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) -#define Z_LARGE64 +# define Z_LARGE64 #endif -#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS - 0 == 64 && defined(Z_LFS64) -#define Z_WANT64 +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 #endif #if !defined(SEEK_SET) && !defined(Z_SOLO) -#define SEEK_SET 0 /* Seek from beginning of file. */ -#define SEEK_CUR 1 /* Seek from current position. */ -#define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ #endif #ifndef z_off_t -#define z_off_t long +# define z_off_t long #endif #if !defined(_WIN32) && defined(Z_LARGE64) -#define z_off64_t off64_t -#else -#if defined(_WIN32) && !defined(__GNUC__) -#define z_off64_t __int64 +# define z_off64_t off64_t #else -#define z_off64_t z_off_t -#endif +# if defined(_WIN32) && !defined(__GNUC__) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif #endif /* MVS linker does not support external names larger than 8 bytes */ #if defined(__MVS__) -#pragma map(deflateInit_, "DEIN") -#pragma map(deflateInit2_, "DEIN2") -#pragma map(deflateEnd, "DEEND") -#pragma map(deflateBound, "DEBND") -#pragma map(inflateInit_, "ININ") -#pragma map(inflateInit2_, "ININ2") -#pragma map(inflateEnd, "INEND") -#pragma map(inflateSync, "INSY") -#pragma map(inflateSetDictionary, "INSEDI") -#pragma map(compressBound, "CMBND") -#pragma map(inflate_table, "INTABL") -#pragma map(inflate_fast, "INFA") -#pragma map(inflate_copyright, "INCOPY") + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") #endif #endif /* ZCONF_H */ diff --git a/lib/zlib-x64/zlib.h b/lib/zlib-x64/zlib.h index a97ffffe..8d4b932e 100644 --- a/lib/zlib-x64/zlib.h +++ b/lib/zlib-x64/zlib.h @@ -79,56 +79,56 @@ extern "C" { */ typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size); -typedef void (*free_func)(voidpf opaque, voidpf address); +typedef void (*free_func)(voidpf opaque, voidpf address); struct internal_state; typedef struct z_stream_s { - z_const Bytef* next_in; /* next input byte */ - uInt avail_in; /* number of bytes available at next_in */ - uLong total_in; /* total number of input bytes read so far */ + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total number of input bytes read so far */ - Bytef* next_out; /* next output byte will go here */ - uInt avail_out; /* remaining free space at next_out */ - uLong total_out; /* total number of bytes output so far */ + Bytef *next_out; /* next output byte will go here */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total number of bytes output so far */ - z_const char* msg; /* last error message, NULL if no error */ - struct internal_state FAR* state; /* not visible by applications */ + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ - alloc_func zalloc; /* used to allocate the internal state */ - free_func zfree; /* used to free the internal state */ - voidpf opaque; /* private data object passed to zalloc and zfree */ + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ - int data_type; /* best guess about the data type: binary or text - for deflate, or the decoding state for inflate */ - uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */ - uLong reserved; /* reserved for future use */ + int data_type; /* best guess about the data type: binary or text + for deflate, or the decoding state for inflate */ + uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ } z_stream; -typedef z_stream FAR* z_streamp; +typedef z_stream FAR *z_streamp; /* gzip header information passed to and from zlib routines. See RFC 1952 for more details on the meanings of these fields. */ typedef struct gz_header_s { - int text; /* true if compressed data believed to be text */ - uLong time; /* modification time */ - int xflags; /* extra flags (not used when writing a gzip file) */ - int os; /* operating system */ - Bytef* extra; /* pointer to extra field or Z_NULL if none */ - uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ - uInt extra_max; /* space at extra (only when reading header) */ - Bytef* name; /* pointer to zero-terminated file name or Z_NULL */ - uInt name_max; /* space at name (only when reading header) */ - Bytef* comment; /* pointer to zero-terminated comment or Z_NULL */ - uInt comm_max; /* space at comment (only when reading header) */ - int hcrc; /* true if there was or will be a header crc */ - int done; /* true when done reading gzip header (not used - when writing a gzip file) */ + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ } gz_header; -typedef gz_header FAR* gz_headerp; +typedef gz_header FAR *gz_headerp; /* The application must update next_in and avail_in when avail_in has dropped @@ -163,60 +163,61 @@ typedef gz_header FAR* gz_headerp; if the decompressor wants to decompress everything in a single step). */ -/* constants */ + /* constants */ -#define Z_NO_FLUSH 0 +#define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 -#define Z_SYNC_FLUSH 2 -#define Z_FULL_FLUSH 3 -#define Z_FINISH 4 -#define Z_BLOCK 5 -#define Z_TREES 6 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +#define Z_TREES 6 /* Allowed flush values; see deflate() and inflate() below for details */ -#define Z_OK 0 -#define Z_STREAM_END 1 -#define Z_NEED_DICT 2 -#define Z_ERRNO (-1) +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) #define Z_STREAM_ERROR (-2) -#define Z_DATA_ERROR (-3) -#define Z_MEM_ERROR (-4) -#define Z_BUF_ERROR (-5) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) #define Z_VERSION_ERROR (-6) /* Return codes for the compression/decompression functions. Negative values * are errors, positive values are used for special but normal events. */ -#define Z_NO_COMPRESSION 0 -#define Z_BEST_SPEED 1 -#define Z_BEST_COMPRESSION 9 -#define Z_DEFAULT_COMPRESSION (-1) +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) /* compression levels */ -#define Z_FILTERED 1 -#define Z_HUFFMAN_ONLY 2 -#define Z_RLE 3 -#define Z_FIXED 4 -#define Z_DEFAULT_STRATEGY 0 +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 /* compression strategy; see deflateInit2() below for details */ -#define Z_BINARY 0 -#define Z_TEXT 1 -#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ -#define Z_UNKNOWN 2 +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 /* Possible values of the data_type field for deflate() */ -#define Z_DEFLATED 8 +#define Z_DEFLATED 8 /* The deflate compression method (the only one supported in this version) */ -#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ #define zlib_version zlibVersion() /* for compatibility with versions < 1.0.2 */ -/* basic functions */ -ZEXTERN const char* ZEXPORT zlibVersion(void); + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion(void); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check @@ -245,6 +246,7 @@ ZEXTERN int ZEXPORT deflateInit(z_streamp strm, int level); this will be done by deflate(). */ + ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush); /* deflate compresses as much data as possible, and stops when the input @@ -357,6 +359,7 @@ ZEXTERN int ZEXPORT deflate(z_streamp strm, int flush); continue compressing. */ + ZEXTERN int ZEXPORT deflateEnd(z_streamp strm); /* All dynamically allocated data structures for this stream are freed. @@ -370,6 +373,7 @@ ZEXTERN int ZEXPORT deflateEnd(z_streamp strm); deallocated). */ + /* ZEXTERN int ZEXPORT inflateInit(z_streamp strm); @@ -393,6 +397,7 @@ ZEXTERN int ZEXPORT inflateInit(z_streamp strm); that is deferred until inflate() is called. */ + ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush); /* inflate decompresses as much data as possible, and stops when the input @@ -512,6 +517,7 @@ ZEXTERN int ZEXPORT inflate(z_streamp strm, int flush); recovery of the data is to be attempted. */ + ZEXTERN int ZEXPORT inflateEnd(z_streamp strm); /* All dynamically allocated data structures for this stream are freed. @@ -522,7 +528,8 @@ ZEXTERN int ZEXPORT inflateEnd(z_streamp strm); was inconsistent. */ -/* Advanced functions */ + + /* Advanced functions */ /* The following functions are needed only in some special applications. @@ -601,7 +608,9 @@ ZEXTERN int ZEXPORT deflateInit2(z_streamp strm, compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef* dictionary, uInt dictLength); +ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm, + const Bytef *dictionary, + uInt dictLength); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. When using the zlib format, this @@ -643,7 +652,9 @@ ZEXTERN int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef* dictionary not perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef* dictionary, uInt* dictLength); +ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm, + Bytef *dictionary, + uInt *dictLength); /* Returns the sliding dictionary being maintained by deflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -663,7 +674,8 @@ ZEXTERN int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef* dictionary, uInt stream state is inconsistent. */ -ZEXTERN int ZEXPORT deflateCopy(z_streamp dest, z_streamp source); +ZEXTERN int ZEXPORT deflateCopy(z_streamp dest, + z_streamp source); /* Sets the destination stream as a complete copy of the source stream. @@ -691,7 +703,9 @@ ZEXTERN int ZEXPORT deflateReset(z_streamp strm); stream state was inconsistent (such as zalloc or state being Z_NULL). */ -ZEXTERN int ZEXPORT deflateParams(z_streamp strm, int level, int strategy); +ZEXTERN int ZEXPORT deflateParams(z_streamp strm, + int level, + int strategy); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2(). This can be @@ -727,7 +741,11 @@ ZEXTERN int ZEXPORT deflateParams(z_streamp strm, int level, int strategy); retried with more output space. */ -ZEXTERN int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain); +ZEXTERN int ZEXPORT deflateTune(z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for @@ -740,7 +758,8 @@ ZEXTERN int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, i returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ -ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen); +ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, + uLong sourceLen); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or @@ -754,7 +773,9 @@ ZEXTERN uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen); than Z_FINISH or Z_NO_FLUSH are used. */ -ZEXTERN int ZEXPORT deflatePending(z_streamp strm, unsigned* pending, int* bits); +ZEXTERN int ZEXPORT deflatePending(z_streamp strm, + unsigned *pending, + int *bits); /* deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not @@ -767,7 +788,9 @@ ZEXTERN int ZEXPORT deflatePending(z_streamp strm, unsigned* pending, int* bits) stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflatePrime(z_streamp strm, int bits, int value); +ZEXTERN int ZEXPORT deflatePrime(z_streamp strm, + int bits, + int value); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits @@ -782,7 +805,8 @@ ZEXTERN int ZEXPORT deflatePrime(z_streamp strm, int bits, int value); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head); +ZEXTERN int ZEXPORT deflateSetHeader(z_streamp strm, + gz_headerp head); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -861,7 +885,9 @@ ZEXTERN int ZEXPORT inflateInit2(z_streamp strm, deferred until inflate() is called. */ -ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef* dictionary, uInt dictLength); +ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm, + const Bytef *dictionary, + uInt dictLength); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -882,7 +908,9 @@ ZEXTERN int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef* dictionary inflate(). */ -ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef* dictionary, uInt* dictLength); +ZEXTERN int ZEXPORT inflateGetDictionary(z_streamp strm, + Bytef *dictionary, + uInt *dictLength); /* Returns the sliding dictionary being maintained by inflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -914,7 +942,8 @@ ZEXTERN int ZEXPORT inflateSync(z_streamp strm); time, until success or end of the input data. */ -ZEXTERN int ZEXPORT inflateCopy(z_streamp dest, z_streamp source); +ZEXTERN int ZEXPORT inflateCopy(z_streamp dest, + z_streamp source); /* Sets the destination stream as a complete copy of the source stream. @@ -940,7 +969,8 @@ ZEXTERN int ZEXPORT inflateReset(z_streamp strm); stream state was inconsistent (such as zalloc or state being Z_NULL). */ -ZEXTERN int ZEXPORT inflateReset2(z_streamp strm, int windowBits); +ZEXTERN int ZEXPORT inflateReset2(z_streamp strm, + int windowBits); /* This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted @@ -953,7 +983,9 @@ ZEXTERN int ZEXPORT inflateReset2(z_streamp strm, int windowBits); the windowBits parameter is invalid. */ -ZEXTERN int ZEXPORT inflatePrime(z_streamp strm, int bits, int value); +ZEXTERN int ZEXPORT inflatePrime(z_streamp strm, + int bits, + int value); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the @@ -1000,7 +1032,8 @@ ZEXTERN long ZEXPORT inflateMark(z_streamp strm); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head); +ZEXTERN int ZEXPORT inflateGetHeader(z_streamp strm, + gz_headerp head); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after @@ -1061,10 +1094,13 @@ ZEXTERN int ZEXPORT inflateBackInit(z_streamp strm, int windowBits, the version of the header file. */ -typedef unsigned (*in_func)(void FAR*, z_const unsigned char FAR* FAR*); -typedef int (*out_func)(void FAR*, unsigned char FAR*, unsigned); +typedef unsigned (*in_func)(void FAR *, + z_const unsigned char FAR * FAR *); +typedef int (*out_func)(void FAR *, unsigned char FAR *, unsigned); -ZEXTERN int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR* in_desc, out_func out, void FAR* out_desc); +ZEXTERN int ZEXPORT inflateBack(z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is potentially more efficient than @@ -1183,7 +1219,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags(void); #ifndef Z_SOLO -/* utility functions */ + /* utility functions */ /* The following utility functions are implemented on top of the basic @@ -1193,7 +1229,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags(void); you need special options. */ -ZEXTERN int ZEXPORT compress(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen); +ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1207,7 +1244,9 @@ ZEXTERN int ZEXPORT compress(Bytef* dest, uLongf* destLen, const Bytef* source, buffer. */ -ZEXTERN int ZEXPORT compress2(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen, int level); +ZEXTERN int ZEXPORT compress2(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte @@ -1228,7 +1267,8 @@ ZEXTERN uLong ZEXPORT compressBound(uLong sourceLen); compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT uncompress(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen); +ZEXTERN int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1245,14 +1285,15 @@ ZEXTERN int ZEXPORT uncompress(Bytef* dest, uLongf* destLen, const Bytef* source buffer with the uncompressed data up to that point. */ -ZEXTERN int ZEXPORT uncompress2(Bytef* dest, uLongf* destLen, const Bytef* source, uLong* sourceLen); +ZEXTERN int ZEXPORT uncompress2(Bytef *dest, uLongf *destLen, + const Bytef *source, uLong *sourceLen); /* Same as uncompress, except that sourceLen is a pointer, where the length of the source is *sourceLen. On return, *sourceLen is the number of source bytes consumed. */ -/* gzip file access functions */ + /* gzip file access functions */ /* This library supports reading and writing files in gzip (.gz) format with @@ -1261,7 +1302,7 @@ ZEXTERN int ZEXPORT uncompress2(Bytef* dest, uLongf* destLen, const Bytef* sourc wrapper, documented in RFC 1952, wrapped around a deflate stream. */ -typedef struct gzFile_s* gzFile; /* semi-opaque gzip file descriptor */ +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ /* ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); @@ -1301,7 +1342,7 @@ ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); file could not be opened. */ -ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char* mode); +ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode); /* Associate a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file has @@ -1381,7 +1422,8 @@ ZEXTERN int ZEXPORT gzread(gzFile file, voidp buf, unsigned len); Z_STREAM_ERROR. */ -ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems, gzFile file); +ZEXTERN z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems, + gzFile file); /* Read and decompress up to nitems items of size size from file into buf, otherwise operating as gzread() does. This duplicates the interface of @@ -1412,7 +1454,8 @@ ZEXTERN int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len); returns the number of uncompressed bytes written or 0 in case of error. */ -ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, z_size_t nitems, gzFile file); +ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, + z_size_t nitems, gzFile file); /* Compress and write nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. If @@ -1425,7 +1468,7 @@ ZEXTERN z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, z_size_t nitems, gz is returned, and the error state is set to Z_STREAM_ERROR. */ -ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char* format, ...); +ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...); /* Convert, format, compress, and write the arguments (...) to file under control of the string format, as in fprintf. gzprintf returns the number of @@ -1440,7 +1483,7 @@ ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char* format, ...); This can be determined using zlibCompileFlags(). */ -ZEXTERN int ZEXPORT gzputs(gzFile file, const char* s); +ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s); /* Compress and write the given null-terminated string s to file, excluding the terminating null character. @@ -1448,7 +1491,7 @@ ZEXTERN int ZEXPORT gzputs(gzFile file, const char* s); gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char* ZEXPORT gzgets(gzFile file, char* buf, int len); +ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len); /* Read and decompress bytes from file into buf, until len-1 characters are read, or until a newline character is read and transferred to buf, or an @@ -1524,7 +1567,7 @@ ZEXTERN z_off_t ZEXPORT gzseek(gzFile file, would be before the current position. */ -ZEXTERN int ZEXPORT gzrewind(gzFile file); +ZEXTERN int ZEXPORT gzrewind(gzFile file); /* Rewind file. This function is supported only for reading. @@ -1588,7 +1631,7 @@ ZEXTERN int ZEXPORT gzdirect(gzFile file); gzip file reading and decompression, which may not be desired.) */ -ZEXTERN int ZEXPORT gzclose(gzFile file); +ZEXTERN int ZEXPORT gzclose(gzFile file); /* Flush all pending output for file, if necessary, close file and deallocate the (de)compression state. Note that once file is closed, you @@ -1613,7 +1656,7 @@ ZEXTERN int ZEXPORT gzclose_w(gzFile file); zlib library. */ -ZEXTERN const char* ZEXPORT gzerror(gzFile file, int* errnum); +ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum); /* Return the error message for the last error which occurred on file. errnum is set to zlib error number. If an error occurred in the file system @@ -1638,7 +1681,7 @@ ZEXTERN void ZEXPORT gzclearerr(gzFile file); #endif /* !Z_SOLO */ -/* checksum functions */ + /* checksum functions */ /* These functions are not related to compression but are exported @@ -1646,7 +1689,7 @@ ZEXTERN void ZEXPORT gzclearerr(gzFile file); library. */ -ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef* buf, uInt len); +ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. An Adler-32 value is in the range of a 32-bit @@ -1666,7 +1709,8 @@ ZEXTERN uLong ZEXPORT adler32(uLong adler, const Bytef* buf, uInt len); if (adler != original_adler) error(); */ -ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef* buf, z_size_t len); +ZEXTERN uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf, + z_size_t len); /* Same as adler32(), but with a size_t length. */ @@ -1683,7 +1727,7 @@ ZEXTERN uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, negative, the result has no meaning or utility. */ -ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef* buf, uInt len); +ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef *buf, uInt len); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer. @@ -1701,7 +1745,8 @@ ZEXTERN uLong ZEXPORT crc32(uLong crc, const Bytef* buf, uInt len); if (crc != original_crc) error(); */ -ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef* buf, z_size_t len); +ZEXTERN uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf, + z_size_t len); /* Same as crc32(), but with a size_t length. */ @@ -1730,28 +1775,54 @@ ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op); crc32_combine() if the generated op is used more than once. */ -/* various hacks, don't look :) */ + + /* various hacks, don't look :) */ /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ -ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level, const char* version, int stream_size); -ZEXTERN int ZEXPORT inflateInit_(z_streamp strm, const char* version, int stream_size); -ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char* version, int stream_size); -ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char* version, int stream_size); -ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR* window, const char* version, int stream_size); +ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level, + const char *version, int stream_size); +ZEXTERN int ZEXPORT inflateInit_(z_streamp strm, + const char *version, int stream_size); +ZEXTERN int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size); +ZEXTERN int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, + const char *version, int stream_size); +ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size); #ifdef Z_PREFIX_SET -#define z_deflateInit(strm, level) deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) -#define z_inflateInit(strm) inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) -#define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) -#define z_inflateInit2(strm, windowBits) inflateInit2_((strm), (windowBits), ZLIB_VERSION, (int)sizeof(z_stream)) -#define z_inflateBackInit(strm, windowBits, window) inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +# define z_inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) #else -#define deflateInit(strm, level) deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) -#define inflateInit(strm) inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) -#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) -#define inflateInit2(strm, windowBits) inflateInit2_((strm), (windowBits), ZLIB_VERSION, (int)sizeof(z_stream)) -#define inflateBackInit(strm, windowBits, window) inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, (int)sizeof(z_stream)) +# define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +# define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +# define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +# define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) #endif #ifndef Z_SOLO @@ -1765,15 +1836,17 @@ ZEXTERN int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned ch */ struct gzFile_s { unsigned have; - unsigned char* next; + unsigned char *next; z_off64_t pos; }; -ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ +ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ #ifdef Z_PREFIX_SET -#undef z_gzgetc -#define z_gzgetc(g) ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) +# undef z_gzgetc +# define z_gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) #else -#define gzgetc(g) ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) +# define gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) #endif /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or @@ -1783,76 +1856,79 @@ ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ * without large file support, _LFS64_LARGEFILE must also be true */ #ifdef Z_LARGE64 -ZEXTERN gzFile ZEXPORT gzopen64(const char*, const char*); -ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); -ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); -ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); -ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t); -ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t); -ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t); + ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); + ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); + ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); + ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t); + ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t); #endif #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) -#ifdef Z_PREFIX_SET -#define z_gzopen z_gzopen64 -#define z_gzseek z_gzseek64 -#define z_gztell z_gztell64 -#define z_gzoffset z_gzoffset64 -#define z_adler32_combine z_adler32_combine64 -#define z_crc32_combine z_crc32_combine64 -#define z_crc32_combine_gen z_crc32_combine_gen64 +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# define z_crc32_combine_gen z_crc32_combine_gen64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# define crc32_combine_gen crc32_combine_gen64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); + ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int); + ZEXTERN z_off_t ZEXPORT gztell64(gzFile); + ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t); +# endif #else -#define gzopen gzopen64 -#define gzseek gzseek64 -#define gztell gztell64 -#define gzoffset gzoffset64 -#define adler32_combine adler32_combine64 -#define crc32_combine crc32_combine64 -#define crc32_combine_gen crc32_combine_gen64 -#endif -#ifndef Z_LARGE64 -ZEXTERN gzFile ZEXPORT gzopen64(const char*, const char*); -ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int); -ZEXTERN z_off_t ZEXPORT gztell64(gzFile); -ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile); -ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t); -#endif -#else -ZEXTERN gzFile ZEXPORT gzopen(const char*, const char*); -ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int); -ZEXTERN z_off_t ZEXPORT gztell(gzFile); -ZEXTERN z_off_t ZEXPORT gzoffset(gzFile); -ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); + ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *); + ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int); + ZEXTERN z_off_t ZEXPORT gztell(gzFile); + ZEXTERN z_off_t ZEXPORT gzoffset(gzFile); + ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); #endif #else /* Z_SOLO */ -ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); -ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); + ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t); + ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t); #endif /* !Z_SOLO */ /* undocumented functions */ -ZEXTERN const char* ZEXPORT zError(int); -ZEXTERN int ZEXPORT inflateSyncPoint(z_streamp); -ZEXTERN const z_crc_t FAR* ZEXPORT get_crc_table(void); -ZEXTERN int ZEXPORT inflateUndermine(z_streamp, int); -ZEXTERN int ZEXPORT inflateValidate(z_streamp, int); -ZEXTERN unsigned long ZEXPORT inflateCodesUsed(z_streamp); -ZEXTERN int ZEXPORT inflateResetKeep(z_streamp); -ZEXTERN int ZEXPORT deflateResetKeep(z_streamp); +ZEXTERN const char * ZEXPORT zError(int); +ZEXTERN int ZEXPORT inflateSyncPoint(z_streamp); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table(void); +ZEXTERN int ZEXPORT inflateUndermine(z_streamp, int); +ZEXTERN int ZEXPORT inflateValidate(z_streamp, int); +ZEXTERN unsigned long ZEXPORT inflateCodesUsed(z_streamp); +ZEXTERN int ZEXPORT inflateResetKeep(z_streamp); +ZEXTERN int ZEXPORT deflateResetKeep(z_streamp); #if defined(_WIN32) && !defined(Z_SOLO) -ZEXTERN gzFile ZEXPORT gzopen_w(const wchar_t* path, const char* mode); +ZEXTERN gzFile ZEXPORT gzopen_w(const wchar_t *path, + const char *mode); #endif #if defined(STDC) || defined(Z_HAVE_STDARG_H) -#ifndef Z_SOLO -ZEXTERN int ZEXPORTVA gzvprintf(gzFile file, const char* format, va_list va); -#endif +# ifndef Z_SOLO +ZEXTERN int ZEXPORTVA gzvprintf(gzFile file, + const char *format, + va_list va); +# endif #endif #ifdef __cplusplus diff --git a/lib/zlib/zconf.h b/lib/zlib/zconf.h index 217fa733..0bbe755f 100644 --- a/lib/zlib/zconf.h +++ b/lib/zlib/zconf.h @@ -13,72 +13,72 @@ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. */ #ifdef Z_PREFIX -#define deflateInit_ z_deflateInit_ -#define deflate z_deflate -#define deflateEnd z_deflateEnd -#define inflateInit_ z_inflateInit_ -#define inflate z_inflate -#define inflateEnd z_inflateEnd -#define deflateInit2_ z_deflateInit2_ -#define deflateSetDictionary z_deflateSetDictionary -#define deflateCopy z_deflateCopy -#define deflateReset z_deflateReset -#define deflateParams z_deflateParams -#define deflateBound z_deflateBound -#define deflatePrime z_deflatePrime -#define inflateInit2_ z_inflateInit2_ -#define inflateSetDictionary z_inflateSetDictionary -#define inflateSync z_inflateSync -#define inflateSyncPoint z_inflateSyncPoint -#define inflateCopy z_inflateCopy -#define inflateReset z_inflateReset -#define inflateBack z_inflateBack -#define inflateBackEnd z_inflateBackEnd -#define compress z_compress -#define compress2 z_compress2 -#define compressBound z_compressBound -#define uncompress z_uncompress -#define adler32 z_adler32 -#define crc32 z_crc32 -#define get_crc_table z_get_crc_table -#define zError z_zError +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define deflateBound z_deflateBound +# define deflatePrime z_deflatePrime +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateCopy z_inflateCopy +# define inflateReset z_inflateReset +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table +# define zError z_zError -#define alloc_func z_alloc_func -#define free_func z_free_func -#define in_func z_in_func -#define out_func z_out_func -#define Byte z_Byte -#define uInt z_uInt -#define uLong z_uLong -#define Bytef z_Bytef -#define charf z_charf -#define intf z_intf -#define uIntf z_uIntf -#define uLongf z_uLongf -#define voidpf z_voidpf -#define voidp z_voidp +# define alloc_func z_alloc_func +# define free_func z_free_func +# define in_func z_in_func +# define out_func z_out_func +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp #endif #if defined(__MSDOS__) && !defined(MSDOS) -#define MSDOS +# define MSDOS #endif #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) -#define OS2 +# define OS2 #endif #if defined(_WINDOWS) && !defined(WINDOWS) -#define WINDOWS +# define WINDOWS #endif #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) -#ifndef WIN32 -#define WIN32 -#endif +# ifndef WIN32 +# define WIN32 +# endif #endif #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) -#if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) -#ifndef SYS16BIT -#define SYS16BIT -#endif -#endif +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif #endif /* @@ -86,57 +86,57 @@ * than 64k bytes at a time (needed on systems with 16-bit int). */ #ifdef SYS16BIT -#define MAXSEG_64K +# define MAXSEG_64K #endif #ifdef MSDOS -#define UNALIGNED_OK +# define UNALIGNED_OK #endif #ifdef __STDC_VERSION__ -#ifndef STDC -#define STDC -#endif -#if __STDC_VERSION__ >= 199901L -#ifndef STDC99 -#define STDC99 -#endif -#endif +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif #endif #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) -#define STDC +# define STDC #endif #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) -#define STDC +# define STDC #endif -#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ -#define STDC +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC #endif #ifndef STDC -#ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ -#define const /* note: need a more gentle solution here */ -#endif +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif #endif /* Some Mac compilers merge all .h files incorrectly: */ -#if defined(__MWERKS__) || defined(applec) || defined(THINK_C) || defined(__SC__) -#define NO_DUMMY_DECL +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL #endif /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL -#ifdef MAXSEG_64K -#define MAX_MEM_LEVEL 8 -#else -#define MAX_MEM_LEVEL 9 -#endif +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif #endif /* Maximum value for windowBits in deflateInit2 and inflateInit2. @@ -145,7 +145,7 @@ * gzip.) */ #ifndef MAX_WBITS -#define MAX_WBITS 15 /* 32K LZ77 window */ +# define MAX_WBITS 15 /* 32K LZ77 window */ #endif /* The memory requirements for deflate are (in bytes): @@ -161,14 +161,14 @@ for small objects. */ -/* Type declarations */ + /* Type declarations */ #ifndef OF /* function prototypes */ -#ifdef STDC -#define OF(args) args -#else -#define OF(args) () -#endif +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif #endif /* The following definitions for FAR are needed only for MSDOS mixed @@ -178,155 +178,155 @@ * just define FAR to be empty. */ #ifdef SYS16BIT -#if defined(M_I86SM) || defined(M_I86MM) -/* MSC small or medium model */ -#define SMALL_MEDIUM -#ifdef _MSC_VER -#define FAR _far -#else -#define FAR far -#endif -#endif -#if (defined(__SMALL__) || defined(__MEDIUM__)) -/* Turbo C small or medium model */ -#define SMALL_MEDIUM -#ifdef __BORLANDC__ -#define FAR _far -#else -#define FAR far -#endif -#endif +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif #endif #if defined(WINDOWS) || defined(WIN32) -/* If building or using zlib as a DLL, define ZLIB_DLL. - * This is not mandatory, but it offers a little performance increase. - */ -#ifdef ZLIB_DLL -#if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) -#ifdef ZLIB_INTERNAL -#define ZEXTERN extern __declspec(dllexport) -#else -#define ZEXTERN extern __declspec(dllimport) -#endif -#endif -#endif /* ZLIB_DLL */ -/* If building or using zlib with the WINAPI/WINAPIV calling convention, - * define ZLIB_WINAPI. - * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. - */ -#ifdef ZLIB_WINAPI -#ifdef FAR -#undef FAR -#endif -#include -/* No need for _export, use ZLIB.DEF instead. */ -/* For complete Windows compatibility, use WINAPI, not __stdcall. */ -#define ZEXPORT WINAPI -#ifdef WIN32 -#define ZEXPORTVA WINAPIV -#else -#define ZEXPORTVA FAR CDECL -#endif -#endif + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif #endif -#if defined(__BEOS__) -#ifdef ZLIB_DLL -#ifdef ZLIB_INTERNAL -#define ZEXPORT __declspec(dllexport) -#define ZEXPORTVA __declspec(dllexport) -#else -#define ZEXPORT __declspec(dllimport) -#define ZEXPORTVA __declspec(dllimport) -#endif -#endif +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif #endif #ifndef ZEXTERN -#define ZEXTERN extern +# define ZEXTERN extern #endif #ifndef ZEXPORT -#define ZEXPORT __cdecl +# define ZEXPORT __cdecl #endif #ifndef ZEXPORTVA -#define ZEXPORTVA __cdecl +# define ZEXPORTVA __cdecl #endif #ifndef FAR -#define FAR +# define FAR #endif #if !defined(__MACTYPES__) -typedef unsigned char Byte; /* 8 bits */ +typedef unsigned char Byte; /* 8 bits */ #endif -typedef unsigned int uInt; /* 16 bits or more */ -typedef unsigned long uLong; /* 32 bits or more */ +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ #ifdef SMALL_MEDIUM -/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ -#define Bytef Byte FAR + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR #else -typedef Byte FAR Bytef; + typedef Byte FAR Bytef; #endif -typedef char FAR charf; -typedef int FAR intf; -typedef uInt FAR uIntf; +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC -typedef void const* voidpc; -typedef void FAR* voidpf; -typedef void* voidp; + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; #else -typedef Byte const* voidpc; -typedef Byte FAR* voidpf; -typedef Byte* voidp; + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; #endif -#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ -#include /* for off_t */ -#include /* for SEEK_* and off_t */ -#ifdef VMS -#include /* for off_t */ -#endif -#define z_off_t off_t +#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# ifdef VMS +# include /* for off_t */ +# endif +# define z_off_t off_t #endif #ifndef SEEK_SET -#define SEEK_SET 0 /* Seek from beginning of file. */ -#define SEEK_CUR 1 /* Seek from current position. */ -#define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ #endif #ifndef z_off_t -#define z_off_t long +# define z_off_t long #endif #if defined(__OS400__) -#define NO_vsnprintf +# define NO_vsnprintf #endif #if defined(__MVS__) -#define NO_vsnprintf -#ifdef FAR -#undef FAR -#endif +# define NO_vsnprintf +# ifdef FAR +# undef FAR +# endif #endif /* MVS linker does not support external names larger than 8 bytes */ #if defined(__MVS__) -#pragma map(deflateInit_, "DEIN") -#pragma map(deflateInit2_, "DEIN2") -#pragma map(deflateEnd, "DEEND") -#pragma map(deflateBound, "DEBND") -#pragma map(inflateInit_, "ININ") -#pragma map(inflateInit2_, "ININ2") -#pragma map(inflateEnd, "INEND") -#pragma map(inflateSync, "INSY") -#pragma map(inflateSetDictionary, "INSEDI") -#pragma map(compressBound, "CMBND") -#pragma map(inflate_table, "INTABL") -#pragma map(inflate_fast, "INFA") -#pragma map(inflate_copyright, "INCOPY") +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") #endif #endif /* ZCONF_H */ diff --git a/lib/zlib/zlib.h b/lib/zlib/zlib.h index 2d483291..02281792 100644 --- a/lib/zlib/zlib.h +++ b/lib/zlib/zlib.h @@ -74,56 +74,56 @@ extern "C" { crash even in case of corrupted input. */ -typedef voidpf(*alloc_func) OF((voidpf opaque, uInt items, uInt size)); -typedef void(*free_func) OF((voidpf opaque, voidpf address)); +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); struct internal_state; typedef struct z_stream_s { - Bytef* next_in; /* next input byte */ - uInt avail_in; /* number of bytes available at next_in */ - uLong total_in; /* total nb of input bytes read so far */ + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ - Bytef* next_out; /* next output byte should be put there */ - uInt avail_out; /* remaining free space at next_out */ - uLong total_out; /* total nb of bytes output so far */ + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ - char* msg; /* last error message, NULL if no error */ - struct internal_state FAR* state; /* not visible by applications */ + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ - alloc_func zalloc; /* used to allocate the internal state */ - free_func zfree; /* used to free the internal state */ - voidpf opaque; /* private data object passed to zalloc and zfree */ + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ - int data_type; /* best guess about the data type: binary or text */ - uLong adler; /* adler32 value of the uncompressed data */ - uLong reserved; /* reserved for future use */ + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ } z_stream; -typedef z_stream FAR* z_streamp; +typedef z_stream FAR *z_streamp; /* gzip header information passed to and from zlib routines. See RFC 1952 for more details on the meanings of these fields. */ typedef struct gz_header_s { - int text; /* true if compressed data believed to be text */ - uLong time; /* modification time */ - int xflags; /* extra flags (not used when writing a gzip file) */ - int os; /* operating system */ - Bytef* extra; /* pointer to extra field or Z_NULL if none */ - uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ - uInt extra_max; /* space at extra (only when reading header) */ - Bytef* name; /* pointer to zero-terminated file name or Z_NULL */ - uInt name_max; /* space at name (only when reading header) */ - Bytef* comment; /* pointer to zero-terminated comment or Z_NULL */ - uInt comm_max; /* space at comment (only when reading header) */ - int hcrc; /* true if there was or will be a header crc */ - int done; /* true when done reading gzip header (not used - when writing a gzip file) */ + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ } gz_header; -typedef gz_header FAR* gz_headerp; +typedef gz_header FAR *gz_headerp; /* The application must update next_in and avail_in when avail_in has @@ -157,59 +157,59 @@ typedef gz_header FAR* gz_headerp; a single step). */ -/* constants */ + /* constants */ -#define Z_NO_FLUSH 0 +#define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ -#define Z_SYNC_FLUSH 2 -#define Z_FULL_FLUSH 3 -#define Z_FINISH 4 -#define Z_BLOCK 5 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 /* Allowed flush values; see deflate() and inflate() below for details */ -#define Z_OK 0 -#define Z_STREAM_END 1 -#define Z_NEED_DICT 2 -#define Z_ERRNO (-1) +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) #define Z_STREAM_ERROR (-2) -#define Z_DATA_ERROR (-3) -#define Z_MEM_ERROR (-4) -#define Z_BUF_ERROR (-5) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) #define Z_VERSION_ERROR (-6) /* Return codes for the compression/decompression functions. Negative * values are errors, positive values are used for special but normal events. */ -#define Z_NO_COMPRESSION 0 -#define Z_BEST_SPEED 1 -#define Z_BEST_COMPRESSION 9 -#define Z_DEFAULT_COMPRESSION (-1) +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) /* compression levels */ -#define Z_FILTERED 1 -#define Z_HUFFMAN_ONLY 2 -#define Z_RLE 3 -#define Z_FIXED 4 -#define Z_DEFAULT_STRATEGY 0 +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 /* compression strategy; see deflateInit2() below for details */ -#define Z_BINARY 0 -#define Z_TEXT 1 -#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ -#define Z_UNKNOWN 2 +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 /* Possible values of the data_type field (though see inflate()) */ -#define Z_DEFLATED 8 +#define Z_DEFLATED 8 /* The deflate compression method (the only one supported in this version) */ -#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ #define zlib_version zlibVersion() /* for compatibility with versions < 1.0.2 */ -/* basic functions */ + /* basic functions */ -ZEXTERN const char* ZEXPORT zlibVersion OF((void)); +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. @@ -238,6 +238,7 @@ ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); perform any compression: this will be done by deflate(). */ + ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); /* deflate compresses as much data as possible, and stops when the input @@ -323,6 +324,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); space to continue compressing. */ + ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); /* All dynamically allocated data structures for this stream are freed. @@ -336,6 +338,7 @@ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); deallocated). */ + /* ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); @@ -356,6 +359,7 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); avail_in may be modified, but next_out and avail_out are unchanged.) */ + ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); /* inflate decompresses as much data as possible, and stops when the input @@ -454,6 +458,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); of the data is desired. */ + ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); /* All dynamically allocated data structures for this stream are freed. @@ -465,7 +470,7 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); static string (which must not be deallocated). */ -/* Advanced functions */ + /* Advanced functions */ /* The following functions are needed only in some special applications. @@ -530,7 +535,9 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, not perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef* dictionary, uInt dictLength)); +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. This function must be called @@ -567,7 +574,8 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef* dictio perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, z_streamp source)); +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); /* Sets the destination stream as a complete copy of the source stream. @@ -595,7 +603,9 @@ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy)); +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2. This can be @@ -614,7 +624,11 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy)); if strm->avail_out was zero. */ -ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)); +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for @@ -627,7 +641,8 @@ ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, int good_length, int max_laz returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ -ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, uLong sourceLen)); +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() @@ -635,7 +650,9 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, uLong sourceLen)); for deflation in a single pass, and so would be called before deflate(). */ -ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, int value)); +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the @@ -649,7 +666,8 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, int value)); stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, gz_headerp head)); +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -715,7 +733,9 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, and avail_out are unchanged.) */ -ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, const Bytef* dictionary, uInt dictLength)); +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -750,7 +770,8 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); until success or end of the input data. */ -ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, z_streamp source)); +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); /* Sets the destination stream as a complete copy of the source stream. @@ -775,7 +796,9 @@ ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, int bits, int value)); +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the @@ -789,7 +812,8 @@ ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, int bits, int value)); stream state was inconsistent. */ -ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, gz_headerp head)); +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after @@ -850,10 +874,12 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, match the version of the header file. */ -typedef unsigned(*in_func) OF((void FAR*, unsigned char FAR* FAR*)); -typedef int(*out_func) OF((void FAR*, unsigned char FAR*, unsigned)); +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); -ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, in_func in, void FAR* in_desc, out_func out, void FAR* out_desc)); +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is more efficient than inflate() for @@ -969,7 +995,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 27-31: 0 (reserved) */ -/* utility functions */ + + /* utility functions */ /* The following utility functions are implemented on top of the @@ -979,7 +1006,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); utility functions can easily be modified if you need special options. */ -ZEXTERN int ZEXPORT compress OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen)); +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total @@ -993,7 +1021,9 @@ ZEXTERN int ZEXPORT compress OF((Bytef * dest, uLongf* destLen, const Bytef* sou buffer. */ -ZEXTERN int ZEXPORT compress2 OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen, int level)); +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte @@ -1014,7 +1044,8 @@ ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); a compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT uncompress OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen)); +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total @@ -1031,9 +1062,10 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef * dest, uLongf* destLen, const Bytef* s buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. */ + typedef voidp gzFile; -ZEXTERN gzFile ZEXPORT gzopen OF((const char* path, const char* mode)); +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); /* Opens a gzip (.gz) file for reading or writing. The mode parameter is as in fopen ("rb" or "wb") but can also include a compression level @@ -1050,7 +1082,7 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char* path, const char* mode)); can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). */ -ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char* mode)); +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); /* gzdopen() associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or @@ -1071,7 +1103,7 @@ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); opened for writing. */ -ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); /* Reads the given number of uncompressed bytes from the compressed file. If the input file was not in gzip format, gzread copies the given number @@ -1079,14 +1111,15 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); gzread returns the number of uncompressed bytes actually read (0 for end of file, -1 for error). */ -ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); /* Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes actually written (0 in case of error). */ -ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char* format, ...)); +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); /* Converts, formats, and writes the args to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of @@ -1099,14 +1132,14 @@ ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char* format, ...)); because the secure snprintf() or vsnprintf() functions were not available. */ -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char* s)); +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char* ZEXPORT gzgets OF((gzFile file, char* buf, int len)); +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); /* Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file @@ -1115,19 +1148,19 @@ ZEXTERN char* ZEXPORT gzgets OF((gzFile file, char* buf, int len)); gzgets returns buf, or Z_NULL in case of error. */ -ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); /* Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. */ -ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); /* Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. */ -ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); /* Push one character back onto the stream to be read again later. Only one character of push-back is allowed. gzungetc() returns the @@ -1137,7 +1170,7 @@ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); or gzrewind(). */ -ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); /* Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib @@ -1147,7 +1180,8 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); degrade compression. */ -ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, z_off_t offset, int whence)); +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); /* Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the @@ -1164,14 +1198,14 @@ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, z_off_t offset, int whence)); would be before the current position. */ -ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); /* Rewinds the given file. This function is supported only for reading. gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) */ -ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); /* Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the @@ -1192,14 +1226,14 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); zero. */ -ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); /* Flushes all pending output if necessary, closes the compressed file and deallocates all the (de)compression state. The return value is the zlib error number (see function gzerror below). */ -ZEXTERN const char* ZEXPORT gzerror OF((gzFile file, int* errnum)); +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); /* Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an @@ -1215,7 +1249,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); file that is being written concurrently. */ -/* checksum functions */ + /* checksum functions */ /* These functions are not related to compression but are exported @@ -1223,7 +1257,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); compression library. */ -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef* buf, uInt len)); +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is NULL, this function returns @@ -1239,7 +1273,8 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef* buf, uInt len)); if (adler != original_adler) error(); */ -ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t len2)); +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); /* Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for @@ -1247,7 +1282,7 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t le seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. */ -ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef* buf, uInt len)); +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is NULL, this function returns the required initial @@ -1273,31 +1308,47 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); len2. */ -/* various hacks, don't look :) */ + + /* various hacks, don't look :) */ /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ -ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, const char* version, int stream_size)); -ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, const char* version, int stream_size)); -ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char* version, int stream_size)); -ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, const char* version, int stream_size)); -ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, unsigned char FAR* window, const char* version, int stream_size)); -#define deflateInit(strm, level) deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) -#define inflateInit(strm) inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) -#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream)) -#define inflateInit2(strm, windowBits) inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) -#define inflateBackInit(strm, windowBits, window) inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, sizeof(z_stream)) +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, sizeof(z_stream)) + #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) -struct internal_state { - int dummy; -}; /* hack for buggy compilers */ + struct internal_state {int dummy;}; /* hack for buggy compilers */ #endif -ZEXTERN const char* ZEXPORT zError OF((int)); -ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); -ZEXTERN const uLongf* ZEXPORT get_crc_table OF((void)); +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); #ifdef __cplusplus }