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