Inside Bitcoin

751                case '-':
752                    out.fill(' ');
753                    out.setf(std::ios::left, std::ios::adjustfield);
754                    continue;
755                case ' ':
756                    // overridden by show positive sign, '+' flag.
757                    if (!(out.flags() & std::ios::showpos))
758                        spacePadPositive = true;
759                    continue;
760                case '+':
761                    out.setf(std::ios::showpos);
762                    spacePadPositive = false;
763                    widthExtra = 1;
764                    continue;
765                default:
766                    break;
767            }
768            break;
769        }
770        // Parse width
771        int width = 0;
772        widthSet = parseWidthOrPrecision(width, c, positionalMode,
773                                         args, argIndex, numArgs);
774        if (widthSet) {
775            if (width < 0) {
776                // negative widths correspond to '-' flag set
777                out.fill(' ');
778                out.setf(std::ios::left, std::ios::adjustfield);
779                width = -width;
780            }
781            out.width(width);
782        }
783    }
784    // 3) Parse precision
785    if (*c == '.') {
786        ++c;
787        int precision = 0;
788        parseWidthOrPrecision(precision, c, positionalMode,
789                              args, argIndex, numArgs);
790        // Presence of `.` indicates precision set, unless the inferred value
791        // was negative in which case the default is used.
792        precisionSet = precision >= 0;
793        if (precisionSet)
794            out.precision(precision);
795    }
796    // 4) Ignore any C99 length modifier
797    while (*c == 'l' || *c == 'h' || *c == 'L' ||
798           *c == 'j' || *c == 'z' || *c == 't') {
799        ++c;
800    }
801    // 5) We're up to the conversion specifier character.
802    // Set stream flags based on conversion specifier (thanks to the
803    // boost::format class for forging the way here).
804    bool intConversion = false;
805    switch (*c) {
806        case 'u': case 'd': case 'i':
807            out.setf(std::ios::dec, std::ios::basefield);
808            intConversion = true;
809            break;
810        case 'o':
811            out.setf(std::ios::oct, std::ios::basefield);
812            intConversion = true;
813            break;
814        case 'X':
815            out.setf(std::ios::uppercase);
816            [[fallthrough]];
817        case 'x': case 'p':
818            out.setf(std::ios::hex, std::ios::basefield);
819            intConversion = true;
820            break;
821        case 'E':
822            out.setf(std::ios::uppercase);
823            [[fallthrough]];
824        case 'e':
825            out.setf(std::ios::scientific, std::ios::floatfield);
826            out.setf(std::ios::dec, std::ios::basefield);
827            break;
828        case 'F':
829            out.setf(std::ios::uppercase);
830            [[fallthrough]];
831        case 'f':
832            out.setf(std::ios::fixed, std::ios::floatfield);
833            break;
834        case 'A':
835            out.setf(std::ios::uppercase);
836            [[fallthrough]];
837        case 'a':
838#           ifdef _MSC_VER
839            // Workaround https://developercommunity.visualstudio.com/content/problem/520472/hexfloat-stream-output-does-not-ignore-precision-a.html
840            // by always setting maximum precision on MSVC to avoid precision
841            // loss for doubles.
842            out.precision(13);
843#           endif
844            out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield);
845            break;
846        case 'G':
847            out.setf(std::ios::uppercase);
848            [[fallthrough]];
849        case 'g':
850            out.setf(std::ios::dec, std::ios::basefield);
851            // As in boost::format, let stream decide float format.
852            out.flags(out.flags() & ~std::ios::floatfield);
853            break;
854        case 'c':
855            // Handled as special case inside formatValue()
856            break;
857        case 's':
858            if (precisionSet)
859                ntrunc = static_cast<int>(out.precision());
860            // Make %s print Booleans as "true" and "false"
861            out.setf(std::ios::boolalpha);
862            break;
863        case 'n':
864            // Not supported - will cause problems!
865            TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
866            break;
867        case '\0':
868            TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
869                             "terminated by end of string");
870            return c;
871        default:
872            break;
873    }
874    if (intConversion && precisionSet && !widthSet) {
875        // "precision" for integers gives the minimum number of digits (to be
876        // padded with zeros on the left).  This isn't really supported by the
877        // iostreams, but we can approximately simulate it with the width if
878        // the width isn't otherwise used.
879        out.width(out.precision() + widthExtra);
880        out.setf(std::ios::internal, std::ios::adjustfield);
881        out.fill('0');
882    }
883    return c+1;
884}
885
886
887//------------------------------------------------------------------------------
888inline void formatImpl(std::ostream& out, const char* fmt,
889                       const detail::FormatArg* args,
890                       int numArgs)
891{
892    // Saved stream state
893    std::streamsize origWidth = out.width();
894    std::streamsize origPrecision = out.precision();
895    std::ios::fmtflags origFlags = out.flags();
896    char origFill = out.fill();
897
898    // "Positional mode" means all format specs should be of the form "%n$..."
899    // with `n` an integer. We detect this in `streamStateFromFormat`.
900    bool positionalMode = false;
901    int argIndex = 0;
902    while (true) {
903        fmt = printFormatStringLiteral(out, fmt);
904        if (*fmt == '\0') {
905            if (!positionalMode && argIndex < numArgs) {
906                TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
907            }
908            break;
909        }
910        bool spacePadPositive = false;
911        int ntrunc = -1;
912        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
913                                                   args, argIndex, numArgs);
914        // NB: argIndex may be incremented by reading variable width/precision
915        // in `streamStateFromFormat`, so do the bounds check here.
916        if (argIndex >= numArgs) {
917            TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
918            return;
919        }
920        const FormatArg& arg = args[argIndex];
921        // Format the arg into the stream.
922        if (!spacePadPositive) {
923            arg.format(out, fmt, fmtEnd, ntrunc);
924        }
925        else {
926            // The following is a special case with no direct correspondence
927            // between stream formatting and the printf() behaviour.  Simulate
928            // it crudely by formatting into a temporary string stream and
929            // munging the resulting string.
930            std::ostringstream tmpStream;
931            tmpStream.copyfmt(out);
932            tmpStream.setf(std::ios::showpos);
933            arg.format(tmpStream, fmt, fmtEnd, ntrunc);
934            std::string result = tmpStream.str(); // allocates... yuck.
935            for (size_t i = 0, iend = result.size(); i < iend; ++i) {
936                if (result[i] == '+')
937                    result[i] = ' ';
938            }
939            out << result;
940        }
941        if (!positionalMode)
942            ++argIndex;
943        fmt = fmtEnd;
944    }
945
946    // Restore stream state
947    out.width(origWidth);
948    out.precision(origPrecision);
949    out.flags(origFlags);
950    out.fill(origFill);
951}
952
953} // namespace detail
954
955
956/// List of template arguments format(), held in a type-opaque way.
957///
958/// A const reference to FormatList (typedef'd as FormatListRef) may be
959/// conveniently used to pass arguments to non-template functions: All type
960/// information has been stripped from the arguments, leaving just enough of a
961/// common interface to perform formatting as required.
962class FormatList
963{
964    public:
965        FormatList(detail::FormatArg* args, int N)
966            : m_args(args), m_N(N) { }
967
968        friend void vformat(std::ostream& out, const char* fmt,
969                            const FormatList& list);
970
971    private:
972        const detail::FormatArg* m_args;
973        int m_N;
974};
975
976/// Reference to type-opaque format list for passing to vformat()
977typedef const FormatList& FormatListRef;
978
979
980namespace detail {
981
982// Format list subclass with fixed storage to avoid dynamic allocation
983template<int N>
984class FormatListN : public FormatList
985{
986    public:
987#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
988        template<typename... Args>
989        explicit FormatListN(const Args&... args)
990            : FormatList(&m_formatterStore[0], N),
991            m_formatterStore { FormatArg(args)... }
992        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
993#else // C++98 version
994        void init(int) {}
995#       define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n)                \
996                                                                        \
997        template<TINYFORMAT_ARGTYPES(n)>                                \
998        FormatListN(TINYFORMAT_VARARGS(n))                              \
999            : FormatList(&m_formatterStore[0], n)                       \
1000        { TINYFORMAT_ASSERT(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \