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