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