Inside Bitcoin

501#define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
502#define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
503#define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
504#define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
505#define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
506#define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
507#define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
508#define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
509#define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
510#define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
511#define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
512#define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
513#define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
514
515#define TINYFORMAT_FOREACH_ARGNUM(m) \
516    m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16)
517//[[[end]]]
518
519
520
521namespace detail {
522
523// Type-opaque holder for an argument to format(), with associated actions on
524// the type held as explicit function pointers.  This allows FormatArg's for
525// each argument to be allocated as a homogeneous array inside FormatList
526// whereas a naive implementation based on inheritance does not.
527class FormatArg
528{
529    public:
530        FormatArg() = default;
531
532        template<typename T>
533        explicit FormatArg(const T& value)
534            : m_value(static_cast<const void*>(&value)),
535            m_formatImpl(&formatImpl<T>),
536            m_toIntImpl(&toIntImpl<T>)
537        { }
538
539        void format(std::ostream& out, const char* fmtBegin,
540                    const char* fmtEnd, int ntrunc) const
541        {
542            TINYFORMAT_ASSERT(m_value);
543            TINYFORMAT_ASSERT(m_formatImpl);
544            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
545        }
546
547        int toInt() const
548        {
549            TINYFORMAT_ASSERT(m_value);
550            TINYFORMAT_ASSERT(m_toIntImpl);
551            return m_toIntImpl(m_value);
552        }
553
554    private:
555        template<typename T>
556        TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
557                        const char* fmtEnd, int ntrunc, const void* value)
558        {
559            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
560        }
561
562        template<typename T>
563        TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
564        {
565            return convertToInt<T>::invoke(*static_cast<const T*>(value));
566        }
567
568        const void* m_value{nullptr};
569        void (*m_formatImpl)(std::ostream& out, const char* fmtBegin,
570                             const char* fmtEnd, int ntrunc, const void* value){nullptr};
571        int (*m_toIntImpl)(const void* value){nullptr};
572};
573
574
575// Parse and return an integer from the string c, as atoi()
576// On return, c is set to one past the end of the integer.
577inline int parseIntAndAdvance(const char*& c)
578{
579    int i = 0;
580    for (;*c >= '0' && *c <= '9'; ++c)
581        i = 10*i + (*c - '0');
582    return i;
583}
584
585// Parse width or precision `n` from format string pointer `c`, and advance it
586// to the next character. If an indirection is requested with `*`, the argument
587// is read from `args[argIndex]` and `argIndex` is incremented (or read
588// from `args[n]` in positional mode). Returns true if one or more
589// characters were read.
590inline bool parseWidthOrPrecision(int& n, const char*& c, bool positionalMode,
591                                  const detail::FormatArg* args,
592                                  int& argIndex, int numArgs)
593{
594    if (*c >= '0' && *c <= '9') {
595        n = parseIntAndAdvance(c);
596    }
597    else if (*c == '*') {
598        ++c;
599        n = 0;
600        if (positionalMode) {
601            int pos = parseIntAndAdvance(c) - 1;
602            if (*c != '$')
603                TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
604            if (pos >= 0 && pos < numArgs)
605                n = args[pos].toInt();
606            else
607                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
608            ++c;
609        }
610        else {
611            if (argIndex < numArgs)
612                n = args[argIndex++].toInt();
613            else
614                TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision");
615        }
616    }
617    else {
618        return false;
619    }
620    return true;
621}
622
623// Print literal part of format string and return next format spec position.
624//
625// Skips over any occurrences of '%%', printing a literal '%' to the output.
626// The position of the first % character of the next nontrivial format spec is
627// returned, or the end of string.
628inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
629{
630    const char* c = fmt;
631    for (;; ++c) {
632        if (*c == '\0') {
633            out.write(fmt, c - fmt);
634            return c;
635        }
636        else if (*c == '%') {
637            out.write(fmt, c - fmt);
638            if (*(c+1) != '%')
639                return c;
640            // for "%%", tack trailing % onto next literal section.
641            fmt = ++c;
642        }
643    }
644}
645
646
647// Parse a format string and set the stream state accordingly.
648//
649// The format mini-language recognized here is meant to be the one from C99,
650// with the form "%[flags][width][.precision][length]type" with POSIX
651// positional arguments extension.
652//
653// POSIX positional arguments extension:
654// Conversions can be applied to the nth argument after the format in
655// the argument list, rather than to the next unused argument. In this case,
656// the conversion specifier character % (see below) is replaced by the sequence
657// "%n$", where n is a decimal integer in the range [1,{NL_ARGMAX}],
658// giving the position of the argument in the argument list. This feature
659// provides for the definition of format strings that select arguments
660// in an order appropriate to specific languages.
661//
662// The format can contain either numbered argument conversion specifications
663// (that is, "%n$" and "*m$"), or unnumbered argument conversion specifications
664// (that is, % and * ), but not both. The only exception to this is that %%
665// can be mixed with the "%n$" form. The results of mixing numbered and
666// unnumbered argument specifications in a format string are undefined.
667// When numbered argument specifications are used, specifying the Nth argument
668// requires that all the leading arguments, from the first to the (N-1)th,
669// are specified in the format string.
670//
671// In format strings containing the "%n$" form of conversion specification,
672// numbered arguments in the argument list can be referenced from the format
673// string as many times as required.
674//
675// Formatting options which can't be natively represented using the ostream
676// state are returned in spacePadPositive (for space padded positive numbers)
677// and ntrunc (for truncating conversions).  argIndex is incremented if
678// necessary to pull out variable width and precision.  The function returns a
679// pointer to the character after the end of the current format spec.
680inline const char* streamStateFromFormat(std::ostream& out, bool& positionalMode,
681                                         bool& spacePadPositive,
682                                         int& ntrunc, const char* fmtStart,
683                                         const detail::FormatArg* args,
684                                         int& argIndex, int numArgs)
685{
686    TINYFORMAT_ASSERT(*fmtStart == '%');
687    // Reset stream state to defaults.
688    out.width(0);
689    out.precision(6);
690    out.fill(' ');
691    // Reset most flags; ignore irrelevant unitbuf & skipws.
692    out.unsetf(std::ios::adjustfield | std::ios::basefield |
693               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
694               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
695    bool precisionSet = false;
696    bool widthSet = false;
697    int widthExtra = 0;
698    const char* c = fmtStart + 1;
699
700    // 1) Parse an argument index (if followed by '$') or a width possibly
701    // preceded with '0' flag.
702    if (*c >= '0' && *c <= '9') {
703        const char tmpc = *c;
704        int value = parseIntAndAdvance(c);
705        if (*c == '$') {
706            // value is an argument index
707            if (value > 0 && value <= numArgs)
708                argIndex = value - 1;
709            else
710                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
711            ++c;
712            positionalMode = true;
713        }
714        else if (positionalMode) {
715            TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
716        }
717        else {
718            if (tmpc == '0') {
719                // Use internal padding so that numeric values are
720                // formatted correctly, eg -00010 rather than 000-10
721                out.fill('0');
722                out.setf(std::ios::internal, std::ios::adjustfield);
723            }
724            if (value != 0) {
725                // Nonzero value means that we parsed width.
726                widthSet = true;
727                out.width(value);
728            }
729        }
730    }
731    else if (positionalMode) {
732        TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
733    }
734    // 2) Parse flags and width if we did not do it in previous step.
735    if (!widthSet) {
736        // Parse flags
737        for (;; ++c) {
738            switch (*c) {
739                case '#':
740                    out.setf(std::ios::showpoint | std::ios::showbase);
741                    continue;
742                case '0':
743                    // overridden by left alignment ('-' flag)
744                    if (!(out.flags() & std::ios::left)) {
745                        // Use internal padding so that numeric values are
746                        // formatted correctly, eg -00010 rather than 000-10
747                        out.fill('0');
748                        out.setf(std::ios::internal, std::ios::adjustfield);
749                    }
750                    continue;