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