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.
  71 //
  72 //
  73 // User defined format functions
  74 // -----------------------------
  75 //
  76 // Simulating variadic templates in C++98 is pretty painful since it requires
  77 // writing out the same function for each desired number of arguments.  To make
  78 // this bearable tinyformat comes with a set of macros which are used
  79 // internally to generate the API, but which may also be used in user code.
  80 //
  81 // The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
  82 // TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
  83 // type/name pairs and argument names respectively when called with an integer
  84 // n between 1 and 16.  We can use these to define a macro which generates the
  85 // desired user defined function with n arguments.  To generate all 16 user
  86 // defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM.  For an
  87 // example, see the implementation of printf() at the end of the source file.
  88 //
  89 //
  90 // Additional API information
  91 // --------------------------
  92 //
  93 // Error handling: Define TINYFORMAT_ERROR to customize the error handling for
  94 // format strings which are unsupported or have the wrong number of format
  95 // specifiers (calls assert() by default).
  96 //
  97 // User defined types: Uses operator<< for user defined types by default.
  98 // Overload formatValue() for more control.
  99
 100
 101 #ifndef TINYFORMAT_H_INCLUDED
 102 #define TINYFORMAT_H_INCLUDED
 103
 104 namespace tinyformat {}
 105 //------------------------------------------------------------------------------
 106 // Config section.  Customize to your liking!
 107
 108 // Namespace alias to encourage brevity
 109 namespace tfm = tinyformat;
 110
 111 // Error handling; calls assert() by default.
 112 #define TINYFORMAT_ERROR(reasonString) throw std::runtime_error(reasonString)
 113
 114 // Define for C++11 variadic templates which make the code shorter & more
 115 // general.  If you don't define this, C++11 support is autodetected below.
 116 // #define TINYFORMAT_USE_VARIADIC_TEMPLATES
 117
 118
 119 //------------------------------------------------------------------------------
 120 // Implementation details.
 121 #include <cassert>
 122 #include <iostream>
 123 #include <sstream>
 124 #include <stdexcept>
 125
 126 #ifndef TINYFORMAT_ERROR
 127 #   define TINYFORMAT_ERROR(reason) assert(0 && reason)
 128 #endif
 129
 130 #if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
 131 #   ifdef __GXX_EXPERIMENTAL_CXX0X__
 132 #       define TINYFORMAT_USE_VARIADIC_TEMPLATES
 133 #   endif
 134 #endif
 135
 136 #ifdef __GNUC__
 137 #   define TINYFORMAT_NOINLINE __attribute__((noinline))
 138 #elif defined(_MSC_VER)
 139 #   define TINYFORMAT_NOINLINE __declspec(noinline)
 140 #else
 141 #   define TINYFORMAT_NOINLINE
 142 #endif
 143
 144 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
 145 //  std::showpos is broken on old libstdc++ as provided with OSX.  See
 146 //  http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
 147 #   define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 148 #endif
 149
 150 namespace tinyformat {
 151
 152 //------------------------------------------------------------------------------
 153 namespace detail {
 154
 155 // Test whether type T1 is convertible to type T2
 156 template <typename T1, typename T2>
 157 struct is_convertible
 158 {
 159     private:
 160         // two types of different size
 161         struct fail { char dummy[2]; };
 162         struct succeed { char dummy; };
 163         // Try to convert a T1 to a T2 by plugging into tryConvert
 164         static fail tryConvert(...);
 165         static succeed tryConvert(const T2&);
 166         static const T1& makeT1();
 167     public:
 168 #       ifdef _MSC_VER
 169         // Disable spurious loss of precision warnings in tryConvert(makeT1())
 170 #       pragma warning(push)
 171 #       pragma warning(disable:4244)
 172 #       pragma warning(disable:4267)
 173 #       endif
 174         // Standard trick: the (...) version of tryConvert will be chosen from
 175         // the overload set only if the version taking a T2 doesn't match.
 176         // Then we compare the sizes of the return types to check which
 177         // function matched.  Very neat, in a disgusting kind of way :)
 178         static const bool value =
 179             sizeof(tryConvert(makeT1())) == sizeof(succeed);
 180 #       ifdef _MSC_VER
 181 #       pragma warning(pop)
 182 #       endif
 183 };
 184
 185
 186 // Detect when a type is not a wchar_t string
 187 template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
 188 template<> struct is_wchar<wchar_t*> {};
 189 template<> struct is_wchar<const wchar_t*> {};
 190 template<int n> struct is_wchar<const wchar_t[n]> {};
 191 template<int n> struct is_wchar<wchar_t[n]> {};
 192
 193
 194 // Format the value by casting to type fmtT.  This default implementation
 195 // should never be called.
 196 template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
 197 struct formatValueAsType
 198 {
 199     static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); }
 200 };
 201 // Specialized version for types that can actually be converted to fmtT, as
 202 // indicated by the "convertible" template parameter.
 203 template<typename T, typename fmtT>
 204 struct formatValueAsType<T,fmtT,true>
 205 {
 206     static void invoke(std::ostream& out, const T& value)
 207         { out << static_cast<fmtT>(value); }
 208 };
 209
 210 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 211 template<typename T, bool convertible = is_convertible<T, int>::value>
 212 struct formatZeroIntegerWorkaround
 213 {
 214     static bool invoke(std::ostream& /**/, const T& /**/) { return false; }
 215 };
 216 template<typename T>
 217 struct formatZeroIntegerWorkaround<T,true>
 218 {
 219     static bool invoke(std::ostream& out, const T& value)
 220     {
 221         if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
 222         {
 223             out << "+0";
 224             return true;
 225         }
 226         return false;
 227     }
 228 };
 229 #endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 230
 231 // Convert an arbitrary type to integer.  The version with convertible=false
 232 // throws an error.
 233 template<typename T, bool convertible = is_convertible<T,int>::value>
 234 struct convertToInt
 235 {
 236     static int invoke(const T& /*value*/)
 237     {
 238         TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
 239                          "integer for use as variable width or precision");
 240         return 0;
 241     }
 242 };
 243 // Specialization for convertToInt when conversion is possible
 244 template<typename T>
 245 struct convertToInt<T,true>
 246 {
 247     static int invoke(const T& value) { return static_cast<int>(value); }
 248 };
 249
 250 } // namespace detail
 251
 252
 253 //------------------------------------------------------------------------------
 254 // Variable formatting functions.  May be overridden for user-defined types if
 255 // desired.
 256
 257
 258 // Format a value into a stream. Called from format() for all types by default.
 259 //
 260 // Users may override this for their own types.  When this function is called,
 261 // the stream flags will have been modified according to the format string.
 262 // The format specification is provided in the range [fmtBegin, fmtEnd).
 263 //
 264 // By default, formatValue() uses the usual stream insertion operator
 265 // operator<< to format the type T, with special cases for the %c and %p
 266 // conversions.
 267 template<typename T>
 268 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
 269                         const char* fmtEnd, const T& value)
 270 {
 271 #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
 272     // Since we don't support printing of wchar_t using "%ls", make it fail at
 273     // compile time in preference to printing as a void* at runtime.
 274     typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
 275     (void) DummyType(); // avoid unused type warning with gcc-4.8
 276 #endif
 277     // The mess here is to support the %c and %p conversions: if these
 278     // conversions are active we try to convert the type to a char or const
 279     // void* respectively and format that instead of the value itself.  For the
 280     // %p conversion it's important to avoid dereferencing the pointer, which
 281     // could otherwise lead to a crash when printing a dangling (const char*).
 282     const bool canConvertToChar = detail::is_convertible<T,char>::value;
 283     const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
 284     if(canConvertToChar && *(fmtEnd-1) == 'c')
 285         detail::formatValueAsType<T, char>::invoke(out, value);
 286     else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
 287         detail::formatValueAsType<T, const void*>::invoke(out, value);
 288 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
 289     else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
 290 #endif
 291     else
 292         out << value;
 293 }
 294
 295
 296 // Overloaded version for char types to support printing as an integer
 297 #define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)                  \
 298 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,  \
 299                         const char* fmtEnd, charType value)           \
 300 {                                                                     \
 301     switch(*(fmtEnd-1))                                               \
 302     {                                                                 \
 303         case 'u': case 'd': case 'i': case 'o': case 'X': case 'x':   \
 304             out << static_cast<int>(value); break;                    \
 305         default:                                                      \
 306             out << value;                   break;                    \
 307     }                                                                 \
 308 }
 309 // per 3.9.1: char, signed char and unsigned char are all distinct types
 310 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
 311 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
 312 TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
 313 #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR
 314
 315
 316 //------------------------------------------------------------------------------
 317 // Tools for emulating variadic templates in C++98.  The basic idea here is
 318 // stolen from the boost preprocessor metaprogramming library and cut down to
 319 // be just general enough for what we need.
 320
 321 #define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
 322 #define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
 323 #define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
 324 #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n
 325
 326 // To keep it as transparent as possible, the macros below have been generated
 327 // using python via the excellent cog.py code generation script.  This avoids
 328 // the need for a bunch of complex (but more general) preprocessor tricks as
 329 // used in boost.preprocessor.
 330 //
 331 // To rerun the code generation in place, use `cog.py -r tinyformat.h`
 332 // (see http://nedbatchelder.com/code/cog).  Alternatively you can just create
 333 // extra versions by hand.
 334
 335 /*[[[cog
 336 maxParams = 16
 337
 338 def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
 339     for j in range(startInd,maxParams+1):
 340         list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
 341         cog.outl(lineTemplate % {'j':j, 'list':list})
 342
 343 makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
 344                   'class T%(i)d')
 345
 346 cog.outl()
 347 makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
 348                   'const T%(i)d& v%(i)d')
 349
 350 cog.outl()
 351 makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')
 352
 353 cog.outl()
 354 cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
 355 makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
 356                   'v%(i)d', startInd = 2)
 357
 358 cog.outl()
 359 cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n    ' +
 360          ' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
 361 ]]]*/
 362 #define TINYFORMAT_ARGTYPES_1 class T1
 363 #define TINYFORMAT_ARGTYPES_2 class T1, class T2
 364 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
 365 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
 366 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
 367 #define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
 368 #define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
 369 #define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
 370 #define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
 371 #define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
 372 #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
 373 #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
 374 #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
 375 #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
 376 #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
 377 #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
 378
 379 #define TINYFORMAT_VARARGS_1 const T1& v1
 380 #define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
 381 #define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
 382 #define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
 383 #define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
 384 #define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
 385 #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
 386 #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
 387 #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
 388 #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
 389 #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
 390 #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
 391 #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
 392 #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
 393 #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
 394 #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
 395
 396 #define TINYFORMAT_PASSARGS_1 v1
 397 #define TINYFORMAT_PASSARGS_2 v1, v2
 398 #define TINYFORMAT_PASSARGS_3 v1, v2, v3
 399 #define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
 400 #define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
 401 #define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
 402 #define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
 403 #define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
 404 #define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
 405 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
 406 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 407 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 408 #define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 409 #define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 410 #define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 411 #define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 412
 413 #define TINYFORMAT_PASSARGS_TAIL_1
 414 #define TINYFORMAT_PASSARGS_TAIL_2 , v2
 415 #define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
 416 #define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
 417 #define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
 418 #define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
 419 #define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
 420 #define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
 421 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
 422 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
 423 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
 424 #define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
 425 #define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
 426 #define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
 427 #define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
 428 #define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
 429
 430 #define TINYFORMAT_FOREACH_ARGNUM(m) \
 431     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)
 432 //[[[end]]]
 433
 434
 435
 436 namespace detail {
 437
 438 // Class holding current position in format string and an output stream into
 439 // which arguments are formatted.
 440 class FormatIterator
 441 {
 442     public:
 443         // Flags for features not representable with standard stream state
 444         enum ExtraFormatFlags
 445         {
 446             Flag_None                = 0,
 447             Flag_TruncateToPrecision = 1<<0, // truncate length to stream precision()
 448             Flag_SpacePadPositive    = 1<<1, // pad positive values with spaces
 449             Flag_VariableWidth       = 1<<2, // variable field width in arg list
 450             Flag_VariablePrecision   = 1<<3  // variable field precision in arg list
 451         };
 452
 453         // out is the output stream, fmt is the full format string
 454         FormatIterator(std::ostream& out, const char* fmt)
 455             : m_out(out),
 456             m_fmt(fmt),
 457             m_extraFlags(Flag_None),
 458             m_wantWidth(false),
 459             m_wantPrecision(false),
 460             m_variableWidth(0),
 461             m_variablePrecision(0),
 462             m_origWidth(out.width()),
 463             m_origPrecision(out.precision()),
 464             m_origFlags(out.flags()),
 465             m_origFill(out.fill())
 466         { }
 467
 468         // Print remaining part of format string.
 469         void finish()
 470         {
 471             // It would be nice if we could do this from the destructor, but we
 472             // can't if TINFORMAT_ERROR is used to throw an exception!
 473             m_fmt = printFormatStringLiteral(m_out, m_fmt);
 474             if(*m_fmt != '\0')
 475                 TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
 476         }
 477
 478         ~FormatIterator()
 479         {
 480             // Restore stream state
 481             m_out.width(m_origWidth);
 482             m_out.precision(m_origPrecision);
 483             m_out.flags(m_origFlags);
 484             m_out.fill(m_origFill);
 485         }
 486
 487         template<typename T>
 488         void accept(const T& value);
 489
 490     private:
 491         // Parse and return an integer from the string c, as atoi()
 492         // On return, c is set to one past the end of the integer.
 493         static int parseIntAndAdvance(const char*& c)
 494         {
 495             int i = 0;
 496             for(;*c >= '0' && *c <= '9'; ++c)
 497                 i = 10*i + (*c - '0');
 498             return i;
 499         }
 500
 501         // Format at most truncLen characters of a C string to the given
 502         // stream.  Return true if formatting proceeded (generic version always
 503         // returns false)
 504         template<typename T>
 505         static bool formatCStringTruncate(std::ostream& /*out*/, const T& /*value*/,
 506                                         std::streamsize /*truncLen*/)
 507         {
 508             return false;
 509         }
 510 #       define TINYFORMAT_DEFINE_FORMAT_C_STRING_TRUNCATE(type)            \
 511         static bool formatCStringTruncate(std::ostream& out, type* value,  \
 512                                         std::streamsize truncLen)          \
 513         {                                                                  \
 514             std::streamsize len = 0;                                       \
 515             while(len < truncLen && value[len] != 0)                       \
 516                 ++len;                                                     \
 517             out.write(value, len);                                         \
 518             return true;                                                   \
 519         }
 520         // Overload for const char* and char*.  Could overload for signed &
 521         // unsigned char too, but these are technically unneeded for printf
 522         // compatibility.
 523         TINYFORMAT_DEFINE_FORMAT_C_STRING_TRUNCATE(const char)
 524         TINYFORMAT_DEFINE_FORMAT_C_STRING_TRUNCATE(char)
 525 #       undef TINYFORMAT_DEFINE_FORMAT_C_STRING_TRUNCATE
 526
 527         // Print literal part of format string and return next format spec
 528         // position.
 529         //
 530         // Skips over any occurrences of '%%', printing a literal '%' to the
 531         // output.  The position of the first % character of the next
 532         // nontrivial format spec is returned, or the end of string.
 533         static const char* printFormatStringLiteral(std::ostream& out,
 534                                                     const char* fmt)
 535         {
 536             const char* c = fmt;
 537             for(; true; ++c)
 538             {
 539                 switch(*c)
 540                 {
 541                     case '\0':
 542                         out.write(fmt, static_cast<std::streamsize>(c - fmt));
 543                         return c;
 544                     case '%':
 545                         out.write(fmt, static_cast<std::streamsize>(c - fmt));
 546                         if(*(c+1) != '%')
 547                             return c;
 548                         // for "%%", tack trailing % onto next literal section.
 549                         fmt = ++c;
 550                         break;
 551                 }
 552             }
 553         }
 554
 555         static const char* streamStateFromFormat(std::ostream& out,
 556                                                  unsigned int& extraFlags,
 557                                                  const char* fmtStart,
 558                                                  int variableWidth,
 559                                                  int variablePrecision);
 560
 561         // Private copy & assign: Kill gcc warnings with -Weffc++
 562         FormatIterator(const FormatIterator&);
 563         FormatIterator& operator=(const FormatIterator&);
 564
 565         // Stream, current format string & state
 566         std::ostream& m_out;
 567         const char* m_fmt;
 568         unsigned int m_extraFlags;
 569         // State machine info for handling of variable width & precision
 570         bool m_wantWidth;
 571         bool m_wantPrecision;
 572         int m_variableWidth;
 573         int m_variablePrecision;
 574         // Saved stream state
 575         std::streamsize m_origWidth;
 576         std::streamsize m_origPrecision;
 577         std::ios::fmtflags m_origFlags;
 578         char m_origFill;
 579 };
 580
 581
 582 // Accept a value for formatting into the internal stream.
 583 template<typename T>
 584 TINYFORMAT_NOINLINE  // < greatly reduces bloat in optimized builds
 585 void FormatIterator::accept(const T& value)
 586 {
 587     // Parse the format string
 588     const char* fmtEnd = 0;
 589     if(m_extraFlags == Flag_None && !m_wantWidth && !m_wantPrecision)
 590     {
 591         m_fmt = printFormatStringLiteral(m_out, m_fmt);
 592         fmtEnd = streamStateFromFormat(m_out, m_extraFlags, m_fmt, 0, 0);
 593         m_wantWidth     = (m_extraFlags & Flag_VariableWidth) != 0;
 594         m_wantPrecision = (m_extraFlags & Flag_VariablePrecision) != 0;
 595     }
 596     // Consume value as variable width and precision specifier if necessary
 597     if(m_extraFlags & (Flag_VariableWidth | Flag_VariablePrecision))
 598     {
 599         if(m_wantWidth || m_wantPrecision)
 600         {
 601             int v = convertToInt<T>::invoke(value);
 602             if(m_wantWidth)
 603             {
 604                 m_variableWidth = v;
 605                 m_wantWidth = false;
 606             }
 607             else if(m_wantPrecision)
 608             {
 609                 m_variablePrecision = v;
 610                 m_wantPrecision = false;
 611             }
 612             return;
 613         }
 614         // If we get here, we've set both the variable precision and width as
 615         // required and we need to rerun the stream state setup to insert these.
 616         fmtEnd = streamStateFromFormat(m_out, m_extraFlags, m_fmt,
 617                                        m_variableWidth, m_variablePrecision);
 618     }
 619
 620     // Format the value into the stream.
 621     if(!(m_extraFlags & (Flag_SpacePadPositive | Flag_TruncateToPrecision)))
 622         formatValue(m_out, m_fmt, fmtEnd, value);
 623     else
 624     {
 625         // The following are special cases where there's no direct
 626         // correspondence between stream formatting and the printf() behaviour.
 627         // Instead, we simulate the behaviour crudely by formatting into a
 628         // temporary string stream and munging the resulting string.
 629         std::ostringstream tmpStream;
 630         tmpStream.copyfmt(m_out);
 631         if(m_extraFlags & Flag_SpacePadPositive)
 632             tmpStream.setf(std::ios::showpos);
 633         // formatCStringTruncate is required for truncating conversions like
 634         // "%.4s" where at most 4 characters of the c-string should be read.
 635         // If we didn't include this special case, we might read off the end.
 636         if(!( (m_extraFlags & Flag_TruncateToPrecision) &&
 637              formatCStringTruncate(tmpStream, value, m_out.precision()) ))
 638         {
 639             // Not a truncated c-string; just format normally.
 640             formatValue(tmpStream, m_fmt, fmtEnd, value);
 641         }
 642         std::string result = tmpStream.str(); // allocates... yuck.
 643         if(m_extraFlags & Flag_SpacePadPositive)
 644         {
 645             for(size_t i = 0, iend = result.size(); i < iend; ++i)
 646                 if(result[i] == '+')
 647                     result[i] = ' ';
 648         }
 649         if((m_extraFlags & Flag_TruncateToPrecision) &&
 650            (int)result.size() > (int)m_out.precision())
 651             m_out.write(result.c_str(), m_out.precision());
 652         else
 653             m_out << result;
 654     }
 655     m_extraFlags = Flag_None;
 656     m_fmt = fmtEnd;
 657 }
 658
 659
 660 // Parse a format string and set the stream state accordingly.
 661 //
 662 // The format mini-language recognized here is meant to be the one from C99,
 663 // with the form "%[flags][width][.precision][length]type".
 664 //
 665 // Formatting options which can't be natively represented using the ostream
 666 // state are returned in the extraFlags parameter which is a bitwise
 667 // combination of values from the ExtraFormatFlags enum.
 668 inline const char* FormatIterator::streamStateFromFormat(std::ostream& out,
 669                                                          unsigned int& extraFlags,
 670                                                          const char* fmtStart,
 671                                                          int variableWidth,
 672                                                          int variablePrecision)
 673 {
 674     if(*fmtStart != '%')
 675     {
 676         TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
 677         return fmtStart;
 678     }
 679     // Reset stream state to defaults.
 680     out.width(0);
 681     out.precision(6);
 682     out.fill(' ');
 683     // Reset most flags; ignore irrelevant unitbuf & skipws.
 684     out.unsetf(std::ios::adjustfield | std::ios::basefield |
 685                std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
 686                std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
 687     extraFlags = Flag_None;
 688     bool precisionSet = false;
 689     bool widthSet = false;
 690     const char* c = fmtStart + 1;
 691     // 1) Parse flags
 692     for(;; ++c)
 693     {
 694         switch(*c)
 695         {
 696             case '#':
 697                 out.setf(std::ios::showpoint | std::ios::showbase);
 698                 continue;
 699             case '0':
 700                 // overridden by left alignment ('-' flag)
 701                 if(!(out.flags() & std::ios::left))
 702                 {
 703                     // Use internal padding so that numeric values are
 704                     // formatted correctly, eg -00010 rather than 000-10
 705                     out.fill('0');
 706                     out.setf(std::ios::internal, std::ios::adjustfield);
 707                 }
 708                 continue;
 709             case '-':
 710                 out.fill(' ');
 711                 out.setf(std::ios::left, std::ios::adjustfield);
 712                 continue;
 713             case ' ':
 714                 // overridden by show positive sign, '+' flag.
 715                 if(!(out.flags() & std::ios::showpos))
 716                     extraFlags |= Flag_SpacePadPositive;
 717                 continue;
 718             case '+':
 719                 out.setf(std::ios::showpos);
 720                 extraFlags &= ~Flag_SpacePadPositive;
 721                 continue;
 722         }
 723         break;
 724     }
 725     // 2) Parse width
 726     if(*c >= '0' && *c <= '9')
 727     {
 728         widthSet = true;
 729         out.width(parseIntAndAdvance(c));
 730     }
 731     if(*c == '*')
 732     {
 733         widthSet = true;
 734         if(variableWidth < 0)
 735         {
 736             // negative widths correspond to '-' flag set
 737             out.fill(' ');
 738             out.setf(std::ios::left, std::ios::adjustfield);
 739             variableWidth = -variableWidth;
 740         }
 741         out.width(variableWidth);
 742         extraFlags |= Flag_VariableWidth;
 743         ++c;
 744     }
 745     // 3) Parse precision
 746     if(*c == '.')
 747     {
 748         ++c;
 749         int precision = 0;
 750         if(*c == '*')
 751         {
 752             ++c;
 753             extraFlags |= Flag_VariablePrecision;
 754             precision = variablePrecision;
 755         }
 756         else
 757         {
 758             if(*c >= '0' && *c <= '9')
 759                 precision = parseIntAndAdvance(c);
 760             else if(*c == '-') // negative precisions ignored, treated as zero.
 761                 parseIntAndAdvance(++c);
 762         }
 763         out.precision(precision);
 764         precisionSet = true;
 765     }
 766     // 4) Ignore any C99 length modifier
 767     while(*c == 'l' || *c == 'h' || *c == 'L' ||
 768           *c == 'j' || *c == 'z' || *c == 't')
 769         ++c;
 770     // 5) We're up to the conversion specifier character.
 771     // Set stream flags based on conversion specifier (thanks to the
 772     // boost::format class for forging the way here).
 773     bool intConversion = false;
 774     switch(*c)
 775     {
 776         case 'u': case 'd': case 'i':
 777             out.setf(std::ios::dec, std::ios::basefield);
 778             intConversion = true;
 779             break;
 780         case 'o':
 781             out.setf(std::ios::oct, std::ios::basefield);
 782             intConversion = true;
 783             break;
 784         case 'X':
 785             out.setf(std::ios::uppercase);
 786         case 'x': case 'p':
 787             out.setf(std::ios::hex, std::ios::basefield);
 788             intConversion = true;
 789             break;
 790         case 'E':
 791             out.setf(std::ios::uppercase);
 792         case 'e':
 793             out.setf(std::ios::scientific, std::ios::floatfield);
 794             out.setf(std::ios::dec, std::ios::basefield);
 795             break;
 796         case 'F':
 797             out.setf(std::ios::uppercase);
 798         case 'f':
 799             out.setf(std::ios::fixed, std::ios::floatfield);
 800             break;
 801         case 'G':
 802             out.setf(std::ios::uppercase);
 803         case 'g':
 804             out.setf(std::ios::dec, std::ios::basefield);
 805             // As in boost::format, let stream decide float format.
 806             out.flags(out.flags() & ~std::ios::floatfield);
 807             break;
 808         case 'a': case 'A':
 809             TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
 810                              "are not supported");
 811             break;
 812         case 'c':
 813             // Handled as special case inside formatValue()
 814             break;
 815         case 's':
 816             if(precisionSet)
 817                 extraFlags |= Flag_TruncateToPrecision;
 818             // Make %s print booleans as "true" and "false"
 819             out.setf(std::ios::boolalpha);
 820             break;
 821         case 'n':
 822             // Not supported - will cause problems!
 823             TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
 824             break;
 825         case '\0':
 826             TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
 827                              "terminated by end of string");
 828             return c;
 829     }
 830     if(intConversion && precisionSet && !widthSet)
 831     {
 832         // "precision" for integers gives the minimum number of digits (to be
 833         // padded with zeros on the left).  This isn't really supported by the
 834         // iostreams, but we can approximately simulate it with the width if
 835         // the width isn't otherwise used.
 836         out.width(out.precision());
 837         out.setf(std::ios::internal, std::ios::adjustfield);
 838         out.fill('0');
 839     }
 840     return c+1;
 841 }
 842
 843
 844
 845 //------------------------------------------------------------------------------
 846 // Private format function on top of which the public interface is implemented.
 847 // We enforce a mimimum of one value to be formatted to prevent bugs looking like
 848 //
 849 //   const char* myStr = "100% broken";
 850 //   printf(myStr);   // Parses % as a format specifier
 851 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 852
 853 template<typename T1>
 854 void format(FormatIterator& fmtIter, const T1& value1)
 855 {
 856     fmtIter.accept(value1);
 857     fmtIter.finish();
 858 }
 859
 860 // General version for C++11
 861 template<typename T1, typename... Args>
 862 void format(FormatIterator& fmtIter, const T1& value1, const Args&... args)
 863 {
 864     fmtIter.accept(value1);
 865     format(fmtIter, args...);
 866 }
 867
 868 #else
 869
 870 inline void format(FormatIterator& fmtIter)
 871 {
 872     fmtIter.finish();
 873 }
 874
 875 // General version for C++98
 876 #define TINYFORMAT_MAKE_FORMAT_DETAIL(n)                                  \
 877 template<TINYFORMAT_ARGTYPES(n)>                                          \
 878 void format(detail::FormatIterator& fmtIter, TINYFORMAT_VARARGS(n))       \
 879 {                                                                         \
 880     fmtIter.accept(v1);                                                   \
 881     format(fmtIter TINYFORMAT_PASSARGS_TAIL(n));                          \
 882 }
 883
 884 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_DETAIL)
 885 #undef TINYFORMAT_MAKE_FORMAT_DETAIL
 886
 887 #endif // End C++98 variadic template emulation for format()
 888
 889 } // namespace detail
 890
 891
 892 //------------------------------------------------------------------------------
 893 // Implement all the main interface functions here in terms of detail::format()
 894
 895 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
 896
 897 // C++11 - the simple case
 898 template<typename T1, typename... Args>
 899 void format(std::ostream& out, const char* fmt, const T1& v1, const Args&... args)
 900 {
 901     detail::FormatIterator fmtIter(out, fmt);
 902     format(fmtIter, v1, args...);
 903 }
 904
 905 template<typename T1, typename... Args>
 906 std::string format(const char* fmt, const T1& v1, const Args&... args)
 907 {
 908     std::ostringstream oss;
 909     format(oss, fmt, v1, args...);
 910     return oss.str();
 911 }
 912
 913 template<typename T1, typename... Args>
 914 std::string format(const std::string &fmt, const T1& v1, const Args&... args)
 915 {
 916     std::ostringstream oss;
 917     format(oss, fmt.c_str(), v1, args...);
 918     return oss.str();
 919 }
 920
 921 template<typename T1, typename... Args>
 922 void printf(const char* fmt, const T1& v1, const Args&... args)
 923 {
 924     format(std::cout, fmt, v1, args...);
 925 }
 926
 927 #else
 928
 929 // C++98 - define the interface functions using the wrapping macros
 930 #define TINYFORMAT_MAKE_FORMAT_FUNCS(n)                                   \
 931                                                                           \
 932 template<TINYFORMAT_ARGTYPES(n)>                                          \
 933 void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n))    \
 934 {                                                                         \
 935     tinyformat::detail::FormatIterator fmtIter(out, fmt);                 \
 936     tinyformat::detail::format(fmtIter, TINYFORMAT_PASSARGS(n));          \
 937 }                                                                         \
 938                                                                           \
 939 template<TINYFORMAT_ARGTYPES(n)>                                          \
 940 std::string format(const char* fmt, TINYFORMAT_VARARGS(n))                \
 941 {                                                                         \
 942     std::ostringstream oss;                                               \
 943     tinyformat::format(oss, fmt, TINYFORMAT_PASSARGS(n));                 \
 944     return oss.str();                                                     \
 945 }                                                                         \
 946                                                                           \
 947 template<TINYFORMAT_ARGTYPES(n)>                                          \
 948 std::string format(const std::string &fmt, TINYFORMAT_VARARGS(n))         \
 949 {                                                                         \
 950     std::ostringstream oss;                                               \
 951     tinyformat::format(oss, fmt.c_str(), TINYFORMAT_PASSARGS(n));         \
 952     return oss.str();                                                     \
 953 }                                                                         \
 954                                                                           \
 955 template<TINYFORMAT_ARGTYPES(n)>                                          \
 956 void printf(const char* fmt, TINYFORMAT_VARARGS(n))                       \
 957 {                                                                         \
 958     tinyformat::format(std::cout, fmt, TINYFORMAT_PASSARGS(n));           \
 959 }
 960
 961 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
 962 #undef TINYFORMAT_MAKE_FORMAT_FUNCS
 963 #endif
 964
 965
 966 //------------------------------------------------------------------------------
 967 // Define deprecated wrapping macro for backward compatibility in tinyformat
 968 // 1.x.  Will be removed in version 2!
 969 #define TINYFORMAT_WRAP_FORMAT_EXTRA_ARGS
 970 #define TINYFORMAT_WRAP_FORMAT_N(n, returnType, funcName, funcDeclSuffix,  \
 971                                  bodyPrefix, streamName, bodySuffix)       \
 972 template<TINYFORMAT_ARGTYPES(n)>                                           \
 973 returnType funcName(TINYFORMAT_WRAP_FORMAT_EXTRA_ARGS const char* fmt,     \
 974                     TINYFORMAT_VARARGS(n)) funcDeclSuffix                  \
 975 {                                                                          \
 976     bodyPrefix                                                             \
 977     tinyformat::format(streamName, fmt, TINYFORMAT_PASSARGS(n));           \
 978     bodySuffix                                                             \
 979 }                                                                          \
 980
 981 #define TINYFORMAT_WRAP_FORMAT(returnType, funcName, funcDeclSuffix,       \
 982                                bodyPrefix, streamName, bodySuffix)         \
 983 inline                                                                     \
 984 returnType funcName(TINYFORMAT_WRAP_FORMAT_EXTRA_ARGS const char* fmt      \
 985                     ) funcDeclSuffix                                       \
 986 {                                                                          \
 987     bodyPrefix                                                             \
 988     tinyformat::detail::FormatIterator(streamName, fmt).finish();          \
 989     bodySuffix                                                             \
 990 }                                                                          \
 991 TINYFORMAT_WRAP_FORMAT_N(1 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 992 TINYFORMAT_WRAP_FORMAT_N(2 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 993 TINYFORMAT_WRAP_FORMAT_N(3 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 994 TINYFORMAT_WRAP_FORMAT_N(4 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 995 TINYFORMAT_WRAP_FORMAT_N(5 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 996 TINYFORMAT_WRAP_FORMAT_N(6 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 997 TINYFORMAT_WRAP_FORMAT_N(7 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 998 TINYFORMAT_WRAP_FORMAT_N(8 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
 999 TINYFORMAT_WRAP_FORMAT_N(9 , returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1000 TINYFORMAT_WRAP_FORMAT_N(10, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1001 TINYFORMAT_WRAP_FORMAT_N(11, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1002 TINYFORMAT_WRAP_FORMAT_N(12, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1003 TINYFORMAT_WRAP_FORMAT_N(13, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1004 TINYFORMAT_WRAP_FORMAT_N(14, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1005 TINYFORMAT_WRAP_FORMAT_N(15, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1006 TINYFORMAT_WRAP_FORMAT_N(16, returnType, funcName, funcDeclSuffix, bodyPrefix, streamName, bodySuffix) \
1007
1008
1009 } // namespace tinyformat
1010
1011 #define strprintf tfm::format
1012
1013 #endif // TINYFORMAT_H_INCLUDED