Line data Source code
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 0 : static void invoke(std::ostream& out, const T& value)
207 0 : { 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 0 : static int invoke(const T& /*value*/)
237 : {
238 0 : 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 0 : 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 299646 : 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 345569 : const bool canConvertToChar = detail::is_convertible<T,char>::value;
283 345569 : const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
284 206356 : if(canConvertToChar && *(fmtEnd-1) == 'c')
285 0 : detail::formatValueAsType<T, char>::invoke(out, value);
286 93290 : else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
287 0 : 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 299646 : out << value;
293 299646 : }
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 0 : TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
311 : TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
312 8 : 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 142028 : 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 142028 : m_origWidth(out.width()),
463 142028 : m_origPrecision(out.precision()),
464 142028 : m_origFlags(out.flags()),
465 710140 : m_origFill(out.fill())
466 142028 : { }
467 :
468 : // Print remaining part of format string.
469 142028 : 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 142028 : m_fmt = printFormatStringLiteral(m_out, m_fmt);
474 142028 : if(*m_fmt != '\0')
475 0 : TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
476 142028 : }
477 :
478 142028 : ~FormatIterator()
479 : {
480 : // Restore stream state
481 142028 : m_out.width(m_origWidth);
482 142028 : m_out.precision(m_origPrecision);
483 142028 : m_out.flags(m_origFlags);
484 142028 : m_out.fill(m_origFill);
485 142028 : }
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 0 : int i = 0;
496 137603 : for(;*c >= '0' && *c <= '9'; ++c)
497 137603 : i = 10*i + (*c - '0');
498 134225 : 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 0 : static bool formatCStringTruncate(std::ostream& /*out*/, const T& /*value*/,
506 : std::streamsize /*truncLen*/)
507 : {
508 0 : 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 0 : TINYFORMAT_DEFINE_FORMAT_C_STRING_TRUNCATE(const char)
524 0 : 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 487601 : static const char* printFormatStringLiteral(std::ostream& out,
534 : const char* fmt)
535 : {
536 487601 : const char* c = fmt;
537 1814272 : for(; true; ++c)
538 : {
539 2301873 : switch(*c)
540 : {
541 : case '\0':
542 142028 : out.write(fmt, static_cast<std::streamsize>(c - fmt));
543 142028 : return c;
544 : case '%':
545 348157 : out.write(fmt, static_cast<std::streamsize>(c - fmt));
546 348156 : if(*(c+1) != '%')
547 : return c;
548 : // for "%%", tack trailing % onto next literal section.
549 2584 : fmt = ++c;
550 2584 : break;
551 : }
552 1814272 : }
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 345573 : void FormatIterator::accept(const T& value)
586 : {
587 : // Parse the format string
588 345573 : const char* fmtEnd = 0;
589 345573 : if(m_extraFlags == Flag_None && !m_wantWidth && !m_wantPrecision)
590 : {
591 345573 : m_fmt = printFormatStringLiteral(m_out, m_fmt);
592 345572 : fmtEnd = streamStateFromFormat(m_out, m_extraFlags, m_fmt, 0, 0);
593 345573 : m_wantWidth = (m_extraFlags & Flag_VariableWidth) != 0;
594 345573 : m_wantPrecision = (m_extraFlags & Flag_VariablePrecision) != 0;
595 : }
596 : // Consume value as variable width and precision specifier if necessary
597 345573 : if(m_extraFlags & (Flag_VariableWidth | Flag_VariablePrecision))
598 : {
599 0 : if(m_wantWidth || m_wantPrecision)
600 : {
601 0 : int v = convertToInt<T>::invoke(value);
602 0 : if(m_wantWidth)
603 : {
604 0 : m_variableWidth = v;
605 0 : m_wantWidth = false;
606 : }
607 0 : else if(m_wantPrecision)
608 : {
609 0 : m_variablePrecision = v;
610 0 : m_wantPrecision = false;
611 : }
612 345573 : 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 0 : fmtEnd = streamStateFromFormat(m_out, m_extraFlags, m_fmt,
617 0 : m_variableWidth, m_variablePrecision);
618 : }
619 :
620 : // Format the value into the stream.
621 345573 : if(!(m_extraFlags & (Flag_SpacePadPositive | Flag_TruncateToPrecision)))
622 345573 : 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 0 : std::ostringstream tmpStream;
630 0 : tmpStream.copyfmt(m_out);
631 0 : 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 0 : if(!( (m_extraFlags & Flag_TruncateToPrecision) &&
637 0 : formatCStringTruncate(tmpStream, value, m_out.precision()) ))
638 : {
639 : // Not a truncated c-string; just format normally.
640 0 : formatValue(tmpStream, m_fmt, fmtEnd, value);
641 : }
642 : std::string result = tmpStream.str(); // allocates... yuck.
643 0 : if(m_extraFlags & Flag_SpacePadPositive)
644 : {
645 0 : for(size_t i = 0, iend = result.size(); i < iend; ++i)
646 0 : if(result[i] == '+')
647 0 : result[i] = ' ';
648 : }
649 0 : if((m_extraFlags & Flag_TruncateToPrecision) &&
650 0 : (int)result.size() > (int)m_out.precision())
651 0 : m_out.write(result.c_str(), m_out.precision());
652 : else
653 0 : m_out << result;
654 : }
655 345573 : m_extraFlags = Flag_None;
656 345573 : 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 345572 : inline const char* FormatIterator::streamStateFromFormat(std::ostream& out,
669 : unsigned int& extraFlags,
670 : const char* fmtStart,
671 : int variableWidth,
672 : int variablePrecision)
673 : {
674 345572 : if(*fmtStart != '%')
675 : {
676 0 : TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
677 : return fmtStart;
678 : }
679 : // Reset stream state to defaults.
680 345572 : out.width(0);
681 345572 : out.precision(6);
682 345572 : 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 345572 : std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
687 345572 : extraFlags = Flag_None;
688 345572 : bool precisionSet = false;
689 345572 : bool widthSet = false;
690 345572 : const char* c = fmtStart + 1;
691 : // 1) Parse flags
692 75447 : for(;; ++c)
693 : {
694 421019 : switch(*c)
695 : {
696 : case '#':
697 0 : out.setf(std::ios::showpoint | std::ios::showbase);
698 : continue;
699 : case '0':
700 : // overridden by left alignment ('-' flag)
701 150554 : 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 75277 : out.fill('0');
706 75277 : out.setf(std::ios::internal, std::ios::adjustfield);
707 : }
708 : continue;
709 : case '-':
710 0 : out.fill(' ');
711 0 : out.setf(std::ios::left, std::ios::adjustfield);
712 : continue;
713 : case ' ':
714 : // overridden by show positive sign, '+' flag.
715 0 : if(!(out.flags() & std::ios::showpos))
716 0 : extraFlags |= Flag_SpacePadPositive;
717 : continue;
718 : case '+':
719 170 : out.setf(std::ios::showpos);
720 170 : extraFlags &= ~Flag_SpacePadPositive;
721 170 : continue;
722 : }
723 : break;
724 : }
725 : // 2) Parse width
726 345572 : if(*c >= '0' && *c <= '9')
727 : {
728 : widthSet = true;
729 93617 : out.width(parseIntAndAdvance(c));
730 : }
731 345572 : if(*c == '*')
732 : {
733 0 : widthSet = true;
734 0 : if(variableWidth < 0)
735 : {
736 : // negative widths correspond to '-' flag set
737 0 : out.fill(' ');
738 0 : out.setf(std::ios::left, std::ios::adjustfield);
739 0 : variableWidth = -variableWidth;
740 : }
741 0 : out.width(variableWidth);
742 0 : extraFlags |= Flag_VariableWidth;
743 0 : ++c;
744 : }
745 : // 3) Parse precision
746 345572 : if(*c == '.')
747 : {
748 40608 : ++c;
749 40608 : int precision = 0;
750 40608 : if(*c == '*')
751 : {
752 0 : ++c;
753 0 : extraFlags |= Flag_VariablePrecision;
754 0 : precision = variablePrecision;
755 : }
756 : else
757 : {
758 40608 : if(*c >= '0' && *c <= '9')
759 40608 : precision = parseIntAndAdvance(c);
760 0 : else if(*c == '-') // negative precisions ignored, treated as zero.
761 0 : parseIntAndAdvance(++c);
762 : }
763 40608 : out.precision(precision);
764 40608 : precisionSet = true;
765 : }
766 : // 4) Ignore any C99 length modifier
767 351151 : while(*c == 'l' || *c == 'h' || *c == 'L' ||
768 345572 : *c == 'j' || *c == 'z' || *c == 't')
769 5579 : ++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 345572 : bool intConversion = false;
774 345572 : switch(*c)
775 : {
776 : case 'u': case 'd': case 'i':
777 154173 : out.setf(std::ios::dec, std::ios::basefield);
778 154173 : intConversion = true;
779 154173 : break;
780 : case 'o':
781 0 : out.setf(std::ios::oct, std::ios::basefield);
782 0 : intConversion = true;
783 0 : break;
784 : case 'X':
785 0 : out.setf(std::ios::uppercase);
786 : case 'x': case 'p':
787 1216 : out.setf(std::ios::hex, std::ios::basefield);
788 1216 : intConversion = true;
789 1216 : break;
790 : case 'E':
791 0 : out.setf(std::ios::uppercase);
792 : case 'e':
793 0 : out.setf(std::ios::scientific, std::ios::floatfield);
794 0 : out.setf(std::ios::dec, std::ios::basefield);
795 : break;
796 : case 'F':
797 0 : out.setf(std::ios::uppercase);
798 : case 'f':
799 38011 : out.setf(std::ios::fixed, std::ios::floatfield);
800 : break;
801 : case 'G':
802 0 : out.setf(std::ios::uppercase);
803 : case 'g':
804 13380 : out.setf(std::ios::dec, std::ios::basefield);
805 : // As in boost::format, let stream decide float format.
806 26760 : out.flags(out.flags() & ~std::ios::floatfield);
807 : break;
808 : case 'a': case 'A':
809 0 : TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
810 0 : "are not supported");
811 : break;
812 : case 'c':
813 : // Handled as special case inside formatValue()
814 : break;
815 : case 's':
816 138793 : if(precisionSet)
817 0 : extraFlags |= Flag_TruncateToPrecision;
818 : // Make %s print booleans as "true" and "false"
819 138793 : out.setf(std::ios::boolalpha);
820 : break;
821 : case 'n':
822 : // Not supported - will cause problems!
823 0 : TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
824 : break;
825 : case '\0':
826 0 : TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
827 0 : "terminated by end of string");
828 : return c;
829 : }
830 345572 : 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 0 : out.width(out.precision());
837 0 : out.setf(std::ios::internal, std::ios::adjustfield);
838 0 : out.fill('0');
839 : }
840 421019 : 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 142028 : 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 312856 : 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 464481 : 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
|
