Commit | Line | Data |
---|---|---|
8dea8d37 SE |
1 | /* |
2 | * snprintf.c - a portable implementation of snprintf | |
3 | * | |
4 | * AUTHOR | |
5 | * Mark Martinec <mark.martinec@ijs.si>, April 1999. | |
6 | * | |
7 | * Copyright 1999, Mark Martinec. All rights reserved. | |
8 | * | |
9 | * TERMS AND CONDITIONS | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the "Frontier Artistic License" which comes | |
12 | * with this Kit. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty | |
16 | * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
17 | * See the Frontier Artistic License for more details. | |
18 | * | |
19 | * You should have received a copy of the Frontier Artistic License | |
20 | * with this Kit in the file named LICENSE.txt . | |
21 | * If not, I'll be glad to provide one. | |
22 | * | |
23 | * FEATURES | |
24 | * - careful adherence to specs regarding flags, field width and precision; | |
25 | * - good performance for large string handling (large format, large | |
26 | * argument or large paddings). Performance is similar to system's sprintf | |
27 | * and in several cases significantly better (make sure you compile with | |
28 | * optimizations turned on, tell the compiler the code is strict ANSI | |
29 | * if necessary to give it more freedom for optimizations); | |
30 | * - return value semantics per ISO/IEC 9899:1999 ("ISO C99"); | |
31 | * - written in standard ISO/ANSI C - requires an ANSI C compiler. | |
32 | * | |
33 | * SUPPORTED CONVERSION SPECIFIERS AND DATA TYPES | |
34 | * | |
35 | * This snprintf only supports the following conversion specifiers: | |
36 | * s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below) | |
37 | * with flags: '-', '+', ' ', '0' and '#'. | |
38 | * An asterisk is supported for field width as well as precision. | |
39 | * | |
40 | * Length modifiers 'h' (short int), 'l' (long int), | |
41 | * and 'll' (long long int) are supported. | |
42 | * NOTE: | |
43 | * If macro SNPRINTF_LONGLONG_SUPPORT is not defined (default) the | |
44 | * length modifier 'll' is recognized but treated the same as 'l', | |
45 | * which may cause argument value truncation! Defining | |
46 | * SNPRINTF_LONGLONG_SUPPORT requires that your system's sprintf also | |
47 | * handles length modifier 'll'. long long int is a language extension | |
48 | * which may not be portable. | |
49 | * | |
50 | * Conversion of numeric data (conversion specifiers d, u, o, x, X, p) | |
51 | * with length modifiers (none or h, l, ll) is left to the system routine | |
52 | * sprintf, but all handling of flags, field width and precision as well as | |
53 | * c and s conversions is done very carefully by this portable routine. | |
54 | * If a string precision (truncation) is specified (e.g. %.8s) it is | |
55 | * guaranteed the string beyond the specified precision will not be referenced. | |
56 | * | |
57 | * Length modifiers h, l and ll are ignored for c and s conversions (data | |
58 | * types wint_t and wchar_t are not supported). | |
59 | * | |
60 | * The following common synonyms for conversion characters are supported: | |
61 | * - i is a synonym for d | |
62 | * - D is a synonym for ld, explicit length modifiers are ignored | |
63 | * - U is a synonym for lu, explicit length modifiers are ignored | |
64 | * - O is a synonym for lo, explicit length modifiers are ignored | |
65 | * The D, O and U conversion characters are nonstandard, they are supported | |
66 | * for backward compatibility only, and should not be used for new code. | |
67 | * | |
68 | * The following is specifically NOT supported: | |
69 | * - flag ' (thousands' grouping character) is recognized but ignored | |
70 | * - numeric conversion specifiers: f, e, E, g, G and synonym F, | |
71 | * as well as the new a and A conversion specifiers | |
72 | * - length modifier 'L' (long double) and 'q' (quad - use 'll' instead) | |
73 | * - wide character/string conversions: lc, ls, and nonstandard | |
74 | * synonyms C and S | |
75 | * - writeback of converted string length: conversion character n | |
76 | * - the n$ specification for direct reference to n-th argument | |
77 | * - locales | |
78 | * | |
79 | * It is permitted for str_m to be zero, and it is permitted to specify NULL | |
80 | * pointer for resulting string argument if str_m is zero (as per ISO C99). | |
81 | * | |
82 | * The return value is the number of characters which would be generated | |
83 | * for the given input, excluding the trailing null. If this value | |
84 | * is greater or equal to str_m, not all characters from the result | |
85 | * have been stored in str, output bytes beyond the (str_m-1) -th character | |
86 | * are discarded. If str_m is greater than zero it is guaranteed | |
87 | * the resulting string will be null-terminated. | |
88 | * | |
89 | * NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1, | |
90 | * but is different from some older and vendor implementations, | |
91 | * and is also different from XPG, XSH5, SUSv2 specifications. | |
92 | * For historical discussion on changes in the semantics and standards | |
93 | * of snprintf see printf(3) man page in the Linux programmers manual. | |
94 | * | |
95 | * Routines asprintf and vasprintf return a pointer (in the ptr argument) | |
96 | * to a buffer sufficiently large to hold the resulting string. This pointer | |
97 | * should be passed to free(3) to release the allocated storage when it is | |
98 | * no longer needed. If sufficient space cannot be allocated, these functions | |
99 | * will return -1 and set ptr to be a NULL pointer. These two routines are a | |
100 | * GNU C library extensions (glibc). | |
101 | * | |
102 | * Routines asnprintf and vasnprintf are similar to asprintf and vasprintf, | |
103 | * yet, like snprintf and vsnprintf counterparts, will write at most str_m-1 | |
104 | * characters into the allocated output string, the last character in the | |
105 | * allocated buffer then gets the terminating null. If the formatted string | |
106 | * length (the return value) is greater than or equal to the str_m argument, | |
107 | * the resulting string was truncated and some of the formatted characters | |
108 | * were discarded. These routines present a handy way to limit the amount | |
109 | * of allocated memory to some sane value. | |
110 | * | |
111 | * AVAILABILITY | |
112 | * http://www.ijs.si/software/snprintf/ | |
113 | * | |
114 | * REVISION HISTORY | |
115 | * 1999-04 V0.9 Mark Martinec | |
116 | * - initial version, some modifications after comparing printf | |
117 | * man pages for Digital Unix 4.0, Solaris 2.6 and HPUX 10, | |
118 | * and checking how Perl handles sprintf (differently!); | |
119 | * 1999-04-09 V1.0 Mark Martinec <mark.martinec@ijs.si> | |
120 | * - added main test program, fixed remaining inconsistencies, | |
121 | * added optional (long long int) support; | |
122 | * 1999-04-12 V1.1 Mark Martinec <mark.martinec@ijs.si> | |
123 | * - support the 'p' conversion (pointer to void); | |
124 | * - if a string precision is specified | |
125 | * make sure the string beyond the specified precision | |
126 | * will not be referenced (e.g. by strlen); | |
127 | * 1999-04-13 V1.2 Mark Martinec <mark.martinec@ijs.si> | |
128 | * - support synonyms %D=%ld, %U=%lu, %O=%lo; | |
129 | * - speed up the case of long format string with few conversions; | |
130 | * 1999-06-30 V1.3 Mark Martinec <mark.martinec@ijs.si> | |
131 | * - fixed runaway loop (eventually crashing when str_l wraps | |
132 | * beyond 2^31) while copying format string without | |
133 | * conversion specifiers to a buffer that is too short | |
134 | * (thanks to Edwin Young <edwiny@autonomy.com> for | |
135 | * spotting the problem); | |
136 | * - added macros PORTABLE_SNPRINTF_VERSION_(MAJOR|MINOR) | |
137 | * to snprintf.h | |
138 | * 2000-02-14 V2.0 (never released) Mark Martinec <mark.martinec@ijs.si> | |
139 | * - relaxed license terms: The Artistic License now applies. | |
140 | * You may still apply the GNU GENERAL PUBLIC LICENSE | |
141 | * as was distributed with previous versions, if you prefer; | |
142 | * - changed REVISION HISTORY dates to use ISO 8601 date format; | |
143 | * - added vsnprintf (patch also independently proposed by | |
144 | * Caolan McNamara 2000-05-04, and Keith M Willenson 2000-06-01) | |
145 | * 2000-06-27 V2.1 Mark Martinec <mark.martinec@ijs.si> | |
146 | * - removed POSIX check for str_m<1; value 0 for str_m is | |
147 | * allowed by ISO C99 (and GNU C library 2.1) - (pointed out | |
148 | * on 2000-05-04 by Caolan McNamara, caolan@ csn dot ul dot ie). | |
149 | * Besides relaxed license this change in standards adherence | |
150 | * is the main reason to bump up the major version number; | |
151 | * - added nonstandard routines asnprintf, vasnprintf, asprintf, | |
152 | * vasprintf that dynamically allocate storage for the | |
153 | * resulting string; these routines are not compiled by default, | |
154 | * see comments where NEED_V?ASN?PRINTF macros are defined; | |
155 | * - autoconf contributed by Caolan McNamara | |
156 | * 2000-10-06 V2.2 Mark Martinec <mark.martinec@ijs.si> | |
157 | * - BUG FIX: the %c conversion used a temporary variable | |
158 | * that was no longer in scope when referenced, | |
159 | * possibly causing incorrect resulting character; | |
160 | * - BUG FIX: make precision and minimal field width unsigned | |
161 | * to handle huge values (2^31 <= n < 2^32) correctly; | |
162 | * also be more careful in the use of signed/unsigned/size_t | |
163 | * internal variables - probably more careful than many | |
164 | * vendor implementations, but there may still be a case | |
165 | * where huge values of str_m, precision or minimal field | |
166 | * could cause incorrect behaviour; | |
167 | * - use separate variables for signed/unsigned arguments, | |
168 | * and for short/int, long, and long long argument lengths | |
169 | * to avoid possible incompatibilities on certain | |
170 | * computer architectures. Also use separate variable | |
171 | * arg_sign to hold sign of a numeric argument, | |
172 | * to make code more transparent; | |
173 | * - some fiddling with zero padding and "0x" to make it | |
174 | * Linux compatible; | |
175 | * - systematically use macros fast_memcpy and fast_memset | |
176 | * instead of case-by-case hand optimization; determine some | |
177 | * breakeven string lengths for different architectures; | |
178 | * - terminology change: 'format' -> 'conversion specifier', | |
179 | * 'C9x' -> 'ISO/IEC 9899:1999 ("ISO C99")', | |
180 | * 'alternative form' -> 'alternate form', | |
181 | * 'data type modifier' -> 'length modifier'; | |
182 | * - several comments rephrased and new ones added; | |
183 | * - make compiler not complain about 'credits' defined but | |
184 | * not used; | |
185 | */ | |
186 | ||
187 | ||
188 | /* Define HAVE_SNPRINTF if your system already has snprintf and vsnprintf. | |
189 | * | |
190 | * If HAVE_SNPRINTF is defined this module will not produce code for | |
191 | * snprintf and vsnprintf, unless PREFER_PORTABLE_SNPRINTF is defined as well, | |
192 | * causing this portable version of snprintf to be called portable_snprintf | |
193 | * (and portable_vsnprintf). | |
194 | */ | |
195 | /* #define HAVE_SNPRINTF */ | |
196 | ||
197 | /* Define PREFER_PORTABLE_SNPRINTF if your system does have snprintf and | |
198 | * vsnprintf but you would prefer to use the portable routine(s) instead. | |
199 | * In this case the portable routine is declared as portable_snprintf | |
200 | * (and portable_vsnprintf) and a macro 'snprintf' (and 'vsnprintf') | |
201 | * is defined to expand to 'portable_v?snprintf' - see file snprintf.h . | |
202 | * Defining this macro is only useful if HAVE_SNPRINTF is also defined, | |
203 | * but does does no harm if defined nevertheless. | |
204 | */ | |
205 | /* #define PREFER_PORTABLE_SNPRINTF */ | |
206 | ||
207 | /* Define SNPRINTF_LONGLONG_SUPPORT if you want to support | |
208 | * data type (long long int) and length modifier 'll' (e.g. %lld). | |
209 | * If undefined, 'll' is recognized but treated as a single 'l'. | |
210 | * | |
211 | * If the system's sprintf does not handle 'll' | |
212 | * the SNPRINTF_LONGLONG_SUPPORT must not be defined! | |
213 | * | |
214 | * This is off by default as (long long int) is a language extension. | |
215 | */ | |
216 | /* #define SNPRINTF_LONGLONG_SUPPORT */ | |
217 | ||
218 | /* Define NEED_SNPRINTF_ONLY if you only need snprintf, and not vsnprintf. | |
219 | * If NEED_SNPRINTF_ONLY is defined, the snprintf will be defined directly, | |
220 | * otherwise both snprintf and vsnprintf routines will be defined | |
221 | * and snprintf will be a simple wrapper around vsnprintf, at the expense | |
222 | * of an extra procedure call. | |
223 | */ | |
224 | /* #define NEED_SNPRINTF_ONLY */ | |
225 | ||
226 | /* Define NEED_V?ASN?PRINTF macros if you need library extension | |
227 | * routines asprintf, vasprintf, asnprintf, vasnprintf respectively, | |
228 | * and your system library does not provide them. They are all small | |
229 | * wrapper routines around portable_vsnprintf. Defining any of the four | |
230 | * NEED_V?ASN?PRINTF macros automatically turns off NEED_SNPRINTF_ONLY | |
231 | * and turns on PREFER_PORTABLE_SNPRINTF. | |
232 | * | |
233 | * Watch for name conflicts with the system library if these routines | |
234 | * are already present there. | |
235 | * | |
236 | * NOTE: vasprintf and vasnprintf routines need va_copy() from stdarg.h, as | |
237 | * specified by C99, to be able to traverse the same list of arguments twice. | |
238 | * I don't know of any other standard and portable way of achieving the same. | |
239 | * With some versions of gcc you may use __va_copy(). You might even get away | |
240 | * with "ap2 = ap", in this case you must not call va_end(ap2) ! | |
241 | * #define va_copy(ap2,ap) ap2 = ap | |
242 | */ | |
243 | /* #define NEED_ASPRINTF */ | |
244 | /* #define NEED_ASNPRINTF */ | |
245 | /* #define NEED_VASPRINTF */ | |
246 | /* #define NEED_VASNPRINTF */ | |
247 | ||
248 | ||
249 | /* Define the following macros if desired: | |
250 | * SOLARIS_COMPATIBLE, SOLARIS_BUG_COMPATIBLE, | |
251 | * HPUX_COMPATIBLE, HPUX_BUG_COMPATIBLE, LINUX_COMPATIBLE, | |
252 | * DIGITAL_UNIX_COMPATIBLE, DIGITAL_UNIX_BUG_COMPATIBLE, | |
253 | * PERL_COMPATIBLE, PERL_BUG_COMPATIBLE, | |
254 | * | |
255 | * - For portable applications it is best not to rely on peculiarities | |
256 | * of a given implementation so it may be best not to define any | |
257 | * of the macros that select compatibility and to avoid features | |
258 | * that vary among the systems. | |
259 | * | |
260 | * - Selecting compatibility with more than one operating system | |
261 | * is not strictly forbidden but is not recommended. | |
262 | * | |
263 | * - 'x'_BUG_COMPATIBLE implies 'x'_COMPATIBLE . | |
264 | * | |
265 | * - 'x'_COMPATIBLE refers to (and enables) a behaviour that is | |
266 | * documented in a sprintf man page on a given operating system | |
267 | * and actually adhered to by the system's sprintf (but not on | |
268 | * most other operating systems). It may also refer to and enable | |
269 | * a behaviour that is declared 'undefined' or 'implementation specific' | |
270 | * in the man page but a given implementation behaves predictably | |
271 | * in a certain way. | |
272 | * | |
273 | * - 'x'_BUG_COMPATIBLE refers to (and enables) a behaviour of system's sprintf | |
274 | * that contradicts the sprintf man page on the same operating system. | |
275 | * | |
276 | * - I do not claim that the 'x'_COMPATIBLE and 'x'_BUG_COMPATIBLE | |
277 | * conditionals take into account all idiosyncrasies of a particular | |
278 | * implementation, there may be other incompatibilities. | |
279 | */ | |
280 | ||
281 | ||
dee2e14c IJ |
282 | #warning Platform has no snprintf?! Please check included snprintf.c for sanity! |
283 | ||
8dea8d37 SE |
284 | \f |
285 | /* ============================================= */ | |
286 | /* NO USER SERVICABLE PARTS FOLLOWING THIS POINT */ | |
287 | /* ============================================= */ | |
288 | ||
289 | #define PORTABLE_SNPRINTF_VERSION_MAJOR 2 | |
290 | #define PORTABLE_SNPRINTF_VERSION_MINOR 2 | |
291 | ||
292 | #if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF) | |
293 | # if defined(NEED_SNPRINTF_ONLY) | |
294 | # undef NEED_SNPRINTF_ONLY | |
295 | # endif | |
296 | # if !defined(PREFER_PORTABLE_SNPRINTF) | |
297 | # define PREFER_PORTABLE_SNPRINTF | |
298 | # endif | |
299 | #endif | |
300 | ||
301 | #if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE) | |
302 | #define SOLARIS_COMPATIBLE | |
303 | #endif | |
304 | ||
305 | #if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE) | |
306 | #define HPUX_COMPATIBLE | |
307 | #endif | |
308 | ||
309 | #if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE) | |
310 | #define DIGITAL_UNIX_COMPATIBLE | |
311 | #endif | |
312 | ||
313 | #if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE) | |
314 | #define PERL_COMPATIBLE | |
315 | #endif | |
316 | ||
317 | #if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE) | |
318 | #define LINUX_COMPATIBLE | |
319 | #endif | |
320 | ||
321 | #include <sys/types.h> | |
322 | #include <string.h> | |
323 | #include <stdlib.h> | |
324 | #include <stdio.h> | |
325 | #include <stdarg.h> | |
326 | #include <assert.h> | |
327 | #include <errno.h> | |
328 | ||
329 | #ifdef isdigit | |
330 | #undef isdigit | |
331 | #endif | |
332 | #define isdigit(c) ((c) >= '0' && (c) <= '9') | |
333 | ||
334 | /* For copying strings longer or equal to 'breakeven_point' | |
335 | * it is more efficient to call memcpy() than to do it inline. | |
336 | * The value depends mostly on the processor architecture, | |
337 | * but also on the compiler and its optimization capabilities. | |
338 | * The value is not critical, some small value greater than zero | |
339 | * will be just fine if you don't care to squeeze every drop | |
340 | * of performance out of the code. | |
341 | * | |
342 | * Small values favor memcpy, large values favor inline code. | |
343 | */ | |
344 | #if defined(__alpha__) || defined(__alpha) | |
345 | # define breakeven_point 2 /* AXP (DEC Alpha) - gcc or cc or egcs */ | |
346 | #endif | |
347 | #if defined(__i386__) || defined(__i386) | |
348 | # define breakeven_point 12 /* Intel Pentium/Linux - gcc 2.96 */ | |
349 | #endif | |
350 | #if defined(__hppa) | |
351 | # define breakeven_point 10 /* HP-PA - gcc */ | |
352 | #endif | |
353 | #if defined(__sparc__) || defined(__sparc) | |
354 | # define breakeven_point 33 /* Sun Sparc 5 - gcc 2.8.1 */ | |
355 | #endif | |
356 | ||
357 | /* some other values of possible interest: */ | |
358 | /* #define breakeven_point 8 */ /* VAX 4000 - vaxc */ | |
359 | /* #define breakeven_point 19 */ /* VAX 4000 - gcc 2.7.0 */ | |
360 | ||
361 | #ifndef breakeven_point | |
362 | # define breakeven_point 6 /* some reasonable one-size-fits-all value */ | |
363 | #endif | |
364 | ||
365 | #define fast_memcpy(d,s,n) \ | |
366 | { register size_t nn = (size_t)(n); \ | |
367 | if (nn >= breakeven_point) memcpy((d), (s), nn); \ | |
368 | else if (nn > 0) { /* proc call overhead is worth only for large strings*/\ | |
369 | register char *dd; register const char *ss; \ | |
370 | for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } } | |
371 | ||
372 | #define fast_memset(d,c,n) \ | |
373 | { register size_t nn = (size_t)(n); \ | |
374 | if (nn >= breakeven_point) memset((d), (int)(c), nn); \ | |
375 | else if (nn > 0) { /* proc call overhead is worth only for large strings*/\ | |
376 | register char *dd; register const int cc=(int)(c); \ | |
377 | for (dd=(d); nn>0; nn--) *dd++ = cc; } } | |
378 | ||
379 | /* prototypes */ | |
380 | ||
381 | #if defined(NEED_ASPRINTF) | |
382 | int asprintf (char **ptr, const char *fmt, /*args*/ ...); | |
383 | #endif | |
384 | #if defined(NEED_VASPRINTF) | |
385 | int vasprintf (char **ptr, const char *fmt, va_list ap); | |
386 | #endif | |
387 | #if defined(NEED_ASNPRINTF) | |
388 | int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...); | |
389 | #endif | |
390 | #if defined(NEED_VASNPRINTF) | |
391 | int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap); | |
392 | #endif | |
393 | ||
394 | #if defined(HAVE_SNPRINTF) | |
395 | /* declare our portable snprintf routine under name portable_snprintf */ | |
396 | /* declare our portable vsnprintf routine under name portable_vsnprintf */ | |
397 | #else | |
398 | /* declare our portable routines under names snprintf and vsnprintf */ | |
399 | #define portable_snprintf snprintf | |
400 | #if !defined(NEED_SNPRINTF_ONLY) | |
401 | #define portable_vsnprintf vsnprintf | |
402 | #endif | |
403 | #endif | |
404 | ||
405 | #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF) | |
406 | int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...); | |
407 | #if !defined(NEED_SNPRINTF_ONLY) | |
408 | int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap); | |
409 | #endif | |
410 | #endif | |
411 | ||
412 | /* declarations */ | |
413 | ||
414 | static char credits[] = "\n\ | |
415 | @(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\ | |
416 | @(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\ | |
417 | @(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n"; | |
418 | ||
419 | #if defined(NEED_ASPRINTF) | |
420 | int asprintf(char **ptr, const char *fmt, /*args*/ ...) { | |
421 | va_list ap; | |
422 | size_t str_m; | |
423 | int str_l; | |
424 | ||
425 | *ptr = NULL; | |
426 | va_start(ap, fmt); /* measure the required size */ | |
427 | str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap); | |
428 | va_end(ap); | |
429 | assert(str_l >= 0); /* possible integer overflow if str_m > INT_MAX */ | |
430 | *ptr = (char *) malloc(str_m = (size_t)str_l + 1); | |
431 | if (*ptr == NULL) { errno = ENOMEM; str_l = -1; } | |
432 | else { | |
433 | int str_l2; | |
434 | va_start(ap, fmt); | |
435 | str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap); | |
436 | va_end(ap); | |
437 | assert(str_l2 == str_l); | |
438 | } | |
439 | return str_l; | |
440 | } | |
441 | #endif | |
442 | ||
443 | #if defined(NEED_VASPRINTF) | |
444 | int vasprintf(char **ptr, const char *fmt, va_list ap) { | |
445 | size_t str_m; | |
446 | int str_l; | |
447 | ||
448 | *ptr = NULL; | |
449 | { va_list ap2; | |
450 | va_copy(ap2, ap); /* don't consume the original ap, we'll need it again */ | |
451 | str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/ | |
452 | va_end(ap2); | |
453 | } | |
454 | assert(str_l >= 0); /* possible integer overflow if str_m > INT_MAX */ | |
455 | *ptr = (char *) malloc(str_m = (size_t)str_l + 1); | |
456 | if (*ptr == NULL) { errno = ENOMEM; str_l = -1; } | |
457 | else { | |
458 | int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap); | |
459 | assert(str_l2 == str_l); | |
460 | } | |
461 | return str_l; | |
462 | } | |
463 | #endif | |
464 | ||
465 | #if defined(NEED_ASNPRINTF) | |
466 | int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) { | |
467 | va_list ap; | |
468 | int str_l; | |
469 | ||
470 | *ptr = NULL; | |
471 | va_start(ap, fmt); /* measure the required size */ | |
472 | str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap); | |
473 | va_end(ap); | |
474 | assert(str_l >= 0); /* possible integer overflow if str_m > INT_MAX */ | |
475 | if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1; /* truncate */ | |
476 | /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */ | |
477 | if (str_m == 0) { /* not interested in resulting string, just return size */ | |
478 | } else { | |
479 | *ptr = (char *) malloc(str_m); | |
480 | if (*ptr == NULL) { errno = ENOMEM; str_l = -1; } | |
481 | else { | |
482 | int str_l2; | |
483 | va_start(ap, fmt); | |
484 | str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap); | |
485 | va_end(ap); | |
486 | assert(str_l2 == str_l); | |
487 | } | |
488 | } | |
489 | return str_l; | |
490 | } | |
491 | #endif | |
492 | ||
493 | #if defined(NEED_VASNPRINTF) | |
494 | int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) { | |
495 | int str_l; | |
496 | ||
497 | *ptr = NULL; | |
498 | { va_list ap2; | |
499 | va_copy(ap2, ap); /* don't consume the original ap, we'll need it again */ | |
500 | str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/ | |
501 | va_end(ap2); | |
502 | } | |
503 | assert(str_l >= 0); /* possible integer overflow if str_m > INT_MAX */ | |
504 | if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1; /* truncate */ | |
505 | /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */ | |
506 | if (str_m == 0) { /* not interested in resulting string, just return size */ | |
507 | } else { | |
508 | *ptr = (char *) malloc(str_m); | |
509 | if (*ptr == NULL) { errno = ENOMEM; str_l = -1; } | |
510 | else { | |
511 | int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap); | |
512 | assert(str_l2 == str_l); | |
513 | } | |
514 | } | |
515 | return str_l; | |
516 | } | |
517 | #endif | |
518 | ||
519 | /* | |
520 | * If the system does have snprintf and the portable routine is not | |
521 | * specifically required, this module produces no code for snprintf/vsnprintf. | |
522 | */ | |
523 | #if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF) | |
524 | ||
525 | #if !defined(NEED_SNPRINTF_ONLY) | |
526 | int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) { | |
527 | va_list ap; | |
528 | int str_l; | |
529 | ||
530 | va_start(ap, fmt); | |
531 | str_l = portable_vsnprintf(str, str_m, fmt, ap); | |
532 | va_end(ap); | |
533 | return str_l; | |
534 | } | |
535 | #endif | |
536 | ||
537 | #if defined(NEED_SNPRINTF_ONLY) | |
538 | int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) { | |
539 | #else | |
540 | int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) { | |
541 | #endif | |
542 | ||
543 | #if defined(NEED_SNPRINTF_ONLY) | |
544 | va_list ap; | |
545 | #endif | |
546 | size_t str_l = 0; | |
547 | const char *p = fmt; | |
548 | ||
549 | /* In contrast with POSIX, the ISO C99 now says | |
550 | * that str can be NULL and str_m can be 0. | |
551 | * This is more useful than the old: if (str_m < 1) return -1; */ | |
552 | ||
553 | #if defined(NEED_SNPRINTF_ONLY) | |
554 | va_start(ap, fmt); | |
555 | #endif | |
556 | if (!p) p = ""; | |
557 | while (*p) { | |
558 | if (*p != '%') { | |
559 | /* if (str_l < str_m) str[str_l++] = *p++; -- this would be sufficient */ | |
560 | /* but the following code achieves better performance for cases | |
561 | * where format string is long and contains few conversions */ | |
562 | const char *q = strchr(p+1,'%'); | |
563 | size_t n = !q ? strlen(p) : (q-p); | |
564 | if (str_l < str_m) { | |
565 | size_t avail = str_m-str_l; | |
566 | fast_memcpy(str+str_l, p, (n>avail?avail:n)); | |
567 | } | |
568 | p += n; str_l += n; | |
569 | } else { | |
570 | const char *starting_p; | |
571 | size_t min_field_width = 0, precision = 0; | |
572 | int zero_padding = 0, precision_specified = 0, justify_left = 0; | |
573 | int alternate_form = 0, force_sign = 0; | |
574 | int space_for_positive = 1; /* If both the ' ' and '+' flags appear, | |
575 | the ' ' flag should be ignored. */ | |
576 | char length_modifier = '\0'; /* allowed values: \0, h, l, L */ | |
577 | char tmp[32];/* temporary buffer for simple numeric->string conversion */ | |
578 | ||
579 | const char *str_arg; /* string address in case of string argument */ | |
580 | size_t str_arg_l; /* natural field width of arg without padding | |
581 | and sign */ | |
582 | unsigned char uchar_arg; | |
583 | /* unsigned char argument value - only defined for c conversion. | |
584 | N.B. standard explicitly states the char argument for | |
585 | the c conversion is unsigned */ | |
586 | ||
587 | size_t number_of_zeros_to_pad = 0; | |
588 | /* number of zeros to be inserted for numeric conversions | |
589 | as required by the precision or minimal field width */ | |
590 | ||
591 | size_t zero_padding_insertion_ind = 0; | |
592 | /* index into tmp where zero padding is to be inserted */ | |
593 | ||
594 | char fmt_spec = '\0'; | |
595 | /* current conversion specifier character */ | |
596 | ||
597 | str_arg = credits;/* just to make compiler happy (defined but not used)*/ | |
598 | str_arg = NULL; | |
599 | starting_p = p; p++; /* skip '%' */ | |
600 | /* parse flags */ | |
601 | while (*p == '0' || *p == '-' || *p == '+' || | |
602 | *p == ' ' || *p == '#' || *p == '\'') { | |
603 | switch (*p) { | |
604 | case '0': zero_padding = 1; break; | |
605 | case '-': justify_left = 1; break; | |
606 | case '+': force_sign = 1; space_for_positive = 0; break; | |
607 | case ' ': force_sign = 1; | |
608 | /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */ | |
609 | #ifdef PERL_COMPATIBLE | |
610 | /* ... but in Perl the last of ' ' and '+' applies */ | |
611 | space_for_positive = 1; | |
612 | #endif | |
613 | break; | |
614 | case '#': alternate_form = 1; break; | |
615 | case '\'': break; | |
616 | } | |
617 | p++; | |
618 | } | |
619 | /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */ | |
620 | ||
621 | /* parse field width */ | |
622 | if (*p == '*') { | |
623 | int j; | |
624 | p++; j = va_arg(ap, int); | |
625 | if (j >= 0) min_field_width = j; | |
626 | else { min_field_width = -j; justify_left = 1; } | |
627 | } else if (isdigit((int)(*p))) { | |
628 | /* size_t could be wider than unsigned int; | |
629 | make sure we treat argument like common implementations do */ | |
630 | unsigned int uj = *p++ - '0'; | |
631 | while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0'); | |
632 | min_field_width = uj; | |
633 | } | |
634 | /* parse precision */ | |
635 | if (*p == '.') { | |
636 | p++; precision_specified = 1; | |
637 | if (*p == '*') { | |
638 | int j = va_arg(ap, int); | |
639 | p++; | |
640 | if (j >= 0) precision = j; | |
641 | else { | |
642 | precision_specified = 0; precision = 0; | |
643 | /* NOTE: | |
644 | * Solaris 2.6 man page claims that in this case the precision | |
645 | * should be set to 0. Digital Unix 4.0, HPUX 10 and BSD man page | |
646 | * claim that this case should be treated as unspecified precision, | |
647 | * which is what we do here. | |
648 | */ | |
649 | } | |
650 | } else if (isdigit((int)(*p))) { | |
651 | /* size_t could be wider than unsigned int; | |
652 | make sure we treat argument like common implementations do */ | |
653 | unsigned int uj = *p++ - '0'; | |
654 | while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0'); | |
655 | precision = uj; | |
656 | } | |
657 | } | |
658 | /* parse 'h', 'l' and 'll' length modifiers */ | |
659 | if (*p == 'h' || *p == 'l') { | |
660 | length_modifier = *p; p++; | |
661 | if (length_modifier == 'l' && *p == 'l') { /* double l = long long */ | |
662 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
663 | length_modifier = '2'; /* double l encoded as '2' */ | |
664 | #else | |
665 | length_modifier = 'l'; /* treat it as a single 'l' */ | |
666 | #endif | |
667 | p++; | |
668 | } | |
669 | } | |
670 | fmt_spec = *p; | |
671 | /* common synonyms: */ | |
672 | switch (fmt_spec) { | |
673 | case 'i': fmt_spec = 'd'; break; | |
674 | case 'D': fmt_spec = 'd'; length_modifier = 'l'; break; | |
675 | case 'U': fmt_spec = 'u'; length_modifier = 'l'; break; | |
676 | case 'O': fmt_spec = 'o'; length_modifier = 'l'; break; | |
677 | default: break; | |
678 | } | |
679 | /* get parameter value, do initial processing */ | |
680 | switch (fmt_spec) { | |
681 | case '%': /* % behaves similar to 's' regarding flags and field widths */ | |
682 | case 'c': /* c behaves similar to 's' regarding flags and field widths */ | |
683 | case 's': | |
684 | length_modifier = '\0'; /* wint_t and wchar_t not supported */ | |
685 | /* the result of zero padding flag with non-numeric conversion specifier*/ | |
686 | /* is undefined. Solaris and HPUX 10 does zero padding in this case, */ | |
687 | /* Digital Unix and Linux does not. */ | |
688 | #if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE) | |
689 | zero_padding = 0; /* turn zero padding off for string conversions */ | |
690 | #endif | |
691 | str_arg_l = 1; | |
692 | switch (fmt_spec) { | |
693 | case '%': | |
694 | str_arg = p; break; | |
695 | case 'c': { | |
696 | int j = va_arg(ap, int); | |
697 | uchar_arg = (unsigned char) j; /* standard demands unsigned char */ | |
698 | str_arg = (const char *) &uchar_arg; | |
699 | break; | |
700 | } | |
701 | case 's': | |
702 | str_arg = va_arg(ap, const char *); | |
703 | if (!str_arg) str_arg_l = 0; | |
704 | /* make sure not to address string beyond the specified precision !!! */ | |
705 | else if (!precision_specified) str_arg_l = strlen(str_arg); | |
706 | /* truncate string if necessary as requested by precision */ | |
707 | else if (precision == 0) str_arg_l = 0; | |
708 | else { | |
709 | /* memchr on HP does not like n > 2^31 !!! */ | |
710 | const char *q = memchr(str_arg, '\0', | |
711 | precision <= 0x7fffffff ? precision : 0x7fffffff); | |
712 | str_arg_l = !q ? precision : (q-str_arg); | |
713 | } | |
714 | break; | |
715 | default: break; | |
716 | } | |
717 | break; | |
718 | case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': { | |
719 | /* NOTE: the u, o, x, X and p conversion specifiers imply | |
720 | the value is unsigned; d implies a signed value */ | |
721 | ||
722 | int arg_sign = 0; | |
723 | /* 0 if numeric argument is zero (or if pointer is NULL for 'p'), | |
724 | +1 if greater than zero (or nonzero for unsigned arguments), | |
725 | -1 if negative (unsigned argument is never negative) */ | |
726 | ||
727 | int int_arg = 0; unsigned int uint_arg = 0; | |
728 | /* only defined for length modifier h, or for no length modifiers */ | |
729 | ||
730 | long int long_arg = 0; unsigned long int ulong_arg = 0; | |
731 | /* only defined for length modifier l */ | |
732 | ||
733 | void *ptr_arg = NULL; | |
734 | /* pointer argument value -only defined for p conversion */ | |
735 | ||
736 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
737 | long long int long_long_arg = 0; | |
738 | unsigned long long int ulong_long_arg = 0; | |
739 | /* only defined for length modifier ll */ | |
740 | #endif | |
741 | if (fmt_spec == 'p') { | |
742 | /* HPUX 10: An l, h, ll or L before any other conversion character | |
743 | * (other than d, i, u, o, x, or X) is ignored. | |
744 | * Digital Unix: | |
745 | * not specified, but seems to behave as HPUX does. | |
746 | * Solaris: If an h, l, or L appears before any other conversion | |
747 | * specifier (other than d, i, u, o, x, or X), the behavior | |
748 | * is undefined. (Actually %hp converts only 16-bits of address | |
749 | * and %llp treats address as 64-bit data which is incompatible | |
750 | * with (void *) argument on a 32-bit system). | |
751 | */ | |
752 | #ifdef SOLARIS_COMPATIBLE | |
753 | # ifdef SOLARIS_BUG_COMPATIBLE | |
754 | /* keep length modifiers even if it represents 'll' */ | |
755 | # else | |
756 | if (length_modifier == '2') length_modifier = '\0'; | |
757 | # endif | |
758 | #else | |
759 | length_modifier = '\0'; | |
760 | #endif | |
761 | ptr_arg = va_arg(ap, void *); | |
762 | if (ptr_arg != NULL) arg_sign = 1; | |
763 | } else if (fmt_spec == 'd') { /* signed */ | |
764 | switch (length_modifier) { | |
765 | case '\0': | |
766 | case 'h': | |
767 | /* It is non-portable to specify a second argument of char or short | |
768 | * to va_arg, because arguments seen by the called function | |
769 | * are not char or short. C converts char and short arguments | |
770 | * to int before passing them to a function. | |
771 | */ | |
772 | int_arg = va_arg(ap, int); | |
773 | if (int_arg > 0) arg_sign = 1; | |
774 | else if (int_arg < 0) arg_sign = -1; | |
775 | break; | |
776 | case 'l': | |
777 | long_arg = va_arg(ap, long int); | |
778 | if (long_arg > 0) arg_sign = 1; | |
779 | else if (long_arg < 0) arg_sign = -1; | |
780 | break; | |
781 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
782 | case '2': | |
783 | long_long_arg = va_arg(ap, long long int); | |
784 | if (long_long_arg > 0) arg_sign = 1; | |
785 | else if (long_long_arg < 0) arg_sign = -1; | |
786 | break; | |
787 | #endif | |
788 | } | |
789 | } else { /* unsigned */ | |
790 | switch (length_modifier) { | |
791 | case '\0': | |
792 | case 'h': | |
793 | uint_arg = va_arg(ap, unsigned int); | |
794 | if (uint_arg) arg_sign = 1; | |
795 | break; | |
796 | case 'l': | |
797 | ulong_arg = va_arg(ap, unsigned long int); | |
798 | if (ulong_arg) arg_sign = 1; | |
799 | break; | |
800 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
801 | case '2': | |
802 | ulong_long_arg = va_arg(ap, unsigned long long int); | |
803 | if (ulong_long_arg) arg_sign = 1; | |
804 | break; | |
805 | #endif | |
806 | } | |
807 | } | |
808 | str_arg = tmp; str_arg_l = 0; | |
809 | /* NOTE: | |
810 | * For d, i, u, o, x, and X conversions, if precision is specified, | |
811 | * the '0' flag should be ignored. This is so with Solaris 2.6, | |
812 | * Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl. | |
813 | */ | |
814 | #ifndef PERL_COMPATIBLE | |
815 | if (precision_specified) zero_padding = 0; | |
816 | #endif | |
817 | if (fmt_spec == 'd') { | |
818 | if (force_sign && arg_sign >= 0) | |
819 | tmp[str_arg_l++] = space_for_positive ? ' ' : '+'; | |
820 | /* leave negative numbers for sprintf to handle, | |
821 | to avoid handling tricky cases like (short int)(-32768) */ | |
822 | #ifdef LINUX_COMPATIBLE | |
823 | } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) { | |
824 | tmp[str_arg_l++] = space_for_positive ? ' ' : '+'; | |
825 | #endif | |
826 | } else if (alternate_form) { | |
827 | if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') ) | |
828 | { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; } | |
829 | /* alternate form should have no effect for p conversion, but ... */ | |
830 | #ifdef HPUX_COMPATIBLE | |
831 | else if (fmt_spec == 'p' | |
832 | /* HPUX 10: for an alternate form of p conversion, | |
833 | * a nonzero result is prefixed by 0x. */ | |
834 | #ifndef HPUX_BUG_COMPATIBLE | |
835 | /* Actually it uses 0x prefix even for a zero value. */ | |
836 | && arg_sign != 0 | |
837 | #endif | |
838 | ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; } | |
839 | #endif | |
840 | } | |
841 | zero_padding_insertion_ind = str_arg_l; | |
842 | if (!precision_specified) precision = 1; /* default precision is 1 */ | |
843 | if (precision == 0 && arg_sign == 0 | |
844 | #if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE) | |
845 | && fmt_spec != 'p' | |
846 | /* HPUX 10 man page claims: With conversion character p the result of | |
847 | * converting a zero value with a precision of zero is a null string. | |
848 | * Actually HP returns all zeroes, and Linux returns "(nil)". */ | |
849 | #endif | |
850 | ) { | |
851 | /* converted to null string */ | |
852 | /* When zero value is formatted with an explicit precision 0, | |
853 | the resulting formatted string is empty (d, i, u, o, x, X, p). */ | |
854 | } else { | |
855 | char f[5]; int f_l = 0; | |
856 | f[f_l++] = '%'; /* construct a simple format string for sprintf */ | |
857 | if (!length_modifier) { } | |
858 | else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; } | |
859 | else f[f_l++] = length_modifier; | |
860 | f[f_l++] = fmt_spec; f[f_l++] = '\0'; | |
861 | if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg); | |
862 | else if (fmt_spec == 'd') { /* signed */ | |
863 | switch (length_modifier) { | |
864 | case '\0': | |
865 | case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg); break; | |
866 | case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break; | |
867 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
868 | case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break; | |
869 | #endif | |
870 | } | |
871 | } else { /* unsigned */ | |
872 | switch (length_modifier) { | |
873 | case '\0': | |
874 | case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg); break; | |
875 | case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break; | |
876 | #ifdef SNPRINTF_LONGLONG_SUPPORT | |
877 | case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break; | |
878 | #endif | |
879 | } | |
880 | } | |
881 | /* include the optional minus sign and possible "0x" | |
882 | in the region before the zero padding insertion point */ | |
883 | if (zero_padding_insertion_ind < str_arg_l && | |
884 | tmp[zero_padding_insertion_ind] == '-') { | |
885 | zero_padding_insertion_ind++; | |
886 | } | |
887 | if (zero_padding_insertion_ind+1 < str_arg_l && | |
888 | tmp[zero_padding_insertion_ind] == '0' && | |
889 | (tmp[zero_padding_insertion_ind+1] == 'x' || | |
890 | tmp[zero_padding_insertion_ind+1] == 'X') ) { | |
891 | zero_padding_insertion_ind += 2; | |
892 | } | |
893 | } | |
894 | { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind; | |
895 | if (alternate_form && fmt_spec == 'o' | |
896 | #ifdef HPUX_COMPATIBLE /* ("%#.o",0) -> "" */ | |
897 | && (str_arg_l > 0) | |
898 | #endif | |
899 | #ifdef DIGITAL_UNIX_BUG_COMPATIBLE /* ("%#o",0) -> "00" */ | |
900 | #else | |
901 | /* unless zero is already the first character */ | |
902 | && !(zero_padding_insertion_ind < str_arg_l | |
903 | && tmp[zero_padding_insertion_ind] == '0') | |
904 | #endif | |
905 | ) { /* assure leading zero for alternate-form octal numbers */ | |
906 | if (!precision_specified || precision < num_of_digits+1) { | |
907 | /* precision is increased to force the first character to be zero, | |
908 | except if a zero value is formatted with an explicit precision | |
909 | of zero */ | |
910 | precision = num_of_digits+1; precision_specified = 1; | |
911 | } | |
912 | } | |
913 | /* zero padding to specified precision? */ | |
914 | if (num_of_digits < precision) | |
915 | number_of_zeros_to_pad = precision - num_of_digits; | |
916 | } | |
917 | /* zero padding to specified minimal field width? */ | |
918 | if (!justify_left && zero_padding) { | |
919 | int n = min_field_width - (str_arg_l+number_of_zeros_to_pad); | |
920 | if (n > 0) number_of_zeros_to_pad += n; | |
921 | } | |
922 | break; | |
923 | } | |
924 | default: /* unrecognized conversion specifier, keep format string as-is*/ | |
925 | zero_padding = 0; /* turn zero padding off for non-numeric convers. */ | |
926 | #ifndef DIGITAL_UNIX_COMPATIBLE | |
927 | justify_left = 1; min_field_width = 0; /* reset flags */ | |
928 | #endif | |
929 | #if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE) | |
930 | /* keep the entire format string unchanged */ | |
931 | str_arg = starting_p; str_arg_l = p - starting_p; | |
932 | /* well, not exactly so for Linux, which does something inbetween, | |
933 | * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y" */ | |
934 | #else | |
935 | /* discard the unrecognized conversion, just keep * | |
936 | * the unrecognized conversion character */ | |
937 | str_arg = p; str_arg_l = 0; | |
938 | #endif | |
939 | if (*p) str_arg_l++; /* include invalid conversion specifier unchanged | |
940 | if not at end-of-string */ | |
941 | break; | |
942 | } | |
943 | if (*p) p++; /* step over the just processed conversion specifier */ | |
944 | /* insert padding to the left as requested by min_field_width; | |
945 | this does not include the zero padding in case of numerical conversions*/ | |
946 | if (!justify_left) { /* left padding with blank or zero */ | |
947 | int n = min_field_width - (str_arg_l+number_of_zeros_to_pad); | |
948 | if (n > 0) { | |
949 | if (str_l < str_m) { | |
950 | size_t avail = str_m-str_l; | |
951 | fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n)); | |
952 | } | |
953 | str_l += n; | |
954 | } | |
955 | } | |
956 | /* zero padding as requested by the precision or by the minimal field width | |
957 | * for numeric conversions required? */ | |
958 | if (number_of_zeros_to_pad <= 0) { | |
959 | /* will not copy first part of numeric right now, * | |
960 | * force it to be copied later in its entirety */ | |
961 | zero_padding_insertion_ind = 0; | |
962 | } else { | |
963 | /* insert first part of numerics (sign or '0x') before zero padding */ | |
964 | int n = zero_padding_insertion_ind; | |
965 | if (n > 0) { | |
966 | if (str_l < str_m) { | |
967 | size_t avail = str_m-str_l; | |
968 | fast_memcpy(str+str_l, str_arg, (n>avail?avail:n)); | |
969 | } | |
970 | str_l += n; | |
971 | } | |
972 | /* insert zero padding as requested by the precision or min field width */ | |
973 | n = number_of_zeros_to_pad; | |
974 | if (n > 0) { | |
975 | if (str_l < str_m) { | |
976 | size_t avail = str_m-str_l; | |
977 | fast_memset(str+str_l, '0', (n>avail?avail:n)); | |
978 | } | |
979 | str_l += n; | |
980 | } | |
981 | } | |
982 | /* insert formatted string | |
983 | * (or as-is conversion specifier for unknown conversions) */ | |
984 | { int n = str_arg_l - zero_padding_insertion_ind; | |
985 | if (n > 0) { | |
986 | if (str_l < str_m) { | |
987 | size_t avail = str_m-str_l; | |
988 | fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind, | |
989 | (n>avail?avail:n)); | |
990 | } | |
991 | str_l += n; | |
992 | } | |
993 | } | |
994 | /* insert right padding */ | |
995 | if (justify_left) { /* right blank padding to the field width */ | |
996 | int n = min_field_width - (str_arg_l+number_of_zeros_to_pad); | |
997 | if (n > 0) { | |
998 | if (str_l < str_m) { | |
999 | size_t avail = str_m-str_l; | |
1000 | fast_memset(str+str_l, ' ', (n>avail?avail:n)); | |
1001 | } | |
1002 | str_l += n; | |
1003 | } | |
1004 | } | |
1005 | } | |
1006 | } | |
1007 | #if defined(NEED_SNPRINTF_ONLY) | |
1008 | va_end(ap); | |
1009 | #endif | |
1010 | if (str_m > 0) { /* make sure the string is null-terminated | |
1011 | even at the expense of overwriting the last character | |
1012 | (shouldn't happen, but just in case) */ | |
1013 | str[str_l <= str_m-1 ? str_l : str_m-1] = '\0'; | |
1014 | } | |
1015 | /* Return the number of characters formatted (excluding trailing null | |
1016 | * character), that is, the number of characters that would have been | |
1017 | * written to the buffer if it were large enough. | |
1018 | * | |
1019 | * The value of str_l should be returned, but str_l is of unsigned type | |
1020 | * size_t, and snprintf is int, possibly leading to an undetected | |
1021 | * integer overflow, resulting in a negative return value, which is illegal. | |
1022 | * Both XSH5 and ISO C99 (at least the draft) are silent on this issue. | |
1023 | * Should errno be set to EOVERFLOW and EOF returned in this case??? | |
1024 | */ | |
1025 | return (int) str_l; | |
1026 | } | |
1027 | #endif |