1 /* vsprintf with automatic memory allocation.
2 Copyright (C) 1999, 2002-2010 Free Software Foundation, Inc.
3
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU Library General Public License as published
6 by the Free Software Foundation; either version 2, or (at your option)
7 any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
17 USA. */
18
19 /* This file can be parametrized with the following macros:
20 VASNPRINTF The name of the function being defined.
21 FCHAR_T The element type of the format string.
22 DCHAR_T The element type of the destination (result) string.
23 FCHAR_T_ONLY_ASCII Set to 1 to enable verification that all characters
24 in the format string are ASCII. MUST be set if
25 FCHAR_T and DCHAR_T are not the same type.
26 DIRECTIVE Structure denoting a format directive.
27 Depends on FCHAR_T.
28 DIRECTIVES Structure denoting the set of format directives of a
29 format string. Depends on FCHAR_T.
30 PRINTF_PARSE Function that parses a format string.
31 Depends on FCHAR_T.
32 DCHAR_CPY memcpy like function for DCHAR_T[] arrays.
33 DCHAR_SET memset like function for DCHAR_T[] arrays.
34 DCHAR_MBSNLEN mbsnlen like function for DCHAR_T[] arrays.
35 SNPRINTF The system's snprintf (or similar) function.
36 This may be either snprintf or swprintf.
37 TCHAR_T The element type of the argument and result string
38 of the said SNPRINTF function. This may be either
39 char or wchar_t. The code exploits that
40 sizeof (TCHAR_T) | sizeof (DCHAR_T) and
41 alignof (TCHAR_T) <= alignof (DCHAR_T).
42 DCHAR_IS_TCHAR Set to 1 if DCHAR_T and TCHAR_T are the same type.
43 DCHAR_CONV_FROM_ENCODING A function to convert from char[] to DCHAR[].
44 DCHAR_IS_UINT8_T Set to 1 if DCHAR_T is uint8_t.
45 DCHAR_IS_UINT16_T Set to 1 if DCHAR_T is uint16_t.
46 DCHAR_IS_UINT32_T Set to 1 if DCHAR_T is uint32_t. */
47
48 /* Tell glibc's <stdio.h> to provide a prototype for snprintf().
49 This must come before <config.h> because <config.h> may include
50 <features.h>, and once <features.h> has been included, it's too late. */
51 #ifndef _GNU_SOURCE
52 # define _GNU_SOURCE 1
53 #endif
54
55 #ifndef VASNPRINTF
56 # include <config.h>
57 #endif
58 #ifndef IN_LIBINTL
59 # include <alloca.h>
60 #endif
61
62 /* Specification. */
63 #ifndef VASNPRINTF
64 # if WIDE_CHAR_VERSION
65 # include "vasnwprintf.h"
66 # else
67 # include "vasnprintf.h"
68 # endif
69 #endif
70
71 #include <locale.h> /* localeconv() */
72 #include <stdio.h> /* snprintf(), sprintf() */
73 #include <stdlib.h> /* abort(), malloc(), realloc(), free() */
74 #include <string.h> /* memcpy(), strlen() */
75 #include <errno.h> /* errno */
76 #include <limits.h> /* CHAR_BIT */
77 #include <float.h> /* DBL_MAX_EXP, LDBL_MAX_EXP */
78 #if HAVE_NL_LANGINFO
79 # include <langinfo.h>
80 #endif
81 #ifndef VASNPRINTF
82 # if WIDE_CHAR_VERSION
83 # include "wprintf-parse.h"
84 # else
85 # include "printf-parse.h"
86 # endif
87 #endif
88
89 /* Checked size_t computations. */
90 #include "xsize.h"
91
92 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
93 # include <math.h>
94 # include "float+.h"
95 #endif
96
97 #if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !defined IN_LIBINTL
98 # include <math.h>
99 # include "isnand-nolibm.h"
100 #endif
101
102 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE) && !defined IN_LIBINTL
103 # include <math.h>
104 # include "isnanl-nolibm.h"
105 # include "fpucw.h"
106 #endif
107
108 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
109 # include <math.h>
110 # include "isnand-nolibm.h"
111 # include "printf-frexp.h"
112 #endif
113
114 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
115 # include <math.h>
116 # include "isnanl-nolibm.h"
117 # include "printf-frexpl.h"
118 # include "fpucw.h"
119 #endif
120
121 /* Default parameters. */
122 #ifndef VASNPRINTF
123 # if WIDE_CHAR_VERSION
124 # define VASNPRINTF vasnwprintf
125 # define FCHAR_T wchar_t
126 # define DCHAR_T wchar_t
127 # define TCHAR_T wchar_t
128 # define DCHAR_IS_TCHAR 1
129 # define DIRECTIVE wchar_t_directive
130 # define DIRECTIVES wchar_t_directives
131 # define PRINTF_PARSE wprintf_parse
132 # define DCHAR_CPY wmemcpy
133 # define DCHAR_SET wmemset
134 # else
135 # define VASNPRINTF vasnprintf
136 # define FCHAR_T char
137 # define DCHAR_T char
138 # define TCHAR_T char
139 # define DCHAR_IS_TCHAR 1
140 # define DIRECTIVE char_directive
141 # define DIRECTIVES char_directives
142 # define PRINTF_PARSE printf_parse
143 # define DCHAR_CPY memcpy
144 # define DCHAR_SET memset
145 # endif
146 #endif
147 #if WIDE_CHAR_VERSION
148 /* TCHAR_T is wchar_t. */
149 # define USE_SNPRINTF 1
150 # if HAVE_DECL__SNWPRINTF
151 /* On Windows, the function swprintf() has a different signature than
152 on Unix; we use the function _snwprintf() or - on mingw - snwprintf()
153 instead. The mingw function snwprintf() has fewer bugs than the
154 MSVCRT function _snwprintf(), so prefer that. */
155 # if defined __MINGW32__
156 # define SNPRINTF snwprintf
157 # else
158 # define SNPRINTF _snwprintf
159 # endif
160 # else
161 /* Unix. */
162 # define SNPRINTF swprintf
163 # endif
164 #else
165 /* TCHAR_T is char. */
166 /* Use snprintf if it exists under the name 'snprintf' or '_snprintf'.
167 But don't use it on BeOS, since BeOS snprintf produces no output if the
168 size argument is >= 0x3000000.
169 Also don't use it on Linux libc5, since there snprintf with size = 1
170 writes any output without bounds, like sprintf. */
171 # if (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF) && !defined __BEOS__ && !(__GNU_LIBRARY__ == 1)
172 # define USE_SNPRINTF 1
173 # else
174 # define USE_SNPRINTF 0
175 # endif
176 # if HAVE_DECL__SNPRINTF
177 /* Windows. The mingw function snprintf() has fewer bugs than the MSVCRT
178 function _snprintf(), so prefer that. */
179 # if defined __MINGW32__
180 # define SNPRINTF snprintf
181 /* Here we need to call the native snprintf, not rpl_snprintf. */
182 # undef snprintf
183 # else
184 # define SNPRINTF _snprintf
185 # endif
186 # else
187 /* Unix. */
188 # define SNPRINTF snprintf
189 /* Here we need to call the native snprintf, not rpl_snprintf. */
190 # undef snprintf
191 # endif
192 #endif
193 /* Here we need to call the native sprintf, not rpl_sprintf. */
194 #undef sprintf
195
196 /* GCC >= 4.0 with -Wall emits unjustified "... may be used uninitialized"
197 warnings in this file. Use -Dlint to suppress them. */
198 #ifdef lint
199 # define IF_LINT(Code) Code
200 #else
201 # define IF_LINT(Code) /* empty */
202 #endif
203
204 /* Avoid some warnings from "gcc -Wshadow".
205 This file doesn't use the exp() and remainder() functions. */
206 #undef exp
207 #define exp expo
208 #undef remainder
209 #define remainder rem
210
211 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && !WIDE_CHAR_VERSION
212 # if (HAVE_STRNLEN && !defined _AIX)
213 # define local_strnlen strnlen
214 # else
215 # ifndef local_strnlen_defined
216 # define local_strnlen_defined 1
217 static size_t
local_strnlen(const char * string,size_t maxlen)218 local_strnlen (const char *string, size_t maxlen)
219 {
220 const char *end = memchr (string, '\0', maxlen);
221 return end ? (size_t) (end - string) : maxlen;
222 }
223 # endif
224 # endif
225 #endif
226
227 #if (((!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && WIDE_CHAR_VERSION) || ((!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || (NEED_PRINTF_DIRECTIVE_LS && !defined IN_LIBINTL)) && !WIDE_CHAR_VERSION && DCHAR_IS_TCHAR)) && HAVE_WCHAR_T
228 # if HAVE_WCSLEN
229 # define local_wcslen wcslen
230 # else
231 /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid
232 a dependency towards this library, here is a local substitute.
233 Define this substitute only once, even if this file is included
234 twice in the same compilation unit. */
235 # ifndef local_wcslen_defined
236 # define local_wcslen_defined 1
237 static size_t
local_wcslen(const wchar_t * s)238 local_wcslen (const wchar_t *s)
239 {
240 const wchar_t *ptr;
241
242 for (ptr = s; *ptr != (wchar_t) 0; ptr++)
243 ;
244 return ptr - s;
245 }
246 # endif
247 # endif
248 #endif
249
250 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99) && HAVE_WCHAR_T && WIDE_CHAR_VERSION
251 # if HAVE_WCSNLEN
252 # define local_wcsnlen wcsnlen
253 # else
254 # ifndef local_wcsnlen_defined
255 # define local_wcsnlen_defined 1
256 static size_t
local_wcsnlen(const wchar_t * s,size_t maxlen)257 local_wcsnlen (const wchar_t *s, size_t maxlen)
258 {
259 const wchar_t *ptr;
260
261 for (ptr = s; maxlen > 0 && *ptr != (wchar_t) 0; ptr++, maxlen--)
262 ;
263 return ptr - s;
264 }
265 # endif
266 # endif
267 #endif
268
269 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && !defined IN_LIBINTL
270 /* Determine the decimal-point character according to the current locale. */
271 # ifndef decimal_point_char_defined
272 # define decimal_point_char_defined 1
273 static char
decimal_point_char(void)274 decimal_point_char (void)
275 {
276 const char *point;
277 /* Determine it in a multithread-safe way. We know nl_langinfo is
278 multithread-safe on glibc systems and MacOS X systems, but is not required
279 to be multithread-safe by POSIX. sprintf(), however, is multithread-safe.
280 localeconv() is rarely multithread-safe. */
281 # if HAVE_NL_LANGINFO && (__GLIBC__ || (defined __APPLE__ && defined __MACH__))
282 point = nl_langinfo (RADIXCHAR);
283 # elif 1
284 char pointbuf[5];
285 sprintf (pointbuf, "%#.0f", 1.0);
286 point = &pointbuf[1];
287 # else
288 point = localeconv () -> decimal_point;
289 # endif
290 /* The decimal point is always a single byte: either '.' or ','. */
291 return (point[0] != '\0' ? point[0] : '.');
292 }
293 # endif
294 #endif
295
296 #if NEED_PRINTF_INFINITE_DOUBLE && !NEED_PRINTF_DOUBLE && !defined IN_LIBINTL
297
298 /* Equivalent to !isfinite(x) || x == 0, but does not require libm. */
299 static int
is_infinite_or_zero(double x)300 is_infinite_or_zero (double x)
301 {
302 return isnand (x) || x + x == x;
303 }
304
305 #endif
306
307 #if NEED_PRINTF_INFINITE_LONG_DOUBLE && !NEED_PRINTF_LONG_DOUBLE && !defined IN_LIBINTL
308
309 /* Equivalent to !isfinite(x) || x == 0, but does not require libm. */
310 static int
is_infinite_or_zerol(long double x)311 is_infinite_or_zerol (long double x)
312 {
313 return isnanl (x) || x + x == x;
314 }
315
316 #endif
317
318 #if (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
319
320 /* Converting 'long double' to decimal without rare rounding bugs requires
321 real bignums. We use the naming conventions of GNU gmp, but vastly simpler
322 (and slower) algorithms. */
323
324 typedef unsigned int mp_limb_t;
325 # define GMP_LIMB_BITS 32
326 typedef int mp_limb_verify[2 * (sizeof (mp_limb_t) * CHAR_BIT == GMP_LIMB_BITS) - 1];
327
328 typedef unsigned long long mp_twolimb_t;
329 # define GMP_TWOLIMB_BITS 64
330 typedef int mp_twolimb_verify[2 * (sizeof (mp_twolimb_t) * CHAR_BIT == GMP_TWOLIMB_BITS) - 1];
331
332 /* Representation of a bignum >= 0. */
333 typedef struct
334 {
335 size_t nlimbs;
336 mp_limb_t *limbs; /* Bits in little-endian order, allocated with malloc(). */
337 } mpn_t;
338
339 /* Compute the product of two bignums >= 0.
340 Return the allocated memory in case of success, NULL in case of memory
341 allocation failure. */
342 static void *
multiply(mpn_t src1,mpn_t src2,mpn_t * dest)343 multiply (mpn_t src1, mpn_t src2, mpn_t *dest)
344 {
345 const mp_limb_t *p1;
346 const mp_limb_t *p2;
347 size_t len1;
348 size_t len2;
349
350 if (src1.nlimbs <= src2.nlimbs)
351 {
352 len1 = src1.nlimbs;
353 p1 = src1.limbs;
354 len2 = src2.nlimbs;
355 p2 = src2.limbs;
356 }
357 else
358 {
359 len1 = src2.nlimbs;
360 p1 = src2.limbs;
361 len2 = src1.nlimbs;
362 p2 = src1.limbs;
363 }
364 /* Now 0 <= len1 <= len2. */
365 if (len1 == 0)
366 {
367 /* src1 or src2 is zero. */
368 dest->nlimbs = 0;
369 dest->limbs = (mp_limb_t *) malloc (1);
370 }
371 else
372 {
373 /* Here 1 <= len1 <= len2. */
374 size_t dlen;
375 mp_limb_t *dp;
376 size_t k, i, j;
377
378 dlen = len1 + len2;
379 dp = (mp_limb_t *) malloc (dlen * sizeof (mp_limb_t));
380 if (dp == NULL)
381 return NULL;
382 for (k = len2; k > 0; )
383 dp[--k] = 0;
384 for (i = 0; i < len1; i++)
385 {
386 mp_limb_t digit1 = p1[i];
387 mp_twolimb_t carry = 0;
388 for (j = 0; j < len2; j++)
389 {
390 mp_limb_t digit2 = p2[j];
391 carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
392 carry += dp[i + j];
393 dp[i + j] = (mp_limb_t) carry;
394 carry = carry >> GMP_LIMB_BITS;
395 }
396 dp[i + len2] = (mp_limb_t) carry;
397 }
398 /* Normalise. */
399 while (dlen > 0 && dp[dlen - 1] == 0)
400 dlen--;
401 dest->nlimbs = dlen;
402 dest->limbs = dp;
403 }
404 return dest->limbs;
405 }
406
407 /* Compute the quotient of a bignum a >= 0 and a bignum b > 0.
408 a is written as a = q * b + r with 0 <= r < b. q is the quotient, r
409 the remainder.
410 Finally, round-to-even is performed: If r > b/2 or if r = b/2 and q is odd,
411 q is incremented.
412 Return the allocated memory in case of success, NULL in case of memory
413 allocation failure. */
414 static void *
divide(mpn_t a,mpn_t b,mpn_t * q)415 divide (mpn_t a, mpn_t b, mpn_t *q)
416 {
417 /* Algorithm:
418 First normalise a and b: a=[a[m-1],...,a[0]], b=[b[n-1],...,b[0]]
419 with m>=0 and n>0 (in base beta = 2^GMP_LIMB_BITS).
420 If m<n, then q:=0 and r:=a.
421 If m>=n=1, perform a single-precision division:
422 r:=0, j:=m,
423 while j>0 do
424 {Here (q[m-1]*beta^(m-1)+...+q[j]*beta^j) * b[0] + r*beta^j =
425 = a[m-1]*beta^(m-1)+...+a[j]*beta^j und 0<=r<b[0]<beta}
426 j:=j-1, r:=r*beta+a[j], q[j]:=floor(r/b[0]), r:=r-b[0]*q[j].
427 Normalise [q[m-1],...,q[0]], yields q.
428 If m>=n>1, perform a multiple-precision division:
429 We have a/b < beta^(m-n+1).
430 s:=intDsize-1-(highest bit in b[n-1]), 0<=s<intDsize.
431 Shift a and b left by s bits, copying them. r:=a.
432 r=[r[m],...,r[0]], b=[b[n-1],...,b[0]] with b[n-1]>=beta/2.
433 For j=m-n,...,0: {Here 0 <= r < b*beta^(j+1).}
434 Compute q* :
435 q* := floor((r[j+n]*beta+r[j+n-1])/b[n-1]).
436 In case of overflow (q* >= beta) set q* := beta-1.
437 Compute c2 := ((r[j+n]*beta+r[j+n-1]) - q* * b[n-1])*beta + r[j+n-2]
438 and c3 := b[n-2] * q*.
439 {We have 0 <= c2 < 2*beta^2, even 0 <= c2 < beta^2 if no overflow
440 occurred. Furthermore 0 <= c3 < beta^2.
441 If there was overflow and
442 r[j+n]*beta+r[j+n-1] - q* * b[n-1] >= beta, i.e. c2 >= beta^2,
443 the next test can be skipped.}
444 While c3 > c2, {Here 0 <= c2 < c3 < beta^2}
445 Put q* := q* - 1, c2 := c2 + b[n-1]*beta, c3 := c3 - b[n-2].
446 If q* > 0:
447 Put r := r - b * q* * beta^j. In detail:
448 [r[n+j],...,r[j]] := [r[n+j],...,r[j]] - q* * [b[n-1],...,b[0]].
449 hence: u:=0, for i:=0 to n-1 do
450 u := u + q* * b[i],
451 r[j+i]:=r[j+i]-(u mod beta) (+ beta, if carry),
452 u:=u div beta (+ 1, if carry in subtraction)
453 r[n+j]:=r[n+j]-u.
454 {Since always u = (q* * [b[i-1],...,b[0]] div beta^i) + 1
455 < q* + 1 <= beta,
456 the carry u does not overflow.}
457 If a negative carry occurs, put q* := q* - 1
458 and [r[n+j],...,r[j]] := [r[n+j],...,r[j]] + [0,b[n-1],...,b[0]].
459 Set q[j] := q*.
460 Normalise [q[m-n],..,q[0]]; this yields the quotient q.
461 Shift [r[n-1],...,r[0]] right by s bits and normalise; this yields the
462 rest r.
463 The room for q[j] can be allocated at the memory location of r[n+j].
464 Finally, round-to-even:
465 Shift r left by 1 bit.
466 If r > b or if r = b and q[0] is odd, q := q+1.
467 */
468 const mp_limb_t *a_ptr = a.limbs;
469 size_t a_len = a.nlimbs;
470 const mp_limb_t *b_ptr = b.limbs;
471 size_t b_len = b.nlimbs;
472 mp_limb_t *roomptr;
473 mp_limb_t *tmp_roomptr = NULL;
474 mp_limb_t *q_ptr;
475 size_t q_len;
476 mp_limb_t *r_ptr;
477 size_t r_len;
478
479 /* Allocate room for a_len+2 digits.
480 (Need a_len+1 digits for the real division and 1 more digit for the
481 final rounding of q.) */
482 roomptr = (mp_limb_t *) malloc ((a_len + 2) * sizeof (mp_limb_t));
483 if (roomptr == NULL)
484 return NULL;
485
486 /* Normalise a. */
487 while (a_len > 0 && a_ptr[a_len - 1] == 0)
488 a_len--;
489
490 /* Normalise b. */
491 for (;;)
492 {
493 if (b_len == 0)
494 /* Division by zero. */
495 abort ();
496 if (b_ptr[b_len - 1] == 0)
497 b_len--;
498 else
499 break;
500 }
501
502 /* Here m = a_len >= 0 and n = b_len > 0. */
503
504 if (a_len < b_len)
505 {
506 /* m<n: trivial case. q=0, r := copy of a. */
507 r_ptr = roomptr;
508 r_len = a_len;
509 memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
510 q_ptr = roomptr + a_len;
511 q_len = 0;
512 }
513 else if (b_len == 1)
514 {
515 /* n=1: single precision division.
516 beta^(m-1) <= a < beta^m ==> beta^(m-2) <= a/b < beta^m */
517 r_ptr = roomptr;
518 q_ptr = roomptr + 1;
519 {
520 mp_limb_t den = b_ptr[0];
521 mp_limb_t remainder = 0;
522 const mp_limb_t *sourceptr = a_ptr + a_len;
523 mp_limb_t *destptr = q_ptr + a_len;
524 size_t count;
525 for (count = a_len; count > 0; count--)
526 {
527 mp_twolimb_t num =
528 ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--sourceptr;
529 *--destptr = num / den;
530 remainder = num % den;
531 }
532 /* Normalise and store r. */
533 if (remainder > 0)
534 {
535 r_ptr[0] = remainder;
536 r_len = 1;
537 }
538 else
539 r_len = 0;
540 /* Normalise q. */
541 q_len = a_len;
542 if (q_ptr[q_len - 1] == 0)
543 q_len--;
544 }
545 }
546 else
547 {
548 /* n>1: multiple precision division.
549 beta^(m-1) <= a < beta^m, beta^(n-1) <= b < beta^n ==>
550 beta^(m-n-1) <= a/b < beta^(m-n+1). */
551 /* Determine s. */
552 size_t s;
553 {
554 mp_limb_t msd = b_ptr[b_len - 1]; /* = b[n-1], > 0 */
555 s = 31;
556 if (msd >= 0x10000)
557 {
558 msd = msd >> 16;
559 s -= 16;
560 }
561 if (msd >= 0x100)
562 {
563 msd = msd >> 8;
564 s -= 8;
565 }
566 if (msd >= 0x10)
567 {
568 msd = msd >> 4;
569 s -= 4;
570 }
571 if (msd >= 0x4)
572 {
573 msd = msd >> 2;
574 s -= 2;
575 }
576 if (msd >= 0x2)
577 {
578 msd = msd >> 1;
579 s -= 1;
580 }
581 }
582 /* 0 <= s < GMP_LIMB_BITS.
583 Copy b, shifting it left by s bits. */
584 if (s > 0)
585 {
586 tmp_roomptr = (mp_limb_t *) malloc (b_len * sizeof (mp_limb_t));
587 if (tmp_roomptr == NULL)
588 {
589 free (roomptr);
590 return NULL;
591 }
592 {
593 const mp_limb_t *sourceptr = b_ptr;
594 mp_limb_t *destptr = tmp_roomptr;
595 mp_twolimb_t accu = 0;
596 size_t count;
597 for (count = b_len; count > 0; count--)
598 {
599 accu += (mp_twolimb_t) *sourceptr++ << s;
600 *destptr++ = (mp_limb_t) accu;
601 accu = accu >> GMP_LIMB_BITS;
602 }
603 /* accu must be zero, since that was how s was determined. */
604 if (accu != 0)
605 abort ();
606 }
607 b_ptr = tmp_roomptr;
608 }
609 /* Copy a, shifting it left by s bits, yields r.
610 Memory layout:
611 At the beginning: r = roomptr[0..a_len],
612 at the end: r = roomptr[0..b_len-1], q = roomptr[b_len..a_len] */
613 r_ptr = roomptr;
614 if (s == 0)
615 {
616 memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));
617 r_ptr[a_len] = 0;
618 }
619 else
620 {
621 const mp_limb_t *sourceptr = a_ptr;
622 mp_limb_t *destptr = r_ptr;
623 mp_twolimb_t accu = 0;
624 size_t count;
625 for (count = a_len; count > 0; count--)
626 {
627 accu += (mp_twolimb_t) *sourceptr++ << s;
628 *destptr++ = (mp_limb_t) accu;
629 accu = accu >> GMP_LIMB_BITS;
630 }
631 *destptr++ = (mp_limb_t) accu;
632 }
633 q_ptr = roomptr + b_len;
634 q_len = a_len - b_len + 1; /* q will have m-n+1 limbs */
635 {
636 size_t j = a_len - b_len; /* m-n */
637 mp_limb_t b_msd = b_ptr[b_len - 1]; /* b[n-1] */
638 mp_limb_t b_2msd = b_ptr[b_len - 2]; /* b[n-2] */
639 mp_twolimb_t b_msdd = /* b[n-1]*beta+b[n-2] */
640 ((mp_twolimb_t) b_msd << GMP_LIMB_BITS) | b_2msd;
641 /* Division loop, traversed m-n+1 times.
642 j counts down, b is unchanged, beta/2 <= b[n-1] < beta. */
643 for (;;)
644 {
645 mp_limb_t q_star;
646 mp_limb_t c1;
647 if (r_ptr[j + b_len] < b_msd) /* r[j+n] < b[n-1] ? */
648 {
649 /* Divide r[j+n]*beta+r[j+n-1] by b[n-1], no overflow. */
650 mp_twolimb_t num =
651 ((mp_twolimb_t) r_ptr[j + b_len] << GMP_LIMB_BITS)
652 | r_ptr[j + b_len - 1];
653 q_star = num / b_msd;
654 c1 = num % b_msd;
655 }
656 else
657 {
658 /* Overflow, hence r[j+n]*beta+r[j+n-1] >= beta*b[n-1]. */
659 q_star = (mp_limb_t)~(mp_limb_t)0; /* q* = beta-1 */
660 /* Test whether r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] >= beta
661 <==> r[j+n]*beta+r[j+n-1] + b[n-1] >= beta*b[n-1]+beta
662 <==> b[n-1] < floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta)
663 {<= beta !}.
664 If yes, jump directly to the subtraction loop.
665 (Otherwise, r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] < beta
666 <==> floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta) = b[n-1] ) */
667 if (r_ptr[j + b_len] > b_msd
668 || (c1 = r_ptr[j + b_len - 1] + b_msd) < b_msd)
669 /* r[j+n] >= b[n-1]+1 or
670 r[j+n] = b[n-1] and the addition r[j+n-1]+b[n-1] gives a
671 carry. */
672 goto subtract;
673 }
674 /* q_star = q*,
675 c1 = (r[j+n]*beta+r[j+n-1]) - q* * b[n-1] (>=0, <beta). */
676 {
677 mp_twolimb_t c2 = /* c1*beta+r[j+n-2] */
678 ((mp_twolimb_t) c1 << GMP_LIMB_BITS) | r_ptr[j + b_len - 2];
679 mp_twolimb_t c3 = /* b[n-2] * q* */
680 (mp_twolimb_t) b_2msd * (mp_twolimb_t) q_star;
681 /* While c2 < c3, increase c2 and decrease c3.
682 Consider c3-c2. While it is > 0, decrease it by
683 b[n-1]*beta+b[n-2]. Because of b[n-1]*beta+b[n-2] >= beta^2/2
684 this can happen only twice. */
685 if (c3 > c2)
686 {
687 q_star = q_star - 1; /* q* := q* - 1 */
688 if (c3 - c2 > b_msdd)
689 q_star = q_star - 1; /* q* := q* - 1 */
690 }
691 }
692 if (q_star > 0)
693 subtract:
694 {
695 /* Subtract r := r - b * q* * beta^j. */
696 mp_limb_t cr;
697 {
698 const mp_limb_t *sourceptr = b_ptr;
699 mp_limb_t *destptr = r_ptr + j;
700 mp_twolimb_t carry = 0;
701 size_t count;
702 for (count = b_len; count > 0; count--)
703 {
704 /* Here 0 <= carry <= q*. */
705 carry =
706 carry
707 + (mp_twolimb_t) q_star * (mp_twolimb_t) *sourceptr++
708 + (mp_limb_t) ~(*destptr);
709 /* Here 0 <= carry <= beta*q* + beta-1. */
710 *destptr++ = ~(mp_limb_t) carry;
711 carry = carry >> GMP_LIMB_BITS; /* <= q* */
712 }
713 cr = (mp_limb_t) carry;
714 }
715 /* Subtract cr from r_ptr[j + b_len], then forget about
716 r_ptr[j + b_len]. */
717 if (cr > r_ptr[j + b_len])
718 {
719 /* Subtraction gave a carry. */
720 q_star = q_star - 1; /* q* := q* - 1 */
721 /* Add b back. */
722 {
723 const mp_limb_t *sourceptr = b_ptr;
724 mp_limb_t *destptr = r_ptr + j;
725 mp_limb_t carry = 0;
726 size_t count;
727 for (count = b_len; count > 0; count--)
728 {
729 mp_limb_t source1 = *sourceptr++;
730 mp_limb_t source2 = *destptr;
731 *destptr++ = source1 + source2 + carry;
732 carry =
733 (carry
734 ? source1 >= (mp_limb_t) ~source2
735 : source1 > (mp_limb_t) ~source2);
736 }
737 }
738 /* Forget about the carry and about r[j+n]. */
739 }
740 }
741 /* q* is determined. Store it as q[j]. */
742 q_ptr[j] = q_star;
743 if (j == 0)
744 break;
745 j--;
746 }
747 }
748 r_len = b_len;
749 /* Normalise q. */
750 if (q_ptr[q_len - 1] == 0)
751 q_len--;
752 # if 0 /* Not needed here, since we need r only to compare it with b/2, and
753 b is shifted left by s bits. */
754 /* Shift r right by s bits. */
755 if (s > 0)
756 {
757 mp_limb_t ptr = r_ptr + r_len;
758 mp_twolimb_t accu = 0;
759 size_t count;
760 for (count = r_len; count > 0; count--)
761 {
762 accu = (mp_twolimb_t) (mp_limb_t) accu << GMP_LIMB_BITS;
763 accu += (mp_twolimb_t) *--ptr << (GMP_LIMB_BITS - s);
764 *ptr = (mp_limb_t) (accu >> GMP_LIMB_BITS);
765 }
766 }
767 # endif
768 /* Normalise r. */
769 while (r_len > 0 && r_ptr[r_len - 1] == 0)
770 r_len--;
771 }
772 /* Compare r << 1 with b. */
773 if (r_len > b_len)
774 goto increment_q;
775 {
776 size_t i;
777 for (i = b_len;;)
778 {
779 mp_limb_t r_i =
780 (i <= r_len && i > 0 ? r_ptr[i - 1] >> (GMP_LIMB_BITS - 1) : 0)
781 | (i < r_len ? r_ptr[i] << 1 : 0);
782 mp_limb_t b_i = (i < b_len ? b_ptr[i] : 0);
783 if (r_i > b_i)
784 goto increment_q;
785 if (r_i < b_i)
786 goto keep_q;
787 if (i == 0)
788 break;
789 i--;
790 }
791 }
792 if (q_len > 0 && ((q_ptr[0] & 1) != 0))
793 /* q is odd. */
794 increment_q:
795 {
796 size_t i;
797 for (i = 0; i < q_len; i++)
798 if (++(q_ptr[i]) != 0)
799 goto keep_q;
800 q_ptr[q_len++] = 1;
801 }
802 keep_q:
803 if (tmp_roomptr != NULL)
804 free (tmp_roomptr);
805 q->limbs = q_ptr;
806 q->nlimbs = q_len;
807 return roomptr;
808 }
809
810 /* Convert a bignum a >= 0, multiplied with 10^extra_zeroes, to decimal
811 representation.
812 Destroys the contents of a.
813 Return the allocated memory - containing the decimal digits in low-to-high
814 order, terminated with a NUL character - in case of success, NULL in case
815 of memory allocation failure. */
816 static char *
convert_to_decimal(mpn_t a,size_t extra_zeroes)817 convert_to_decimal (mpn_t a, size_t extra_zeroes)
818 {
819 mp_limb_t *a_ptr = a.limbs;
820 size_t a_len = a.nlimbs;
821 /* 0.03345 is slightly larger than log(2)/(9*log(10)). */
822 size_t c_len = 9 * ((size_t)(a_len * (GMP_LIMB_BITS * 0.03345f)) + 1);
823 char *c_ptr = (char *) malloc (xsum (c_len, extra_zeroes));
824 if (c_ptr != NULL)
825 {
826 char *d_ptr = c_ptr;
827 for (; extra_zeroes > 0; extra_zeroes--)
828 *d_ptr++ = '0';
829 while (a_len > 0)
830 {
831 /* Divide a by 10^9, in-place. */
832 mp_limb_t remainder = 0;
833 mp_limb_t *ptr = a_ptr + a_len;
834 size_t count;
835 for (count = a_len; count > 0; count--)
836 {
837 mp_twolimb_t num =
838 ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--ptr;
839 *ptr = num / 1000000000;
840 remainder = num % 1000000000;
841 }
842 /* Store the remainder as 9 decimal digits. */
843 for (count = 9; count > 0; count--)
844 {
845 *d_ptr++ = '0' + (remainder % 10);
846 remainder = remainder / 10;
847 }
848 /* Normalize a. */
849 if (a_ptr[a_len - 1] == 0)
850 a_len--;
851 }
852 /* Remove leading zeroes. */
853 while (d_ptr > c_ptr && d_ptr[-1] == '0')
854 d_ptr--;
855 /* But keep at least one zero. */
856 if (d_ptr == c_ptr)
857 *d_ptr++ = '0';
858 /* Terminate the string. */
859 *d_ptr = '\0';
860 }
861 return c_ptr;
862 }
863
864 # if NEED_PRINTF_LONG_DOUBLE
865
866 /* Assuming x is finite and >= 0:
867 write x as x = 2^e * m, where m is a bignum.
868 Return the allocated memory in case of success, NULL in case of memory
869 allocation failure. */
870 static void *
decode_long_double(long double x,int * ep,mpn_t * mp)871 decode_long_double (long double x, int *ep, mpn_t *mp)
872 {
873 mpn_t m;
874 int exp;
875 long double y;
876 size_t i;
877
878 /* Allocate memory for result. */
879 m.nlimbs = (LDBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
880 m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
881 if (m.limbs == NULL)
882 return NULL;
883 /* Split into exponential part and mantissa. */
884 y = frexpl (x, &exp);
885 if (!(y >= 0.0L && y < 1.0L))
886 abort ();
887 /* x = 2^exp * y = 2^(exp - LDBL_MANT_BIT) * (y * LDBL_MANT_BIT), and the
888 latter is an integer. */
889 /* Convert the mantissa (y * LDBL_MANT_BIT) to a sequence of limbs.
890 I'm not sure whether it's safe to cast a 'long double' value between
891 2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
892 'long double' values between 0 and 2^16 (to 'unsigned int' or 'int',
893 doesn't matter). */
894 # if (LDBL_MANT_BIT % GMP_LIMB_BITS) != 0
895 # if (LDBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
896 {
897 mp_limb_t hi, lo;
898 y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % (GMP_LIMB_BITS / 2));
899 hi = (int) y;
900 y -= hi;
901 if (!(y >= 0.0L && y < 1.0L))
902 abort ();
903 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
904 lo = (int) y;
905 y -= lo;
906 if (!(y >= 0.0L && y < 1.0L))
907 abort ();
908 m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
909 }
910 # else
911 {
912 mp_limb_t d;
913 y *= (mp_limb_t) 1 << (LDBL_MANT_BIT % GMP_LIMB_BITS);
914 d = (int) y;
915 y -= d;
916 if (!(y >= 0.0L && y < 1.0L))
917 abort ();
918 m.limbs[LDBL_MANT_BIT / GMP_LIMB_BITS] = d;
919 }
920 # endif
921 # endif
922 for (i = LDBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
923 {
924 mp_limb_t hi, lo;
925 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
926 hi = (int) y;
927 y -= hi;
928 if (!(y >= 0.0L && y < 1.0L))
929 abort ();
930 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
931 lo = (int) y;
932 y -= lo;
933 if (!(y >= 0.0L && y < 1.0L))
934 abort ();
935 m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
936 }
937 #if 0 /* On FreeBSD 6.1/x86, 'long double' numbers sometimes have excess
938 precision. */
939 if (!(y == 0.0L))
940 abort ();
941 #endif
942 /* Normalise. */
943 while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
944 m.nlimbs--;
945 *mp = m;
946 *ep = exp - LDBL_MANT_BIT;
947 return m.limbs;
948 }
949
950 # endif
951
952 # if NEED_PRINTF_DOUBLE
953
954 /* Assuming x is finite and >= 0:
955 write x as x = 2^e * m, where m is a bignum.
956 Return the allocated memory in case of success, NULL in case of memory
957 allocation failure. */
958 static void *
decode_double(double x,int * ep,mpn_t * mp)959 decode_double (double x, int *ep, mpn_t *mp)
960 {
961 mpn_t m;
962 int exp;
963 double y;
964 size_t i;
965
966 /* Allocate memory for result. */
967 m.nlimbs = (DBL_MANT_BIT + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
968 m.limbs = (mp_limb_t *) malloc (m.nlimbs * sizeof (mp_limb_t));
969 if (m.limbs == NULL)
970 return NULL;
971 /* Split into exponential part and mantissa. */
972 y = frexp (x, &exp);
973 if (!(y >= 0.0 && y < 1.0))
974 abort ();
975 /* x = 2^exp * y = 2^(exp - DBL_MANT_BIT) * (y * DBL_MANT_BIT), and the
976 latter is an integer. */
977 /* Convert the mantissa (y * DBL_MANT_BIT) to a sequence of limbs.
978 I'm not sure whether it's safe to cast a 'double' value between
979 2^31 and 2^32 to 'unsigned int', therefore play safe and cast only
980 'double' values between 0 and 2^16 (to 'unsigned int' or 'int',
981 doesn't matter). */
982 # if (DBL_MANT_BIT % GMP_LIMB_BITS) != 0
983 # if (DBL_MANT_BIT % GMP_LIMB_BITS) > GMP_LIMB_BITS / 2
984 {
985 mp_limb_t hi, lo;
986 y *= (mp_limb_t) 1 << (DBL_MANT_BIT % (GMP_LIMB_BITS / 2));
987 hi = (int) y;
988 y -= hi;
989 if (!(y >= 0.0 && y < 1.0))
990 abort ();
991 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
992 lo = (int) y;
993 y -= lo;
994 if (!(y >= 0.0 && y < 1.0))
995 abort ();
996 m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = (hi << (GMP_LIMB_BITS / 2)) | lo;
997 }
998 # else
999 {
1000 mp_limb_t d;
1001 y *= (mp_limb_t) 1 << (DBL_MANT_BIT % GMP_LIMB_BITS);
1002 d = (int) y;
1003 y -= d;
1004 if (!(y >= 0.0 && y < 1.0))
1005 abort ();
1006 m.limbs[DBL_MANT_BIT / GMP_LIMB_BITS] = d;
1007 }
1008 # endif
1009 # endif
1010 for (i = DBL_MANT_BIT / GMP_LIMB_BITS; i > 0; )
1011 {
1012 mp_limb_t hi, lo;
1013 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
1014 hi = (int) y;
1015 y -= hi;
1016 if (!(y >= 0.0 && y < 1.0))
1017 abort ();
1018 y *= (mp_limb_t) 1 << (GMP_LIMB_BITS / 2);
1019 lo = (int) y;
1020 y -= lo;
1021 if (!(y >= 0.0 && y < 1.0))
1022 abort ();
1023 m.limbs[--i] = (hi << (GMP_LIMB_BITS / 2)) | lo;
1024 }
1025 if (!(y == 0.0))
1026 abort ();
1027 /* Normalise. */
1028 while (m.nlimbs > 0 && m.limbs[m.nlimbs - 1] == 0)
1029 m.nlimbs--;
1030 *mp = m;
1031 *ep = exp - DBL_MANT_BIT;
1032 return m.limbs;
1033 }
1034
1035 # endif
1036
1037 /* Assuming x = 2^e * m is finite and >= 0, and n is an integer:
1038 Returns the decimal representation of round (x * 10^n).
1039 Return the allocated memory - containing the decimal digits in low-to-high
1040 order, terminated with a NUL character - in case of success, NULL in case
1041 of memory allocation failure. */
1042 static char *
scale10_round_decimal_decoded(int e,mpn_t m,void * memory,int n)1043 scale10_round_decimal_decoded (int e, mpn_t m, void *memory, int n)
1044 {
1045 int s;
1046 size_t extra_zeroes;
1047 unsigned int abs_n;
1048 unsigned int abs_s;
1049 mp_limb_t *pow5_ptr;
1050 size_t pow5_len;
1051 unsigned int s_limbs;
1052 unsigned int s_bits;
1053 mpn_t pow5;
1054 mpn_t z;
1055 void *z_memory;
1056 char *digits;
1057
1058 if (memory == NULL)
1059 return NULL;
1060 /* x = 2^e * m, hence
1061 y = round (2^e * 10^n * m) = round (2^(e+n) * 5^n * m)
1062 = round (2^s * 5^n * m). */
1063 s = e + n;
1064 extra_zeroes = 0;
1065 /* Factor out a common power of 10 if possible. */
1066 if (s > 0 && n > 0)
1067 {
1068 extra_zeroes = (s < n ? s : n);
1069 s -= extra_zeroes;
1070 n -= extra_zeroes;
1071 }
1072 /* Here y = round (2^s * 5^n * m) * 10^extra_zeroes.
1073 Before converting to decimal, we need to compute
1074 z = round (2^s * 5^n * m). */
1075 /* Compute 5^|n|, possibly shifted by |s| bits if n and s have the same
1076 sign. 2.322 is slightly larger than log(5)/log(2). */
1077 abs_n = (n >= 0 ? n : -n);
1078 abs_s = (s >= 0 ? s : -s);
1079 pow5_ptr = (mp_limb_t *) malloc (((int)(abs_n * (2.322f / GMP_LIMB_BITS)) + 1
1080 + abs_s / GMP_LIMB_BITS + 1)
1081 * sizeof (mp_limb_t));
1082 if (pow5_ptr == NULL)
1083 {
1084 free (memory);
1085 return NULL;
1086 }
1087 /* Initialize with 1. */
1088 pow5_ptr[0] = 1;
1089 pow5_len = 1;
1090 /* Multiply with 5^|n|. */
1091 if (abs_n > 0)
1092 {
1093 static mp_limb_t const small_pow5[13 + 1] =
1094 {
1095 1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625,
1096 48828125, 244140625, 1220703125
1097 };
1098 unsigned int n13;
1099 for (n13 = 0; n13 <= abs_n; n13 += 13)
1100 {
1101 mp_limb_t digit1 = small_pow5[n13 + 13 <= abs_n ? 13 : abs_n - n13];
1102 size_t j;
1103 mp_twolimb_t carry = 0;
1104 for (j = 0; j < pow5_len; j++)
1105 {
1106 mp_limb_t digit2 = pow5_ptr[j];
1107 carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;
1108 pow5_ptr[j] = (mp_limb_t) carry;
1109 carry = carry >> GMP_LIMB_BITS;
1110 }
1111 if (carry > 0)
1112 pow5_ptr[pow5_len++] = (mp_limb_t) carry;
1113 }
1114 }
1115 s_limbs = abs_s / GMP_LIMB_BITS;
1116 s_bits = abs_s % GMP_LIMB_BITS;
1117 if (n >= 0 ? s >= 0 : s <= 0)
1118 {
1119 /* Multiply with 2^|s|. */
1120 if (s_bits > 0)
1121 {
1122 mp_limb_t *ptr = pow5_ptr;
1123 mp_twolimb_t accu = 0;
1124 size_t count;
1125 for (count = pow5_len; count > 0; count--)
1126 {
1127 accu += (mp_twolimb_t) *ptr << s_bits;
1128 *ptr++ = (mp_limb_t) accu;
1129 accu = accu >> GMP_LIMB_BITS;
1130 }
1131 if (accu > 0)
1132 {
1133 *ptr = (mp_limb_t) accu;
1134 pow5_len++;
1135 }
1136 }
1137 if (s_limbs > 0)
1138 {
1139 size_t count;
1140 for (count = pow5_len; count > 0;)
1141 {
1142 count--;
1143 pow5_ptr[s_limbs + count] = pow5_ptr[count];
1144 }
1145 for (count = s_limbs; count > 0;)
1146 {
1147 count--;
1148 pow5_ptr[count] = 0;
1149 }
1150 pow5_len += s_limbs;
1151 }
1152 pow5.limbs = pow5_ptr;
1153 pow5.nlimbs = pow5_len;
1154 if (n >= 0)
1155 {
1156 /* Multiply m with pow5. No division needed. */
1157 z_memory = multiply (m, pow5, &z);
1158 }
1159 else
1160 {
1161 /* Divide m by pow5 and round. */
1162 z_memory = divide (m, pow5, &z);
1163 }
1164 }
1165 else
1166 {
1167 pow5.limbs = pow5_ptr;
1168 pow5.nlimbs = pow5_len;
1169 if (n >= 0)
1170 {
1171 /* n >= 0, s < 0.
1172 Multiply m with pow5, then divide by 2^|s|. */
1173 mpn_t numerator;
1174 mpn_t denominator;
1175 void *tmp_memory;
1176 tmp_memory = multiply (m, pow5, &numerator);
1177 if (tmp_memory == NULL)
1178 {
1179 free (pow5_ptr);
1180 free (memory);
1181 return NULL;
1182 }
1183 /* Construct 2^|s|. */
1184 {
1185 mp_limb_t *ptr = pow5_ptr + pow5_len;
1186 size_t i;
1187 for (i = 0; i < s_limbs; i++)
1188 ptr[i] = 0;
1189 ptr[s_limbs] = (mp_limb_t) 1 << s_bits;
1190 denominator.limbs = ptr;
1191 denominator.nlimbs = s_limbs + 1;
1192 }
1193 z_memory = divide (numerator, denominator, &z);
1194 free (tmp_memory);
1195 }
1196 else
1197 {
1198 /* n < 0, s > 0.
1199 Multiply m with 2^s, then divide by pow5. */
1200 mpn_t numerator;
1201 mp_limb_t *num_ptr;
1202 num_ptr = (mp_limb_t *) malloc ((m.nlimbs + s_limbs + 1)
1203 * sizeof (mp_limb_t));
1204 if (num_ptr == NULL)
1205 {
1206 free (pow5_ptr);
1207 free (memory);
1208 return NULL;
1209 }
1210 {
1211 mp_limb_t *destptr = num_ptr;
1212 {
1213 size_t i;
1214 for (i = 0; i < s_limbs; i++)
1215 *destptr++ = 0;
1216 }
1217 if (s_bits > 0)
1218 {
1219 const mp_limb_t *sourceptr = m.limbs;
1220 mp_twolimb_t accu = 0;
1221 size_t count;
1222 for (count = m.nlimbs; count > 0; count--)
1223 {
1224 accu += (mp_twolimb_t) *sourceptr++ << s_bits;
1225 *destptr++ = (mp_limb_t) accu;
1226 accu = accu >> GMP_LIMB_BITS;
1227 }
1228 if (accu > 0)
1229 *destptr++ = (mp_limb_t) accu;
1230 }
1231 else
1232 {
1233 const mp_limb_t *sourceptr = m.limbs;
1234 size_t count;
1235 for (count = m.nlimbs; count > 0; count--)
1236 *destptr++ = *sourceptr++;
1237 }
1238 numerator.limbs = num_ptr;
1239 numerator.nlimbs = destptr - num_ptr;
1240 }
1241 z_memory = divide (numerator, pow5, &z);
1242 free (num_ptr);
1243 }
1244 }
1245 free (pow5_ptr);
1246 free (memory);
1247
1248 /* Here y = round (x * 10^n) = z * 10^extra_zeroes. */
1249
1250 if (z_memory == NULL)
1251 return NULL;
1252 digits = convert_to_decimal (z, extra_zeroes);
1253 free (z_memory);
1254 return digits;
1255 }
1256
1257 # if NEED_PRINTF_LONG_DOUBLE
1258
1259 /* Assuming x is finite and >= 0, and n is an integer:
1260 Returns the decimal representation of round (x * 10^n).
1261 Return the allocated memory - containing the decimal digits in low-to-high
1262 order, terminated with a NUL character - in case of success, NULL in case
1263 of memory allocation failure. */
1264 static char *
scale10_round_decimal_long_double(long double x,int n)1265 scale10_round_decimal_long_double (long double x, int n)
1266 {
1267 int e IF_LINT(= 0);
1268 mpn_t m;
1269 void *memory = decode_long_double (x, &e, &m);
1270 return scale10_round_decimal_decoded (e, m, memory, n);
1271 }
1272
1273 # endif
1274
1275 # if NEED_PRINTF_DOUBLE
1276
1277 /* Assuming x is finite and >= 0, and n is an integer:
1278 Returns the decimal representation of round (x * 10^n).
1279 Return the allocated memory - containing the decimal digits in low-to-high
1280 order, terminated with a NUL character - in case of success, NULL in case
1281 of memory allocation failure. */
1282 static char *
scale10_round_decimal_double(double x,int n)1283 scale10_round_decimal_double (double x, int n)
1284 {
1285 int e IF_LINT(= 0);
1286 mpn_t m;
1287 void *memory = decode_double (x, &e, &m);
1288 return scale10_round_decimal_decoded (e, m, memory, n);
1289 }
1290
1291 # endif
1292
1293 # if NEED_PRINTF_LONG_DOUBLE
1294
1295 /* Assuming x is finite and > 0:
1296 Return an approximation for n with 10^n <= x < 10^(n+1).
1297 The approximation is usually the right n, but may be off by 1 sometimes. */
1298 static int
floorlog10l(long double x)1299 floorlog10l (long double x)
1300 {
1301 int exp;
1302 long double y;
1303 double z;
1304 double l;
1305
1306 /* Split into exponential part and mantissa. */
1307 y = frexpl (x, &exp);
1308 if (!(y >= 0.0L && y < 1.0L))
1309 abort ();
1310 if (y == 0.0L)
1311 return INT_MIN;
1312 if (y < 0.5L)
1313 {
1314 while (y < (1.0L / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
1315 {
1316 y *= 1.0L * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
1317 exp -= GMP_LIMB_BITS;
1318 }
1319 if (y < (1.0L / (1 << 16)))
1320 {
1321 y *= 1.0L * (1 << 16);
1322 exp -= 16;
1323 }
1324 if (y < (1.0L / (1 << 8)))
1325 {
1326 y *= 1.0L * (1 << 8);
1327 exp -= 8;
1328 }
1329 if (y < (1.0L / (1 << 4)))
1330 {
1331 y *= 1.0L * (1 << 4);
1332 exp -= 4;
1333 }
1334 if (y < (1.0L / (1 << 2)))
1335 {
1336 y *= 1.0L * (1 << 2);
1337 exp -= 2;
1338 }
1339 if (y < (1.0L / (1 << 1)))
1340 {
1341 y *= 1.0L * (1 << 1);
1342 exp -= 1;
1343 }
1344 }
1345 if (!(y >= 0.5L && y < 1.0L))
1346 abort ();
1347 /* Compute an approximation for l = log2(x) = exp + log2(y). */
1348 l = exp;
1349 z = y;
1350 if (z < 0.70710678118654752444)
1351 {
1352 z *= 1.4142135623730950488;
1353 l -= 0.5;
1354 }
1355 if (z < 0.8408964152537145431)
1356 {
1357 z *= 1.1892071150027210667;
1358 l -= 0.25;
1359 }
1360 if (z < 0.91700404320467123175)
1361 {
1362 z *= 1.0905077326652576592;
1363 l -= 0.125;
1364 }
1365 if (z < 0.9576032806985736469)
1366 {
1367 z *= 1.0442737824274138403;
1368 l -= 0.0625;
1369 }
1370 /* Now 0.95 <= z <= 1.01. */
1371 z = 1 - z;
1372 /* log2(1-z) = 1/log(2) * (- z - z^2/2 - z^3/3 - z^4/4 - ...)
1373 Four terms are enough to get an approximation with error < 10^-7. */
1374 l -= 1.4426950408889634074 * z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
1375 /* Finally multiply with log(2)/log(10), yields an approximation for
1376 log10(x). */
1377 l *= 0.30102999566398119523;
1378 /* Round down to the next integer. */
1379 return (int) l + (l < 0 ? -1 : 0);
1380 }
1381
1382 # endif
1383
1384 # if NEED_PRINTF_DOUBLE
1385
1386 /* Assuming x is finite and > 0:
1387 Return an approximation for n with 10^n <= x < 10^(n+1).
1388 The approximation is usually the right n, but may be off by 1 sometimes. */
1389 static int
floorlog10(double x)1390 floorlog10 (double x)
1391 {
1392 int exp;
1393 double y;
1394 double z;
1395 double l;
1396
1397 /* Split into exponential part and mantissa. */
1398 y = frexp (x, &exp);
1399 if (!(y >= 0.0 && y < 1.0))
1400 abort ();
1401 if (y == 0.0)
1402 return INT_MIN;
1403 if (y < 0.5)
1404 {
1405 while (y < (1.0 / (1 << (GMP_LIMB_BITS / 2)) / (1 << (GMP_LIMB_BITS / 2))))
1406 {
1407 y *= 1.0 * (1 << (GMP_LIMB_BITS / 2)) * (1 << (GMP_LIMB_BITS / 2));
1408 exp -= GMP_LIMB_BITS;
1409 }
1410 if (y < (1.0 / (1 << 16)))
1411 {
1412 y *= 1.0 * (1 << 16);
1413 exp -= 16;
1414 }
1415 if (y < (1.0 / (1 << 8)))
1416 {
1417 y *= 1.0 * (1 << 8);
1418 exp -= 8;
1419 }
1420 if (y < (1.0 / (1 << 4)))
1421 {
1422 y *= 1.0 * (1 << 4);
1423 exp -= 4;
1424 }
1425 if (y < (1.0 / (1 << 2)))
1426 {
1427 y *= 1.0 * (1 << 2);
1428 exp -= 2;
1429 }
1430 if (y < (1.0 / (1 << 1)))
1431 {
1432 y *= 1.0 * (1 << 1);
1433 exp -= 1;
1434 }
1435 }
1436 if (!(y >= 0.5 && y < 1.0))
1437 abort ();
1438 /* Compute an approximation for l = log2(x) = exp + log2(y). */
1439 l = exp;
1440 z = y;
1441 if (z < 0.70710678118654752444)
1442 {
1443 z *= 1.4142135623730950488;
1444 l -= 0.5;
1445 }
1446 if (z < 0.8408964152537145431)
1447 {
1448 z *= 1.1892071150027210667;
1449 l -= 0.25;
1450 }
1451 if (z < 0.91700404320467123175)
1452 {
1453 z *= 1.0905077326652576592;
1454 l -= 0.125;
1455 }
1456 if (z < 0.9576032806985736469)
1457 {
1458 z *= 1.0442737824274138403;
1459 l -= 0.0625;
1460 }
1461 /* Now 0.95 <= z <= 1.01. */
1462 z = 1 - z;
1463 /* log2(1-z) = 1/log(2) * (- z - z^2/2 - z^3/3 - z^4/4 - ...)
1464 Four terms are enough to get an approximation with error < 10^-7. */
1465 l -= 1.4426950408889634074 * z * (1.0 + z * (0.5 + z * ((1.0 / 3) + z * 0.25)));
1466 /* Finally multiply with log(2)/log(10), yields an approximation for
1467 log10(x). */
1468 l *= 0.30102999566398119523;
1469 /* Round down to the next integer. */
1470 return (int) l + (l < 0 ? -1 : 0);
1471 }
1472
1473 # endif
1474
1475 /* Tests whether a string of digits consists of exactly PRECISION zeroes and
1476 a single '1' digit. */
1477 static int
is_borderline(const char * digits,size_t precision)1478 is_borderline (const char *digits, size_t precision)
1479 {
1480 for (; precision > 0; precision--, digits++)
1481 if (*digits != '0')
1482 return 0;
1483 if (*digits != '1')
1484 return 0;
1485 digits++;
1486 return *digits == '\0';
1487 }
1488
1489 #endif
1490
1491 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99
1492
1493 /* Use a different function name, to make it possible that the 'wchar_t'
1494 parametrization and the 'char' parametrization get compiled in the same
1495 translation unit. */
1496 # if WIDE_CHAR_VERSION
1497 # define MAX_ROOM_NEEDED wmax_room_needed
1498 # else
1499 # define MAX_ROOM_NEEDED max_room_needed
1500 # endif
1501
1502 /* Returns the number of TCHAR_T units needed as temporary space for the result
1503 of sprintf or SNPRINTF of a single conversion directive. */
1504 static inline size_t
MAX_ROOM_NEEDED(const arguments * ap,size_t arg_index,FCHAR_T conversion,arg_type type,int flags,size_t width,int has_precision,size_t precision,int pad_ourselves)1505 MAX_ROOM_NEEDED (const arguments *ap, size_t arg_index, FCHAR_T conversion,
1506 arg_type type, int flags, size_t width, int has_precision,
1507 size_t precision, int pad_ourselves)
1508 {
1509 size_t tmp_length;
1510
1511 switch (conversion)
1512 {
1513 case 'd': case 'i': case 'u':
1514 # if HAVE_LONG_LONG_INT
1515 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1516 tmp_length =
1517 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1518 * 0.30103 /* binary -> decimal */
1519 )
1520 + 1; /* turn floor into ceil */
1521 else
1522 # endif
1523 if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1524 tmp_length =
1525 (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1526 * 0.30103 /* binary -> decimal */
1527 )
1528 + 1; /* turn floor into ceil */
1529 else
1530 tmp_length =
1531 (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1532 * 0.30103 /* binary -> decimal */
1533 )
1534 + 1; /* turn floor into ceil */
1535 if (tmp_length < precision)
1536 tmp_length = precision;
1537 /* Multiply by 2, as an estimate for FLAG_GROUP. */
1538 tmp_length = xsum (tmp_length, tmp_length);
1539 /* Add 1, to account for a leading sign. */
1540 tmp_length = xsum (tmp_length, 1);
1541 break;
1542
1543 case 'o':
1544 # if HAVE_LONG_LONG_INT
1545 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1546 tmp_length =
1547 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1548 * 0.333334 /* binary -> octal */
1549 )
1550 + 1; /* turn floor into ceil */
1551 else
1552 # endif
1553 if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1554 tmp_length =
1555 (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1556 * 0.333334 /* binary -> octal */
1557 )
1558 + 1; /* turn floor into ceil */
1559 else
1560 tmp_length =
1561 (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1562 * 0.333334 /* binary -> octal */
1563 )
1564 + 1; /* turn floor into ceil */
1565 if (tmp_length < precision)
1566 tmp_length = precision;
1567 /* Add 1, to account for a leading sign. */
1568 tmp_length = xsum (tmp_length, 1);
1569 break;
1570
1571 case 'x': case 'X':
1572 # if HAVE_LONG_LONG_INT
1573 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
1574 tmp_length =
1575 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
1576 * 0.25 /* binary -> hexadecimal */
1577 )
1578 + 1; /* turn floor into ceil */
1579 else
1580 # endif
1581 if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
1582 tmp_length =
1583 (unsigned int) (sizeof (unsigned long) * CHAR_BIT
1584 * 0.25 /* binary -> hexadecimal */
1585 )
1586 + 1; /* turn floor into ceil */
1587 else
1588 tmp_length =
1589 (unsigned int) (sizeof (unsigned int) * CHAR_BIT
1590 * 0.25 /* binary -> hexadecimal */
1591 )
1592 + 1; /* turn floor into ceil */
1593 if (tmp_length < precision)
1594 tmp_length = precision;
1595 /* Add 2, to account for a leading sign or alternate form. */
1596 tmp_length = xsum (tmp_length, 2);
1597 break;
1598
1599 case 'f': case 'F':
1600 if (type == TYPE_LONGDOUBLE)
1601 tmp_length =
1602 (unsigned int) (LDBL_MAX_EXP
1603 * 0.30103 /* binary -> decimal */
1604 * 2 /* estimate for FLAG_GROUP */
1605 )
1606 + 1 /* turn floor into ceil */
1607 + 10; /* sign, decimal point etc. */
1608 else
1609 tmp_length =
1610 (unsigned int) (DBL_MAX_EXP
1611 * 0.30103 /* binary -> decimal */
1612 * 2 /* estimate for FLAG_GROUP */
1613 )
1614 + 1 /* turn floor into ceil */
1615 + 10; /* sign, decimal point etc. */
1616 tmp_length = xsum (tmp_length, precision);
1617 break;
1618
1619 case 'e': case 'E': case 'g': case 'G':
1620 tmp_length =
1621 12; /* sign, decimal point, exponent etc. */
1622 tmp_length = xsum (tmp_length, precision);
1623 break;
1624
1625 case 'a': case 'A':
1626 if (type == TYPE_LONGDOUBLE)
1627 tmp_length =
1628 (unsigned int) (LDBL_DIG
1629 * 0.831 /* decimal -> hexadecimal */
1630 )
1631 + 1; /* turn floor into ceil */
1632 else
1633 tmp_length =
1634 (unsigned int) (DBL_DIG
1635 * 0.831 /* decimal -> hexadecimal */
1636 )
1637 + 1; /* turn floor into ceil */
1638 if (tmp_length < precision)
1639 tmp_length = precision;
1640 /* Account for sign, decimal point etc. */
1641 tmp_length = xsum (tmp_length, 12);
1642 break;
1643
1644 case 'c':
1645 # if HAVE_WINT_T && !WIDE_CHAR_VERSION
1646 if (type == TYPE_WIDE_CHAR)
1647 tmp_length = MB_CUR_MAX;
1648 else
1649 # endif
1650 tmp_length = 1;
1651 break;
1652
1653 case 's':
1654 # if HAVE_WCHAR_T
1655 if (type == TYPE_WIDE_STRING)
1656 {
1657 # if WIDE_CHAR_VERSION
1658 /* ISO C says about %ls in fwprintf:
1659 "If the precision is not specified or is greater than the size
1660 of the array, the array shall contain a null wide character."
1661 So if there is a precision, we must not use wcslen. */
1662 const wchar_t *arg = ap->arg[arg_index].a.a_wide_string;
1663
1664 if (has_precision)
1665 tmp_length = local_wcsnlen (arg, precision);
1666 else
1667 tmp_length = local_wcslen (arg);
1668 # else
1669 /* ISO C says about %ls in fprintf:
1670 "If a precision is specified, no more than that many bytes are
1671 written (including shift sequences, if any), and the array
1672 shall contain a null wide character if, to equal the multibyte
1673 character sequence length given by the precision, the function
1674 would need to access a wide character one past the end of the
1675 array."
1676 So if there is a precision, we must not use wcslen. */
1677 /* This case has already been handled separately in VASNPRINTF. */
1678 abort ();
1679 # endif
1680 }
1681 else
1682 # endif
1683 {
1684 # if WIDE_CHAR_VERSION
1685 /* ISO C says about %s in fwprintf:
1686 "If the precision is not specified or is greater than the size
1687 of the converted array, the converted array shall contain a
1688 null wide character."
1689 So if there is a precision, we must not use strlen. */
1690 /* This case has already been handled separately in VASNPRINTF. */
1691 abort ();
1692 # else
1693 /* ISO C says about %s in fprintf:
1694 "If the precision is not specified or greater than the size of
1695 the array, the array shall contain a null character."
1696 So if there is a precision, we must not use strlen. */
1697 const char *arg = ap->arg[arg_index].a.a_string;
1698
1699 if (has_precision)
1700 tmp_length = local_strnlen (arg, precision);
1701 else
1702 tmp_length = strlen (arg);
1703 # endif
1704 }
1705 break;
1706
1707 case 'p':
1708 tmp_length =
1709 (unsigned int) (sizeof (void *) * CHAR_BIT
1710 * 0.25 /* binary -> hexadecimal */
1711 )
1712 + 1 /* turn floor into ceil */
1713 + 2; /* account for leading 0x */
1714 break;
1715
1716 default:
1717 abort ();
1718 }
1719
1720 if (!pad_ourselves)
1721 {
1722 # if ENABLE_UNISTDIO
1723 /* Padding considers the number of characters, therefore the number of
1724 elements after padding may be
1725 > max (tmp_length, width)
1726 but is certainly
1727 <= tmp_length + width. */
1728 tmp_length = xsum (tmp_length, width);
1729 # else
1730 /* Padding considers the number of elements, says POSIX. */
1731 if (tmp_length < width)
1732 tmp_length = width;
1733 # endif
1734 }
1735
1736 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
1737
1738 return tmp_length;
1739 }
1740
1741 #endif
1742
1743 DCHAR_T *
VASNPRINTF(DCHAR_T * resultbuf,size_t * lengthp,const FCHAR_T * format,va_list args)1744 VASNPRINTF (DCHAR_T *resultbuf, size_t *lengthp,
1745 const FCHAR_T *format, va_list args)
1746 {
1747 DIRECTIVES d;
1748 arguments a;
1749
1750 if (PRINTF_PARSE (format, &d, &a) < 0)
1751 /* errno is already set. */
1752 return NULL;
1753
1754 #define CLEANUP() \
1755 free (d.dir); \
1756 if (a.arg) \
1757 free (a.arg);
1758
1759 if (PRINTF_FETCHARGS (args, &a) < 0)
1760 {
1761 CLEANUP ();
1762 errno = EINVAL;
1763 return NULL;
1764 }
1765
1766 {
1767 size_t buf_neededlength;
1768 TCHAR_T *buf;
1769 TCHAR_T *buf_malloced;
1770 const FCHAR_T *cp;
1771 size_t i;
1772 DIRECTIVE *dp;
1773 /* Output string accumulator. */
1774 DCHAR_T *result;
1775 size_t allocated;
1776 size_t length;
1777
1778 /* Allocate a small buffer that will hold a directive passed to
1779 sprintf or snprintf. */
1780 buf_neededlength =
1781 xsum4 (7, d.max_width_length, d.max_precision_length, 6);
1782 #if HAVE_ALLOCA
1783 if (buf_neededlength < 4000 / sizeof (TCHAR_T))
1784 {
1785 buf = (TCHAR_T *) alloca (buf_neededlength * sizeof (TCHAR_T));
1786 buf_malloced = NULL;
1787 }
1788 else
1789 #endif
1790 {
1791 size_t buf_memsize = xtimes (buf_neededlength, sizeof (TCHAR_T));
1792 if (size_overflow_p (buf_memsize))
1793 goto out_of_memory_1;
1794 buf = (TCHAR_T *) malloc (buf_memsize);
1795 if (buf == NULL)
1796 goto out_of_memory_1;
1797 buf_malloced = buf;
1798 }
1799
1800 if (resultbuf != NULL)
1801 {
1802 result = resultbuf;
1803 allocated = *lengthp;
1804 }
1805 else
1806 {
1807 result = NULL;
1808 allocated = 0;
1809 }
1810 length = 0;
1811 /* Invariants:
1812 result is either == resultbuf or == NULL or malloc-allocated.
1813 If length > 0, then result != NULL. */
1814
1815 /* Ensures that allocated >= needed. Aborts through a jump to
1816 out_of_memory if needed is SIZE_MAX or otherwise too big. */
1817 #define ENSURE_ALLOCATION(needed) \
1818 if ((needed) > allocated) \
1819 { \
1820 size_t memory_size; \
1821 DCHAR_T *memory; \
1822 \
1823 allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \
1824 if ((needed) > allocated) \
1825 allocated = (needed); \
1826 memory_size = xtimes (allocated, sizeof (DCHAR_T)); \
1827 if (size_overflow_p (memory_size)) \
1828 goto out_of_memory; \
1829 if (result == resultbuf || result == NULL) \
1830 memory = (DCHAR_T *) malloc (memory_size); \
1831 else \
1832 memory = (DCHAR_T *) realloc (result, memory_size); \
1833 if (memory == NULL) \
1834 goto out_of_memory; \
1835 if (result == resultbuf && length > 0) \
1836 DCHAR_CPY (memory, result, length); \
1837 result = memory; \
1838 }
1839
1840 for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++)
1841 {
1842 if (cp != dp->dir_start)
1843 {
1844 size_t n = dp->dir_start - cp;
1845 size_t augmented_length = xsum (length, n);
1846
1847 ENSURE_ALLOCATION (augmented_length);
1848 /* This copies a piece of FCHAR_T[] into a DCHAR_T[]. Here we
1849 need that the format string contains only ASCII characters
1850 if FCHAR_T and DCHAR_T are not the same type. */
1851 if (sizeof (FCHAR_T) == sizeof (DCHAR_T))
1852 {
1853 DCHAR_CPY (result + length, (const DCHAR_T *) cp, n);
1854 length = augmented_length;
1855 }
1856 else
1857 {
1858 do
1859 result[length++] = (unsigned char) *cp++;
1860 while (--n > 0);
1861 }
1862 }
1863 if (i == d.count)
1864 break;
1865
1866 /* Execute a single directive. */
1867 if (dp->conversion == '%')
1868 {
1869 size_t augmented_length;
1870
1871 if (!(dp->arg_index == ARG_NONE))
1872 abort ();
1873 augmented_length = xsum (length, 1);
1874 ENSURE_ALLOCATION (augmented_length);
1875 result[length] = '%';
1876 length = augmented_length;
1877 }
1878 else
1879 {
1880 if (!(dp->arg_index != ARG_NONE))
1881 abort ();
1882
1883 if (dp->conversion == 'n')
1884 {
1885 switch (a.arg[dp->arg_index].type)
1886 {
1887 case TYPE_COUNT_SCHAR_POINTER:
1888 *a.arg[dp->arg_index].a.a_count_schar_pointer = length;
1889 break;
1890 case TYPE_COUNT_SHORT_POINTER:
1891 *a.arg[dp->arg_index].a.a_count_short_pointer = length;
1892 break;
1893 case TYPE_COUNT_INT_POINTER:
1894 *a.arg[dp->arg_index].a.a_count_int_pointer = length;
1895 break;
1896 case TYPE_COUNT_LONGINT_POINTER:
1897 *a.arg[dp->arg_index].a.a_count_longint_pointer = length;
1898 break;
1899 #if HAVE_LONG_LONG_INT
1900 case TYPE_COUNT_LONGLONGINT_POINTER:
1901 *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length;
1902 break;
1903 #endif
1904 default:
1905 abort ();
1906 }
1907 }
1908 #if ENABLE_UNISTDIO
1909 /* The unistdio extensions. */
1910 else if (dp->conversion == 'U')
1911 {
1912 arg_type type = a.arg[dp->arg_index].type;
1913 int flags = dp->flags;
1914 int has_width;
1915 size_t width;
1916 int has_precision;
1917 size_t precision;
1918
1919 has_width = 0;
1920 width = 0;
1921 if (dp->width_start != dp->width_end)
1922 {
1923 if (dp->width_arg_index != ARG_NONE)
1924 {
1925 int arg;
1926
1927 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
1928 abort ();
1929 arg = a.arg[dp->width_arg_index].a.a_int;
1930 if (arg < 0)
1931 {
1932 /* "A negative field width is taken as a '-' flag
1933 followed by a positive field width." */
1934 flags |= FLAG_LEFT;
1935 width = (unsigned int) (-arg);
1936 }
1937 else
1938 width = arg;
1939 }
1940 else
1941 {
1942 const FCHAR_T *digitp = dp->width_start;
1943
1944 do
1945 width = xsum (xtimes (width, 10), *digitp++ - '0');
1946 while (digitp != dp->width_end);
1947 }
1948 has_width = 1;
1949 }
1950
1951 has_precision = 0;
1952 precision = 0;
1953 if (dp->precision_start != dp->precision_end)
1954 {
1955 if (dp->precision_arg_index != ARG_NONE)
1956 {
1957 int arg;
1958
1959 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
1960 abort ();
1961 arg = a.arg[dp->precision_arg_index].a.a_int;
1962 /* "A negative precision is taken as if the precision
1963 were omitted." */
1964 if (arg >= 0)
1965 {
1966 precision = arg;
1967 has_precision = 1;
1968 }
1969 }
1970 else
1971 {
1972 const FCHAR_T *digitp = dp->precision_start + 1;
1973
1974 precision = 0;
1975 while (digitp != dp->precision_end)
1976 precision = xsum (xtimes (precision, 10), *digitp++ - '0');
1977 has_precision = 1;
1978 }
1979 }
1980
1981 switch (type)
1982 {
1983 case TYPE_U8_STRING:
1984 {
1985 const uint8_t *arg = a.arg[dp->arg_index].a.a_u8_string;
1986 const uint8_t *arg_end;
1987 size_t characters;
1988
1989 if (has_precision)
1990 {
1991 /* Use only PRECISION characters, from the left. */
1992 arg_end = arg;
1993 characters = 0;
1994 for (; precision > 0; precision--)
1995 {
1996 int count = u8_strmblen (arg_end);
1997 if (count == 0)
1998 break;
1999 if (count < 0)
2000 {
2001 if (!(result == resultbuf || result == NULL))
2002 free (result);
2003 if (buf_malloced != NULL)
2004 free (buf_malloced);
2005 CLEANUP ();
2006 errno = EILSEQ;
2007 return NULL;
2008 }
2009 arg_end += count;
2010 characters++;
2011 }
2012 }
2013 else if (has_width)
2014 {
2015 /* Use the entire string, and count the number of
2016 characters. */
2017 arg_end = arg;
2018 characters = 0;
2019 for (;;)
2020 {
2021 int count = u8_strmblen (arg_end);
2022 if (count == 0)
2023 break;
2024 if (count < 0)
2025 {
2026 if (!(result == resultbuf || result == NULL))
2027 free (result);
2028 if (buf_malloced != NULL)
2029 free (buf_malloced);
2030 CLEANUP ();
2031 errno = EILSEQ;
2032 return NULL;
2033 }
2034 arg_end += count;
2035 characters++;
2036 }
2037 }
2038 else
2039 {
2040 /* Use the entire string. */
2041 arg_end = arg + u8_strlen (arg);
2042 /* The number of characters doesn't matter. */
2043 characters = 0;
2044 }
2045
2046 if (has_width && width > characters
2047 && !(dp->flags & FLAG_LEFT))
2048 {
2049 size_t n = width - characters;
2050 ENSURE_ALLOCATION (xsum (length, n));
2051 DCHAR_SET (result + length, ' ', n);
2052 length += n;
2053 }
2054
2055 # if DCHAR_IS_UINT8_T
2056 {
2057 size_t n = arg_end - arg;
2058 ENSURE_ALLOCATION (xsum (length, n));
2059 DCHAR_CPY (result + length, arg, n);
2060 length += n;
2061 }
2062 # else
2063 { /* Convert. */
2064 DCHAR_T *converted = result + length;
2065 size_t converted_len = allocated - length;
2066 # if DCHAR_IS_TCHAR
2067 /* Convert from UTF-8 to locale encoding. */
2068 converted =
2069 u8_conv_to_encoding (locale_charset (),
2070 iconveh_question_mark,
2071 arg, arg_end - arg, NULL,
2072 converted, &converted_len);
2073 # else
2074 /* Convert from UTF-8 to UTF-16/UTF-32. */
2075 converted =
2076 U8_TO_DCHAR (arg, arg_end - arg,
2077 converted, &converted_len);
2078 # endif
2079 if (converted == NULL)
2080 {
2081 int saved_errno = errno;
2082 if (!(result == resultbuf || result == NULL))
2083 free (result);
2084 if (buf_malloced != NULL)
2085 free (buf_malloced);
2086 CLEANUP ();
2087 errno = saved_errno;
2088 return NULL;
2089 }
2090 if (converted != result + length)
2091 {
2092 ENSURE_ALLOCATION (xsum (length, converted_len));
2093 DCHAR_CPY (result + length, converted, converted_len);
2094 free (converted);
2095 }
2096 length += converted_len;
2097 }
2098 # endif
2099
2100 if (has_width && width > characters
2101 && (dp->flags & FLAG_LEFT))
2102 {
2103 size_t n = width - characters;
2104 ENSURE_ALLOCATION (xsum (length, n));
2105 DCHAR_SET (result + length, ' ', n);
2106 length += n;
2107 }
2108 }
2109 break;
2110
2111 case TYPE_U16_STRING:
2112 {
2113 const uint16_t *arg = a.arg[dp->arg_index].a.a_u16_string;
2114 const uint16_t *arg_end;
2115 size_t characters;
2116
2117 if (has_precision)
2118 {
2119 /* Use only PRECISION characters, from the left. */
2120 arg_end = arg;
2121 characters = 0;
2122 for (; precision > 0; precision--)
2123 {
2124 int count = u16_strmblen (arg_end);
2125 if (count == 0)
2126 break;
2127 if (count < 0)
2128 {
2129 if (!(result == resultbuf || result == NULL))
2130 free (result);
2131 if (buf_malloced != NULL)
2132 free (buf_malloced);
2133 CLEANUP ();
2134 errno = EILSEQ;
2135 return NULL;
2136 }
2137 arg_end += count;
2138 characters++;
2139 }
2140 }
2141 else if (has_width)
2142 {
2143 /* Use the entire string, and count the number of
2144 characters. */
2145 arg_end = arg;
2146 characters = 0;
2147 for (;;)
2148 {
2149 int count = u16_strmblen (arg_end);
2150 if (count == 0)
2151 break;
2152 if (count < 0)
2153 {
2154 if (!(result == resultbuf || result == NULL))
2155 free (result);
2156 if (buf_malloced != NULL)
2157 free (buf_malloced);
2158 CLEANUP ();
2159 errno = EILSEQ;
2160 return NULL;
2161 }
2162 arg_end += count;
2163 characters++;
2164 }
2165 }
2166 else
2167 {
2168 /* Use the entire string. */
2169 arg_end = arg + u16_strlen (arg);
2170 /* The number of characters doesn't matter. */
2171 characters = 0;
2172 }
2173
2174 if (has_width && width > characters
2175 && !(dp->flags & FLAG_LEFT))
2176 {
2177 size_t n = width - characters;
2178 ENSURE_ALLOCATION (xsum (length, n));
2179 DCHAR_SET (result + length, ' ', n);
2180 length += n;
2181 }
2182
2183 # if DCHAR_IS_UINT16_T
2184 {
2185 size_t n = arg_end - arg;
2186 ENSURE_ALLOCATION (xsum (length, n));
2187 DCHAR_CPY (result + length, arg, n);
2188 length += n;
2189 }
2190 # else
2191 { /* Convert. */
2192 DCHAR_T *converted = result + length;
2193 size_t converted_len = allocated - length;
2194 # if DCHAR_IS_TCHAR
2195 /* Convert from UTF-16 to locale encoding. */
2196 converted =
2197 u16_conv_to_encoding (locale_charset (),
2198 iconveh_question_mark,
2199 arg, arg_end - arg, NULL,
2200 converted, &converted_len);
2201 # else
2202 /* Convert from UTF-16 to UTF-8/UTF-32. */
2203 converted =
2204 U16_TO_DCHAR (arg, arg_end - arg,
2205 converted, &converted_len);
2206 # endif
2207 if (converted == NULL)
2208 {
2209 int saved_errno = errno;
2210 if (!(result == resultbuf || result == NULL))
2211 free (result);
2212 if (buf_malloced != NULL)
2213 free (buf_malloced);
2214 CLEANUP ();
2215 errno = saved_errno;
2216 return NULL;
2217 }
2218 if (converted != result + length)
2219 {
2220 ENSURE_ALLOCATION (xsum (length, converted_len));
2221 DCHAR_CPY (result + length, converted, converted_len);
2222 free (converted);
2223 }
2224 length += converted_len;
2225 }
2226 # endif
2227
2228 if (has_width && width > characters
2229 && (dp->flags & FLAG_LEFT))
2230 {
2231 size_t n = width - characters;
2232 ENSURE_ALLOCATION (xsum (length, n));
2233 DCHAR_SET (result + length, ' ', n);
2234 length += n;
2235 }
2236 }
2237 break;
2238
2239 case TYPE_U32_STRING:
2240 {
2241 const uint32_t *arg = a.arg[dp->arg_index].a.a_u32_string;
2242 const uint32_t *arg_end;
2243 size_t characters;
2244
2245 if (has_precision)
2246 {
2247 /* Use only PRECISION characters, from the left. */
2248 arg_end = arg;
2249 characters = 0;
2250 for (; precision > 0; precision--)
2251 {
2252 int count = u32_strmblen (arg_end);
2253 if (count == 0)
2254 break;
2255 if (count < 0)
2256 {
2257 if (!(result == resultbuf || result == NULL))
2258 free (result);
2259 if (buf_malloced != NULL)
2260 free (buf_malloced);
2261 CLEANUP ();
2262 errno = EILSEQ;
2263 return NULL;
2264 }
2265 arg_end += count;
2266 characters++;
2267 }
2268 }
2269 else if (has_width)
2270 {
2271 /* Use the entire string, and count the number of
2272 characters. */
2273 arg_end = arg;
2274 characters = 0;
2275 for (;;)
2276 {
2277 int count = u32_strmblen (arg_end);
2278 if (count == 0)
2279 break;
2280 if (count < 0)
2281 {
2282 if (!(result == resultbuf || result == NULL))
2283 free (result);
2284 if (buf_malloced != NULL)
2285 free (buf_malloced);
2286 CLEANUP ();
2287 errno = EILSEQ;
2288 return NULL;
2289 }
2290 arg_end += count;
2291 characters++;
2292 }
2293 }
2294 else
2295 {
2296 /* Use the entire string. */
2297 arg_end = arg + u32_strlen (arg);
2298 /* The number of characters doesn't matter. */
2299 characters = 0;
2300 }
2301
2302 if (has_width && width > characters
2303 && !(dp->flags & FLAG_LEFT))
2304 {
2305 size_t n = width - characters;
2306 ENSURE_ALLOCATION (xsum (length, n));
2307 DCHAR_SET (result + length, ' ', n);
2308 length += n;
2309 }
2310
2311 # if DCHAR_IS_UINT32_T
2312 {
2313 size_t n = arg_end - arg;
2314 ENSURE_ALLOCATION (xsum (length, n));
2315 DCHAR_CPY (result + length, arg, n);
2316 length += n;
2317 }
2318 # else
2319 { /* Convert. */
2320 DCHAR_T *converted = result + length;
2321 size_t converted_len = allocated - length;
2322 # if DCHAR_IS_TCHAR
2323 /* Convert from UTF-32 to locale encoding. */
2324 converted =
2325 u32_conv_to_encoding (locale_charset (),
2326 iconveh_question_mark,
2327 arg, arg_end - arg, NULL,
2328 converted, &converted_len);
2329 # else
2330 /* Convert from UTF-32 to UTF-8/UTF-16. */
2331 converted =
2332 U32_TO_DCHAR (arg, arg_end - arg,
2333 converted, &converted_len);
2334 # endif
2335 if (converted == NULL)
2336 {
2337 int saved_errno = errno;
2338 if (!(result == resultbuf || result == NULL))
2339 free (result);
2340 if (buf_malloced != NULL)
2341 free (buf_malloced);
2342 CLEANUP ();
2343 errno = saved_errno;
2344 return NULL;
2345 }
2346 if (converted != result + length)
2347 {
2348 ENSURE_ALLOCATION (xsum (length, converted_len));
2349 DCHAR_CPY (result + length, converted, converted_len);
2350 free (converted);
2351 }
2352 length += converted_len;
2353 }
2354 # endif
2355
2356 if (has_width && width > characters
2357 && (dp->flags & FLAG_LEFT))
2358 {
2359 size_t n = width - characters;
2360 ENSURE_ALLOCATION (xsum (length, n));
2361 DCHAR_SET (result + length, ' ', n);
2362 length += n;
2363 }
2364 }
2365 break;
2366
2367 default:
2368 abort ();
2369 }
2370 }
2371 #endif
2372 #if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || (NEED_PRINTF_DIRECTIVE_LS && !defined IN_LIBINTL)) && HAVE_WCHAR_T
2373 else if (dp->conversion == 's'
2374 # if WIDE_CHAR_VERSION
2375 && a.arg[dp->arg_index].type != TYPE_WIDE_STRING
2376 # else
2377 && a.arg[dp->arg_index].type == TYPE_WIDE_STRING
2378 # endif
2379 )
2380 {
2381 /* The normal handling of the 's' directive below requires
2382 allocating a temporary buffer. The determination of its
2383 length (tmp_length), in the case when a precision is
2384 specified, below requires a conversion between a char[]
2385 string and a wchar_t[] wide string. It could be done, but
2386 we have no guarantee that the implementation of sprintf will
2387 use the exactly same algorithm. Without this guarantee, it
2388 is possible to have buffer overrun bugs. In order to avoid
2389 such bugs, we implement the entire processing of the 's'
2390 directive ourselves. */
2391 int flags = dp->flags;
2392 int has_width;
2393 size_t width;
2394 int has_precision;
2395 size_t precision;
2396
2397 has_width = 0;
2398 width = 0;
2399 if (dp->width_start != dp->width_end)
2400 {
2401 if (dp->width_arg_index != ARG_NONE)
2402 {
2403 int arg;
2404
2405 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
2406 abort ();
2407 arg = a.arg[dp->width_arg_index].a.a_int;
2408 if (arg < 0)
2409 {
2410 /* "A negative field width is taken as a '-' flag
2411 followed by a positive field width." */
2412 flags |= FLAG_LEFT;
2413 width = (unsigned int) (-arg);
2414 }
2415 else
2416 width = arg;
2417 }
2418 else
2419 {
2420 const FCHAR_T *digitp = dp->width_start;
2421
2422 do
2423 width = xsum (xtimes (width, 10), *digitp++ - '0');
2424 while (digitp != dp->width_end);
2425 }
2426 has_width = 1;
2427 }
2428
2429 has_precision = 0;
2430 precision = 6;
2431 if (dp->precision_start != dp->precision_end)
2432 {
2433 if (dp->precision_arg_index != ARG_NONE)
2434 {
2435 int arg;
2436
2437 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
2438 abort ();
2439 arg = a.arg[dp->precision_arg_index].a.a_int;
2440 /* "A negative precision is taken as if the precision
2441 were omitted." */
2442 if (arg >= 0)
2443 {
2444 precision = arg;
2445 has_precision = 1;
2446 }
2447 }
2448 else
2449 {
2450 const FCHAR_T *digitp = dp->precision_start + 1;
2451
2452 precision = 0;
2453 while (digitp != dp->precision_end)
2454 precision = xsum (xtimes (precision, 10), *digitp++ - '0');
2455 has_precision = 1;
2456 }
2457 }
2458
2459 # if WIDE_CHAR_VERSION
2460 /* %s in vasnwprintf. See the specification of fwprintf. */
2461 {
2462 const char *arg = a.arg[dp->arg_index].a.a_string;
2463 const char *arg_end;
2464 size_t characters;
2465
2466 if (has_precision)
2467 {
2468 /* Use only as many bytes as needed to produce PRECISION
2469 wide characters, from the left. */
2470 # if HAVE_MBRTOWC
2471 mbstate_t state;
2472 memset (&state, '\0', sizeof (mbstate_t));
2473 # endif
2474 arg_end = arg;
2475 characters = 0;
2476 for (; precision > 0; precision--)
2477 {
2478 int count;
2479 # if HAVE_MBRTOWC
2480 count = mbrlen (arg_end, MB_CUR_MAX, &state);
2481 # else
2482 count = mblen (arg_end, MB_CUR_MAX);
2483 # endif
2484 if (count == 0)
2485 /* Found the terminating NUL. */
2486 break;
2487 if (count < 0)
2488 {
2489 /* Invalid or incomplete multibyte character. */
2490 if (!(result == resultbuf || result == NULL))
2491 free (result);
2492 if (buf_malloced != NULL)
2493 free (buf_malloced);
2494 CLEANUP ();
2495 errno = EILSEQ;
2496 return NULL;
2497 }
2498 arg_end += count;
2499 characters++;
2500 }
2501 }
2502 else if (has_width)
2503 {
2504 /* Use the entire string, and count the number of wide
2505 characters. */
2506 # if HAVE_MBRTOWC
2507 mbstate_t state;
2508 memset (&state, '\0', sizeof (mbstate_t));
2509 # endif
2510 arg_end = arg;
2511 characters = 0;
2512 for (;;)
2513 {
2514 int count;
2515 # if HAVE_MBRTOWC
2516 count = mbrlen (arg_end, MB_CUR_MAX, &state);
2517 # else
2518 count = mblen (arg_end, MB_CUR_MAX);
2519 # endif
2520 if (count == 0)
2521 /* Found the terminating NUL. */
2522 break;
2523 if (count < 0)
2524 {
2525 /* Invalid or incomplete multibyte character. */
2526 if (!(result == resultbuf || result == NULL))
2527 free (result);
2528 if (buf_malloced != NULL)
2529 free (buf_malloced);
2530 CLEANUP ();
2531 errno = EILSEQ;
2532 return NULL;
2533 }
2534 arg_end += count;
2535 characters++;
2536 }
2537 }
2538 else
2539 {
2540 /* Use the entire string. */
2541 arg_end = arg + strlen (arg);
2542 /* The number of characters doesn't matter. */
2543 characters = 0;
2544 }
2545
2546 if (has_width && width > characters
2547 && !(dp->flags & FLAG_LEFT))
2548 {
2549 size_t n = width - characters;
2550 ENSURE_ALLOCATION (xsum (length, n));
2551 DCHAR_SET (result + length, ' ', n);
2552 length += n;
2553 }
2554
2555 if (has_precision || has_width)
2556 {
2557 /* We know the number of wide characters in advance. */
2558 size_t remaining;
2559 # if HAVE_MBRTOWC
2560 mbstate_t state;
2561 memset (&state, '\0', sizeof (mbstate_t));
2562 # endif
2563 ENSURE_ALLOCATION (xsum (length, characters));
2564 for (remaining = characters; remaining > 0; remaining--)
2565 {
2566 wchar_t wc;
2567 int count;
2568 # if HAVE_MBRTOWC
2569 count = mbrtowc (&wc, arg, arg_end - arg, &state);
2570 # else
2571 count = mbtowc (&wc, arg, arg_end - arg);
2572 # endif
2573 if (count <= 0)
2574 /* mbrtowc not consistent with mbrlen, or mbtowc
2575 not consistent with mblen. */
2576 abort ();
2577 result[length++] = wc;
2578 arg += count;
2579 }
2580 if (!(arg == arg_end))
2581 abort ();
2582 }
2583 else
2584 {
2585 # if HAVE_MBRTOWC
2586 mbstate_t state;
2587 memset (&state, '\0', sizeof (mbstate_t));
2588 # endif
2589 while (arg < arg_end)
2590 {
2591 wchar_t wc;
2592 int count;
2593 # if HAVE_MBRTOWC
2594 count = mbrtowc (&wc, arg, arg_end - arg, &state);
2595 # else
2596 count = mbtowc (&wc, arg, arg_end - arg);
2597 # endif
2598 if (count <= 0)
2599 /* mbrtowc not consistent with mbrlen, or mbtowc
2600 not consistent with mblen. */
2601 abort ();
2602 ENSURE_ALLOCATION (xsum (length, 1));
2603 result[length++] = wc;
2604 arg += count;
2605 }
2606 }
2607
2608 if (has_width && width > characters
2609 && (dp->flags & FLAG_LEFT))
2610 {
2611 size_t n = width - characters;
2612 ENSURE_ALLOCATION (xsum (length, n));
2613 DCHAR_SET (result + length, ' ', n);
2614 length += n;
2615 }
2616 }
2617 # else
2618 /* %ls in vasnprintf. See the specification of fprintf. */
2619 {
2620 const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
2621 const wchar_t *arg_end;
2622 size_t characters;
2623 # if !DCHAR_IS_TCHAR
2624 /* This code assumes that TCHAR_T is 'char'. */
2625 typedef int TCHAR_T_verify[2 * (sizeof (TCHAR_T) == 1) - 1];
2626 TCHAR_T *tmpsrc;
2627 DCHAR_T *tmpdst;
2628 size_t tmpdst_len;
2629 # endif
2630 size_t w;
2631
2632 if (has_precision)
2633 {
2634 /* Use only as many wide characters as needed to produce
2635 at most PRECISION bytes, from the left. */
2636 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2637 mbstate_t state;
2638 memset (&state, '\0', sizeof (mbstate_t));
2639 # endif
2640 arg_end = arg;
2641 characters = 0;
2642 while (precision > 0)
2643 {
2644 char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */
2645 int count;
2646
2647 if (*arg_end == 0)
2648 /* Found the terminating null wide character. */
2649 break;
2650 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2651 count = wcrtomb (cbuf, *arg_end, &state);
2652 # else
2653 count = wctomb (cbuf, *arg_end);
2654 # endif
2655 if (count < 0)
2656 {
2657 /* Cannot convert. */
2658 if (!(result == resultbuf || result == NULL))
2659 free (result);
2660 if (buf_malloced != NULL)
2661 free (buf_malloced);
2662 CLEANUP ();
2663 errno = EILSEQ;
2664 return NULL;
2665 }
2666 if (precision < count)
2667 break;
2668 arg_end++;
2669 characters += count;
2670 precision -= count;
2671 }
2672 }
2673 # if DCHAR_IS_TCHAR
2674 else if (has_width)
2675 # else
2676 else
2677 # endif
2678 {
2679 /* Use the entire string, and count the number of
2680 bytes. */
2681 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2682 mbstate_t state;
2683 memset (&state, '\0', sizeof (mbstate_t));
2684 # endif
2685 arg_end = arg;
2686 characters = 0;
2687 for (;;)
2688 {
2689 char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */
2690 int count;
2691
2692 if (*arg_end == 0)
2693 /* Found the terminating null wide character. */
2694 break;
2695 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2696 count = wcrtomb (cbuf, *arg_end, &state);
2697 # else
2698 count = wctomb (cbuf, *arg_end);
2699 # endif
2700 if (count < 0)
2701 {
2702 /* Cannot convert. */
2703 if (!(result == resultbuf || result == NULL))
2704 free (result);
2705 if (buf_malloced != NULL)
2706 free (buf_malloced);
2707 CLEANUP ();
2708 errno = EILSEQ;
2709 return NULL;
2710 }
2711 arg_end++;
2712 characters += count;
2713 }
2714 }
2715 # if DCHAR_IS_TCHAR
2716 else
2717 {
2718 /* Use the entire string. */
2719 arg_end = arg + local_wcslen (arg);
2720 /* The number of bytes doesn't matter. */
2721 characters = 0;
2722 }
2723 # endif
2724
2725 # if !DCHAR_IS_TCHAR
2726 /* Convert the string into a piece of temporary memory. */
2727 tmpsrc = (TCHAR_T *) malloc (characters * sizeof (TCHAR_T));
2728 if (tmpsrc == NULL)
2729 goto out_of_memory;
2730 {
2731 TCHAR_T *tmpptr = tmpsrc;
2732 size_t remaining;
2733 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2734 mbstate_t state;
2735 memset (&state, '\0', sizeof (mbstate_t));
2736 # endif
2737 for (remaining = characters; remaining > 0; )
2738 {
2739 char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */
2740 int count;
2741
2742 if (*arg == 0)
2743 abort ();
2744 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2745 count = wcrtomb (cbuf, *arg, &state);
2746 # else
2747 count = wctomb (cbuf, *arg);
2748 # endif
2749 if (count <= 0)
2750 /* Inconsistency. */
2751 abort ();
2752 memcpy (tmpptr, cbuf, count);
2753 tmpptr += count;
2754 arg++;
2755 remaining -= count;
2756 }
2757 if (!(arg == arg_end))
2758 abort ();
2759 }
2760
2761 /* Convert from TCHAR_T[] to DCHAR_T[]. */
2762 tmpdst =
2763 DCHAR_CONV_FROM_ENCODING (locale_charset (),
2764 iconveh_question_mark,
2765 tmpsrc, characters,
2766 NULL,
2767 NULL, &tmpdst_len);
2768 if (tmpdst == NULL)
2769 {
2770 int saved_errno = errno;
2771 free (tmpsrc);
2772 if (!(result == resultbuf || result == NULL))
2773 free (result);
2774 if (buf_malloced != NULL)
2775 free (buf_malloced);
2776 CLEANUP ();
2777 errno = saved_errno;
2778 return NULL;
2779 }
2780 free (tmpsrc);
2781 # endif
2782
2783 if (has_width)
2784 {
2785 # if ENABLE_UNISTDIO
2786 /* Outside POSIX, it's preferrable to compare the width
2787 against the number of _characters_ of the converted
2788 value. */
2789 w = DCHAR_MBSNLEN (result + length, characters);
2790 # else
2791 /* The width is compared against the number of _bytes_
2792 of the converted value, says POSIX. */
2793 w = characters;
2794 # endif
2795 }
2796 else
2797 /* w doesn't matter. */
2798 w = 0;
2799
2800 if (has_width && width > w
2801 && !(dp->flags & FLAG_LEFT))
2802 {
2803 size_t n = width - w;
2804 ENSURE_ALLOCATION (xsum (length, n));
2805 DCHAR_SET (result + length, ' ', n);
2806 length += n;
2807 }
2808
2809 # if DCHAR_IS_TCHAR
2810 if (has_precision || has_width)
2811 {
2812 /* We know the number of bytes in advance. */
2813 size_t remaining;
2814 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2815 mbstate_t state;
2816 memset (&state, '\0', sizeof (mbstate_t));
2817 # endif
2818 ENSURE_ALLOCATION (xsum (length, characters));
2819 for (remaining = characters; remaining > 0; )
2820 {
2821 char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */
2822 int count;
2823
2824 if (*arg == 0)
2825 abort ();
2826 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2827 count = wcrtomb (cbuf, *arg, &state);
2828 # else
2829 count = wctomb (cbuf, *arg);
2830 # endif
2831 if (count <= 0)
2832 /* Inconsistency. */
2833 abort ();
2834 memcpy (result + length, cbuf, count);
2835 length += count;
2836 arg++;
2837 remaining -= count;
2838 }
2839 if (!(arg == arg_end))
2840 abort ();
2841 }
2842 else
2843 {
2844 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2845 mbstate_t state;
2846 memset (&state, '\0', sizeof (mbstate_t));
2847 # endif
2848 while (arg < arg_end)
2849 {
2850 char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */
2851 int count;
2852
2853 if (*arg == 0)
2854 abort ();
2855 # if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t
2856 count = wcrtomb (cbuf, *arg, &state);
2857 # else
2858 count = wctomb (cbuf, *arg);
2859 # endif
2860 if (count <= 0)
2861 {
2862 /* Cannot convert. */
2863 if (!(result == resultbuf || result == NULL))
2864 free (result);
2865 if (buf_malloced != NULL)
2866 free (buf_malloced);
2867 CLEANUP ();
2868 errno = EILSEQ;
2869 return NULL;
2870 }
2871 ENSURE_ALLOCATION (xsum (length, count));
2872 memcpy (result + length, cbuf, count);
2873 length += count;
2874 arg++;
2875 }
2876 }
2877 # else
2878 ENSURE_ALLOCATION (xsum (length, tmpdst_len));
2879 DCHAR_CPY (result + length, tmpdst, tmpdst_len);
2880 free (tmpdst);
2881 length += tmpdst_len;
2882 # endif
2883
2884 if (has_width && width > w
2885 && (dp->flags & FLAG_LEFT))
2886 {
2887 size_t n = width - w;
2888 ENSURE_ALLOCATION (xsum (length, n));
2889 DCHAR_SET (result + length, ' ', n);
2890 length += n;
2891 }
2892 }
2893 # endif
2894 }
2895 #endif
2896 #if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL
2897 else if ((dp->conversion == 'a' || dp->conversion == 'A')
2898 # if !(NEED_PRINTF_DIRECTIVE_A || (NEED_PRINTF_LONG_DOUBLE && NEED_PRINTF_DOUBLE))
2899 && (0
2900 # if NEED_PRINTF_DOUBLE
2901 || a.arg[dp->arg_index].type == TYPE_DOUBLE
2902 # endif
2903 # if NEED_PRINTF_LONG_DOUBLE
2904 || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
2905 # endif
2906 )
2907 # endif
2908 )
2909 {
2910 arg_type type = a.arg[dp->arg_index].type;
2911 int flags = dp->flags;
2912 int has_width;
2913 size_t width;
2914 int has_precision;
2915 size_t precision;
2916 size_t tmp_length;
2917 DCHAR_T tmpbuf[700];
2918 DCHAR_T *tmp;
2919 DCHAR_T *pad_ptr;
2920 DCHAR_T *p;
2921
2922 has_width = 0;
2923 width = 0;
2924 if (dp->width_start != dp->width_end)
2925 {
2926 if (dp->width_arg_index != ARG_NONE)
2927 {
2928 int arg;
2929
2930 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
2931 abort ();
2932 arg = a.arg[dp->width_arg_index].a.a_int;
2933 if (arg < 0)
2934 {
2935 /* "A negative field width is taken as a '-' flag
2936 followed by a positive field width." */
2937 flags |= FLAG_LEFT;
2938 width = (unsigned int) (-arg);
2939 }
2940 else
2941 width = arg;
2942 }
2943 else
2944 {
2945 const FCHAR_T *digitp = dp->width_start;
2946
2947 do
2948 width = xsum (xtimes (width, 10), *digitp++ - '0');
2949 while (digitp != dp->width_end);
2950 }
2951 has_width = 1;
2952 }
2953
2954 has_precision = 0;
2955 precision = 0;
2956 if (dp->precision_start != dp->precision_end)
2957 {
2958 if (dp->precision_arg_index != ARG_NONE)
2959 {
2960 int arg;
2961
2962 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
2963 abort ();
2964 arg = a.arg[dp->precision_arg_index].a.a_int;
2965 /* "A negative precision is taken as if the precision
2966 were omitted." */
2967 if (arg >= 0)
2968 {
2969 precision = arg;
2970 has_precision = 1;
2971 }
2972 }
2973 else
2974 {
2975 const FCHAR_T *digitp = dp->precision_start + 1;
2976
2977 precision = 0;
2978 while (digitp != dp->precision_end)
2979 precision = xsum (xtimes (precision, 10), *digitp++ - '0');
2980 has_precision = 1;
2981 }
2982 }
2983
2984 /* Allocate a temporary buffer of sufficient size. */
2985 if (type == TYPE_LONGDOUBLE)
2986 tmp_length =
2987 (unsigned int) ((LDBL_DIG + 1)
2988 * 0.831 /* decimal -> hexadecimal */
2989 )
2990 + 1; /* turn floor into ceil */
2991 else
2992 tmp_length =
2993 (unsigned int) ((DBL_DIG + 1)
2994 * 0.831 /* decimal -> hexadecimal */
2995 )
2996 + 1; /* turn floor into ceil */
2997 if (tmp_length < precision)
2998 tmp_length = precision;
2999 /* Account for sign, decimal point etc. */
3000 tmp_length = xsum (tmp_length, 12);
3001
3002 if (tmp_length < width)
3003 tmp_length = width;
3004
3005 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
3006
3007 if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T))
3008 tmp = tmpbuf;
3009 else
3010 {
3011 size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));
3012
3013 if (size_overflow_p (tmp_memsize))
3014 /* Overflow, would lead to out of memory. */
3015 goto out_of_memory;
3016 tmp = (DCHAR_T *) malloc (tmp_memsize);
3017 if (tmp == NULL)
3018 /* Out of memory. */
3019 goto out_of_memory;
3020 }
3021
3022 pad_ptr = NULL;
3023 p = tmp;
3024 if (type == TYPE_LONGDOUBLE)
3025 {
3026 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE
3027 long double arg = a.arg[dp->arg_index].a.a_longdouble;
3028
3029 if (isnanl (arg))
3030 {
3031 if (dp->conversion == 'A')
3032 {
3033 *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3034 }
3035 else
3036 {
3037 *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3038 }
3039 }
3040 else
3041 {
3042 int sign = 0;
3043 DECL_LONG_DOUBLE_ROUNDING
3044
3045 BEGIN_LONG_DOUBLE_ROUNDING ();
3046
3047 if (signbit (arg)) /* arg < 0.0L or negative zero */
3048 {
3049 sign = -1;
3050 arg = -arg;
3051 }
3052
3053 if (sign < 0)
3054 *p++ = '-';
3055 else if (flags & FLAG_SHOWSIGN)
3056 *p++ = '+';
3057 else if (flags & FLAG_SPACE)
3058 *p++ = ' ';
3059
3060 if (arg > 0.0L && arg + arg == arg)
3061 {
3062 if (dp->conversion == 'A')
3063 {
3064 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3065 }
3066 else
3067 {
3068 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3069 }
3070 }
3071 else
3072 {
3073 int exponent;
3074 long double mantissa;
3075
3076 if (arg > 0.0L)
3077 mantissa = printf_frexpl (arg, &exponent);
3078 else
3079 {
3080 exponent = 0;
3081 mantissa = 0.0L;
3082 }
3083
3084 if (has_precision
3085 && precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1)
3086 {
3087 /* Round the mantissa. */
3088 long double tail = mantissa;
3089 size_t q;
3090
3091 for (q = precision; ; q--)
3092 {
3093 int digit = (int) tail;
3094 tail -= digit;
3095 if (q == 0)
3096 {
3097 if (digit & 1 ? tail >= 0.5L : tail > 0.5L)
3098 tail = 1 - tail;
3099 else
3100 tail = - tail;
3101 break;
3102 }
3103 tail *= 16.0L;
3104 }
3105 if (tail != 0.0L)
3106 for (q = precision; q > 0; q--)
3107 tail *= 0.0625L;
3108 mantissa += tail;
3109 }
3110
3111 *p++ = '0';
3112 *p++ = dp->conversion - 'A' + 'X';
3113 pad_ptr = p;
3114 {
3115 int digit;
3116
3117 digit = (int) mantissa;
3118 mantissa -= digit;
3119 *p++ = '0' + digit;
3120 if ((flags & FLAG_ALT)
3121 || mantissa > 0.0L || precision > 0)
3122 {
3123 *p++ = decimal_point_char ();
3124 /* This loop terminates because we assume
3125 that FLT_RADIX is a power of 2. */
3126 while (mantissa > 0.0L)
3127 {
3128 mantissa *= 16.0L;
3129 digit = (int) mantissa;
3130 mantissa -= digit;
3131 *p++ = digit
3132 + (digit < 10
3133 ? '0'
3134 : dp->conversion - 10);
3135 if (precision > 0)
3136 precision--;
3137 }
3138 while (precision > 0)
3139 {
3140 *p++ = '0';
3141 precision--;
3142 }
3143 }
3144 }
3145 *p++ = dp->conversion - 'A' + 'P';
3146 # if WIDE_CHAR_VERSION
3147 {
3148 static const wchar_t decimal_format[] =
3149 { '%', '+', 'd', '\0' };
3150 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3151 }
3152 while (*p != '\0')
3153 p++;
3154 # else
3155 if (sizeof (DCHAR_T) == 1)
3156 {
3157 sprintf ((char *) p, "%+d", exponent);
3158 while (*p != '\0')
3159 p++;
3160 }
3161 else
3162 {
3163 char expbuf[6 + 1];
3164 const char *ep;
3165 sprintf (expbuf, "%+d", exponent);
3166 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3167 p++;
3168 }
3169 # endif
3170 }
3171
3172 END_LONG_DOUBLE_ROUNDING ();
3173 }
3174 # else
3175 abort ();
3176 # endif
3177 }
3178 else
3179 {
3180 # if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE
3181 double arg = a.arg[dp->arg_index].a.a_double;
3182
3183 if (isnand (arg))
3184 {
3185 if (dp->conversion == 'A')
3186 {
3187 *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3188 }
3189 else
3190 {
3191 *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3192 }
3193 }
3194 else
3195 {
3196 int sign = 0;
3197
3198 if (signbit (arg)) /* arg < 0.0 or negative zero */
3199 {
3200 sign = -1;
3201 arg = -arg;
3202 }
3203
3204 if (sign < 0)
3205 *p++ = '-';
3206 else if (flags & FLAG_SHOWSIGN)
3207 *p++ = '+';
3208 else if (flags & FLAG_SPACE)
3209 *p++ = ' ';
3210
3211 if (arg > 0.0 && arg + arg == arg)
3212 {
3213 if (dp->conversion == 'A')
3214 {
3215 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3216 }
3217 else
3218 {
3219 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3220 }
3221 }
3222 else
3223 {
3224 int exponent;
3225 double mantissa;
3226
3227 if (arg > 0.0)
3228 mantissa = printf_frexp (arg, &exponent);
3229 else
3230 {
3231 exponent = 0;
3232 mantissa = 0.0;
3233 }
3234
3235 if (has_precision
3236 && precision < (unsigned int) ((DBL_DIG + 1) * 0.831) + 1)
3237 {
3238 /* Round the mantissa. */
3239 double tail = mantissa;
3240 size_t q;
3241
3242 for (q = precision; ; q--)
3243 {
3244 int digit = (int) tail;
3245 tail -= digit;
3246 if (q == 0)
3247 {
3248 if (digit & 1 ? tail >= 0.5 : tail > 0.5)
3249 tail = 1 - tail;
3250 else
3251 tail = - tail;
3252 break;
3253 }
3254 tail *= 16.0;
3255 }
3256 if (tail != 0.0)
3257 for (q = precision; q > 0; q--)
3258 tail *= 0.0625;
3259 mantissa += tail;
3260 }
3261
3262 *p++ = '0';
3263 *p++ = dp->conversion - 'A' + 'X';
3264 pad_ptr = p;
3265 {
3266 int digit;
3267
3268 digit = (int) mantissa;
3269 mantissa -= digit;
3270 *p++ = '0' + digit;
3271 if ((flags & FLAG_ALT)
3272 || mantissa > 0.0 || precision > 0)
3273 {
3274 *p++ = decimal_point_char ();
3275 /* This loop terminates because we assume
3276 that FLT_RADIX is a power of 2. */
3277 while (mantissa > 0.0)
3278 {
3279 mantissa *= 16.0;
3280 digit = (int) mantissa;
3281 mantissa -= digit;
3282 *p++ = digit
3283 + (digit < 10
3284 ? '0'
3285 : dp->conversion - 10);
3286 if (precision > 0)
3287 precision--;
3288 }
3289 while (precision > 0)
3290 {
3291 *p++ = '0';
3292 precision--;
3293 }
3294 }
3295 }
3296 *p++ = dp->conversion - 'A' + 'P';
3297 # if WIDE_CHAR_VERSION
3298 {
3299 static const wchar_t decimal_format[] =
3300 { '%', '+', 'd', '\0' };
3301 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3302 }
3303 while (*p != '\0')
3304 p++;
3305 # else
3306 if (sizeof (DCHAR_T) == 1)
3307 {
3308 sprintf ((char *) p, "%+d", exponent);
3309 while (*p != '\0')
3310 p++;
3311 }
3312 else
3313 {
3314 char expbuf[6 + 1];
3315 const char *ep;
3316 sprintf (expbuf, "%+d", exponent);
3317 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3318 p++;
3319 }
3320 # endif
3321 }
3322 }
3323 # else
3324 abort ();
3325 # endif
3326 }
3327 /* The generated string now extends from tmp to p, with the
3328 zero padding insertion point being at pad_ptr. */
3329 if (has_width && p - tmp < width)
3330 {
3331 size_t pad = width - (p - tmp);
3332 DCHAR_T *end = p + pad;
3333
3334 if (flags & FLAG_LEFT)
3335 {
3336 /* Pad with spaces on the right. */
3337 for (; pad > 0; pad--)
3338 *p++ = ' ';
3339 }
3340 else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
3341 {
3342 /* Pad with zeroes. */
3343 DCHAR_T *q = end;
3344
3345 while (p > pad_ptr)
3346 *--q = *--p;
3347 for (; pad > 0; pad--)
3348 *p++ = '0';
3349 }
3350 else
3351 {
3352 /* Pad with spaces on the left. */
3353 DCHAR_T *q = end;
3354
3355 while (p > tmp)
3356 *--q = *--p;
3357 for (; pad > 0; pad--)
3358 *p++ = ' ';
3359 }
3360
3361 p = end;
3362 }
3363
3364 {
3365 size_t count = p - tmp;
3366
3367 if (count >= tmp_length)
3368 /* tmp_length was incorrectly calculated - fix the
3369 code above! */
3370 abort ();
3371
3372 /* Make room for the result. */
3373 if (count >= allocated - length)
3374 {
3375 size_t n = xsum (length, count);
3376
3377 ENSURE_ALLOCATION (n);
3378 }
3379
3380 /* Append the result. */
3381 memcpy (result + length, tmp, count * sizeof (DCHAR_T));
3382 if (tmp != tmpbuf)
3383 free (tmp);
3384 length += count;
3385 }
3386 }
3387 #endif
3388 #if (NEED_PRINTF_INFINITE_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL
3389 else if ((dp->conversion == 'f' || dp->conversion == 'F'
3390 || dp->conversion == 'e' || dp->conversion == 'E'
3391 || dp->conversion == 'g' || dp->conversion == 'G'
3392 || dp->conversion == 'a' || dp->conversion == 'A')
3393 && (0
3394 # if NEED_PRINTF_DOUBLE
3395 || a.arg[dp->arg_index].type == TYPE_DOUBLE
3396 # elif NEED_PRINTF_INFINITE_DOUBLE
3397 || (a.arg[dp->arg_index].type == TYPE_DOUBLE
3398 /* The systems (mingw) which produce wrong output
3399 for Inf, -Inf, and NaN also do so for -0.0.
3400 Therefore we treat this case here as well. */
3401 && is_infinite_or_zero (a.arg[dp->arg_index].a.a_double))
3402 # endif
3403 # if NEED_PRINTF_LONG_DOUBLE
3404 || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
3405 # elif NEED_PRINTF_INFINITE_LONG_DOUBLE
3406 || (a.arg[dp->arg_index].type == TYPE_LONGDOUBLE
3407 /* Some systems produce wrong output for Inf,
3408 -Inf, and NaN. Some systems in this category
3409 (IRIX 5.3) also do so for -0.0. Therefore we
3410 treat this case here as well. */
3411 && is_infinite_or_zerol (a.arg[dp->arg_index].a.a_longdouble))
3412 # endif
3413 ))
3414 {
3415 # if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE)
3416 arg_type type = a.arg[dp->arg_index].type;
3417 # endif
3418 int flags = dp->flags;
3419 int has_width;
3420 size_t width;
3421 int has_precision;
3422 size_t precision;
3423 size_t tmp_length;
3424 DCHAR_T tmpbuf[700];
3425 DCHAR_T *tmp;
3426 DCHAR_T *pad_ptr;
3427 DCHAR_T *p;
3428
3429 has_width = 0;
3430 width = 0;
3431 if (dp->width_start != dp->width_end)
3432 {
3433 if (dp->width_arg_index != ARG_NONE)
3434 {
3435 int arg;
3436
3437 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
3438 abort ();
3439 arg = a.arg[dp->width_arg_index].a.a_int;
3440 if (arg < 0)
3441 {
3442 /* "A negative field width is taken as a '-' flag
3443 followed by a positive field width." */
3444 flags |= FLAG_LEFT;
3445 width = (unsigned int) (-arg);
3446 }
3447 else
3448 width = arg;
3449 }
3450 else
3451 {
3452 const FCHAR_T *digitp = dp->width_start;
3453
3454 do
3455 width = xsum (xtimes (width, 10), *digitp++ - '0');
3456 while (digitp != dp->width_end);
3457 }
3458 has_width = 1;
3459 }
3460
3461 has_precision = 0;
3462 precision = 0;
3463 if (dp->precision_start != dp->precision_end)
3464 {
3465 if (dp->precision_arg_index != ARG_NONE)
3466 {
3467 int arg;
3468
3469 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
3470 abort ();
3471 arg = a.arg[dp->precision_arg_index].a.a_int;
3472 /* "A negative precision is taken as if the precision
3473 were omitted." */
3474 if (arg >= 0)
3475 {
3476 precision = arg;
3477 has_precision = 1;
3478 }
3479 }
3480 else
3481 {
3482 const FCHAR_T *digitp = dp->precision_start + 1;
3483
3484 precision = 0;
3485 while (digitp != dp->precision_end)
3486 precision = xsum (xtimes (precision, 10), *digitp++ - '0');
3487 has_precision = 1;
3488 }
3489 }
3490
3491 /* POSIX specifies the default precision to be 6 for %f, %F,
3492 %e, %E, but not for %g, %G. Implementations appear to use
3493 the same default precision also for %g, %G. But for %a, %A,
3494 the default precision is 0. */
3495 if (!has_precision)
3496 if (!(dp->conversion == 'a' || dp->conversion == 'A'))
3497 precision = 6;
3498
3499 /* Allocate a temporary buffer of sufficient size. */
3500 # if NEED_PRINTF_DOUBLE && NEED_PRINTF_LONG_DOUBLE
3501 tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : DBL_DIG + 1);
3502 # elif NEED_PRINTF_INFINITE_DOUBLE && NEED_PRINTF_LONG_DOUBLE
3503 tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : 0);
3504 # elif NEED_PRINTF_LONG_DOUBLE
3505 tmp_length = LDBL_DIG + 1;
3506 # elif NEED_PRINTF_DOUBLE
3507 tmp_length = DBL_DIG + 1;
3508 # else
3509 tmp_length = 0;
3510 # endif
3511 if (tmp_length < precision)
3512 tmp_length = precision;
3513 # if NEED_PRINTF_LONG_DOUBLE
3514 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
3515 if (type == TYPE_LONGDOUBLE)
3516 # endif
3517 if (dp->conversion == 'f' || dp->conversion == 'F')
3518 {
3519 long double arg = a.arg[dp->arg_index].a.a_longdouble;
3520 if (!(isnanl (arg) || arg + arg == arg))
3521 {
3522 /* arg is finite and nonzero. */
3523 int exponent = floorlog10l (arg < 0 ? -arg : arg);
3524 if (exponent >= 0 && tmp_length < exponent + precision)
3525 tmp_length = exponent + precision;
3526 }
3527 }
3528 # endif
3529 # if NEED_PRINTF_DOUBLE
3530 # if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
3531 if (type == TYPE_DOUBLE)
3532 # endif
3533 if (dp->conversion == 'f' || dp->conversion == 'F')
3534 {
3535 double arg = a.arg[dp->arg_index].a.a_double;
3536 if (!(isnand (arg) || arg + arg == arg))
3537 {
3538 /* arg is finite and nonzero. */
3539 int exponent = floorlog10 (arg < 0 ? -arg : arg);
3540 if (exponent >= 0 && tmp_length < exponent + precision)
3541 tmp_length = exponent + precision;
3542 }
3543 }
3544 # endif
3545 /* Account for sign, decimal point etc. */
3546 tmp_length = xsum (tmp_length, 12);
3547
3548 if (tmp_length < width)
3549 tmp_length = width;
3550
3551 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
3552
3553 if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T))
3554 tmp = tmpbuf;
3555 else
3556 {
3557 size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));
3558
3559 if (size_overflow_p (tmp_memsize))
3560 /* Overflow, would lead to out of memory. */
3561 goto out_of_memory;
3562 tmp = (DCHAR_T *) malloc (tmp_memsize);
3563 if (tmp == NULL)
3564 /* Out of memory. */
3565 goto out_of_memory;
3566 }
3567
3568 pad_ptr = NULL;
3569 p = tmp;
3570
3571 # if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE
3572 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
3573 if (type == TYPE_LONGDOUBLE)
3574 # endif
3575 {
3576 long double arg = a.arg[dp->arg_index].a.a_longdouble;
3577
3578 if (isnanl (arg))
3579 {
3580 if (dp->conversion >= 'A' && dp->conversion <= 'Z')
3581 {
3582 *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
3583 }
3584 else
3585 {
3586 *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
3587 }
3588 }
3589 else
3590 {
3591 int sign = 0;
3592 DECL_LONG_DOUBLE_ROUNDING
3593
3594 BEGIN_LONG_DOUBLE_ROUNDING ();
3595
3596 if (signbit (arg)) /* arg < 0.0L or negative zero */
3597 {
3598 sign = -1;
3599 arg = -arg;
3600 }
3601
3602 if (sign < 0)
3603 *p++ = '-';
3604 else if (flags & FLAG_SHOWSIGN)
3605 *p++ = '+';
3606 else if (flags & FLAG_SPACE)
3607 *p++ = ' ';
3608
3609 if (arg > 0.0L && arg + arg == arg)
3610 {
3611 if (dp->conversion >= 'A' && dp->conversion <= 'Z')
3612 {
3613 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
3614 }
3615 else
3616 {
3617 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
3618 }
3619 }
3620 else
3621 {
3622 # if NEED_PRINTF_LONG_DOUBLE
3623 pad_ptr = p;
3624
3625 if (dp->conversion == 'f' || dp->conversion == 'F')
3626 {
3627 char *digits;
3628 size_t ndigits;
3629
3630 digits =
3631 scale10_round_decimal_long_double (arg, precision);
3632 if (digits == NULL)
3633 {
3634 END_LONG_DOUBLE_ROUNDING ();
3635 goto out_of_memory;
3636 }
3637 ndigits = strlen (digits);
3638
3639 if (ndigits > precision)
3640 do
3641 {
3642 --ndigits;
3643 *p++ = digits[ndigits];
3644 }
3645 while (ndigits > precision);
3646 else
3647 *p++ = '0';
3648 /* Here ndigits <= precision. */
3649 if ((flags & FLAG_ALT) || precision > 0)
3650 {
3651 *p++ = decimal_point_char ();
3652 for (; precision > ndigits; precision--)
3653 *p++ = '0';
3654 while (ndigits > 0)
3655 {
3656 --ndigits;
3657 *p++ = digits[ndigits];
3658 }
3659 }
3660
3661 free (digits);
3662 }
3663 else if (dp->conversion == 'e' || dp->conversion == 'E')
3664 {
3665 int exponent;
3666
3667 if (arg == 0.0L)
3668 {
3669 exponent = 0;
3670 *p++ = '0';
3671 if ((flags & FLAG_ALT) || precision > 0)
3672 {
3673 *p++ = decimal_point_char ();
3674 for (; precision > 0; precision--)
3675 *p++ = '0';
3676 }
3677 }
3678 else
3679 {
3680 /* arg > 0.0L. */
3681 int adjusted;
3682 char *digits;
3683 size_t ndigits;
3684
3685 exponent = floorlog10l (arg);
3686 adjusted = 0;
3687 for (;;)
3688 {
3689 digits =
3690 scale10_round_decimal_long_double (arg,
3691 (int)precision - exponent);
3692 if (digits == NULL)
3693 {
3694 END_LONG_DOUBLE_ROUNDING ();
3695 goto out_of_memory;
3696 }
3697 ndigits = strlen (digits);
3698
3699 if (ndigits == precision + 1)
3700 break;
3701 if (ndigits < precision
3702 || ndigits > precision + 2)
3703 /* The exponent was not guessed
3704 precisely enough. */
3705 abort ();
3706 if (adjusted)
3707 /* None of two values of exponent is
3708 the right one. Prevent an endless
3709 loop. */
3710 abort ();
3711 free (digits);
3712 if (ndigits == precision)
3713 exponent -= 1;
3714 else
3715 exponent += 1;
3716 adjusted = 1;
3717 }
3718 /* Here ndigits = precision+1. */
3719 if (is_borderline (digits, precision))
3720 {
3721 /* Maybe the exponent guess was too high
3722 and a smaller exponent can be reached
3723 by turning a 10...0 into 9...9x. */
3724 char *digits2 =
3725 scale10_round_decimal_long_double (arg,
3726 (int)precision - exponent + 1);
3727 if (digits2 == NULL)
3728 {
3729 free (digits);
3730 END_LONG_DOUBLE_ROUNDING ();
3731 goto out_of_memory;
3732 }
3733 if (strlen (digits2) == precision + 1)
3734 {
3735 free (digits);
3736 digits = digits2;
3737 exponent -= 1;
3738 }
3739 else
3740 free (digits2);
3741 }
3742 /* Here ndigits = precision+1. */
3743
3744 *p++ = digits[--ndigits];
3745 if ((flags & FLAG_ALT) || precision > 0)
3746 {
3747 *p++ = decimal_point_char ();
3748 while (ndigits > 0)
3749 {
3750 --ndigits;
3751 *p++ = digits[ndigits];
3752 }
3753 }
3754
3755 free (digits);
3756 }
3757
3758 *p++ = dp->conversion; /* 'e' or 'E' */
3759 # if WIDE_CHAR_VERSION
3760 {
3761 static const wchar_t decimal_format[] =
3762 { '%', '+', '.', '2', 'd', '\0' };
3763 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3764 }
3765 while (*p != '\0')
3766 p++;
3767 # else
3768 if (sizeof (DCHAR_T) == 1)
3769 {
3770 sprintf ((char *) p, "%+.2d", exponent);
3771 while (*p != '\0')
3772 p++;
3773 }
3774 else
3775 {
3776 char expbuf[6 + 1];
3777 const char *ep;
3778 sprintf (expbuf, "%+.2d", exponent);
3779 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3780 p++;
3781 }
3782 # endif
3783 }
3784 else if (dp->conversion == 'g' || dp->conversion == 'G')
3785 {
3786 if (precision == 0)
3787 precision = 1;
3788 /* precision >= 1. */
3789
3790 if (arg == 0.0L)
3791 /* The exponent is 0, >= -4, < precision.
3792 Use fixed-point notation. */
3793 {
3794 size_t ndigits = precision;
3795 /* Number of trailing zeroes that have to be
3796 dropped. */
3797 size_t nzeroes =
3798 (flags & FLAG_ALT ? 0 : precision - 1);
3799
3800 --ndigits;
3801 *p++ = '0';
3802 if ((flags & FLAG_ALT) || ndigits > nzeroes)
3803 {
3804 *p++ = decimal_point_char ();
3805 while (ndigits > nzeroes)
3806 {
3807 --ndigits;
3808 *p++ = '0';
3809 }
3810 }
3811 }
3812 else
3813 {
3814 /* arg > 0.0L. */
3815 int exponent;
3816 int adjusted;
3817 char *digits;
3818 size_t ndigits;
3819 size_t nzeroes;
3820
3821 exponent = floorlog10l (arg);
3822 adjusted = 0;
3823 for (;;)
3824 {
3825 digits =
3826 scale10_round_decimal_long_double (arg,
3827 (int)(precision - 1) - exponent);
3828 if (digits == NULL)
3829 {
3830 END_LONG_DOUBLE_ROUNDING ();
3831 goto out_of_memory;
3832 }
3833 ndigits = strlen (digits);
3834
3835 if (ndigits == precision)
3836 break;
3837 if (ndigits < precision - 1
3838 || ndigits > precision + 1)
3839 /* The exponent was not guessed
3840 precisely enough. */
3841 abort ();
3842 if (adjusted)
3843 /* None of two values of exponent is
3844 the right one. Prevent an endless
3845 loop. */
3846 abort ();
3847 free (digits);
3848 if (ndigits < precision)
3849 exponent -= 1;
3850 else
3851 exponent += 1;
3852 adjusted = 1;
3853 }
3854 /* Here ndigits = precision. */
3855 if (is_borderline (digits, precision - 1))
3856 {
3857 /* Maybe the exponent guess was too high
3858 and a smaller exponent can be reached
3859 by turning a 10...0 into 9...9x. */
3860 char *digits2 =
3861 scale10_round_decimal_long_double (arg,
3862 (int)(precision - 1) - exponent + 1);
3863 if (digits2 == NULL)
3864 {
3865 free (digits);
3866 END_LONG_DOUBLE_ROUNDING ();
3867 goto out_of_memory;
3868 }
3869 if (strlen (digits2) == precision)
3870 {
3871 free (digits);
3872 digits = digits2;
3873 exponent -= 1;
3874 }
3875 else
3876 free (digits2);
3877 }
3878 /* Here ndigits = precision. */
3879
3880 /* Determine the number of trailing zeroes
3881 that have to be dropped. */
3882 nzeroes = 0;
3883 if ((flags & FLAG_ALT) == 0)
3884 while (nzeroes < ndigits
3885 && digits[nzeroes] == '0')
3886 nzeroes++;
3887
3888 /* The exponent is now determined. */
3889 if (exponent >= -4
3890 && exponent < (long)precision)
3891 {
3892 /* Fixed-point notation:
3893 max(exponent,0)+1 digits, then the
3894 decimal point, then the remaining
3895 digits without trailing zeroes. */
3896 if (exponent >= 0)
3897 {
3898 size_t count = exponent + 1;
3899 /* Note: count <= precision = ndigits. */
3900 for (; count > 0; count--)
3901 *p++ = digits[--ndigits];
3902 if ((flags & FLAG_ALT) || ndigits > nzeroes)
3903 {
3904 *p++ = decimal_point_char ();
3905 while (ndigits > nzeroes)
3906 {
3907 --ndigits;
3908 *p++ = digits[ndigits];
3909 }
3910 }
3911 }
3912 else
3913 {
3914 size_t count = -exponent - 1;
3915 *p++ = '0';
3916 *p++ = decimal_point_char ();
3917 for (; count > 0; count--)
3918 *p++ = '0';
3919 while (ndigits > nzeroes)
3920 {
3921 --ndigits;
3922 *p++ = digits[ndigits];
3923 }
3924 }
3925 }
3926 else
3927 {
3928 /* Exponential notation. */
3929 *p++ = digits[--ndigits];
3930 if ((flags & FLAG_ALT) || ndigits > nzeroes)
3931 {
3932 *p++ = decimal_point_char ();
3933 while (ndigits > nzeroes)
3934 {
3935 --ndigits;
3936 *p++ = digits[ndigits];
3937 }
3938 }
3939 *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
3940 # if WIDE_CHAR_VERSION
3941 {
3942 static const wchar_t decimal_format[] =
3943 { '%', '+', '.', '2', 'd', '\0' };
3944 SNPRINTF (p, 6 + 1, decimal_format, exponent);
3945 }
3946 while (*p != '\0')
3947 p++;
3948 # else
3949 if (sizeof (DCHAR_T) == 1)
3950 {
3951 sprintf ((char *) p, "%+.2d", exponent);
3952 while (*p != '\0')
3953 p++;
3954 }
3955 else
3956 {
3957 char expbuf[6 + 1];
3958 const char *ep;
3959 sprintf (expbuf, "%+.2d", exponent);
3960 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
3961 p++;
3962 }
3963 # endif
3964 }
3965
3966 free (digits);
3967 }
3968 }
3969 else
3970 abort ();
3971 # else
3972 /* arg is finite. */
3973 if (!(arg == 0.0L))
3974 abort ();
3975
3976 pad_ptr = p;
3977
3978 if (dp->conversion == 'f' || dp->conversion == 'F')
3979 {
3980 *p++ = '0';
3981 if ((flags & FLAG_ALT) || precision > 0)
3982 {
3983 *p++ = decimal_point_char ();
3984 for (; precision > 0; precision--)
3985 *p++ = '0';
3986 }
3987 }
3988 else if (dp->conversion == 'e' || dp->conversion == 'E')
3989 {
3990 *p++ = '0';
3991 if ((flags & FLAG_ALT) || precision > 0)
3992 {
3993 *p++ = decimal_point_char ();
3994 for (; precision > 0; precision--)
3995 *p++ = '0';
3996 }
3997 *p++ = dp->conversion; /* 'e' or 'E' */
3998 *p++ = '+';
3999 *p++ = '0';
4000 *p++ = '0';
4001 }
4002 else if (dp->conversion == 'g' || dp->conversion == 'G')
4003 {
4004 *p++ = '0';
4005 if (flags & FLAG_ALT)
4006 {
4007 size_t ndigits =
4008 (precision > 0 ? precision - 1 : 0);
4009 *p++ = decimal_point_char ();
4010 for (; ndigits > 0; --ndigits)
4011 *p++ = '0';
4012 }
4013 }
4014 else if (dp->conversion == 'a' || dp->conversion == 'A')
4015 {
4016 *p++ = '0';
4017 *p++ = dp->conversion - 'A' + 'X';
4018 pad_ptr = p;
4019 *p++ = '0';
4020 if ((flags & FLAG_ALT) || precision > 0)
4021 {
4022 *p++ = decimal_point_char ();
4023 for (; precision > 0; precision--)
4024 *p++ = '0';
4025 }
4026 *p++ = dp->conversion - 'A' + 'P';
4027 *p++ = '+';
4028 *p++ = '0';
4029 }
4030 else
4031 abort ();
4032 # endif
4033 }
4034
4035 END_LONG_DOUBLE_ROUNDING ();
4036 }
4037 }
4038 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
4039 else
4040 # endif
4041 # endif
4042 # if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE
4043 {
4044 double arg = a.arg[dp->arg_index].a.a_double;
4045
4046 if (isnand (arg))
4047 {
4048 if (dp->conversion >= 'A' && dp->conversion <= 'Z')
4049 {
4050 *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
4051 }
4052 else
4053 {
4054 *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
4055 }
4056 }
4057 else
4058 {
4059 int sign = 0;
4060
4061 if (signbit (arg)) /* arg < 0.0 or negative zero */
4062 {
4063 sign = -1;
4064 arg = -arg;
4065 }
4066
4067 if (sign < 0)
4068 *p++ = '-';
4069 else if (flags & FLAG_SHOWSIGN)
4070 *p++ = '+';
4071 else if (flags & FLAG_SPACE)
4072 *p++ = ' ';
4073
4074 if (arg > 0.0 && arg + arg == arg)
4075 {
4076 if (dp->conversion >= 'A' && dp->conversion <= 'Z')
4077 {
4078 *p++ = 'I'; *p++ = 'N'; *p++ = 'F';
4079 }
4080 else
4081 {
4082 *p++ = 'i'; *p++ = 'n'; *p++ = 'f';
4083 }
4084 }
4085 else
4086 {
4087 # if NEED_PRINTF_DOUBLE
4088 pad_ptr = p;
4089
4090 if (dp->conversion == 'f' || dp->conversion == 'F')
4091 {
4092 char *digits;
4093 size_t ndigits;
4094
4095 digits =
4096 scale10_round_decimal_double (arg, precision);
4097 if (digits == NULL)
4098 goto out_of_memory;
4099 ndigits = strlen (digits);
4100
4101 if (ndigits > precision)
4102 do
4103 {
4104 --ndigits;
4105 *p++ = digits[ndigits];
4106 }
4107 while (ndigits > precision);
4108 else
4109 *p++ = '0';
4110 /* Here ndigits <= precision. */
4111 if ((flags & FLAG_ALT) || precision > 0)
4112 {
4113 *p++ = decimal_point_char ();
4114 for (; precision > ndigits; precision--)
4115 *p++ = '0';
4116 while (ndigits > 0)
4117 {
4118 --ndigits;
4119 *p++ = digits[ndigits];
4120 }
4121 }
4122
4123 free (digits);
4124 }
4125 else if (dp->conversion == 'e' || dp->conversion == 'E')
4126 {
4127 int exponent;
4128
4129 if (arg == 0.0)
4130 {
4131 exponent = 0;
4132 *p++ = '0';
4133 if ((flags & FLAG_ALT) || precision > 0)
4134 {
4135 *p++ = decimal_point_char ();
4136 for (; precision > 0; precision--)
4137 *p++ = '0';
4138 }
4139 }
4140 else
4141 {
4142 /* arg > 0.0. */
4143 int adjusted;
4144 char *digits;
4145 size_t ndigits;
4146
4147 exponent = floorlog10 (arg);
4148 adjusted = 0;
4149 for (;;)
4150 {
4151 digits =
4152 scale10_round_decimal_double (arg,
4153 (int)precision - exponent);
4154 if (digits == NULL)
4155 goto out_of_memory;
4156 ndigits = strlen (digits);
4157
4158 if (ndigits == precision + 1)
4159 break;
4160 if (ndigits < precision
4161 || ndigits > precision + 2)
4162 /* The exponent was not guessed
4163 precisely enough. */
4164 abort ();
4165 if (adjusted)
4166 /* None of two values of exponent is
4167 the right one. Prevent an endless
4168 loop. */
4169 abort ();
4170 free (digits);
4171 if (ndigits == precision)
4172 exponent -= 1;
4173 else
4174 exponent += 1;
4175 adjusted = 1;
4176 }
4177 /* Here ndigits = precision+1. */
4178 if (is_borderline (digits, precision))
4179 {
4180 /* Maybe the exponent guess was too high
4181 and a smaller exponent can be reached
4182 by turning a 10...0 into 9...9x. */
4183 char *digits2 =
4184 scale10_round_decimal_double (arg,
4185 (int)precision - exponent + 1);
4186 if (digits2 == NULL)
4187 {
4188 free (digits);
4189 goto out_of_memory;
4190 }
4191 if (strlen (digits2) == precision + 1)
4192 {
4193 free (digits);
4194 digits = digits2;
4195 exponent -= 1;
4196 }
4197 else
4198 free (digits2);
4199 }
4200 /* Here ndigits = precision+1. */
4201
4202 *p++ = digits[--ndigits];
4203 if ((flags & FLAG_ALT) || precision > 0)
4204 {
4205 *p++ = decimal_point_char ();
4206 while (ndigits > 0)
4207 {
4208 --ndigits;
4209 *p++ = digits[ndigits];
4210 }
4211 }
4212
4213 free (digits);
4214 }
4215
4216 *p++ = dp->conversion; /* 'e' or 'E' */
4217 # if WIDE_CHAR_VERSION
4218 {
4219 static const wchar_t decimal_format[] =
4220 /* Produce the same number of exponent digits
4221 as the native printf implementation. */
4222 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4223 { '%', '+', '.', '3', 'd', '\0' };
4224 # else
4225 { '%', '+', '.', '2', 'd', '\0' };
4226 # endif
4227 SNPRINTF (p, 6 + 1, decimal_format, exponent);
4228 }
4229 while (*p != '\0')
4230 p++;
4231 # else
4232 {
4233 static const char decimal_format[] =
4234 /* Produce the same number of exponent digits
4235 as the native printf implementation. */
4236 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4237 "%+.3d";
4238 # else
4239 "%+.2d";
4240 # endif
4241 if (sizeof (DCHAR_T) == 1)
4242 {
4243 sprintf ((char *) p, decimal_format, exponent);
4244 while (*p != '\0')
4245 p++;
4246 }
4247 else
4248 {
4249 char expbuf[6 + 1];
4250 const char *ep;
4251 sprintf (expbuf, decimal_format, exponent);
4252 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
4253 p++;
4254 }
4255 }
4256 # endif
4257 }
4258 else if (dp->conversion == 'g' || dp->conversion == 'G')
4259 {
4260 if (precision == 0)
4261 precision = 1;
4262 /* precision >= 1. */
4263
4264 if (arg == 0.0)
4265 /* The exponent is 0, >= -4, < precision.
4266 Use fixed-point notation. */
4267 {
4268 size_t ndigits = precision;
4269 /* Number of trailing zeroes that have to be
4270 dropped. */
4271 size_t nzeroes =
4272 (flags & FLAG_ALT ? 0 : precision - 1);
4273
4274 --ndigits;
4275 *p++ = '0';
4276 if ((flags & FLAG_ALT) || ndigits > nzeroes)
4277 {
4278 *p++ = decimal_point_char ();
4279 while (ndigits > nzeroes)
4280 {
4281 --ndigits;
4282 *p++ = '0';
4283 }
4284 }
4285 }
4286 else
4287 {
4288 /* arg > 0.0. */
4289 int exponent;
4290 int adjusted;
4291 char *digits;
4292 size_t ndigits;
4293 size_t nzeroes;
4294
4295 exponent = floorlog10 (arg);
4296 adjusted = 0;
4297 for (;;)
4298 {
4299 digits =
4300 scale10_round_decimal_double (arg,
4301 (int)(precision - 1) - exponent);
4302 if (digits == NULL)
4303 goto out_of_memory;
4304 ndigits = strlen (digits);
4305
4306 if (ndigits == precision)
4307 break;
4308 if (ndigits < precision - 1
4309 || ndigits > precision + 1)
4310 /* The exponent was not guessed
4311 precisely enough. */
4312 abort ();
4313 if (adjusted)
4314 /* None of two values of exponent is
4315 the right one. Prevent an endless
4316 loop. */
4317 abort ();
4318 free (digits);
4319 if (ndigits < precision)
4320 exponent -= 1;
4321 else
4322 exponent += 1;
4323 adjusted = 1;
4324 }
4325 /* Here ndigits = precision. */
4326 if (is_borderline (digits, precision - 1))
4327 {
4328 /* Maybe the exponent guess was too high
4329 and a smaller exponent can be reached
4330 by turning a 10...0 into 9...9x. */
4331 char *digits2 =
4332 scale10_round_decimal_double (arg,
4333 (int)(precision - 1) - exponent + 1);
4334 if (digits2 == NULL)
4335 {
4336 free (digits);
4337 goto out_of_memory;
4338 }
4339 if (strlen (digits2) == precision)
4340 {
4341 free (digits);
4342 digits = digits2;
4343 exponent -= 1;
4344 }
4345 else
4346 free (digits2);
4347 }
4348 /* Here ndigits = precision. */
4349
4350 /* Determine the number of trailing zeroes
4351 that have to be dropped. */
4352 nzeroes = 0;
4353 if ((flags & FLAG_ALT) == 0)
4354 while (nzeroes < ndigits
4355 && digits[nzeroes] == '0')
4356 nzeroes++;
4357
4358 /* The exponent is now determined. */
4359 if (exponent >= -4
4360 && exponent < (long)precision)
4361 {
4362 /* Fixed-point notation:
4363 max(exponent,0)+1 digits, then the
4364 decimal point, then the remaining
4365 digits without trailing zeroes. */
4366 if (exponent >= 0)
4367 {
4368 size_t count = exponent + 1;
4369 /* Note: count <= precision = ndigits. */
4370 for (; count > 0; count--)
4371 *p++ = digits[--ndigits];
4372 if ((flags & FLAG_ALT) || ndigits > nzeroes)
4373 {
4374 *p++ = decimal_point_char ();
4375 while (ndigits > nzeroes)
4376 {
4377 --ndigits;
4378 *p++ = digits[ndigits];
4379 }
4380 }
4381 }
4382 else
4383 {
4384 size_t count = -exponent - 1;
4385 *p++ = '0';
4386 *p++ = decimal_point_char ();
4387 for (; count > 0; count--)
4388 *p++ = '0';
4389 while (ndigits > nzeroes)
4390 {
4391 --ndigits;
4392 *p++ = digits[ndigits];
4393 }
4394 }
4395 }
4396 else
4397 {
4398 /* Exponential notation. */
4399 *p++ = digits[--ndigits];
4400 if ((flags & FLAG_ALT) || ndigits > nzeroes)
4401 {
4402 *p++ = decimal_point_char ();
4403 while (ndigits > nzeroes)
4404 {
4405 --ndigits;
4406 *p++ = digits[ndigits];
4407 }
4408 }
4409 *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */
4410 # if WIDE_CHAR_VERSION
4411 {
4412 static const wchar_t decimal_format[] =
4413 /* Produce the same number of exponent digits
4414 as the native printf implementation. */
4415 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4416 { '%', '+', '.', '3', 'd', '\0' };
4417 # else
4418 { '%', '+', '.', '2', 'd', '\0' };
4419 # endif
4420 SNPRINTF (p, 6 + 1, decimal_format, exponent);
4421 }
4422 while (*p != '\0')
4423 p++;
4424 # else
4425 {
4426 static const char decimal_format[] =
4427 /* Produce the same number of exponent digits
4428 as the native printf implementation. */
4429 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4430 "%+.3d";
4431 # else
4432 "%+.2d";
4433 # endif
4434 if (sizeof (DCHAR_T) == 1)
4435 {
4436 sprintf ((char *) p, decimal_format, exponent);
4437 while (*p != '\0')
4438 p++;
4439 }
4440 else
4441 {
4442 char expbuf[6 + 1];
4443 const char *ep;
4444 sprintf (expbuf, decimal_format, exponent);
4445 for (ep = expbuf; (*p = *ep) != '\0'; ep++)
4446 p++;
4447 }
4448 }
4449 # endif
4450 }
4451
4452 free (digits);
4453 }
4454 }
4455 else
4456 abort ();
4457 # else
4458 /* arg is finite. */
4459 if (!(arg == 0.0))
4460 abort ();
4461
4462 pad_ptr = p;
4463
4464 if (dp->conversion == 'f' || dp->conversion == 'F')
4465 {
4466 *p++ = '0';
4467 if ((flags & FLAG_ALT) || precision > 0)
4468 {
4469 *p++ = decimal_point_char ();
4470 for (; precision > 0; precision--)
4471 *p++ = '0';
4472 }
4473 }
4474 else if (dp->conversion == 'e' || dp->conversion == 'E')
4475 {
4476 *p++ = '0';
4477 if ((flags & FLAG_ALT) || precision > 0)
4478 {
4479 *p++ = decimal_point_char ();
4480 for (; precision > 0; precision--)
4481 *p++ = '0';
4482 }
4483 *p++ = dp->conversion; /* 'e' or 'E' */
4484 *p++ = '+';
4485 /* Produce the same number of exponent digits as
4486 the native printf implementation. */
4487 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4488 *p++ = '0';
4489 # endif
4490 *p++ = '0';
4491 *p++ = '0';
4492 }
4493 else if (dp->conversion == 'g' || dp->conversion == 'G')
4494 {
4495 *p++ = '0';
4496 if (flags & FLAG_ALT)
4497 {
4498 size_t ndigits =
4499 (precision > 0 ? precision - 1 : 0);
4500 *p++ = decimal_point_char ();
4501 for (; ndigits > 0; --ndigits)
4502 *p++ = '0';
4503 }
4504 }
4505 else
4506 abort ();
4507 # endif
4508 }
4509 }
4510 }
4511 # endif
4512
4513 /* The generated string now extends from tmp to p, with the
4514 zero padding insertion point being at pad_ptr. */
4515 if (has_width && p - tmp < width)
4516 {
4517 size_t pad = width - (p - tmp);
4518 DCHAR_T *end = p + pad;
4519
4520 if (flags & FLAG_LEFT)
4521 {
4522 /* Pad with spaces on the right. */
4523 for (; pad > 0; pad--)
4524 *p++ = ' ';
4525 }
4526 else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
4527 {
4528 /* Pad with zeroes. */
4529 DCHAR_T *q = end;
4530
4531 while (p > pad_ptr)
4532 *--q = *--p;
4533 for (; pad > 0; pad--)
4534 *p++ = '0';
4535 }
4536 else
4537 {
4538 /* Pad with spaces on the left. */
4539 DCHAR_T *q = end;
4540
4541 while (p > tmp)
4542 *--q = *--p;
4543 for (; pad > 0; pad--)
4544 *p++ = ' ';
4545 }
4546
4547 p = end;
4548 }
4549
4550 {
4551 size_t count = p - tmp;
4552
4553 if (count >= tmp_length)
4554 /* tmp_length was incorrectly calculated - fix the
4555 code above! */
4556 abort ();
4557
4558 /* Make room for the result. */
4559 if (count >= allocated - length)
4560 {
4561 size_t n = xsum (length, count);
4562
4563 ENSURE_ALLOCATION (n);
4564 }
4565
4566 /* Append the result. */
4567 memcpy (result + length, tmp, count * sizeof (DCHAR_T));
4568 if (tmp != tmpbuf)
4569 free (tmp);
4570 length += count;
4571 }
4572 }
4573 #endif
4574 else
4575 {
4576 arg_type type = a.arg[dp->arg_index].type;
4577 int flags = dp->flags;
4578 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4579 int has_width;
4580 size_t width;
4581 #endif
4582 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || NEED_PRINTF_UNBOUNDED_PRECISION
4583 int has_precision;
4584 size_t precision;
4585 #endif
4586 #if NEED_PRINTF_UNBOUNDED_PRECISION
4587 int prec_ourselves;
4588 #else
4589 # define prec_ourselves 0
4590 #endif
4591 #if NEED_PRINTF_FLAG_LEFTADJUST
4592 # define pad_ourselves 1
4593 #elif !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4594 int pad_ourselves;
4595 #else
4596 # define pad_ourselves 0
4597 #endif
4598 TCHAR_T *fbp;
4599 unsigned int prefix_count;
4600 int prefixes[2] IF_LINT (= { 0 });
4601 #if !USE_SNPRINTF
4602 size_t tmp_length;
4603 TCHAR_T tmpbuf[700];
4604 TCHAR_T *tmp;
4605 #endif
4606
4607 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
4608 has_width = 0;
4609 width = 0;
4610 if (dp->width_start != dp->width_end)
4611 {
4612 if (dp->width_arg_index != ARG_NONE)
4613 {
4614 int arg;
4615
4616 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
4617 abort ();
4618 arg = a.arg[dp->width_arg_index].a.a_int;
4619 if (arg < 0)
4620 {
4621 /* "A negative field width is taken as a '-' flag
4622 followed by a positive field width." */
4623 flags |= FLAG_LEFT;
4624 width = (unsigned int) (-arg);
4625 }
4626 else
4627 width = arg;
4628 }
4629 else
4630 {
4631 const FCHAR_T *digitp = dp->width_start;
4632
4633 do
4634 width = xsum (xtimes (width, 10), *digitp++ - '0');
4635 while (digitp != dp->width_end);
4636 }
4637 has_width = 1;
4638 }
4639 #endif
4640
4641 #if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || NEED_PRINTF_UNBOUNDED_PRECISION
4642 has_precision = 0;
4643 precision = 6;
4644 if (dp->precision_start != dp->precision_end)
4645 {
4646 if (dp->precision_arg_index != ARG_NONE)
4647 {
4648 int arg;
4649
4650 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
4651 abort ();
4652 arg = a.arg[dp->precision_arg_index].a.a_int;
4653 /* "A negative precision is taken as if the precision
4654 were omitted." */
4655 if (arg >= 0)
4656 {
4657 precision = arg;
4658 has_precision = 1;
4659 }
4660 }
4661 else
4662 {
4663 const FCHAR_T *digitp = dp->precision_start + 1;
4664
4665 precision = 0;
4666 while (digitp != dp->precision_end)
4667 precision = xsum (xtimes (precision, 10), *digitp++ - '0');
4668 has_precision = 1;
4669 }
4670 }
4671 #endif
4672
4673 /* Decide whether to handle the precision ourselves. */
4674 #if NEED_PRINTF_UNBOUNDED_PRECISION
4675 switch (dp->conversion)
4676 {
4677 case 'd': case 'i': case 'u':
4678 case 'o':
4679 case 'x': case 'X': case 'p':
4680 prec_ourselves = has_precision && (precision > 0);
4681 break;
4682 default:
4683 prec_ourselves = 0;
4684 break;
4685 }
4686 #endif
4687
4688 /* Decide whether to perform the padding ourselves. */
4689 #if !NEED_PRINTF_FLAG_LEFTADJUST && (!DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION)
4690 switch (dp->conversion)
4691 {
4692 # if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO
4693 /* If we need conversion from TCHAR_T[] to DCHAR_T[], we need
4694 to perform the padding after this conversion. Functions
4695 with unistdio extensions perform the padding based on
4696 character count rather than element count. */
4697 case 'c': case 's':
4698 # endif
4699 # if NEED_PRINTF_FLAG_ZERO
4700 case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
4701 case 'a': case 'A':
4702 # endif
4703 pad_ourselves = 1;
4704 break;
4705 default:
4706 pad_ourselves = prec_ourselves;
4707 break;
4708 }
4709 #endif
4710
4711 #if !USE_SNPRINTF
4712 /* Allocate a temporary buffer of sufficient size for calling
4713 sprintf. */
4714 tmp_length =
4715 MAX_ROOM_NEEDED (&a, dp->arg_index, dp->conversion, type,
4716 flags, width, has_precision, precision,
4717 pad_ourselves);
4718
4719 if (tmp_length <= sizeof (tmpbuf) / sizeof (TCHAR_T))
4720 tmp = tmpbuf;
4721 else
4722 {
4723 size_t tmp_memsize = xtimes (tmp_length, sizeof (TCHAR_T));
4724
4725 if (size_overflow_p (tmp_memsize))
4726 /* Overflow, would lead to out of memory. */
4727 goto out_of_memory;
4728 tmp = (TCHAR_T *) malloc (tmp_memsize);
4729 if (tmp == NULL)
4730 /* Out of memory. */
4731 goto out_of_memory;
4732 }
4733 #endif
4734
4735 /* Construct the format string for calling snprintf or
4736 sprintf. */
4737 fbp = buf;
4738 *fbp++ = '%';
4739 #if NEED_PRINTF_FLAG_GROUPING
4740 /* The underlying implementation doesn't support the ' flag.
4741 Produce no grouping characters in this case; this is
4742 acceptable because the grouping is locale dependent. */
4743 #else
4744 if (flags & FLAG_GROUP)
4745 *fbp++ = '\'';
4746 #endif
4747 if (flags & FLAG_LEFT)
4748 *fbp++ = '-';
4749 if (flags & FLAG_SHOWSIGN)
4750 *fbp++ = '+';
4751 if (flags & FLAG_SPACE)
4752 *fbp++ = ' ';
4753 if (flags & FLAG_ALT)
4754 *fbp++ = '#';
4755 if (!pad_ourselves)
4756 {
4757 if (flags & FLAG_ZERO)
4758 *fbp++ = '0';
4759 if (dp->width_start != dp->width_end)
4760 {
4761 size_t n = dp->width_end - dp->width_start;
4762 /* The width specification is known to consist only
4763 of standard ASCII characters. */
4764 if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
4765 {
4766 memcpy (fbp, dp->width_start, n * sizeof (TCHAR_T));
4767 fbp += n;
4768 }
4769 else
4770 {
4771 const FCHAR_T *mp = dp->width_start;
4772 do
4773 *fbp++ = (unsigned char) *mp++;
4774 while (--n > 0);
4775 }
4776 }
4777 }
4778 if (!prec_ourselves)
4779 {
4780 if (dp->precision_start != dp->precision_end)
4781 {
4782 size_t n = dp->precision_end - dp->precision_start;
4783 /* The precision specification is known to consist only
4784 of standard ASCII characters. */
4785 if (sizeof (FCHAR_T) == sizeof (TCHAR_T))
4786 {
4787 memcpy (fbp, dp->precision_start, n * sizeof (TCHAR_T));
4788 fbp += n;
4789 }
4790 else
4791 {
4792 const FCHAR_T *mp = dp->precision_start;
4793 do
4794 *fbp++ = (unsigned char) *mp++;
4795 while (--n > 0);
4796 }
4797 }
4798 }
4799
4800 switch (type)
4801 {
4802 #if HAVE_LONG_LONG_INT
4803 case TYPE_LONGLONGINT:
4804 case TYPE_ULONGLONGINT:
4805 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
4806 *fbp++ = 'I';
4807 *fbp++ = '6';
4808 *fbp++ = '4';
4809 break;
4810 # else
4811 *fbp++ = 'l';
4812 /*FALLTHROUGH*/
4813 # endif
4814 #endif
4815 case TYPE_LONGINT:
4816 case TYPE_ULONGINT:
4817 #if HAVE_WINT_T
4818 case TYPE_WIDE_CHAR:
4819 #endif
4820 #if HAVE_WCHAR_T
4821 case TYPE_WIDE_STRING:
4822 #endif
4823 *fbp++ = 'l';
4824 break;
4825 case TYPE_LONGDOUBLE:
4826 *fbp++ = 'L';
4827 break;
4828 default:
4829 break;
4830 }
4831 #if NEED_PRINTF_DIRECTIVE_F
4832 if (dp->conversion == 'F')
4833 *fbp = 'f';
4834 else
4835 #endif
4836 *fbp = dp->conversion;
4837 #if USE_SNPRINTF
4838 # if !(__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__))
4839 fbp[1] = '%';
4840 fbp[2] = 'n';
4841 fbp[3] = '\0';
4842 # else
4843 /* On glibc2 systems from glibc >= 2.3 - probably also older
4844 ones - we know that snprintf's returns value conforms to
4845 ISO C 99: the gl_SNPRINTF_DIRECTIVE_N test passes.
4846 Therefore we can avoid using %n in this situation.
4847 On glibc2 systems from 2004-10-18 or newer, the use of %n
4848 in format strings in writable memory may crash the program
4849 (if compiled with _FORTIFY_SOURCE=2), so we should avoid it
4850 in this situation. */
4851 /* On native Win32 systems (such as mingw), we can avoid using
4852 %n because:
4853 - Although the gl_SNPRINTF_TRUNCATION_C99 test fails,
4854 snprintf does not write more than the specified number
4855 of bytes. (snprintf (buf, 3, "%d %d", 4567, 89) writes
4856 '4', '5', '6' into buf, not '4', '5', '\0'.)
4857 - Although the gl_SNPRINTF_RETVAL_C99 test fails, snprintf
4858 allows us to recognize the case of an insufficient
4859 buffer size: it returns -1 in this case.
4860 On native Win32 systems (such as mingw) where the OS is
4861 Windows Vista, the use of %n in format strings by default
4862 crashes the program. See
4863 <http://gcc.gnu.org/ml/gcc/2007-06/msg00122.html> and
4864 <http://msdn2.microsoft.com/en-us/library/ms175782(VS.80).aspx>
4865 So we should avoid %n in this situation. */
4866 fbp[1] = '\0';
4867 # endif
4868 #else
4869 fbp[1] = '\0';
4870 #endif
4871
4872 /* Construct the arguments for calling snprintf or sprintf. */
4873 prefix_count = 0;
4874 if (!pad_ourselves && dp->width_arg_index != ARG_NONE)
4875 {
4876 if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
4877 abort ();
4878 prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int;
4879 }
4880 if (!prec_ourselves && dp->precision_arg_index != ARG_NONE)
4881 {
4882 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
4883 abort ();
4884 prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int;
4885 }
4886
4887 #if USE_SNPRINTF
4888 /* The SNPRINTF result is appended after result[0..length].
4889 The latter is an array of DCHAR_T; SNPRINTF appends an
4890 array of TCHAR_T to it. This is possible because
4891 sizeof (TCHAR_T) divides sizeof (DCHAR_T) and
4892 alignof (TCHAR_T) <= alignof (DCHAR_T). */
4893 # define TCHARS_PER_DCHAR (sizeof (DCHAR_T) / sizeof (TCHAR_T))
4894 /* Ensure that maxlen below will be >= 2. Needed on BeOS,
4895 where an snprintf() with maxlen==1 acts like sprintf(). */
4896 ENSURE_ALLOCATION (xsum (length,
4897 (2 + TCHARS_PER_DCHAR - 1)
4898 / TCHARS_PER_DCHAR));
4899 /* Prepare checking whether snprintf returns the count
4900 via %n. */
4901 *(TCHAR_T *) (result + length) = '\0';
4902 #endif
4903
4904 for (;;)
4905 {
4906 int count = -1;
4907
4908 #if USE_SNPRINTF
4909 int retcount = 0;
4910 size_t maxlen = allocated - length;
4911 /* SNPRINTF can fail if its second argument is
4912 > INT_MAX. */
4913 if (maxlen > INT_MAX / TCHARS_PER_DCHAR)
4914 maxlen = INT_MAX / TCHARS_PER_DCHAR;
4915 maxlen = maxlen * TCHARS_PER_DCHAR;
4916 # define SNPRINTF_BUF(arg) \
4917 switch (prefix_count) \
4918 { \
4919 case 0: \
4920 retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4921 maxlen, buf, \
4922 arg, &count); \
4923 break; \
4924 case 1: \
4925 retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4926 maxlen, buf, \
4927 prefixes[0], arg, &count); \
4928 break; \
4929 case 2: \
4930 retcount = SNPRINTF ((TCHAR_T *) (result + length), \
4931 maxlen, buf, \
4932 prefixes[0], prefixes[1], arg, \
4933 &count); \
4934 break; \
4935 default: \
4936 abort (); \
4937 }
4938 #else
4939 # define SNPRINTF_BUF(arg) \
4940 switch (prefix_count) \
4941 { \
4942 case 0: \
4943 count = sprintf (tmp, buf, arg); \
4944 break; \
4945 case 1: \
4946 count = sprintf (tmp, buf, prefixes[0], arg); \
4947 break; \
4948 case 2: \
4949 count = sprintf (tmp, buf, prefixes[0], prefixes[1],\
4950 arg); \
4951 break; \
4952 default: \
4953 abort (); \
4954 }
4955 #endif
4956
4957 errno = 0;
4958 switch (type)
4959 {
4960 case TYPE_SCHAR:
4961 {
4962 int arg = a.arg[dp->arg_index].a.a_schar;
4963 SNPRINTF_BUF (arg);
4964 }
4965 break;
4966 case TYPE_UCHAR:
4967 {
4968 unsigned int arg = a.arg[dp->arg_index].a.a_uchar;
4969 SNPRINTF_BUF (arg);
4970 }
4971 break;
4972 case TYPE_SHORT:
4973 {
4974 int arg = a.arg[dp->arg_index].a.a_short;
4975 SNPRINTF_BUF (arg);
4976 }
4977 break;
4978 case TYPE_USHORT:
4979 {
4980 unsigned int arg = a.arg[dp->arg_index].a.a_ushort;
4981 SNPRINTF_BUF (arg);
4982 }
4983 break;
4984 case TYPE_INT:
4985 {
4986 int arg = a.arg[dp->arg_index].a.a_int;
4987 SNPRINTF_BUF (arg);
4988 }
4989 break;
4990 case TYPE_UINT:
4991 {
4992 unsigned int arg = a.arg[dp->arg_index].a.a_uint;
4993 SNPRINTF_BUF (arg);
4994 }
4995 break;
4996 case TYPE_LONGINT:
4997 {
4998 long int arg = a.arg[dp->arg_index].a.a_longint;
4999 SNPRINTF_BUF (arg);
5000 }
5001 break;
5002 case TYPE_ULONGINT:
5003 {
5004 unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint;
5005 SNPRINTF_BUF (arg);
5006 }
5007 break;
5008 #if HAVE_LONG_LONG_INT
5009 case TYPE_LONGLONGINT:
5010 {
5011 long long int arg = a.arg[dp->arg_index].a.a_longlongint;
5012 SNPRINTF_BUF (arg);
5013 }
5014 break;
5015 case TYPE_ULONGLONGINT:
5016 {
5017 unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint;
5018 SNPRINTF_BUF (arg);
5019 }
5020 break;
5021 #endif
5022 case TYPE_DOUBLE:
5023 {
5024 double arg = a.arg[dp->arg_index].a.a_double;
5025 SNPRINTF_BUF (arg);
5026 }
5027 break;
5028 case TYPE_LONGDOUBLE:
5029 {
5030 long double arg = a.arg[dp->arg_index].a.a_longdouble;
5031 SNPRINTF_BUF (arg);
5032 }
5033 break;
5034 case TYPE_CHAR:
5035 {
5036 int arg = a.arg[dp->arg_index].a.a_char;
5037 SNPRINTF_BUF (arg);
5038 }
5039 break;
5040 #if HAVE_WINT_T
5041 case TYPE_WIDE_CHAR:
5042 {
5043 wint_t arg = a.arg[dp->arg_index].a.a_wide_char;
5044 SNPRINTF_BUF (arg);
5045 }
5046 break;
5047 #endif
5048 case TYPE_STRING:
5049 {
5050 const char *arg = a.arg[dp->arg_index].a.a_string;
5051 SNPRINTF_BUF (arg);
5052 }
5053 break;
5054 #if HAVE_WCHAR_T
5055 case TYPE_WIDE_STRING:
5056 {
5057 const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
5058 SNPRINTF_BUF (arg);
5059 }
5060 break;
5061 #endif
5062 case TYPE_POINTER:
5063 {
5064 void *arg = a.arg[dp->arg_index].a.a_pointer;
5065 SNPRINTF_BUF (arg);
5066 }
5067 break;
5068 default:
5069 abort ();
5070 }
5071
5072 #if USE_SNPRINTF
5073 /* Portability: Not all implementations of snprintf()
5074 are ISO C 99 compliant. Determine the number of
5075 bytes that snprintf() has produced or would have
5076 produced. */
5077 if (count >= 0)
5078 {
5079 /* Verify that snprintf() has NUL-terminated its
5080 result. */
5081 if (count < maxlen
5082 && ((TCHAR_T *) (result + length)) [count] != '\0')
5083 abort ();
5084 /* Portability hack. */
5085 if (retcount > count)
5086 count = retcount;
5087 }
5088 else
5089 {
5090 /* snprintf() doesn't understand the '%n'
5091 directive. */
5092 if (fbp[1] != '\0')
5093 {
5094 /* Don't use the '%n' directive; instead, look
5095 at the snprintf() return value. */
5096 fbp[1] = '\0';
5097 continue;
5098 }
5099 else
5100 {
5101 /* Look at the snprintf() return value. */
5102 if (retcount < 0)
5103 {
5104 # if !HAVE_SNPRINTF_RETVAL_C99
5105 /* HP-UX 10.20 snprintf() is doubly deficient:
5106 It doesn't understand the '%n' directive,
5107 *and* it returns -1 (rather than the length
5108 that would have been required) when the
5109 buffer is too small.
5110 But a failure at this point can also come
5111 from other reasons than a too small buffer,
5112 such as an invalid wide string argument to
5113 the %ls directive, or possibly an invalid
5114 floating-point argument. */
5115 size_t tmp_length =
5116 MAX_ROOM_NEEDED (&a, dp->arg_index,
5117 dp->conversion, type, flags,
5118 width, has_precision,
5119 precision, pad_ourselves);
5120
5121 if (maxlen < tmp_length)
5122 {
5123 /* Make more room. But try to do through
5124 this reallocation only once. */
5125 size_t bigger_need =
5126 xsum (length,
5127 xsum (tmp_length,
5128 TCHARS_PER_DCHAR - 1)
5129 / TCHARS_PER_DCHAR);
5130 /* And always grow proportionally.
5131 (There may be several arguments, each
5132 needing a little more room than the
5133 previous one.) */
5134 size_t bigger_need2 =
5135 xsum (xtimes (allocated, 2), 12);
5136 if (bigger_need < bigger_need2)
5137 bigger_need = bigger_need2;
5138 ENSURE_ALLOCATION (bigger_need);
5139 continue;
5140 }
5141 # endif
5142 }
5143 else
5144 count = retcount;
5145 }
5146 }
5147 #endif
5148
5149 /* Attempt to handle failure. */
5150 if (count < 0)
5151 {
5152 /* SNPRINTF or sprintf failed. Save and use the errno
5153 that it has set, if any. */
5154 int saved_errno = errno;
5155
5156 if (!(result == resultbuf || result == NULL))
5157 free (result);
5158 if (buf_malloced != NULL)
5159 free (buf_malloced);
5160 CLEANUP ();
5161 errno =
5162 (saved_errno != 0
5163 ? saved_errno
5164 : (dp->conversion == 'c' || dp->conversion == 's'
5165 ? EILSEQ
5166 : EINVAL));
5167 return NULL;
5168 }
5169
5170 #if USE_SNPRINTF
5171 /* Handle overflow of the allocated buffer.
5172 If such an overflow occurs, a C99 compliant snprintf()
5173 returns a count >= maxlen. However, a non-compliant
5174 snprintf() function returns only count = maxlen - 1. To
5175 cover both cases, test whether count >= maxlen - 1. */
5176 if ((unsigned int) count + 1 >= maxlen)
5177 {
5178 /* If maxlen already has attained its allowed maximum,
5179 allocating more memory will not increase maxlen.
5180 Instead of looping, bail out. */
5181 if (maxlen == INT_MAX / TCHARS_PER_DCHAR)
5182 goto overflow;
5183 else
5184 {
5185 /* Need at least (count + 1) * sizeof (TCHAR_T)
5186 bytes. (The +1 is for the trailing NUL.)
5187 But ask for (count + 2) * sizeof (TCHAR_T)
5188 bytes, so that in the next round, we likely get
5189 maxlen > (unsigned int) count + 1
5190 and so we don't get here again.
5191 And allocate proportionally, to avoid looping
5192 eternally if snprintf() reports a too small
5193 count. */
5194 size_t n =
5195 xmax (xsum (length,
5196 ((unsigned int) count + 2
5197 + TCHARS_PER_DCHAR - 1)
5198 / TCHARS_PER_DCHAR),
5199 xtimes (allocated, 2));
5200
5201 ENSURE_ALLOCATION (n);
5202 continue;
5203 }
5204 }
5205 #endif
5206
5207 #if NEED_PRINTF_UNBOUNDED_PRECISION
5208 if (prec_ourselves)
5209 {
5210 /* Handle the precision. */
5211 TCHAR_T *prec_ptr =
5212 # if USE_SNPRINTF
5213 (TCHAR_T *) (result + length);
5214 # else
5215 tmp;
5216 # endif
5217 size_t prefix_count;
5218 size_t move;
5219
5220 prefix_count = 0;
5221 /* Put the additional zeroes after the sign. */
5222 if (count >= 1
5223 && (*prec_ptr == '-' || *prec_ptr == '+'
5224 || *prec_ptr == ' '))
5225 prefix_count = 1;
5226 /* Put the additional zeroes after the 0x prefix if
5227 (flags & FLAG_ALT) || (dp->conversion == 'p'). */
5228 else if (count >= 2
5229 && prec_ptr[0] == '0'
5230 && (prec_ptr[1] == 'x' || prec_ptr[1] == 'X'))
5231 prefix_count = 2;
5232
5233 move = count - prefix_count;
5234 if (precision > move)
5235 {
5236 /* Insert zeroes. */
5237 size_t insert = precision - move;
5238 TCHAR_T *prec_end;
5239
5240 # if USE_SNPRINTF
5241 size_t n =
5242 xsum (length,
5243 (count + insert + TCHARS_PER_DCHAR - 1)
5244 / TCHARS_PER_DCHAR);
5245 length += (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
5246 ENSURE_ALLOCATION (n);
5247 length -= (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR;
5248 prec_ptr = (TCHAR_T *) (result + length);
5249 # endif
5250
5251 prec_end = prec_ptr + count;
5252 prec_ptr += prefix_count;
5253
5254 while (prec_end > prec_ptr)
5255 {
5256 prec_end--;
5257 prec_end[insert] = prec_end[0];
5258 }
5259
5260 prec_end += insert;
5261 do
5262 *--prec_end = '0';
5263 while (prec_end > prec_ptr);
5264
5265 count += insert;
5266 }
5267 }
5268 #endif
5269
5270 #if !USE_SNPRINTF
5271 if (count >= tmp_length)
5272 /* tmp_length was incorrectly calculated - fix the
5273 code above! */
5274 abort ();
5275 #endif
5276
5277 #if !DCHAR_IS_TCHAR
5278 /* Convert from TCHAR_T[] to DCHAR_T[]. */
5279 if (dp->conversion == 'c' || dp->conversion == 's')
5280 {
5281 /* type = TYPE_CHAR or TYPE_WIDE_CHAR or TYPE_STRING
5282 TYPE_WIDE_STRING.
5283 The result string is not certainly ASCII. */
5284 const TCHAR_T *tmpsrc;
5285 DCHAR_T *tmpdst;
5286 size_t tmpdst_len;
5287 /* This code assumes that TCHAR_T is 'char'. */
5288 typedef int TCHAR_T_verify
5289 [2 * (sizeof (TCHAR_T) == 1) - 1];
5290 # if USE_SNPRINTF
5291 tmpsrc = (TCHAR_T *) (result + length);
5292 # else
5293 tmpsrc = tmp;
5294 # endif
5295 tmpdst =
5296 DCHAR_CONV_FROM_ENCODING (locale_charset (),
5297 iconveh_question_mark,
5298 tmpsrc, count,
5299 NULL,
5300 NULL, &tmpdst_len);
5301 if (tmpdst == NULL)
5302 {
5303 int saved_errno = errno;
5304 if (!(result == resultbuf || result == NULL))
5305 free (result);
5306 if (buf_malloced != NULL)
5307 free (buf_malloced);
5308 CLEANUP ();
5309 errno = saved_errno;
5310 return NULL;
5311 }
5312 ENSURE_ALLOCATION (xsum (length, tmpdst_len));
5313 DCHAR_CPY (result + length, tmpdst, tmpdst_len);
5314 free (tmpdst);
5315 count = tmpdst_len;
5316 }
5317 else
5318 {
5319 /* The result string is ASCII.
5320 Simple 1:1 conversion. */
5321 # if USE_SNPRINTF
5322 /* If sizeof (DCHAR_T) == sizeof (TCHAR_T), it's a
5323 no-op conversion, in-place on the array starting
5324 at (result + length). */
5325 if (sizeof (DCHAR_T) != sizeof (TCHAR_T))
5326 # endif
5327 {
5328 const TCHAR_T *tmpsrc;
5329 DCHAR_T *tmpdst;
5330 size_t n;
5331
5332 # if USE_SNPRINTF
5333 if (result == resultbuf)
5334 {
5335 tmpsrc = (TCHAR_T *) (result + length);
5336 /* ENSURE_ALLOCATION will not move tmpsrc
5337 (because it's part of resultbuf). */
5338 ENSURE_ALLOCATION (xsum (length, count));
5339 }
5340 else
5341 {
5342 /* ENSURE_ALLOCATION will move the array
5343 (because it uses realloc(). */
5344 ENSURE_ALLOCATION (xsum (length, count));
5345 tmpsrc = (TCHAR_T *) (result + length);
5346 }
5347 # else
5348 tmpsrc = tmp;
5349 ENSURE_ALLOCATION (xsum (length, count));
5350 # endif
5351 tmpdst = result + length;
5352 /* Copy backwards, because of overlapping. */
5353 tmpsrc += count;
5354 tmpdst += count;
5355 for (n = count; n > 0; n--)
5356 *--tmpdst = (unsigned char) *--tmpsrc;
5357 }
5358 }
5359 #endif
5360
5361 #if DCHAR_IS_TCHAR && !USE_SNPRINTF
5362 /* Make room for the result. */
5363 if (count > allocated - length)
5364 {
5365 /* Need at least count elements. But allocate
5366 proportionally. */
5367 size_t n =
5368 xmax (xsum (length, count), xtimes (allocated, 2));
5369
5370 ENSURE_ALLOCATION (n);
5371 }
5372 #endif
5373
5374 /* Here count <= allocated - length. */
5375
5376 /* Perform padding. */
5377 #if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION
5378 if (pad_ourselves && has_width)
5379 {
5380 size_t w;
5381 # if ENABLE_UNISTDIO
5382 /* Outside POSIX, it's preferrable to compare the width
5383 against the number of _characters_ of the converted
5384 value. */
5385 w = DCHAR_MBSNLEN (result + length, count);
5386 # else
5387 /* The width is compared against the number of _bytes_
5388 of the converted value, says POSIX. */
5389 w = count;
5390 # endif
5391 if (w < width)
5392 {
5393 size_t pad = width - w;
5394
5395 /* Make room for the result. */
5396 if (xsum (count, pad) > allocated - length)
5397 {
5398 /* Need at least count + pad elements. But
5399 allocate proportionally. */
5400 size_t n =
5401 xmax (xsum3 (length, count, pad),
5402 xtimes (allocated, 2));
5403
5404 # if USE_SNPRINTF
5405 length += count;
5406 ENSURE_ALLOCATION (n);
5407 length -= count;
5408 # else
5409 ENSURE_ALLOCATION (n);
5410 # endif
5411 }
5412 /* Here count + pad <= allocated - length. */
5413
5414 {
5415 # if !DCHAR_IS_TCHAR || USE_SNPRINTF
5416 DCHAR_T * const rp = result + length;
5417 # else
5418 DCHAR_T * const rp = tmp;
5419 # endif
5420 DCHAR_T *p = rp + count;
5421 DCHAR_T *end = p + pad;
5422 DCHAR_T *pad_ptr;
5423 # if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO
5424 if (dp->conversion == 'c'
5425 || dp->conversion == 's')
5426 /* No zero-padding for string directives. */
5427 pad_ptr = NULL;
5428 else
5429 # endif
5430 {
5431 pad_ptr = (*rp == '-' ? rp + 1 : rp);
5432 /* No zero-padding of "inf" and "nan". */
5433 if ((*pad_ptr >= 'A' && *pad_ptr <= 'Z')
5434 || (*pad_ptr >= 'a' && *pad_ptr <= 'z'))
5435 pad_ptr = NULL;
5436 }
5437 /* The generated string now extends from rp to p,
5438 with the zero padding insertion point being at
5439 pad_ptr. */
5440
5441 count = count + pad; /* = end - rp */
5442
5443 if (flags & FLAG_LEFT)
5444 {
5445 /* Pad with spaces on the right. */
5446 for (; pad > 0; pad--)
5447 *p++ = ' ';
5448 }
5449 else if ((flags & FLAG_ZERO) && pad_ptr != NULL)
5450 {
5451 /* Pad with zeroes. */
5452 DCHAR_T *q = end;
5453
5454 while (p > pad_ptr)
5455 *--q = *--p;
5456 for (; pad > 0; pad--)
5457 *p++ = '0';
5458 }
5459 else
5460 {
5461 /* Pad with spaces on the left. */
5462 DCHAR_T *q = end;
5463
5464 while (p > rp)
5465 *--q = *--p;
5466 for (; pad > 0; pad--)
5467 *p++ = ' ';
5468 }
5469 }
5470 }
5471 }
5472 #endif
5473
5474 /* Here still count <= allocated - length. */
5475
5476 #if !DCHAR_IS_TCHAR || USE_SNPRINTF
5477 /* The snprintf() result did fit. */
5478 #else
5479 /* Append the sprintf() result. */
5480 memcpy (result + length, tmp, count * sizeof (DCHAR_T));
5481 #endif
5482 #if !USE_SNPRINTF
5483 if (tmp != tmpbuf)
5484 free (tmp);
5485 #endif
5486
5487 #if NEED_PRINTF_DIRECTIVE_F
5488 if (dp->conversion == 'F')
5489 {
5490 /* Convert the %f result to upper case for %F. */
5491 DCHAR_T *rp = result + length;
5492 size_t rc;
5493 for (rc = count; rc > 0; rc--, rp++)
5494 if (*rp >= 'a' && *rp <= 'z')
5495 *rp = *rp - 'a' + 'A';
5496 }
5497 #endif
5498
5499 length += count;
5500 break;
5501 }
5502 #undef pad_ourselves
5503 #undef prec_ourselves
5504 }
5505 }
5506 }
5507
5508 /* Add the final NUL. */
5509 ENSURE_ALLOCATION (xsum (length, 1));
5510 result[length] = '\0';
5511
5512 if (result != resultbuf && length + 1 < allocated)
5513 {
5514 /* Shrink the allocated memory if possible. */
5515 DCHAR_T *memory;
5516
5517 memory = (DCHAR_T *) realloc (result, (length + 1) * sizeof (DCHAR_T));
5518 if (memory != NULL)
5519 result = memory;
5520 }
5521
5522 if (buf_malloced != NULL)
5523 free (buf_malloced);
5524 CLEANUP ();
5525 *lengthp = length;
5526 /* Note that we can produce a big string of a length > INT_MAX. POSIX
5527 says that snprintf() fails with errno = EOVERFLOW in this case, but
5528 that's only because snprintf() returns an 'int'. This function does
5529 not have this limitation. */
5530 return result;
5531
5532 #if USE_SNPRINTF
5533 overflow:
5534 if (!(result == resultbuf || result == NULL))
5535 free (result);
5536 if (buf_malloced != NULL)
5537 free (buf_malloced);
5538 CLEANUP ();
5539 errno = EOVERFLOW;
5540 return NULL;
5541 #endif
5542
5543 out_of_memory:
5544 if (!(result == resultbuf || result == NULL))
5545 free (result);
5546 if (buf_malloced != NULL)
5547 free (buf_malloced);
5548 out_of_memory_1:
5549 CLEANUP ();
5550 errno = ENOMEM;
5551 return NULL;
5552 }
5553 }
5554
5555 #undef MAX_ROOM_NEEDED
5556 #undef TCHARS_PER_DCHAR
5557 #undef SNPRINTF
5558 #undef USE_SNPRINTF
5559 #undef DCHAR_SET
5560 #undef DCHAR_CPY
5561 #undef PRINTF_PARSE
5562 #undef DIRECTIVES
5563 #undef DIRECTIVE
5564 #undef DCHAR_IS_TCHAR
5565 #undef TCHAR_T
5566 #undef DCHAR_T
5567 #undef FCHAR_T
5568 #undef VASNPRINTF
5569