src/cpp-common/vendor/fmt/printf.h

   1 // Formatting library for C++ - legacy printf implementation
   2 //
   3 // Copyright (c) 2012 - 2016, Victor Zverovich
   4 // All rights reserved.
   5 //
   6 // For the license information refer to format.h.
   7
   8 #ifndef FMT_PRINTF_H_
   9 #define FMT_PRINTF_H_
  10
  11 #include <algorithm>  // std::max
  12 #include <limits>     // std::numeric_limits
  13
  14 #include "format.h"
  15
  16 FMT_BEGIN_NAMESPACE
  17 FMT_BEGIN_EXPORT
  18
  19 template <typename T> struct printf_formatter { printf_formatter() = delete; };
  20
  21 template <typename Char> class basic_printf_context {
  22  private:
  23   detail::buffer_appender<Char> out_;
  24   basic_format_args<basic_printf_context> args_;
  25
  26  public:
  27   using char_type = Char;
  28   using parse_context_type = basic_format_parse_context<Char>;
  29   template <typename T> using formatter_type = printf_formatter<T>;
  30
  31   /**
  32     \rst
  33     Constructs a ``printf_context`` object. References to the arguments are
  34     stored in the context object so make sure they have appropriate lifetimes.
  35     \endrst
  36    */
  37   basic_printf_context(detail::buffer_appender<Char> out,
  38                        basic_format_args<basic_printf_context> args)
  39       : out_(out), args_(args) {}
  40
  41   auto out() -> detail::buffer_appender<Char> { return out_; }
  42   void advance_to(detail::buffer_appender<Char>) {}
  43
  44   auto locale() -> detail::locale_ref { return {}; }
  45
  46   auto arg(int id) const -> basic_format_arg<basic_printf_context> {
  47     return args_.get(id);
  48   }
  49
  50   FMT_CONSTEXPR void on_error(const char* message) {
  51     detail::error_handler().on_error(message);
  52   }
  53 };
  54
  55 namespace detail {
  56
  57 // Checks if a value fits in int - used to avoid warnings about comparing
  58 // signed and unsigned integers.
  59 template <bool IsSigned> struct int_checker {
  60   template <typename T> static auto fits_in_int(T value) -> bool {
  61     unsigned max = max_value<int>();
  62     return value <= max;
  63   }
  64   static auto fits_in_int(bool) -> bool { return true; }
  65 };
  66
  67 template <> struct int_checker<true> {
  68   template <typename T> static auto fits_in_int(T value) -> bool {
  69     return value >= (std::numeric_limits<int>::min)() &&
  70            value <= max_value<int>();
  71   }
  72   static auto fits_in_int(int) -> bool { return true; }
  73 };
  74
  75 struct printf_precision_handler {
  76   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  77   auto operator()(T value) -> int {
  78     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
  79       throw_format_error("number is too big");
  80     return (std::max)(static_cast<int>(value), 0);
  81   }
  82
  83   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  84   auto operator()(T) -> int {
  85     throw_format_error("precision is not integer");
  86     return 0;
  87   }
  88 };
  89
  90 // An argument visitor that returns true iff arg is a zero integer.
  91 struct is_zero_int {
  92   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  93   auto operator()(T value) -> bool {
  94     return value == 0;
  95   }
  96
  97   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  98   auto operator()(T) -> bool {
  99     return false;
 100   }
 101 };
 102
 103 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
 104
 105 template <> struct make_unsigned_or_bool<bool> { using type = bool; };
 106
 107 template <typename T, typename Context> class arg_converter {
 108  private:
 109   using char_type = typename Context::char_type;
 110
 111   basic_format_arg<Context>& arg_;
 112   char_type type_;
 113
 114  public:
 115   arg_converter(basic_format_arg<Context>& arg, char_type type)
 116       : arg_(arg), type_(type) {}
 117
 118   void operator()(bool value) {
 119     if (type_ != 's') operator()<bool>(value);
 120   }
 121
 122   template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
 123   void operator()(U value) {
 124     bool is_signed = type_ == 'd' || type_ == 'i';
 125     using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
 126     if (const_check(sizeof(target_type) <= sizeof(int))) {
 127       // Extra casts are used to silence warnings.
 128       if (is_signed) {
 129         auto n = static_cast<int>(static_cast<target_type>(value));
 130         arg_ = detail::make_arg<Context>(n);
 131       } else {
 132         using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
 133         auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
 134         arg_ = detail::make_arg<Context>(n);
 135       }
 136     } else {
 137       if (is_signed) {
 138         // glibc's printf doesn't sign extend arguments of smaller types:
 139         //   std::printf("%lld", -42);  // prints "4294967254"
 140         // but we don't have to do the same because it's a UB.
 141         auto n = static_cast<long long>(value);
 142         arg_ = detail::make_arg<Context>(n);
 143       } else {
 144         auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
 145         arg_ = detail::make_arg<Context>(n);
 146       }
 147     }
 148   }
 149
 150   template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
 151   void operator()(U) {}  // No conversion needed for non-integral types.
 152 };
 153
 154 // Converts an integer argument to T for printf, if T is an integral type.
 155 // If T is void, the argument is converted to corresponding signed or unsigned
 156 // type depending on the type specifier: 'd' and 'i' - signed, other -
 157 // unsigned).
 158 template <typename T, typename Context, typename Char>
 159 void convert_arg(basic_format_arg<Context>& arg, Char type) {
 160   visit_format_arg(arg_converter<T, Context>(arg, type), arg);
 161 }
 162
 163 // Converts an integer argument to char for printf.
 164 template <typename Context> class char_converter {
 165  private:
 166   basic_format_arg<Context>& arg_;
 167
 168  public:
 169   explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
 170
 171   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 172   void operator()(T value) {
 173     auto c = static_cast<typename Context::char_type>(value);
 174     arg_ = detail::make_arg<Context>(c);
 175   }
 176
 177   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
 178   void operator()(T) {}  // No conversion needed for non-integral types.
 179 };
 180
 181 // An argument visitor that return a pointer to a C string if argument is a
 182 // string or null otherwise.
 183 template <typename Char> struct get_cstring {
 184   template <typename T> auto operator()(T) -> const Char* { return nullptr; }
 185   auto operator()(const Char* s) -> const Char* { return s; }
 186 };
 187
 188 // Checks if an argument is a valid printf width specifier and sets
 189 // left alignment if it is negative.
 190 template <typename Char> class printf_width_handler {
 191  private:
 192   format_specs<Char>& specs_;
 193
 194  public:
 195   explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
 196
 197   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 198   auto operator()(T value) -> unsigned {
 199     auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
 200     if (detail::is_negative(value)) {
 201       specs_.align = align::left;
 202       width = 0 - width;
 203     }
 204     unsigned int_max = max_value<int>();
 205     if (width > int_max) throw_format_error("number is too big");
 206     return static_cast<unsigned>(width);
 207   }
 208
 209   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
 210   auto operator()(T) -> unsigned {
 211     throw_format_error("width is not integer");
 212     return 0;
 213   }
 214 };
 215
 216 // Workaround for a bug with the XL compiler when initializing
 217 // printf_arg_formatter's base class.
 218 template <typename Char>
 219 auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
 220     -> arg_formatter<Char> {
 221   return {iter, s, locale_ref()};
 222 }
 223
 224 // The ``printf`` argument formatter.
 225 template <typename Char>
 226 class printf_arg_formatter : public arg_formatter<Char> {
 227  private:
 228   using base = arg_formatter<Char>;
 229   using context_type = basic_printf_context<Char>;
 230
 231   context_type& context_;
 232
 233   void write_null_pointer(bool is_string = false) {
 234     auto s = this->specs;
 235     s.type = presentation_type::none;
 236     write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
 237   }
 238
 239  public:
 240   printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
 241                        context_type& ctx)
 242       : base(make_arg_formatter(iter, s)), context_(ctx) {}
 243
 244   void operator()(monostate value) { base::operator()(value); }
 245
 246   template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
 247   void operator()(T value) {
 248     // MSVC2013 fails to compile separate overloads for bool and Char so use
 249     // std::is_same instead.
 250     if (!std::is_same<T, Char>::value) {
 251       base::operator()(value);
 252       return;
 253     }
 254     format_specs<Char> fmt_specs = this->specs;
 255     if (fmt_specs.type != presentation_type::none &&
 256         fmt_specs.type != presentation_type::chr) {
 257       return (*this)(static_cast<int>(value));
 258     }
 259     fmt_specs.sign = sign::none;
 260     fmt_specs.alt = false;
 261     fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
 262     // align::numeric needs to be overwritten here since the '0' flag is
 263     // ignored for non-numeric types
 264     if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
 265       fmt_specs.align = align::right;
 266     write<Char>(this->out, static_cast<Char>(value), fmt_specs);
 267   }
 268
 269   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
 270   void operator()(T value) {
 271     base::operator()(value);
 272   }
 273
 274   /** Formats a null-terminated C string. */
 275   void operator()(const char* value) {
 276     if (value)
 277       base::operator()(value);
 278     else
 279       write_null_pointer(this->specs.type != presentation_type::pointer);
 280   }
 281
 282   /** Formats a null-terminated wide C string. */
 283   void operator()(const wchar_t* value) {
 284     if (value)
 285       base::operator()(value);
 286     else
 287       write_null_pointer(this->specs.type != presentation_type::pointer);
 288   }
 289
 290   void operator()(basic_string_view<Char> value) { base::operator()(value); }
 291
 292   /** Formats a pointer. */
 293   void operator()(const void* value) {
 294     if (value)
 295       base::operator()(value);
 296     else
 297       write_null_pointer();
 298   }
 299
 300   /** Formats an argument of a custom (user-defined) type. */
 301   void operator()(typename basic_format_arg<context_type>::handle handle) {
 302     auto parse_ctx = basic_format_parse_context<Char>({});
 303     handle.format(parse_ctx, context_);
 304   }
 305 };
 306
 307 template <typename Char>
 308 void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
 309   for (; it != end; ++it) {
 310     switch (*it) {
 311     case '-':
 312       specs.align = align::left;
 313       break;
 314     case '+':
 315       specs.sign = sign::plus;
 316       break;
 317     case '0':
 318       specs.fill[0] = '0';
 319       break;
 320     case ' ':
 321       if (specs.sign != sign::plus) specs.sign = sign::space;
 322       break;
 323     case '#':
 324       specs.alt = true;
 325       break;
 326     default:
 327       return;
 328     }
 329   }
 330 }
 331
 332 template <typename Char, typename GetArg>
 333 auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
 334                   GetArg get_arg) -> int {
 335   int arg_index = -1;
 336   Char c = *it;
 337   if (c >= '0' && c <= '9') {
 338     // Parse an argument index (if followed by '$') or a width possibly
 339     // preceded with '0' flag(s).
 340     int value = parse_nonnegative_int(it, end, -1);
 341     if (it != end && *it == '$') {  // value is an argument index
 342       ++it;
 343       arg_index = value != -1 ? value : max_value<int>();
 344     } else {
 345       if (c == '0') specs.fill[0] = '0';
 346       if (value != 0) {
 347         // Nonzero value means that we parsed width and don't need to
 348         // parse it or flags again, so return now.
 349         if (value == -1) throw_format_error("number is too big");
 350         specs.width = value;
 351         return arg_index;
 352       }
 353     }
 354   }
 355   parse_flags(specs, it, end);
 356   // Parse width.
 357   if (it != end) {
 358     if (*it >= '0' && *it <= '9') {
 359       specs.width = parse_nonnegative_int(it, end, -1);
 360       if (specs.width == -1) throw_format_error("number is too big");
 361     } else if (*it == '*') {
 362       ++it;
 363       specs.width = static_cast<int>(visit_format_arg(
 364           detail::printf_width_handler<Char>(specs), get_arg(-1)));
 365     }
 366   }
 367   return arg_index;
 368 }
 369
 370 inline auto parse_printf_presentation_type(char c, type t)
 371     -> presentation_type {
 372   using pt = presentation_type;
 373   constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
 374   switch (c) {
 375   case 'd':
 376     return in(t, integral_set) ? pt::dec : pt::none;
 377   case 'o':
 378     return in(t, integral_set) ? pt::oct : pt::none;
 379   case 'x':
 380     return in(t, integral_set) ? pt::hex_lower : pt::none;
 381   case 'X':
 382     return in(t, integral_set) ? pt::hex_upper : pt::none;
 383   case 'a':
 384     return in(t, float_set) ? pt::hexfloat_lower : pt::none;
 385   case 'A':
 386     return in(t, float_set) ? pt::hexfloat_upper : pt::none;
 387   case 'e':
 388     return in(t, float_set) ? pt::exp_lower : pt::none;
 389   case 'E':
 390     return in(t, float_set) ? pt::exp_upper : pt::none;
 391   case 'f':
 392     return in(t, float_set) ? pt::fixed_lower : pt::none;
 393   case 'F':
 394     return in(t, float_set) ? pt::fixed_upper : pt::none;
 395   case 'g':
 396     return in(t, float_set) ? pt::general_lower : pt::none;
 397   case 'G':
 398     return in(t, float_set) ? pt::general_upper : pt::none;
 399   case 'c':
 400     return in(t, integral_set) ? pt::chr : pt::none;
 401   case 's':
 402     return in(t, string_set | cstring_set) ? pt::string : pt::none;
 403   case 'p':
 404     return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
 405   default:
 406     return pt::none;
 407   }
 408 }
 409
 410 template <typename Char, typename Context>
 411 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
 412              basic_format_args<Context> args) {
 413   using iterator = buffer_appender<Char>;
 414   auto out = iterator(buf);
 415   auto context = basic_printf_context<Char>(out, args);
 416   auto parse_ctx = basic_format_parse_context<Char>(format);
 417
 418   // Returns the argument with specified index or, if arg_index is -1, the next
 419   // argument.
 420   auto get_arg = [&](int arg_index) {
 421     if (arg_index < 0)
 422       arg_index = parse_ctx.next_arg_id();
 423     else
 424       parse_ctx.check_arg_id(--arg_index);
 425     return detail::get_arg(context, arg_index);
 426   };
 427
 428   const Char* start = parse_ctx.begin();
 429   const Char* end = parse_ctx.end();
 430   auto it = start;
 431   while (it != end) {
 432     if (!find<false, Char>(it, end, '%', it)) {
 433       it = end;  // find leaves it == nullptr if it doesn't find '%'.
 434       break;
 435     }
 436     Char c = *it++;
 437     if (it != end && *it == c) {
 438       write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 439       start = ++it;
 440       continue;
 441     }
 442     write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
 443
 444     auto specs = format_specs<Char>();
 445     specs.align = align::right;
 446
 447     // Parse argument index, flags and width.
 448     int arg_index = parse_header(it, end, specs, get_arg);
 449     if (arg_index == 0) throw_format_error("argument not found");
 450
 451     // Parse precision.
 452     if (it != end && *it == '.') {
 453       ++it;
 454       c = it != end ? *it : 0;
 455       if ('0' <= c && c <= '9') {
 456         specs.precision = parse_nonnegative_int(it, end, 0);
 457       } else if (c == '*') {
 458         ++it;
 459         specs.precision = static_cast<int>(
 460             visit_format_arg(printf_precision_handler(), get_arg(-1)));
 461       } else {
 462         specs.precision = 0;
 463       }
 464     }
 465
 466     auto arg = get_arg(arg_index);
 467     // For d, i, o, u, x, and X conversion specifiers, if a precision is
 468     // specified, the '0' flag is ignored
 469     if (specs.precision >= 0 && arg.is_integral()) {
 470       // Ignore '0' for non-numeric types or if '-' present.
 471       specs.fill[0] = ' ';
 472     }
 473     if (specs.precision >= 0 && arg.type() == type::cstring_type) {
 474       auto str = visit_format_arg(get_cstring<Char>(), arg);
 475       auto str_end = str + specs.precision;
 476       auto nul = std::find(str, str_end, Char());
 477       auto sv = basic_string_view<Char>(
 478           str, to_unsigned(nul != str_end ? nul - str : specs.precision));
 479       arg = make_arg<basic_printf_context<Char>>(sv);
 480     }
 481     if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
 482     if (specs.fill[0] == '0') {
 483       if (arg.is_arithmetic() && specs.align != align::left)
 484         specs.align = align::numeric;
 485       else
 486         specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
 487                               // flag is also present.
 488     }
 489
 490     // Parse length and convert the argument to the required type.
 491     c = it != end ? *it++ : 0;
 492     Char t = it != end ? *it : 0;
 493     switch (c) {
 494     case 'h':
 495       if (t == 'h') {
 496         ++it;
 497         t = it != end ? *it : 0;
 498         convert_arg<signed char>(arg, t);
 499       } else {
 500         convert_arg<short>(arg, t);
 501       }
 502       break;
 503     case 'l':
 504       if (t == 'l') {
 505         ++it;
 506         t = it != end ? *it : 0;
 507         convert_arg<long long>(arg, t);
 508       } else {
 509         convert_arg<long>(arg, t);
 510       }
 511       break;
 512     case 'j':
 513       convert_arg<intmax_t>(arg, t);
 514       break;
 515     case 'z':
 516       convert_arg<size_t>(arg, t);
 517       break;
 518     case 't':
 519       convert_arg<std::ptrdiff_t>(arg, t);
 520       break;
 521     case 'L':
 522       // printf produces garbage when 'L' is omitted for long double, no
 523       // need to do the same.
 524       break;
 525     default:
 526       --it;
 527       convert_arg<void>(arg, c);
 528     }
 529
 530     // Parse type.
 531     if (it == end) throw_format_error("invalid format string");
 532     char type = static_cast<char>(*it++);
 533     if (arg.is_integral()) {
 534       // Normalize type.
 535       switch (type) {
 536       case 'i':
 537       case 'u':
 538         type = 'd';
 539         break;
 540       case 'c':
 541         visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
 542         break;
 543       }
 544     }
 545     specs.type = parse_printf_presentation_type(type, arg.type());
 546     if (specs.type == presentation_type::none)
 547       throw_format_error("invalid format specifier");
 548
 549     start = it;
 550
 551     // Format argument.
 552     visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
 553   }
 554   write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 555 }
 556 }  // namespace detail
 557
 558 using printf_context = basic_printf_context<char>;
 559 using wprintf_context = basic_printf_context<wchar_t>;
 560
 561 using printf_args = basic_format_args<printf_context>;
 562 using wprintf_args = basic_format_args<wprintf_context>;
 563
 564 /**
 565   \rst
 566   Constructs an `~fmt::format_arg_store` object that contains references to
 567   arguments and can be implicitly converted to `~fmt::printf_args`.
 568   \endrst
 569  */
 570 template <typename... T>
 571 inline auto make_printf_args(const T&... args)
 572     -> format_arg_store<printf_context, T...> {
 573   return {args...};
 574 }
 575
 576 // DEPRECATED!
 577 template <typename... T>
 578 inline auto make_wprintf_args(const T&... args)
 579     -> format_arg_store<wprintf_context, T...> {
 580   return {args...};
 581 }
 582
 583 template <typename Char>
 584 inline auto vsprintf(
 585     basic_string_view<Char> fmt,
 586     basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
 587     -> std::basic_string<Char> {
 588   auto buf = basic_memory_buffer<Char>();
 589   detail::vprintf(buf, fmt, args);
 590   return to_string(buf);
 591 }
 592
 593 /**
 594   \rst
 595   Formats arguments and returns the result as a string.
 596
 597   **Example**::
 598
 599     std::string message = fmt::sprintf("The answer is %d", 42);
 600   \endrst
 601 */
 602 template <typename S, typename... T,
 603           typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
 604 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
 605   return vsprintf(detail::to_string_view(fmt),
 606                   fmt::make_format_args<basic_printf_context<Char>>(args...));
 607 }
 608
 609 template <typename Char>
 610 inline auto vfprintf(
 611     std::FILE* f, basic_string_view<Char> fmt,
 612     basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
 613     -> int {
 614   auto buf = basic_memory_buffer<Char>();
 615   detail::vprintf(buf, fmt, args);
 616   size_t size = buf.size();
 617   return std::fwrite(buf.data(), sizeof(Char), size, f) < size
 618              ? -1
 619              : static_cast<int>(size);
 620 }
 621
 622 /**
 623   \rst
 624   Prints formatted data to the file *f*.
 625
 626   **Example**::
 627
 628     fmt::fprintf(stderr, "Don't %s!", "panic");
 629   \endrst
 630  */
 631 template <typename S, typename... T, typename Char = char_t<S>>
 632 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
 633   return vfprintf(f, detail::to_string_view(fmt),
 634                   fmt::make_format_args<basic_printf_context<Char>>(args...));
 635 }
 636
 637 template <typename Char>
 638 FMT_DEPRECATED inline auto vprintf(
 639     basic_string_view<Char> fmt,
 640     basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
 641     -> int {
 642   return vfprintf(stdout, fmt, args);
 643 }
 644
 645 /**
 646   \rst
 647   Prints formatted data to ``stdout``.
 648
 649   **Example**::
 650
 651     fmt::printf("Elapsed time: %.2f seconds", 1.23);
 652   \endrst
 653  */
 654 template <typename... T>
 655 inline auto printf(string_view fmt, const T&... args) -> int {
 656   return vfprintf(stdout, fmt, make_printf_args(args...));
 657 }
 658 template <typename... T>
 659 FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
 660                                   const T&... args) -> int {
 661   return vfprintf(stdout, fmt, make_wprintf_args(args...));
 662 }
 663
 664 FMT_END_EXPORT
 665 FMT_END_NAMESPACE
 666
 667 #endif  // FMT_PRINTF_H_