src/tinyformat.h

   1 // tinyformat.h
   2 // Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com]
   3 //
   4 // Boost Software License - Version 1.0
   5 //
   6 // Permission is hereby granted, free of charge, to any person or organization
   7 // obtaining a copy of the software and accompanying documentation covered by
   8 // this license (the "Software") to use, reproduce, display, distribute,
   9 // execute, and transmit the Software, and to prepare derivative works of the
  10 // Software, and to permit third-parties to whom the Software is furnished to
  11 // do so, all subject to the following:
  12 //
  13 // The copyright notices in the Software and this entire statement, including
  14 // the above license grant, this restriction and the following disclaimer,
  15 // must be included in all copies of the Software, in whole or in part, and
  16 // all derivative works of the Software, unless such copies or derivative
  17 // works are solely in the form of machine-executable object code generated by
  18 // a source language processor.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 // FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
  23 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
  24 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
  25 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26 // DEALINGS IN THE SOFTWARE.
  27
  28 //------------------------------------------------------------------------------
  29 // Tinyformat: A minimal type safe printf replacement
  30 //
  31 // tinyformat.h is a type safe printf replacement library in a single C++
  32 // header file.  Design goals include:
  33 //
  34 // * Type safety and extensibility for user defined types.
  35 // * C99 printf() compatibility, to the extent possible using std::ostream
  36 // * Simplicity and minimalism.  A single header file to include and distribute
  37 //   with your projects.
  38 // * Augment rather than replace the standard stream formatting mechanism
  39 // * C++98 support, with optional C++11 niceties
  40 //
  41 //
  42 // Main interface example usage
  43 // ----------------------------
  44 //
  45 // To print a date to std::cout:
  46 //
  47 //   std::string weekday = "Wednesday";
  48 //   const char* month = "July";
  49 //   size_t day = 27;
  50 //   long hour = 14;
  51 //   int min = 44;
  52 //
  53 //   tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
  54 //
  55 // The strange types here emphasize the type safety of the interface; it is
  56 // possible to print a std::string using the "%s" conversion, and a
  57 // size_t using the "%d" conversion.  A similar result could be achieved
  58 // using either of the tfm::format() functions.  One prints on a user provided
  59 // stream:
  60 //
  61 //   tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n",
  62 //               weekday, month, day, hour, min);
  63 //
  64 // The other returns a std::string:
  65 //
  66 //   std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n",
  67 //                                  weekday, month, day, hour, min);
  68 //   std::cout << date;
  69 //
  70 // These are the three primary interface functions.  There is also a
  71 // convenience function printfln() which appends a newline to the usual result
  72 // of printf() for super simple logging.
  73 //
  74 //
  75 // User defined format functions
  76 // -----------------------------
  77 //
  78 // Simulating variadic templates in C++98 is pretty painful since it requires
  79 // writing out the same function for each desired number of arguments.  To make
  80 // this bearable tinyformat comes with a set of macros which are used
  81 // internally to generate the API, but which may also be used in user code.
  82 //
  83 // The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
  84 // TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
  85 // type/name pairs and argument names respectively when called with an integer
  86 // n between 1 and 16.  We can use these to define a macro which generates the
  87 // desired user defined function with n arguments.  To generate all 16 user
  88 // defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM.  For an
  89 // example, see the implementation of printf() at the end of the source file.
  90 //
  91 // Sometimes it's useful to be able to pass a list of format arguments through
  92 // to a non-template function.  The FormatList class is provided as a way to do
  93 // this by storing the argument list in a type-opaque way.  Continuing the
  94 // example from above, we construct a FormatList using makeFormatList():
  95 //
  96 //   FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min);
  97 //
  98 // The format list can now be passed into any non-template function and used
  99 // via a call to the vformat() function:
 100 //
 101 //   tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList);
 102 //
 103 //
 104 // Additional API information
 105 // --------------------------
 106 //
 107 // Error handling: Define TINYFORMAT_ERROR to customize the error handling for
 108 // format strings which are unsupported or have the wrong number of format
 109 // specifiers (calls assert() by default).
 110 //
 111 // User defined types: Uses operator<< for user defined types by default.
 112 // Overload formatValue() for more control.
 113
 114
 115 #ifndef TINYFORMAT_H_INCLUDED
 116 #define TINYFORMAT_H_INCLUDED
 117
 118 namespace tinyformat {}
 119 //------------------------------------------------------------------------------
 120 // Config section.  Customize to your liking!
 121
 122 // Namespace alias to encourage brevity
 123 namespace tfm = tinyformat;
 124
 125 // Error handling; calls assert() by default.
 126 #define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
 127
 128 // Define for C++11 variadic templates which make the code shorter & more
 129 // general.  If you don't define this, C++11 support is autodetected below.
 130 #define TINYFORMAT_USE_VARIADIC_TEMPLATES
 131
 132
 133 //------------------------------------------------------------------------------
 134 // Implementation details.
 135 #include <algorithm>
 136 #include <cassert>
 137 #include <iostream>
 138 #include <sstream>
 139 #include <stdexcept>
 140
 141 #ifndef TINYFORMAT_ERROR
 142 #   define TINYFORMAT_ERROR(reason) assert(0 && reason)
 143 #endif
 144
 145 #if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
 146 #   ifdef __GXX_EXPERIMENTAL_CXX0X__
 147 #       define TINYFORMAT_USE_VARIADIC_TEMPLATES
 148 #   endif
 149 #endif
 150
 151 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
 152 //  std::showpos is broken on old libstdc++ as provided with OSX.  See
 153 //  http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
 154 #   define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 155 #endif
 156
 157 #ifdef __APPLE__
 158 // Workaround OSX linker warning: xcode uses different default symbol
 159 // visibilities for static libs vs executables (see issue #25)
 160 #   define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
 161 #else
 162 #   define TINYFORMAT_HIDDEN
 163 #endif
 164
 165 namespace tinyformat {
 166
 167 class format_error: public std::runtime_error
 168 {
 169 public:
 170     format_error(const std::string &what): std::runtime_error(what) {
 171     }
 172 };
 173
 174 //------------------------------------------------------------------------------
 175 namespace detail {
 176
 177 // Test whether type T1 is convertible to type T2
 178 template <typename T1, typename T2>
 179 struct is_convertible
 180 {
 181     private:
 182         // two types of different size
 183         struct fail { char dummy[2]; };
 184         struct succeed { char dummy; };
 185         // Try to convert a T1 to a T2 by plugging into tryConvert
 186         static fail tryConvert(...);
 187         static succeed tryConvert(const T2&);
 188         static const T1& makeT1();
 189     public:
 190 #       ifdef _MSC_VER
 191         // Disable spurious loss of precision warnings in tryConvert(makeT1())
 192 #       pragma warning(push)
 193 #       pragma warning(disable:4244)
 194 #       pragma warning(disable:4267)
 195 #       endif
 196         // Standard trick: the (...) version of tryConvert will be chosen from
 197         // the overload set only if the version taking a T2 doesn't match.
 198         // Then we compare the sizes of the return types to check which
 199         // function matched.  Very neat, in a disgusting kind of way :)
 200         static const bool value =
 201             sizeof(tryConvert(makeT1())) == sizeof(succeed);
 202 #       ifdef _MSC_VER
 203 #       pragma warning(pop)
 204 #       endif
 205 };
 206
 207
 208 // Detect when a type is not a wchar_t string
 209 template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
 210 template<> struct is_wchar<wchar_t*> {};
 211 template<> struct is_wchar<const wchar_t*> {};
 212 template<int n> struct is_wchar<const wchar_t[n]> {};
 213 template<int n> struct is_wchar<wchar_t[n]> {};
 214
 215
 216 // Format the value by casting to type fmtT.  This default implementation
 217 // should never be called.
 218 template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
 219 struct formatValueAsType
 220 {
 221     static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); }
 222 };
 223 // Specialized version for types that can actually be converted to fmtT, as
 224 // indicated by the "convertible" template parameter.
 225 template<typename T, typename fmtT>
 226 struct formatValueAsType<T,fmtT,true>
 227 {
 228     static void invoke(std::ostream& out, const T& value)
 229         { out << static_cast<fmtT>(value); }
 230 };
 231
 232 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 233 template<typename T, bool convertible = is_convertible<T, int>::value>
 234 struct formatZeroIntegerWorkaround
 235 {
 236     static bool invoke(std::ostream& /**/, const T& /**/) { return false; }
 237 };
 238 template<typename T>
 239 struct formatZeroIntegerWorkaround<T,true>
 240 {
 241     static bool invoke(std::ostream& out, const T& value)
 242     {
 243         if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
 244         {
 245             out << "+0";
 246             return true;
 247         }
 248         return false;
 249     }
 250 };
 251 #endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 252
 253 // Convert an arbitrary type to integer.  The version with convertible=false
 254 // throws an error.
 255 template<typename T, bool convertible = is_convertible<T,int>::value>
 256 struct convertToInt
 257 {
 258     static int invoke(const T& /*value*/)
 259     {
 260         TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
 261                          "integer for use as variable width or precision");
 262         return 0;
 263     }
 264 };
 265 // Specialization for convertToInt when conversion is possible
 266 template<typename T>
 267 struct convertToInt<T,true>
 268 {
 269     static int invoke(const T& value) { return static_cast<int>(value); }
 270 };
 271
 272 // Format at most ntrunc characters to the given stream.
 273 template<typename T>
 274 inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
 275 {
 276     std::ostringstream tmp;
 277     tmp << value;
 278     std::string result = tmp.str();
 279     out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
 280 }
 281 #define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type)       \
 282 inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
 283 {                                                           \
 284     std::streamsize len = 0;                                \
 285     while(len < ntrunc && value[len] != 0)                  \
 286         ++len;                                              \
 287     out.write(value, len);                                  \
 288 }
 289 // Overload for const char* and char*.  Could overload for signed & unsigned
 290 // char too, but these are technically unneeded for printf compatibility.
 291 TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
 292 TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char)
 293 #undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR
 294
 295 } // namespace detail
 296
 297
 298 //------------------------------------------------------------------------------
 299 // Variable formatting functions.  May be overridden for user-defined types if
 300 // desired.
 301
 302
 303 /// Format a value into a stream, delegating to operator<< by default.
 304 ///
 305 /// Users may override this for their own types.  When this function is called,
 306 /// the stream flags will have been modified according to the format string.
 307 /// The format specification is provided in the range [fmtBegin, fmtEnd).  For
 308 /// truncating conversions, ntrunc is set to the desired maximum number of
 309 /// characters, for example "%.7s" calls formatValue with ntrunc = 7.
 310 ///
 311 /// By default, formatValue() uses the usual stream insertion operator
 312 /// operator<< to format the type T, with special cases for the %c and %p
 313 /// conversions.
 314 template<typename T>
 315 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
 316                         const char* fmtEnd, int ntrunc, const T& value)
 317 {
 318 #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
 319     // Since we don't support printing of wchar_t using "%ls", make it fail at
 320     // compile time in preference to printing as a void* at runtime.
 321     typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
 322     (void) DummyType(); // avoid unused type warning with gcc-4.8
 323 #endif
 324     // The mess here is to support the %c and %p conversions: if these
 325     // conversions are active we try to convert the type to a char or const
 326     // void* respectively and format that instead of the value itself.  For the
 327     // %p conversion it's important to avoid dereferencing the pointer, which
 328     // could otherwise lead to a crash when printing a dangling (const char*).
 329     const bool canConvertToChar = detail::is_convertible<T,char>::value;
 330     const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
 331     if(canConvertToChar && *(fmtEnd-1) == 'c')
 332         detail::formatValueAsType<T, char>::invoke(out, value);
 333     else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
 334         detail::formatValueAsType<T, const void*>::invoke(out, value);
 335 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 336     else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
 337 #endif
 338     else if(ntrunc >= 0)
 339     {
 340         // Take care not to overread C strings in truncating conversions like
 341         // "%.4s" where at most 4 characters may be read.
 342         detail::formatTruncated(out, value, ntrunc);
 343     }
 344     else
 345         out << value;
 346 }
 347
 348
 349 // Overloaded version for char types to support printing as an integer
 350 #define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)                  \
 351 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,  \
 352                         const char* fmtEnd, int /**/, charType value) \
 353 {                                                                     \
 354     switch(*(fmtEnd-1))                                               \
 355     {                                                                 \
 356         case 'u': case 'd': case 'i': case 'o': case 'X': case 'x':   \
 357             out << static_cast<int>(value); break;                    \
 358         default:                                                      \
 359             out << value;                   break;                    \
 360     }                                                                 \
 361 }
 362 // per 3.9.1: char, signed char and unsigned char are all distinct types
 363 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
 364 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
 365 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
 366 #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR
 367
 368
 369 //------------------------------------------------------------------------------
 370 // Tools for emulating variadic templates in C++98.  The basic idea here is
 371 // stolen from the boost preprocessor metaprogramming library and cut down to
 372 // be just general enough for what we need.
 373
 374 #define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
 375 #define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
 376 #define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
 377 #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n
 378
 379 // To keep it as transparent as possible, the macros below have been generated
 380 // using python via the excellent cog.py code generation script.  This avoids
 381 // the need for a bunch of complex (but more general) preprocessor tricks as
 382 // used in boost.preprocessor.
 383 //
 384 // To rerun the code generation in place, use `cog.py -r tinyformat.h`
 385 // (see http://nedbatchelder.com/code/cog).  Alternatively you can just create
 386 // extra versions by hand.
 387
 388 /*[[[cog
 389 maxParams = 16
 390
 391 def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
 392     for j in range(startInd,maxParams+1):
 393         list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
 394         cog.outl(lineTemplate % {'j':j, 'list':list})
 395
 396 makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
 397                   'class T%(i)d')
 398
 399 cog.outl()
 400 makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
 401                   'const T%(i)d& v%(i)d')
 402
 403 cog.outl()
 404 makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')
 405
 406 cog.outl()
 407 cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
 408 makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
 409                   'v%(i)d', startInd = 2)
 410
 411 cog.outl()
 412 cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n    ' +
 413          ' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
 414 ]]]*/
 415 #define TINYFORMAT_ARGTYPES_1 class T1
 416 #define TINYFORMAT_ARGTYPES_2 class T1, class T2
 417 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
 418 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
 419 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
 420 #define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
 421 #define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
 422 #define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
 423 #define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
 424 #define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
 425 #define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11
 426 #define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12
 427 #define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13
 428 #define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14
 429 #define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15
 430 #define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16
 431
 432 #define TINYFORMAT_VARARGS_1 const T1& v1
 433 #define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
 434 #define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
 435 #define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
 436 #define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
 437 #define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
 438 #define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7
 439 #define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8
 440 #define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9
 441 #define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10
 442 #define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11
 443 #define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12
 444 #define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13
 445 #define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14
 446 #define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15
 447 #define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16
 448
 449 #define TINYFORMAT_PASSARGS_1 v1
 450 #define TINYFORMAT_PASSARGS_2 v1, v2
 451 #define TINYFORMAT_PASSARGS_3 v1, v2, v3
 452 #define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
 453 #define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
 454 #define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
 455 #define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
 456 #define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
 457 #define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
 458 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
 459 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 460 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 461 #define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 462 #define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 463 #define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 464 #define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 465
 466 #define TINYFORMAT_PASSARGS_TAIL_1
 467 #define TINYFORMAT_PASSARGS_TAIL_2 , v2
 468 #define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
 469 #define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
 470 #define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
 471 #define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
 472 #define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
 473 #define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
 474 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
 475 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
 476 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 477 #define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 478 #define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 479 #define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 480 #define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 481 #define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 482
 483 #define TINYFORMAT_FOREACH_ARGNUM(m) \
 484     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)
 485 //[[[end]]]
 486
 487
 488
 489 namespace detail {
 490
 491 // Type-opaque holder for an argument to format(), with associated actions on
 492 // the type held as explicit function pointers.  This allows FormatArg's for
 493 // each argument to be allocated as a homogenous array inside FormatList
 494 // whereas a naive implementation based on inheritance does not.
 495 class FormatArg
 496 {
 497     public:
 498         FormatArg() {}
 499
 500         template<typename T>
 501         FormatArg(const T& value)
 502             : m_value(static_cast<const void*>(&value)),
 503             m_formatImpl(&formatImpl<T>),
 504             m_toIntImpl(&toIntImpl<T>)
 505         { }
 506
 507         void format(std::ostream& out, const char* fmtBegin,
 508                     const char* fmtEnd, int ntrunc) const
 509         {
 510             m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
 511         }
 512
 513         int toInt() const
 514         {
 515             return m_toIntImpl(m_value);
 516         }
 517
 518     private:
 519         template<typename T>
 520         TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
 521                         const char* fmtEnd, int ntrunc, const void* value)
 522         {
 523             formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
 524         }
 525
 526         template<typename T>
 527         TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
 528         {
 529             return convertToInt<T>::invoke(*static_cast<const T*>(value));
 530         }
 531
 532         const void* m_value;
 533         void (*m_formatImpl)(std::ostream& out, const char* fmtBegin,
 534                              const char* fmtEnd, int ntrunc, const void* value);
 535         int (*m_toIntImpl)(const void* value);
 536 };
 537
 538
 539 // Parse and return an integer from the string c, as atoi()
 540 // On return, c is set to one past the end of the integer.
 541 inline int parseIntAndAdvance(const char*& c)
 542 {
 543     int i = 0;
 544     for(;*c >= '0' && *c <= '9'; ++c)
 545         i = 10*i + (*c - '0');
 546     return i;
 547 }
 548
 549 // Print literal part of format string and return next format spec
 550 // position.
 551 //
 552 // Skips over any occurrences of '%%', printing a literal '%' to the
 553 // output.  The position of the first % character of the next
 554 // nontrivial format spec is returned, or the end of string.
 555 inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
 556 {
 557     const char* c = fmt;
 558     for(;; ++c)
 559     {
 560         switch(*c)
 561         {
 562             case '\0':
 563                 out.write(fmt, c - fmt);
 564                 return c;
 565             case '%':
 566                 out.write(fmt, c - fmt);
 567                 if(*(c+1) != '%')
 568                     return c;
 569                 // for "%%", tack trailing % onto next literal section.
 570                 fmt = ++c;
 571                 break;
 572             default:
 573                 break;
 574         }
 575     }
 576 }
 577
 578
 579 // Parse a format string and set the stream state accordingly.
 580 //
 581 // The format mini-language recognized here is meant to be the one from C99,
 582 // with the form "%[flags][width][.precision][length]type".
 583 //
 584 // Formatting options which can't be natively represented using the ostream
 585 // state are returned in spacePadPositive (for space padded positive numbers)
 586 // and ntrunc (for truncating conversions).  argIndex is incremented if
 587 // necessary to pull out variable width and precision .  The function returns a
 588 // pointer to the character after the end of the current format spec.
 589 inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive,
 590                                          int& ntrunc, const char* fmtStart,
 591                                          const detail::FormatArg* formatters,
 592                                          int& argIndex, int numFormatters)
 593 {
 594     if(*fmtStart != '%')
 595     {
 596         TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
 597         return fmtStart;
 598     }
 599     // Reset stream state to defaults.
 600     out.width(0);
 601     out.precision(6);
 602     out.fill(' ');
 603     // Reset most flags; ignore irrelevant unitbuf & skipws.
 604     out.unsetf(std::ios::adjustfield | std::ios::basefield |
 605                std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
 606                std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
 607     bool precisionSet = false;
 608     bool widthSet = false;
 609     int widthExtra = 0;
 610     const char* c = fmtStart + 1;
 611     // 1) Parse flags
 612     for(;; ++c)
 613     {
 614         switch(*c)
 615         {
 616             case '#':
 617                 out.setf(std::ios::showpoint | std::ios::showbase);
 618                 continue;
 619             case '0':
 620                 // overridden by left alignment ('-' flag)
 621                 if(!(out.flags() & std::ios::left))
 622                 {
 623                     // Use internal padding so that numeric values are
 624                     // formatted correctly, eg -00010 rather than 000-10
 625                     out.fill('0');
 626                     out.setf(std::ios::internal, std::ios::adjustfield);
 627                 }
 628                 continue;
 629             case '-':
 630                 out.fill(' ');
 631                 out.setf(std::ios::left, std::ios::adjustfield);
 632                 continue;
 633             case ' ':
 634                 // overridden by show positive sign, '+' flag.
 635                 if(!(out.flags() & std::ios::showpos))
 636                     spacePadPositive = true;
 637                 continue;
 638             case '+':
 639                 out.setf(std::ios::showpos);
 640                 spacePadPositive = false;
 641                 widthExtra = 1;
 642                 continue;
 643             default:
 644                 break;
 645         }
 646         break;
 647     }
 648     // 2) Parse width
 649     if(*c >= '0' && *c <= '9')
 650     {
 651         widthSet = true;
 652         out.width(parseIntAndAdvance(c));
 653     }
 654     if(*c == '*')
 655     {
 656         widthSet = true;
 657         int width = 0;
 658         if(argIndex < numFormatters)
 659             width = formatters[argIndex++].toInt();
 660         else
 661             TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width");
 662         if(width < 0)
 663         {
 664             // negative widths correspond to '-' flag set
 665             out.fill(' ');
 666             out.setf(std::ios::left, std::ios::adjustfield);
 667             width = -width;
 668         }
 669         out.width(width);
 670         ++c;
 671     }
 672     // 3) Parse precision
 673     if(*c == '.')
 674     {
 675         ++c;
 676         int precision = 0;
 677         if(*c == '*')
 678         {
 679             ++c;
 680             if(argIndex < numFormatters)
 681                 precision = formatters[argIndex++].toInt();
 682             else
 683                 TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
 684         }
 685         else
 686         {
 687             if(*c >= '0' && *c <= '9')
 688                 precision = parseIntAndAdvance(c);
 689             else if(*c == '-') // negative precisions ignored, treated as zero.
 690                 parseIntAndAdvance(++c);
 691         }
 692         out.precision(precision);
 693         precisionSet = true;
 694     }
 695     // 4) Ignore any C99 length modifier
 696     while(*c == 'l' || *c == 'h' || *c == 'L' ||
 697           *c == 'j' || *c == 'z' || *c == 't')
 698         ++c;
 699     // 5) We're up to the conversion specifier character.
 700     // Set stream flags based on conversion specifier (thanks to the
 701     // boost::format class for forging the way here).
 702     bool intConversion = false;
 703     switch(*c)
 704     {
 705         case 'u': case 'd': case 'i':
 706             out.setf(std::ios::dec, std::ios::basefield);
 707             intConversion = true;
 708             break;
 709         case 'o':
 710             out.setf(std::ios::oct, std::ios::basefield);
 711             intConversion = true;
 712             break;
 713         case 'X':
 714             out.setf(std::ios::uppercase);
 715         case 'x': case 'p':
 716             out.setf(std::ios::hex, std::ios::basefield);
 717             intConversion = true;
 718             break;
 719         case 'E':
 720             out.setf(std::ios::uppercase);
 721         case 'e':
 722             out.setf(std::ios::scientific, std::ios::floatfield);
 723             out.setf(std::ios::dec, std::ios::basefield);
 724             break;
 725         case 'F':
 726             out.setf(std::ios::uppercase);
 727         case 'f':
 728             out.setf(std::ios::fixed, std::ios::floatfield);
 729             break;
 730         case 'G':
 731             out.setf(std::ios::uppercase);
 732         case 'g':
 733             out.setf(std::ios::dec, std::ios::basefield);
 734             // As in boost::format, let stream decide float format.
 735             out.flags(out.flags() & ~std::ios::floatfield);
 736             break;
 737         case 'a': case 'A':
 738             TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
 739                              "are not supported");
 740             break;
 741         case 'c':
 742             // Handled as special case inside formatValue()
 743             break;
 744         case 's':
 745             if(precisionSet)
 746                 ntrunc = static_cast<int>(out.precision());
 747             // Make %s print booleans as "true" and "false"
 748             out.setf(std::ios::boolalpha);
 749             break;
 750         case 'n':
 751             // Not supported - will cause problems!
 752             TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
 753             break;
 754         case '\0':
 755             TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
 756                              "terminated by end of string");
 757             return c;
 758         default:
 759             break;
 760     }
 761     if(intConversion && precisionSet && !widthSet)
 762     {
 763         // "precision" for integers gives the minimum number of digits (to be
 764         // padded with zeros on the left).  This isn't really supported by the
 765         // iostreams, but we can approximately simulate it with the width if
 766         // the width isn't otherwise used.
 767         out.width(out.precision() + widthExtra);
 768         out.setf(std::ios::internal, std::ios::adjustfield);
 769         out.fill('0');
 770     }
 771     return c+1;
 772 }
 773
 774
 775 //------------------------------------------------------------------------------
 776 inline void formatImpl(std::ostream& out, const char* fmt,
 777                        const detail::FormatArg* formatters,
 778                        int numFormatters)
 779 {
 780     // Saved stream state
 781     std::streamsize origWidth = out.width();
 782     std::streamsize origPrecision = out.precision();
 783     std::ios::fmtflags origFlags = out.flags();
 784     char origFill = out.fill();
 785
 786     for (int argIndex = 0; argIndex < numFormatters; ++argIndex)
 787     {
 788         // Parse the format string
 789         fmt = printFormatStringLiteral(out, fmt);
 790         bool spacePadPositive = false;
 791         int ntrunc = -1;
 792         const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
 793                                                    formatters, argIndex, numFormatters);
 794         if (argIndex >= numFormatters)
 795         {
 796             // Check args remain after reading any variable width/precision
 797             TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
 798             return;
 799         }
 800         const FormatArg& arg = formatters[argIndex];
 801         // Format the arg into the stream.
 802         if(!spacePadPositive)
 803             arg.format(out, fmt, fmtEnd, ntrunc);
 804         else
 805         {
 806             // The following is a special case with no direct correspondence
 807             // between stream formatting and the printf() behaviour.  Simulate
 808             // it crudely by formatting into a temporary string stream and
 809             // munging the resulting string.
 810             std::ostringstream tmpStream;
 811             tmpStream.copyfmt(out);
 812             tmpStream.setf(std::ios::showpos);
 813             arg.format(tmpStream, fmt, fmtEnd, ntrunc);
 814             std::string result = tmpStream.str(); // allocates... yuck.
 815             for(size_t i = 0, iend = result.size(); i < iend; ++i)
 816                 if(result[i] == '+') result[i] = ' ';
 817             out << result;
 818         }
 819         fmt = fmtEnd;
 820     }
 821
 822     // Print remaining part of format string.
 823     fmt = printFormatStringLiteral(out, fmt);
 824     if(*fmt != '\0')
 825         TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
 826
 827     // Restore stream state
 828     out.width(origWidth);
 829     out.precision(origPrecision);
 830     out.flags(origFlags);
 831     out.fill(origFill);
 832 }
 833
 834 } // namespace detail
 835
 836
 837 /// List of template arguments format(), held in a type-opaque way.
 838 ///
 839 /// A const reference to FormatList (typedef'd as FormatListRef) may be
 840 /// conveniently used to pass arguments to non-template functions: All type
 841 /// information has been stripped from the arguments, leaving just enough of a
 842 /// common interface to perform formatting as required.
 843 class FormatList
 844 {
 845     public:
 846         FormatList(detail::FormatArg* formatters, int N)
 847             : m_formatters(formatters), m_N(N) { }
 848
 849         friend void vformat(std::ostream& out, const char* fmt,
 850                             const FormatList& list);
 851
 852     private:
 853         const detail::FormatArg* m_formatters;
 854         int m_N;
 855 };
 856
 857 /// Reference to type-opaque format list for passing to vformat()
 858 typedef const FormatList& FormatListRef;
 859
 860
 861 namespace detail {
 862
 863 // Format list subclass with fixed storage to avoid dynamic allocation
 864 template<int N>
 865 class FormatListN : public FormatList
 866 {
 867     public:
 868 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 869         template<typename... Args>
 870         FormatListN(const Args&... args)
 871             : FormatList(&m_formatterStore[0], N),
 872             m_formatterStore { FormatArg(args)... }
 873         { static_assert(sizeof...(args) == N, "Number of args must be N"); }
 874 #else // C++98 version
 875         void init(int) {}
 876 #       define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n)       \
 877                                                                \
 878         template<TINYFORMAT_ARGTYPES(n)>                       \
 879         FormatListN(TINYFORMAT_VARARGS(n))                     \
 880             : FormatList(&m_formatterStore[0], n)              \
 881         { assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); }   \
 882                                                                \
 883         template<TINYFORMAT_ARGTYPES(n)>                       \
 884         void init(int i, TINYFORMAT_VARARGS(n))                \
 885         {                                                      \
 886             m_formatterStore[i] = FormatArg(v1);               \
 887             init(i+1 TINYFORMAT_PASSARGS_TAIL(n));             \
 888         }
 889
 890         TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
 891 #       undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
 892 #endif
 893
 894     private:
 895         FormatArg m_formatterStore[N];
 896 };
 897
 898 // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
 899 template<> class FormatListN<0> : public FormatList
 900 {
 901     public: FormatListN() : FormatList(0, 0) {}
 902 };
 903
 904 } // namespace detail
 905
 906
 907 //------------------------------------------------------------------------------
 908 // Primary API functions
 909
 910 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 911
 912 /// Make type-agnostic format list from list of template arguments.
 913 ///
 914 /// The exact return type of this function is an implementation detail and
 915 /// shouldn't be relied upon.  Instead it should be stored as a FormatListRef:
 916 ///
 917 ///   FormatListRef formatList = makeFormatList( /*...*/ );
 918 template<typename... Args>
 919 detail::FormatListN<sizeof...(Args)> makeFormatList(const Args&... args)
 920 {
 921     return detail::FormatListN<sizeof...(args)>(args...);
 922 }
 923
 924 #else // C++98 version
 925
 926 inline detail::FormatListN<0> makeFormatList()
 927 {
 928     return detail::FormatListN<0>();
 929 }
 930 #define TINYFORMAT_MAKE_MAKEFORMATLIST(n)                     \
 931 template<TINYFORMAT_ARGTYPES(n)>                              \
 932 detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n))  \
 933 {                                                             \
 934     return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n));    \
 935 }
 936 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
 937 #undef TINYFORMAT_MAKE_MAKEFORMATLIST
 938
 939 #endif
 940
 941 /// Format list of arguments to the stream according to the given format string.
 942 ///
 943 /// The name vformat() is chosen for the semantic similarity to vprintf(): the
 944 /// list of format arguments is held in a single function argument.
 945 inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
 946 {
 947     detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
 948 }
 949
 950
 951 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 952
 953 /// Format list of arguments to the stream according to given format string.
 954 template<typename... Args>
 955 void format(std::ostream& out, const char* fmt, const Args&... args)
 956 {
 957     vformat(out, fmt, makeFormatList(args...));
 958 }
 959
 960 /// Format list of arguments according to the given format string and return
 961 /// the result as a string.
 962 template<typename... Args>
 963 std::string format(const char* fmt, const Args&... args)
 964 {
 965     std::ostringstream oss;
 966     format(oss, fmt, args...);
 967     return oss.str();
 968 }
 969
 970 /// Format list of arguments to std::cout, according to the given format string
 971 template<typename... Args>
 972 void printf(const char* fmt, const Args&... args)
 973 {
 974     format(std::cout, fmt, args...);
 975 }
 976
 977 template<typename... Args>
 978 void printfln(const char* fmt, const Args&... args)
 979 {
 980     format(std::cout, fmt, args...);
 981     std::cout << '\n';
 982 }
 983
 984 #else // C++98 version
 985
 986 inline void format(std::ostream& out, const char* fmt)
 987 {
 988     vformat(out, fmt, makeFormatList());
 989 }
 990
 991 inline std::string format(const char* fmt)
 992 {
 993     std::ostringstream oss;
 994     format(oss, fmt);
 995     return oss.str();
 996 }
 997
 998 inline void printf(const char* fmt)
 999 {
1000     format(std::cout, fmt);
1001 }
1002
1003 inline void printfln(const char* fmt)
1004 {
1005     format(std::cout, fmt);
1006     std::cout << '\n';
1007 }
1008
1009 #define TINYFORMAT_MAKE_FORMAT_FUNCS(n)                                   \
1010                                                                           \
1011 template<TINYFORMAT_ARGTYPES(n)>                                          \
1012 void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n))    \
1013 {                                                                         \
1014     vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n)));            \
1015 }                                                                         \
1016                                                                           \
1017 template<TINYFORMAT_ARGTYPES(n)>                                          \
1018 std::string format(const char* fmt, TINYFORMAT_VARARGS(n))                \
1019 {                                                                         \
1020     std::ostringstream oss;                                               \
1021     format(oss, fmt, TINYFORMAT_PASSARGS(n));                             \
1022     return oss.str();                                                     \
1023 }                                                                         \
1024                                                                           \
1025 template<TINYFORMAT_ARGTYPES(n)>                                          \
1026 void printf(const char* fmt, TINYFORMAT_VARARGS(n))                       \
1027 {                                                                         \
1028     format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                       \
1029 }                                                                         \
1030                                                                           \
1031 template<TINYFORMAT_ARGTYPES(n)>                                          \
1032 void printfln(const char* fmt, TINYFORMAT_VARARGS(n))                     \
1033 {                                                                         \
1034     format(std::cout, fmt, TINYFORMAT_PASSARGS(n));                       \
1035     std::cout << '\n';                                                    \
1036 }
1037
1038 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
1039 #undef TINYFORMAT_MAKE_FORMAT_FUNCS
1040
1041 #endif
1042
1043 // Added for Bitcoin Core
1044 template<typename... Args>
1045 std::string format(const std::string &fmt, const Args&... args)
1046 {
1047     std::ostringstream oss;
1048     format(oss, fmt.c_str(), args...);
1049     return oss.str();
1050 }
1051
1052 } // namespace tinyformat
1053
1054 #define strprintf tfm::format
1055
1056 #endif // TINYFORMAT_H_INCLUDED