1 /* mpfr_vasnprintf_aux -- helper function for the formatted output functions 2 (printf functions family). 3 4 Copyright 2007-2023 Free Software Foundation, Inc. 5 Contributed by the AriC and Caramba projects, INRIA. 6 7 This file is part of the GNU MPFR Library. 8 9 The GNU MPFR Library is free software; you can redistribute it and/or modify 10 it under the terms of the GNU Lesser General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or (at your 12 option) any later version. 13 14 The GNU MPFR Library is distributed in the hope that it will be useful, but 15 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 17 License for more details. 18 19 You should have received a copy of the GNU Lesser General Public License 20 along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see 21 https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., 22 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */ 23 24 /* If the number of output characters is larger than INT_MAX, the 25 ISO C99 / C11 standards are silent, but POSIX[*] requires the 26 function to return a negative value and set errno to EOVERFLOW. 27 [*] The Open Group Base Specifications Issue 7, 2018 edition 28 IEEE Std 1003.1-2017 (Revision of IEEE Std 1003.1-2008) 29 https://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html 30 This follows a defect report submitted in 2007 to austin-review-l. 31 Even in case of such a failure (just because of the limitation on int), 32 we try to support %n, %ln, %jn when possible. That's why the sizes (or 33 lengths) are expressed using mpfr_intmax_t in the code below. */ 34 35 /* Notes about limitations on some platforms: 36 37 Due to limitations from the C standard and GMP, if size_t < unsigned int 38 (which is allowed by the C standard but unlikely to occur on any 39 platform), the behavior is undefined for output that would reach 40 SIZE_MAX = (size_t) -1 (if the result cannot be delivered, there should 41 be an assertion failure, but this could not be tested). 42 43 The stdarg(3) Linux man page says: 44 On some systems, va_end contains a closing '}' matching a '{' in 45 va_start, so that both macros must occur in the same function, 46 and in a way that allows this. 47 However, the only requirement from ISO C is that both macros must be 48 invoked in the same function (MPFR uses va_copy instead of va_start, 49 but the requirement is the same). Here, MPFR just follows ISO C. 50 */ 51 52 /* Needed due to the tests on HAVE_STDARG and MPFR_USE_MINI_GMP */ 53 #ifdef HAVE_CONFIG_H 54 # include "config.h" 55 #endif 56 57 /* The mpfr_printf-like functions are defined only if <stdarg.h> exists. 58 Since they use mpf_t, they cannot be defined with mini-gmp. */ 59 #if defined(HAVE_STDARG) && !defined(MPFR_USE_MINI_GMP) 60 61 #include <stdarg.h> 62 63 #ifndef HAVE_VA_COPY 64 # ifdef HAVE___VA_COPY 65 # define va_copy(dst,src) __va_copy(dst, src) 66 # else 67 /* autoconf manual advocates this fallback. 68 This is also the solution chosen by gmp */ 69 # define va_copy(dst,src) \ 70 do { memcpy(&(dst), &(src), sizeof(va_list)); } while (0) 71 # endif /* HAVE___VA_COPY */ 72 #endif /* HAVE_VA_COPY */ 73 74 #ifdef HAVE_WCHAR_H 75 #include <wchar.h> 76 #endif 77 78 #if defined (__cplusplus) 79 #include <cstddef> 80 #else 81 #include <stddef.h> /* for ptrdiff_t */ 82 #endif 83 84 #include <errno.h> 85 86 #define MPFR_NEED_LONGLONG_H 87 #define MPFR_NEED_INTMAX_H 88 #include "mpfr-impl.h" 89 90 /* Define a length modifier corresponding to mpfr_prec_t. 91 We use literal string instead of literal character so as to permit future 92 extension to long long int ("ll"). */ 93 #if _MPFR_PREC_FORMAT == 1 94 #define MPFR_PREC_FORMAT_TYPE "h" 95 #define MPFR_PREC_FORMAT_SIZE 1 96 #elif _MPFR_PREC_FORMAT == 2 97 #define MPFR_PREC_FORMAT_TYPE "" 98 #define MPFR_PREC_FORMAT_SIZE 0 99 #elif _MPFR_PREC_FORMAT == 3 100 #define MPFR_PREC_FORMAT_TYPE "l" 101 #define MPFR_PREC_FORMAT_SIZE 1 102 #else 103 #error "mpfr_prec_t size not supported" 104 #endif 105 106 /* Output for special values defined in the C99 standard */ 107 #define MPFR_NAN_STRING_LC "nan" 108 #define MPFR_NAN_STRING_UC "NAN" 109 #define MPFR_NAN_STRING_LENGTH 3 110 #define MPFR_INF_STRING_LC "inf" 111 #define MPFR_INF_STRING_UC "INF" 112 #define MPFR_INF_STRING_LENGTH 3 113 114 #define DEFAULT_DECIMAL_PREC 6 115 116 /* The implicit \0 is useless, but we do not write num_to_text[16] 117 otherwise g++ complains. */ 118 static const char num_to_text[] = "0123456789abcdef"; 119 120 /* some macro and functions for parsing format string */ 121 122 /* Read an integer var of type mpfr_intmax_t. In case of overflow, set 123 overflow to 1. 124 The variable var must be 0 on input. If there are no digits, it is 125 left to 0. 126 This macro will be used to read the field width and the precision. 127 The behavior will be similar to ISO C99. Note that unless "*" is 128 used, the result will be non-negative (ISO C99 and C11 just specify 129 "optional decimal integer" for the precision, but the behavior with 130 a hardcoded negative integer is not explicitly defined, thus it is 131 undefined, so that it is fine to reject such integers; the C2x draft 132 now clarifies this: "an optional non-negative decimal integer"). 133 Note: Since mpfr_intmax_t = int is theoretically possible, all values 134 of var are potentially valid values (via '*'). Hence the need of an 135 overflow flag instead of a special value that would indicate overflow. 136 Just saturating would not be OK either as the maximum value could be 137 meaningful with %jn and/or in the case mpfr_intmax_t = int, for 138 MPFR_PREC_ARG, i.e. one must be able to distinguish the maximum value 139 from an overflow. 140 */ 141 #define READ_INT(ap, format, var) \ 142 do { \ 143 MPFR_ASSERTD ((var) == 0); \ 144 if (*(format) == '*') \ 145 { \ 146 (var) = va_arg ((ap), int); \ 147 ++(format); \ 148 } \ 149 else \ 150 for ( ; *(format) >= '0' && *(format) <= '9' ; ++(format)) \ 151 if (!(overflow)) \ 152 { \ 153 if ((var) > MPFR_INTMAX_MAX / 10) \ 154 (overflow) = 1; \ 155 else \ 156 { \ 157 int _i; \ 158 (var) *= 10; \ 159 _i = *(format) - '0'; \ 160 MPFR_ASSERTN (_i >= 0 && _i <= 9); \ 161 if ((var) > MPFR_INTMAX_MAX - _i) \ 162 (overflow) = 1; \ 163 else \ 164 (var) += _i; \ 165 } \ 166 } \ 167 } while (0) 168 169 /* arg_t contains all the types described by the 'type' field of the 170 format string */ 171 enum arg_t 172 { 173 NONE, 174 CHAR_ARG, 175 SHORT_ARG, 176 LONG_ARG, 177 LONG_LONG_ARG, 178 INTMAX_ARG, 179 SIZE_ARG, 180 PTRDIFF_ARG, 181 LONG_DOUBLE_ARG, 182 MPF_ARG, 183 MPQ_ARG, 184 MP_LIMB_ARG, 185 MP_LIMB_ARRAY_ARG, 186 MPZ_ARG, 187 MPFR_PREC_ARG, 188 MPFR_ARG, 189 UNSUPPORTED 190 }; 191 192 /* Each conversion specification of the format string will be translated in a 193 printf_spec structure by the parser. 194 This structure is adapted from the GNU libc one. */ 195 struct printf_spec 196 { 197 unsigned int alt:1; /* # flag */ 198 unsigned int space:1; /* Space flag */ 199 unsigned int left:1; /* - flag */ 200 unsigned int showsign:1; /* + flag */ 201 unsigned int group:1; /* ' flag */ 202 203 mpfr_intmax_t width; /* Width */ 204 mpfr_intmax_t prec; /* Precision, or negative if omitted */ 205 size_t size; /* Wanted size (0 iff snprintf with size=0) */ 206 207 enum arg_t arg_type; /* Type of argument */ 208 mpfr_rnd_t rnd_mode; /* Rounding mode */ 209 char spec; /* Conversion specifier */ 210 211 char pad; /* Padding character */ 212 }; 213 214 static void 215 specinfo_init (struct printf_spec *specinfo) 216 { 217 specinfo->alt = 0; 218 specinfo->space = 0; 219 specinfo->left = 0; 220 specinfo->showsign = 0; 221 specinfo->group = 0; 222 specinfo->width = 0; 223 specinfo->prec = 0; 224 specinfo->size = 1; 225 specinfo->arg_type = NONE; 226 specinfo->rnd_mode = MPFR_RNDN; 227 specinfo->spec = '\0'; 228 specinfo->pad = ' '; 229 } 230 231 /* Note: LONG_ARG is unusual, but is accepted (ISO C99 says "as no effect 232 on a following a, A, e, E, f, F, g, or G conversion specifier"). */ 233 #define FLOATING_POINT_ARG_TYPE(at) \ 234 ((at) == MPFR_ARG || (at) == MPF_ARG \ 235 || (at) == LONG_ARG || (at) == LONG_DOUBLE_ARG) 236 237 #define INTEGER_LIKE_ARG_TYPE(at) \ 238 ((at) == SHORT_ARG || (at) == LONG_ARG || (at) == LONG_LONG_ARG \ 239 || (at) == INTMAX_ARG || (at) == MPFR_PREC_ARG || (at) == MPZ_ARG \ 240 || (at) == MPQ_ARG || (at) == MP_LIMB_ARG || (at) == MP_LIMB_ARRAY_ARG \ 241 || (at) == CHAR_ARG || (at) == SIZE_ARG || (at) == PTRDIFF_ARG) 242 243 static int 244 specinfo_is_valid (struct printf_spec spec) 245 { 246 switch (spec.spec) 247 { 248 case 'n': 249 return -1; 250 251 case 'a': case 'A': 252 case 'e': case 'E': 253 case 'f': /* 'F': see below */ 254 case 'g': case 'G': 255 return (spec.arg_type == NONE 256 || FLOATING_POINT_ARG_TYPE (spec.arg_type)); 257 258 case 'F': /* only MPFR_ARG is supported since GMP doesn't support it 259 due to its use as the mpf_t type specifier */ 260 case 'b': 261 return spec.arg_type == MPFR_ARG; 262 263 case 'd': case 'i': 264 case 'o': case 'u': 265 case 'x': case 'X': 266 return (spec.arg_type == NONE 267 || INTEGER_LIKE_ARG_TYPE (spec.arg_type)); 268 269 case 'c': 270 case 's': 271 return (spec.arg_type == NONE || spec.arg_type == LONG_ARG); 272 273 case 'p': 274 return spec.arg_type == NONE; 275 276 default: 277 return 0; 278 } 279 } 280 281 /* Note: additional flags should be added to the MPFR_PREC_ARG code 282 for gmp_asprintf (when supported). */ 283 MPFR_RETURNS_NONNULL static const char * 284 parse_flags (const char *format, struct printf_spec *specinfo) 285 { 286 while (*format) 287 { 288 switch (*format) 289 { 290 case '0': 291 specinfo->pad = '0'; 292 ++format; 293 break; 294 case '#': 295 specinfo->alt = 1; 296 ++format; 297 break; 298 case '+': 299 specinfo->showsign = 1; 300 ++format; 301 break; 302 case ' ': 303 specinfo->space = 1; 304 ++format; 305 break; 306 case '-': 307 specinfo->left = 1; 308 ++format; 309 break; 310 case '\'': 311 /* Single UNIX Specification for thousand separator */ 312 specinfo->group = 1; 313 ++format; 314 break; 315 default: 316 return format; 317 } 318 } 319 return format; 320 } 321 322 MPFR_RETURNS_NONNULL static const char * 323 parse_arg_type (const char *format, struct printf_spec *specinfo) 324 { 325 switch (*format) 326 { 327 case '\0': 328 break; 329 case 'h': 330 if (*++format == 'h') 331 { 332 ++format; 333 specinfo->arg_type = CHAR_ARG; 334 } 335 else 336 specinfo->arg_type = SHORT_ARG; 337 break; 338 case 'l': 339 if (*++format == 'l') 340 { 341 ++format; 342 #if defined (HAVE_LONG_LONG) 343 specinfo->arg_type = LONG_LONG_ARG; 344 #else 345 specinfo->arg_type = UNSUPPORTED; 346 #endif 347 break; 348 } 349 else 350 { 351 specinfo->arg_type = LONG_ARG; 352 break; 353 } 354 case 'j': 355 ++format; 356 #if defined(_MPFR_H_HAVE_INTMAX_T) 357 specinfo->arg_type = INTMAX_ARG; 358 #else 359 specinfo->arg_type = UNSUPPORTED; 360 #endif 361 break; 362 case 'z': 363 ++format; 364 specinfo->arg_type = SIZE_ARG; 365 break; 366 case 't': 367 ++format; 368 specinfo->arg_type = PTRDIFF_ARG; 369 break; 370 case 'L': 371 ++format; 372 specinfo->arg_type = LONG_DOUBLE_ARG; 373 break; 374 case 'F': 375 ++format; 376 specinfo->arg_type = MPF_ARG; 377 break; 378 case 'Q': 379 ++format; 380 specinfo->arg_type = MPQ_ARG; 381 break; 382 case 'M': 383 ++format; 384 /* The 'M' specifier was added in gmp 4.2.0 */ 385 specinfo->arg_type = MP_LIMB_ARG; 386 break; 387 case 'N': 388 ++format; 389 specinfo->arg_type = MP_LIMB_ARRAY_ARG; 390 break; 391 case 'Z': 392 ++format; 393 specinfo->arg_type = MPZ_ARG; 394 break; 395 396 /* mpfr specific specifiers */ 397 case 'P': 398 ++format; 399 specinfo->arg_type = MPFR_PREC_ARG; 400 break; 401 case 'R': 402 ++format; 403 specinfo->arg_type = MPFR_ARG; 404 } 405 return format; 406 } 407 408 409 /* some macros and functions filling the buffer */ 410 411 /* CONSUME_VA_ARG removes from va_list AP the type expected by SPECINFO */ 412 413 /* With a C++ compiler wchar_t and enumeration in va_list are converted to 414 integer type : int, unsigned int, long or unsigned long (unfortunately, 415 this is implementation dependent). 416 We follow gmp which assumes in print/doprnt.c that wchar_t is converted 417 to int (because wchar_t <= int). 418 For wint_t, we assume that the case WINT_MAX < INT_MAX yields an 419 integer promotion. */ 420 #if defined(WINT_MAX) && WINT_MAX < INT_MAX 421 typedef int mpfr_va_wint; /* integer promotion */ 422 #else 423 typedef wint_t mpfr_va_wint; 424 #endif 425 #define CASE_LONG_ARG(specinfo, ap) \ 426 case LONG_ARG: \ 427 if ((specinfo).spec == 'd' || (specinfo).spec == 'i' \ 428 || (specinfo).spec == 'o' || (specinfo).spec == 'u' \ 429 || (specinfo).spec == 'x' || (specinfo).spec == 'X') \ 430 (void) va_arg ((ap), long); \ 431 else if ((specinfo).spec == 'c') \ 432 (void) va_arg ((ap), mpfr_va_wint); \ 433 else if ((specinfo).spec == 's') \ 434 (void) va_arg ((ap), int); /* we assume integer promotion */ \ 435 else if ((specinfo).spec == 'a' || (specinfo).spec == 'A' \ 436 || (specinfo).spec == 'e' || (specinfo).spec == 'E' \ 437 || (specinfo).spec == 'f' /* 'F' impossible */ \ 438 || (specinfo).spec == 'g' || (specinfo).spec == 'G') \ 439 (void) va_arg ((ap), double); \ 440 else \ 441 MPFR_RET_NEVER_GO_HERE(); \ 442 break; 443 444 #if defined(_MPFR_H_HAVE_INTMAX_T) 445 #define CASE_INTMAX_ARG(specinfo, ap) \ 446 case INTMAX_ARG: \ 447 (void) va_arg ((ap), intmax_t); \ 448 break; 449 #else 450 #define CASE_INTMAX_ARG(specinfo, ap) 451 #endif 452 453 #ifdef HAVE_LONG_LONG 454 #define CASE_LONG_LONG_ARG(specinfo, ap) \ 455 case LONG_LONG_ARG: \ 456 (void) va_arg ((ap), long long); \ 457 break; 458 #else 459 #define CASE_LONG_LONG_ARG(specinfo, ap) 460 #endif 461 462 /* Note: (specinfo).width may be incorrect in case of overflow, 463 but it is not used by CONSUME_VA_ARG. */ 464 #define CONSUME_VA_ARG(specinfo, ap) \ 465 do { \ 466 switch ((specinfo).arg_type) \ 467 { \ 468 case CHAR_ARG: \ 469 case SHORT_ARG: \ 470 (void) va_arg ((ap), int); \ 471 break; \ 472 CASE_LONG_ARG (specinfo, ap) \ 473 CASE_LONG_LONG_ARG (specinfo, ap) \ 474 CASE_INTMAX_ARG (specinfo, ap) \ 475 case SIZE_ARG: \ 476 (void) va_arg ((ap), size_t); \ 477 break; \ 478 case PTRDIFF_ARG: \ 479 (void) va_arg ((ap), ptrdiff_t); \ 480 break; \ 481 case LONG_DOUBLE_ARG: \ 482 (void) va_arg ((ap), long double); \ 483 break; \ 484 case MPF_ARG: \ 485 (void) va_arg ((ap), mpf_srcptr); \ 486 break; \ 487 case MPQ_ARG: \ 488 (void) va_arg ((ap), mpq_srcptr); \ 489 break; \ 490 case MP_LIMB_ARG: \ 491 (void) va_arg ((ap), mp_limb_t); \ 492 break; \ 493 case MP_LIMB_ARRAY_ARG: \ 494 (void) va_arg ((ap), mpfr_limb_ptr); \ 495 (void) va_arg ((ap), mp_size_t); \ 496 break; \ 497 case MPZ_ARG: \ 498 (void) va_arg ((ap), mpz_srcptr); \ 499 break; \ 500 default: \ 501 switch ((specinfo).spec) \ 502 { \ 503 case 'd': \ 504 case 'i': \ 505 case 'o': \ 506 case 'u': \ 507 case 'x': \ 508 case 'X': \ 509 case 'c': \ 510 (void) va_arg ((ap), int); \ 511 break; \ 512 case 'a': \ 513 case 'A': \ 514 case 'e': \ 515 case 'E': \ 516 case 'f': \ 517 /* 'F' impossible */ \ 518 case 'g': \ 519 case 'G': \ 520 (void) va_arg ((ap), double); \ 521 break; \ 522 case 's': \ 523 (void) va_arg ((ap), char *); \ 524 break; \ 525 case 'p': \ 526 (void) va_arg ((ap), void *); \ 527 } \ 528 } \ 529 } while (0) 530 531 /* Process the format part which does not deal with mpfr types, 532 Jump to external label 'error' if gmp_asprintf return -1. 533 Note: start and end are pointers to the format string, so that 534 size_t is the best type to express the difference. 535 FIXME: If buf.size = 0 or size != 0, gmp_vsnprintf should be called 536 instead of gmp_vasprintf, outputting data directly to the buffer 537 when applicable. 538 */ 539 #define FLUSH(flag, start, end, ap, buf_ptr) \ 540 do { \ 541 const size_t n = (end) - (start); \ 542 if ((flag)) \ 543 /* previous specifiers are understood by gmp_printf */ \ 544 { \ 545 MPFR_TMP_DECL (marker); \ 546 char *fmt_copy, *s; \ 547 int length; \ 548 \ 549 MPFR_TMP_MARK (marker); \ 550 fmt_copy = (char *) MPFR_TMP_ALLOC (n + 1); \ 551 strncpy (fmt_copy, (start), n); \ 552 fmt_copy[n] = '\0'; \ 553 length = gmp_vasprintf (&s, fmt_copy, (ap)); \ 554 if (length < 0) \ 555 { \ 556 MPFR_TMP_FREE (marker); \ 557 goto error; \ 558 } \ 559 buffer_cat ((buf_ptr), s, length); \ 560 mpfr_free_str (s); \ 561 (flag) = 0; \ 562 MPFR_TMP_FREE (marker); \ 563 } \ 564 else if ((start) != (end)) \ 565 /* no conversion specification, just simple characters */ \ 566 buffer_cat ((buf_ptr), (start), n); \ 567 } while (0) 568 569 /* Note: in case some form of %n is used in the format string, 570 we may need the maximum signed integer type for len. */ 571 struct string_buffer 572 { 573 char *start; /* beginning of the buffer */ 574 char *curr; /* null terminating character */ 575 size_t size; /* buffer capacity */ 576 mpfr_intmax_t len; /* string length or -1 if overflow */ 577 }; 578 579 static void 580 buffer_init (struct string_buffer *b, size_t s) 581 { 582 if (s != 0) 583 { 584 b->start = (char *) mpfr_allocate_func (s); 585 b->start[0] = '\0'; 586 b->curr = b->start; 587 } 588 b->size = s; 589 b->len = 0; 590 } 591 592 /* Increase the len field of the buffer. Return non-zero iff overflow. */ 593 static int 594 buffer_incr_len (struct string_buffer *b, mpfr_intmax_t len) 595 { 596 if (b->len == -1) 597 return 1; 598 else 599 { 600 /* We need to take mpfr_uintmax_t as the type must be as large 601 as both size_t (which is unsigned) and mpfr_intmax_t (which 602 is used for the 'n' format specifier). */ 603 mpfr_uintmax_t newlen = (mpfr_uintmax_t) b->len + len; 604 605 /* mpfr_uintmax_t is unsigned, thus the above is valid, but one 606 has newlen < len in case of overflow. */ 607 608 if (MPFR_UNLIKELY (newlen < len || newlen > MPFR_INTMAX_MAX)) 609 { 610 MPFR_LOG_MSG (("Overflow\n", 0)); 611 b->len = -1; 612 return 1; 613 } 614 else 615 { 616 b->len = newlen; 617 return 0; 618 } 619 } 620 } 621 622 /* Increase buffer size by a number of character being the least multiple of 623 4096 greater than len+1. */ 624 static void 625 buffer_widen (struct string_buffer *b, size_t len) 626 { 627 const size_t pos = b->curr - b->start; 628 const size_t n = 0x1000 + (len & ~((size_t) 0xfff)); 629 630 /* There are currently limitations here. We would need to switch to 631 the null-size behavior once there is an overflow in the buffer. */ 632 633 MPFR_ASSERTN (n >= 0x1000 && n >= len); 634 635 MPFR_ASSERTD (*b->curr == '\0'); 636 MPFR_ASSERTD (pos < b->size); 637 638 MPFR_ASSERTN (b->size < ((size_t) -1) - n); 639 640 b->start = (char *) mpfr_reallocate_func (b->start, b->size, b->size + n); 641 b->size += n; 642 b->curr = b->start + pos; 643 644 MPFR_ASSERTD (pos < b->size); 645 MPFR_ASSERTD (*b->curr == '\0'); 646 } 647 648 /* Concatenate the first len characters of the string s to the buffer b and 649 expand it if needed. Return non-zero if overflow. */ 650 static int 651 buffer_cat (struct string_buffer *b, const char *s, size_t len) 652 { 653 /* If len == 0, which is possible when outputting an integer 0 654 (either a native one or mpfr_prec_t) with precision field = 0, 655 do nothing. This test is not necessary since the code below is 656 valid for len == 0, but this is safer, just in case. */ 657 if (len == 0) 658 return 0; 659 660 MPFR_ASSERTD (len <= strlen (s)); 661 662 if (buffer_incr_len (b, len)) 663 return 1; 664 665 if (b->size != 0) 666 { 667 MPFR_ASSERTD (*b->curr == '\0'); 668 MPFR_ASSERTN (b->size < ((size_t) -1) - len); 669 if (MPFR_UNLIKELY (b->curr + len >= b->start + b->size)) 670 buffer_widen (b, len); 671 672 /* strncat is similar to strncpy here, except that strncat ensures 673 that the buffer will be null-terminated. */ 674 strncat (b->curr, s, len); 675 b->curr += len; 676 677 MPFR_ASSERTD (b->curr < b->start + b->size); 678 MPFR_ASSERTD (*b->curr == '\0'); 679 } 680 681 return 0; 682 } 683 684 /* Add n characters c to the end of buffer b. Return non-zero if overflow. */ 685 static int 686 buffer_pad (struct string_buffer *b, const char c, const mpfr_intmax_t n) 687 { 688 MPFR_ASSERTD (n > 0); 689 690 if (buffer_incr_len (b, n)) 691 return 1; 692 693 if (b->size != 0) 694 { 695 MPFR_ASSERTD (*b->curr == '\0'); 696 697 if (n > (size_t) -1 || b->size > ((size_t) -1) - n) 698 { 699 /* Reallocation will not be possible. Regard this as an overflow. */ 700 b->len = -1; 701 return 1; 702 } 703 704 if (MPFR_UNLIKELY (b->curr + n >= b->start + b->size)) 705 buffer_widen (b, n); 706 707 if (n == 1) 708 *b->curr = c; 709 else 710 memset (b->curr, c, n); 711 b->curr += n; 712 *b->curr = '\0'; 713 714 MPFR_ASSERTD (b->curr < b->start + b->size); 715 } 716 717 return 0; 718 } 719 720 /* Form a string by concatenating the first len characters of str to tz 721 zero(s), insert into one character c each 3 characters starting from end 722 to beginning and concatenate the result to the buffer b. 723 Assume c is not null (\0). Return non-zero if overflow. */ 724 static int 725 buffer_sandwich (struct string_buffer *b, char *str, size_t len, 726 const size_t tz, const char c) 727 { 728 const size_t step = 3; 729 size_t size, q, r, fullsize, i; 730 char *oldcurr; 731 732 MPFR_ASSERTD (b->size != 0); 733 MPFR_ASSERTD (tz == 0 || tz == 1); 734 735 if (len <= ULONG_MAX) 736 MPFR_LOG_MSG (("len=%lu\n", (unsigned long) len)); 737 if (tz <= ULONG_MAX) 738 MPFR_LOG_MSG (("tz=%lu\n", (unsigned long) tz)); 739 740 MPFR_ASSERTD (len <= strlen (str)); 741 MPFR_ASSERTD (c != '\0'); 742 743 /* check that len + tz does not overflow */ 744 if (len > (size_t) -1 - tz) 745 return 1; 746 747 size = len + tz; /* number of digits */ 748 MPFR_ASSERTD (size > 0); 749 750 q = (size - 1) / step; /* number of separators C */ 751 r = ((size - 1) % step) + 1; /* number of digits in the leftmost block */ 752 MPFR_ASSERTD (r >= 1 && r <= step); 753 754 /* check that size + q does not overflow */ 755 if (size > (size_t) -1 - q) 756 return 1; 757 758 fullsize = size + q; /* number of digits and separators */ 759 760 if (buffer_incr_len (b, fullsize)) 761 return 1; 762 763 MPFR_ASSERTD (*b->curr == '\0'); 764 MPFR_ASSERTN (b->size < ((size_t) -1) - fullsize); 765 if (MPFR_UNLIKELY (b->curr + fullsize >= b->start + b->size)) 766 buffer_widen (b, fullsize); 767 768 MPFR_DBGRES (oldcurr = b->curr); 769 770 /* first r significant digits (leftmost block) */ 771 if (r <= len) 772 { 773 memcpy (b->curr, str, r); 774 str += r; 775 len -= r; 776 } 777 else 778 { 779 MPFR_ASSERTD (r > len); 780 MPFR_ASSERTD (len < step); /* as a consequence */ 781 MPFR_ASSERTD (size <= step); /* as a consequence */ 782 MPFR_ASSERTD (q == 0); /* as a consequence */ 783 MPFR_ASSERTD (r == size); /* as a consequence */ 784 MPFR_ASSERTD (tz == 1); /* as a consequence */ 785 memcpy (b->curr, str, len); 786 *(b->curr + len) = '0'; /* trailing zero */ 787 /* We do not need to set len to 0 since it will not be read again 788 (q = 0, so that the loop below will have 0 iterations). */ 789 } 790 b->curr += r; 791 792 for (i = 0; i < q; ++i) 793 { 794 *b->curr++ = c; 795 if (MPFR_LIKELY (len >= step)) 796 { 797 memcpy (b->curr, str, step); 798 len -= step; 799 str += step; 800 } 801 else 802 { 803 /* last digits */ 804 MPFR_ASSERTD (i == q - 1 && step - len == 1); 805 memcpy (b->curr, str, len); 806 *(b->curr + len) = '0'; /* trailing zero */ 807 } 808 b->curr += step; 809 } 810 811 MPFR_ASSERTD (b->curr - oldcurr == fullsize); 812 813 *b->curr = '\0'; 814 815 MPFR_ASSERTD (b->curr < b->start + b->size); 816 817 return 0; 818 } 819 820 /* Helper struct and functions for temporary strings management */ 821 /* struct for easy string clearing */ 822 struct string_list 823 { 824 char *string; 825 struct string_list *next; /* NULL in last node */ 826 }; 827 828 /* initialization */ 829 static void 830 init_string_list (struct string_list *sl) 831 { 832 sl->string = NULL; 833 sl->next = NULL; 834 } 835 836 /* clear all strings in the list */ 837 static void 838 clear_string_list (struct string_list *sl) 839 { 840 struct string_list *n; 841 842 while (sl) 843 { 844 if (sl->string) 845 mpfr_free_str (sl->string); 846 n = sl->next; 847 mpfr_free_func (sl, sizeof(struct string_list)); 848 sl = n; 849 } 850 } 851 852 /* add a string in the list */ 853 static char * 854 register_string (struct string_list *sl, char *new_string) 855 { 856 /* look for the last node */ 857 while (sl->next) 858 sl = sl->next; 859 860 sl->next = (struct string_list *) 861 mpfr_allocate_func (sizeof (struct string_list)); 862 863 sl = sl->next; 864 sl->next = NULL; 865 return sl->string = new_string; 866 } 867 868 /* padding type: where are the padding characters */ 869 enum pad_t 870 { 871 LEFT, /* spaces in left hand side for right justification */ 872 LEADING_ZEROS, /* padding with '0' characters in integral part */ 873 RIGHT /* spaces in right hand side for left justification */ 874 }; 875 876 /* number_parts details how much characters are needed in each part of a float 877 print. */ 878 struct number_parts 879 { 880 enum pad_t pad_type; /* Padding type */ 881 mpfr_intmax_t pad_size; /* Number of padding characters */ 882 883 char sign; /* Sign character ('-', '+', ' ', or '\0') */ 884 885 char *prefix_ptr; /* Pointer to prefix part */ 886 size_t prefix_size; /* Number of characters in *prefix_ptr */ 887 888 char thousands_sep; /* Thousands separator (only with style 'f') */ 889 890 char *ip_ptr; /* Pointer to integral part characters*/ 891 size_t ip_size; /* Number of digits in *ip_ptr */ 892 int ip_trailing_digits; /* Number of additional digits in integral part 893 (if spec.size != 0, this can only be a zero) */ 894 895 char point; /* Decimal point character */ 896 897 mpfr_intmax_t fp_leading_zeros; /* Number of additional leading zeros in 898 fractional part */ 899 char *fp_ptr; /* Pointer to fractional part characters */ 900 size_t fp_size; /* Number of digits in *fp_ptr */ 901 mpfr_intmax_t fp_trailing_zeros; /* Number of additional trailing zeros in 902 fractional part */ 903 904 char *exp_ptr; /* Pointer to exponent part */ 905 size_t exp_size; /* Number of characters in *exp_ptr */ 906 907 struct string_list *sl; /* List of string buffers in use: we need such a 908 mechanism because fp_ptr may point into the same 909 string as ip_ptr */ 910 }; 911 912 /* For a real non zero number x, what is the base exponent f when rounding x 913 with rounding mode r to r(x) = m*b^f, where m is a digit and 1 <= m < b ? 914 Return non zero value if x is rounded up to b^f, return zero otherwise */ 915 /* FIXME: It seems that the base-2 exponent is taken into account, which is 916 what is expected. In this case, the description is incorrect. */ 917 static int 918 next_base_power_p (mpfr_srcptr x, int base, mpfr_rnd_t rnd) 919 { 920 mpfr_prec_t nbits; 921 mp_limb_t pm; 922 mp_limb_t xm; 923 924 MPFR_ASSERTD (MPFR_IS_PURE_FP (x)); 925 MPFR_ASSERTD (base == 2 || base == 16); 926 927 /* Warning: the decimal point is AFTER THE FIRST DIGIT in this output 928 representation. */ 929 nbits = base == 2 ? 1 : 4; 930 931 if (rnd == MPFR_RNDZ 932 || (rnd == MPFR_RNDD && MPFR_IS_POS (x)) 933 || (rnd == MPFR_RNDU && MPFR_IS_NEG (x)) 934 || MPFR_PREC (x) <= nbits) 935 /* no rounding when printing x with 1 digit */ 936 return 0; 937 938 xm = MPFR_MANT (x) [MPFR_LIMB_SIZE (x) - 1]; 939 pm = MPFR_LIMB_MASK (GMP_NUMB_BITS - nbits); 940 if ((xm & ~pm) ^ ~pm) 941 /* do no round up if some of the nbits first bits are 0s. */ 942 return 0; 943 944 if (rnd == MPFR_RNDN) 945 /* mask for rounding bit */ 946 pm = (MPFR_LIMB_ONE << (GMP_NUMB_BITS - nbits - 1)); 947 948 /* round up if some remaining bits are 1 */ 949 /* warning: the return value must be an int */ 950 return xm & pm ? 1 : 0; 951 } 952 953 /* Record information from mpfr_get_str() so as to avoid multiple 954 calls to this expensive function. */ 955 struct decimal_info 956 { 957 mpfr_exp_t exp; 958 char *str; 959 }; 960 961 /* For a real non zero number x, what is the exponent f so that 962 10^f <= x < 10^(f+1). */ 963 static mpfr_exp_t 964 floor_log10 (mpfr_srcptr x) 965 { 966 mpfr_t y; 967 mpfr_exp_t exp; 968 969 /* make sure first that y can represent a mpfr_exp_t exactly 970 and can compare with x */ 971 mpfr_prec_t prec = sizeof (mpfr_exp_t) * CHAR_BIT; 972 mpfr_init2 (y, MAX (prec, MPFR_PREC (x))); 973 974 exp = mpfr_ceil_mul (MPFR_GET_EXP (x), 10, 1) - 1; 975 mpfr_set_exp_t (y, exp, MPFR_RNDU); 976 /* The following call to mpfr_ui_pow should be fast: y is an integer 977 (not too large), so that mpfr_pow_z will be used internally. */ 978 mpfr_ui_pow (y, 10, y, MPFR_RNDU); 979 if (mpfr_cmpabs (x, y) < 0) 980 exp--; 981 982 mpfr_clear (y); 983 return exp; 984 } 985 986 #define NDIGITS 8 987 988 MPFR_RETURNS_NONNULL static char * 989 mpfr_get_str_wrapper (mpfr_exp_t *exp, int base, size_t n, mpfr_srcptr op, 990 const struct printf_spec spec) 991 { 992 size_t ndigits; 993 char *str, *s, nine; 994 int neg; 995 996 /* Possibles bases for the *printf functions. */ 997 MPFR_ASSERTD (base == 2 || base == 10 || base == 16); 998 999 if (spec.size != 0) 1000 return mpfr_get_str (NULL, exp, base, n, op, spec.rnd_mode); 1001 1002 /* Special case size = 0, i.e., xxx_snprintf with size = 0: we only want 1003 to compute the number of printed characters. Try to deduce it from 1004 a small number of significant digits. */ 1005 nine = base == 2 ? '1' : base == 10 ? '9' : 'f'; 1006 for (ndigits = NDIGITS; ; ndigits *= 2) 1007 { 1008 mpfr_rnd_t rnd = MPFR_RNDZ; 1009 /* when ndigits > n, we reduce it to the target size n, and then we use 1010 the wanted rounding mode, to avoid errors for example when n=1 and 1011 x = 9.5 with spec.rnd_mode = RNDU */ 1012 if (ndigits >= n) 1013 { 1014 ndigits = n; 1015 rnd = spec.rnd_mode; 1016 } 1017 str = mpfr_get_str (NULL, exp, base, ndigits, op, rnd); 1018 if (ndigits == n) 1019 break; 1020 neg = str[0] == '-'; 1021 s = str + neg; 1022 while (*s == nine) 1023 s ++; 1024 if (s < str + neg + ndigits) /* we don't have ndigits 'nines' */ 1025 break; 1026 mpfr_free_str (str); 1027 MPFR_ASSERTN (ndigits <= ((size_t) -1) / 2); 1028 /* to make sure that the product by 2 is representable. */ 1029 } 1030 return str; 1031 } 1032 1033 /* Determine the different parts of the string representation of the regular 1034 number P when spec.spec is 'a', 'A', or 'b'. 1035 1036 Return -1 in case of overflow on the sizes. 1037 1038 Note for 'a'/'A': If the precision field is non-zero, the output is the 1039 one with a binary exponent that is a multiple of 4 (thus this is similar 1040 to base 16, where base-16 exponent = binary exponent / 4). But if the 1041 precision field is 0, the exponent is no longer restricted to a multiple 1042 of 4; the precision is maximized, but the displayed digit may be 1; this 1043 is completely unintuitive. 1044 The obtained output for 4 values with precision fields 0 and 1: 1045 0 1 1046 30 0xfp+1 0x1.ep+4 1047 31 0x1p+5 0x1.fp+4 1048 32 0x8p+2 0x2.0p+4 1049 33 0x8p+2 0x2.1p+4 1050 First, the output for numbers that round up to the next power of 16 1051 with a precision field 0, like 31 here, has an unexpected form: here 1052 with 31, "0x1p+5" instead of "0x8p+2". 1053 Moreover, if one increases the output precision, the output form 1054 changes (even if no rounding is involved). For instance, for 32, 1055 "0x8p+2" changes to "0x2.0p+4" instead of "0x8.0p+2". 1056 FIXME: choose first digit = always 1. Discussion: 1057 https://sympa.inria.fr/sympa/arc/mpfr/2021-05/msg00002.html 1058 */ 1059 static int 1060 regular_ab (struct number_parts *np, mpfr_srcptr p, 1061 const struct printf_spec spec) 1062 { 1063 int uppercase; 1064 int base; 1065 char *str; 1066 mpfr_exp_t exp; 1067 1068 uppercase = spec.spec == 'A'; 1069 1070 if (spec.spec == 'a' || spec.spec == 'A') 1071 /* prefix part */ 1072 { 1073 np->prefix_size = 2; 1074 str = (char *) mpfr_allocate_func (1 + np->prefix_size); 1075 str[0] = '0'; 1076 str[1] = uppercase ? 'X' : 'x'; 1077 str[2] = '\0'; 1078 np->prefix_ptr = register_string (np->sl, str); 1079 } 1080 1081 /* integral part */ 1082 np->ip_size = 1; 1083 base = (spec.spec == 'b') ? 2 : 16; 1084 1085 if (spec.prec != 0) 1086 { 1087 size_t nsd; 1088 1089 /* Number of significant digits: 1090 - if no given precision, let mpfr_get_str determine it; 1091 - if a non-zero precision is specified, then one digit before decimal 1092 point plus SPEC.PREC after it (which will give nsd > 1 below). */ 1093 MPFR_ASSERTD (np->ip_size == 1); /* thus the + 1 below */ 1094 if (spec.prec < 0) 1095 nsd = 0; 1096 else 1097 { 1098 if (MPFR_UNLIKELY (spec.prec > (size_t) -2)) /* overflow */ 1099 return -1; 1100 nsd = (size_t) spec.prec + 1; 1101 MPFR_ASSERTD (nsd != 1); 1102 } 1103 str = mpfr_get_str_wrapper (&exp, base, nsd, p, spec); 1104 register_string (np->sl, str); 1105 np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign if any */ 1106 1107 if (base == 16) 1108 /* EXP is the exponent for radix sixteen with decimal point BEFORE the 1109 first digit, we want the exponent for radix two and the decimal 1110 point AFTER the first digit. */ 1111 { 1112 /* An integer overflow is normally not possible since MPFR_EXP_MIN 1113 is twice as large as MPFR_EMIN_MIN. */ 1114 MPFR_ASSERTN (exp > (MPFR_EXP_MIN + 3) / 4); 1115 exp = (exp - 1) * 4; 1116 } 1117 else 1118 /* EXP is the exponent for decimal point BEFORE the first digit, we 1119 want the exponent for decimal point AFTER the first digit. */ 1120 { 1121 /* An integer overflow is normally not possible since MPFR_EXP_MIN 1122 is twice as large as MPFR_EMIN_MIN. */ 1123 MPFR_ASSERTN (exp > MPFR_EXP_MIN); 1124 --exp; 1125 } 1126 } 1127 else if (next_base_power_p (p, base, spec.rnd_mode)) 1128 { 1129 str = (char *) mpfr_allocate_func (2); 1130 str[0] = '1'; 1131 str[1] = '\0'; 1132 np->ip_ptr = register_string (np->sl, str); 1133 1134 exp = MPFR_GET_EXP (p); 1135 } 1136 else if (base == 2) 1137 { 1138 str = (char *) mpfr_allocate_func (2); 1139 str[0] = '1'; 1140 str[1] = '\0'; 1141 np->ip_ptr = register_string (np->sl, str); 1142 1143 exp = MPFR_GET_EXP (p) - 1; 1144 } 1145 else 1146 { 1147 int digit; 1148 mp_limb_t msl = MPFR_MANT (p)[MPFR_LIMB_SIZE (p) - 1]; 1149 int rnd_bit = GMP_NUMB_BITS - 5; 1150 1151 /* pick up the 4 first bits */ 1152 digit = msl >> (rnd_bit + 1); 1153 if (spec.rnd_mode == MPFR_RNDA 1154 || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p)) 1155 || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p)) 1156 || (spec.rnd_mode == MPFR_RNDN 1157 && (msl & (MPFR_LIMB_ONE << rnd_bit)))) 1158 digit++; 1159 MPFR_ASSERTD (0 <= digit && digit <= 15); 1160 1161 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1162 str[0] = num_to_text [digit]; 1163 str[1] = '\0'; 1164 np->ip_ptr = register_string (np->sl, str); 1165 1166 exp = MPFR_GET_EXP (p) - 4; 1167 } 1168 1169 if (uppercase) 1170 /* All digits in upper case */ 1171 { 1172 char *s1 = str; 1173 while (*s1) 1174 { 1175 switch (*s1) 1176 { 1177 case 'a': 1178 *s1 = 'A'; 1179 break; 1180 case 'b': 1181 *s1 = 'B'; 1182 break; 1183 case 'c': 1184 *s1 = 'C'; 1185 break; 1186 case 'd': 1187 *s1 = 'D'; 1188 break; 1189 case 'e': 1190 *s1 = 'E'; 1191 break; 1192 case 'f': 1193 *s1 = 'F'; 1194 break; 1195 } 1196 s1++; 1197 } 1198 } 1199 1200 if (spec.spec == 'b' || spec.prec != 0) 1201 /* compute the number of digits in fractional part */ 1202 { 1203 char *ptr; 1204 size_t str_len; 1205 1206 /* the sign has been skipped, skip also the first digit */ 1207 ++str; 1208 str_len = strlen (str); 1209 ptr = str + str_len - 1; /* points to the end of str */ 1210 1211 if (spec.prec < 0) 1212 /* remove trailing zeros, if any */ 1213 { 1214 while (*ptr == '0' && str_len != 0) 1215 { 1216 --ptr; 1217 --str_len; 1218 } 1219 } 1220 1221 if (str_len != 0) 1222 /* there are some non-zero digits in fractional part */ 1223 { 1224 np->fp_ptr = str; 1225 np->fp_size = str_len; 1226 /* Warning! str_len has type size_t, which is unsigned. */ 1227 if (spec.prec > 0 && str_len < spec.prec) 1228 { 1229 np->fp_trailing_zeros = spec.prec - str_len; 1230 MPFR_ASSERTD (np->fp_trailing_zeros >= 0); 1231 } 1232 } 1233 } 1234 1235 /* decimal point */ 1236 if (np->fp_size != 0 || spec.alt) 1237 np->point = MPFR_DECIMAL_POINT; 1238 1239 /* the exponent part contains the character 'p', or 'P' plus the sign 1240 character plus at least one digit and only as many more digits as 1241 necessary to represent the exponent. 1242 We assume that |EXP| < 10^INT_MAX. */ 1243 np->exp_size = 3; 1244 { 1245 mpfr_uexp_t x; 1246 1247 x = SAFE_ABS (mpfr_uexp_t, exp); 1248 while (x > 9) 1249 { 1250 np->exp_size++; 1251 x /= 10; 1252 } 1253 } 1254 str = (char *) mpfr_allocate_func (1 + np->exp_size); 1255 np->exp_ptr = register_string (np->sl, str); 1256 { 1257 char exp_fmt[8]; /* contains at most 7 characters like in "p%+.1i", 1258 or "P%+.2li" */ 1259 1260 exp_fmt[0] = uppercase ? 'P' : 'p'; 1261 exp_fmt[1] = '\0'; 1262 strcat (exp_fmt, "%+.1" MPFR_EXP_FSPEC "d"); 1263 1264 if (MPFR_UNLIKELY (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)) 1265 return -1; 1266 } 1267 1268 return 0; 1269 } 1270 1271 /* Determine the different parts of the string representation of the regular 1272 number P when spec.spec is 'e', 'E', 'g', or 'G'. 1273 dec_info contains the previously computed exponent and string or is 1274 a null pointer. 1275 1276 Return -1 in case of overflow on the sizes. */ 1277 static int 1278 regular_eg (struct number_parts *np, mpfr_srcptr p, 1279 const struct printf_spec spec, struct decimal_info *dec_info, 1280 int keep_trailing_zeros) 1281 { 1282 char *str; 1283 mpfr_exp_t exp; 1284 1285 const int uppercase = spec.spec == 'E' || spec.spec == 'G'; 1286 1287 /* integral part */ 1288 np->ip_size = 1; 1289 if (dec_info == NULL) 1290 { 1291 size_t nsd; 1292 1293 /* Number of significant digits: 1294 - if no given precision, then let mpfr_get_str determine it, 1295 - if a precision is specified, then one digit before decimal point 1296 plus SPEC.PREC after it. 1297 We use the fact here that mpfr_get_str allows us to ask for only one 1298 significant digit when the base is not a power of 2. */ 1299 MPFR_ASSERTD (np->ip_size == 1); /* thus the + 1 below */ 1300 if (spec.prec < 0) 1301 nsd = 0; 1302 else 1303 { 1304 if (MPFR_UNLIKELY (spec.prec > (size_t) -2)) /* overflow */ 1305 return -1; 1306 nsd = (size_t) spec.prec + 1; 1307 } 1308 str = mpfr_get_str_wrapper (&exp, 10, nsd, p, spec); 1309 register_string (np->sl, str); 1310 } 1311 else 1312 { 1313 exp = dec_info->exp; 1314 str = dec_info->str; 1315 } 1316 np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign if any */ 1317 1318 if (spec.prec != 0) 1319 /* compute the number of digits in fractional part */ 1320 { 1321 char *ptr; 1322 size_t str_len; 1323 1324 /* the sign has been skipped, skip also the first digit */ 1325 ++str; 1326 str_len = strlen (str); 1327 ptr = str + str_len - 1; /* points to the end of str */ 1328 1329 if (!keep_trailing_zeros) 1330 /* remove trailing zeros, if any */ 1331 { 1332 while (*ptr == '0' && str_len != 0) 1333 { 1334 --ptr; 1335 --str_len; 1336 } 1337 } 1338 1339 if (str_len != 0) 1340 /* there are some non-zero digits in fractional part */ 1341 { 1342 np->fp_ptr = str; 1343 np->fp_size = str_len; 1344 /* Warning! str_len has type size_t, which is unsigned. */ 1345 if (keep_trailing_zeros && spec.prec > 0 && str_len < spec.prec) 1346 { 1347 /* add missing trailing zeros */ 1348 np->fp_trailing_zeros = spec.prec - str_len; 1349 MPFR_ASSERTD (np->fp_trailing_zeros >= 0); 1350 } 1351 } 1352 } 1353 1354 /* decimal point */ 1355 if (np->fp_size != 0 || spec.alt) 1356 np->point = MPFR_DECIMAL_POINT; 1357 1358 /* EXP is the exponent for decimal point BEFORE the first digit, we want 1359 the exponent for decimal point AFTER the first digit. 1360 Here, no possible overflow because exp < MPFR_EXP (p) / 3 */ 1361 exp--; 1362 1363 /* the exponent part contains the character 'e', or 'E' plus the sign 1364 character plus at least two digits and only as many more digits as 1365 necessary to represent the exponent. 1366 We assume that |EXP| < 10^INT_MAX. */ 1367 np->exp_size = 3; 1368 { 1369 mpfr_uexp_t x; 1370 1371 x = SAFE_ABS (mpfr_uexp_t, exp); 1372 while (x > 9) 1373 { 1374 np->exp_size++; 1375 x /= 10; 1376 } 1377 } 1378 if (np->exp_size < 4) 1379 np->exp_size = 4; 1380 1381 str = (char *) mpfr_allocate_func (1 + np->exp_size); 1382 np->exp_ptr = register_string (np->sl, str); 1383 1384 { 1385 char exp_fmt[8]; /* e.g. "e%+.2i", or "E%+.2li" */ 1386 1387 exp_fmt[0] = uppercase ? 'E' : 'e'; 1388 exp_fmt[1] = '\0'; 1389 strcat (exp_fmt, "%+.2" MPFR_EXP_FSPEC "d"); 1390 1391 if (MPFR_UNLIKELY (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)) 1392 return -1; 1393 } 1394 1395 return 0; 1396 } 1397 1398 /* Determine the different parts of the string representation of the regular 1399 number P when spec.spec is 'f', 'F', 'g', or 'G'. 1400 dec_info contains the previously computed exponent and string or is 1401 a null pointer. 1402 1403 Return -1 in case of overflow on the sizes. */ 1404 static int 1405 regular_fg (struct number_parts *np, mpfr_srcptr p, 1406 const struct printf_spec spec, struct decimal_info *dec_info, 1407 int keep_trailing_zeros) 1408 { 1409 mpfr_exp_t exp; 1410 char * str; 1411 1412 /* WARNING: an empty precision field is forbidden (it means precision = 6 1413 and it should have been changed to 6 before the function call) */ 1414 MPFR_ASSERTD (spec.prec >= 0); 1415 1416 if (MPFR_GET_EXP (p) <= 0) 1417 /* 0 < |p| < 1 */ 1418 { 1419 /* Most of the time, integral part is 0 */ 1420 np->ip_size = 1; 1421 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1422 str[0] = '0'; 1423 str[1] = '\0'; 1424 np->ip_ptr = register_string (np->sl, str); 1425 1426 if (spec.prec == 0) 1427 /* only two possibilities: either 1 or 0. */ 1428 { 1429 mpfr_t y; 1430 /* y = abs(p) */ 1431 MPFR_ALIAS (y, p, 1, MPFR_EXP (p)); 1432 1433 if (spec.rnd_mode == MPFR_RNDA 1434 || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p)) 1435 || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p)) 1436 || (spec.rnd_mode == MPFR_RNDN && mpfr_cmp_d (y, 0.5) > 0)) 1437 /* rounded up to 1: one digit '1' in integral part. 1438 note that 0.5 is rounded to 0 with RNDN (round ties to even) */ 1439 np->ip_ptr[0] = '1'; 1440 } 1441 else 1442 { 1443 /* exp = position of the most significant decimal digit. */ 1444 exp = floor_log10 (p); 1445 MPFR_ASSERTD (exp < 0); 1446 1447 if (exp < -spec.prec) 1448 /* only the last digit may be non zero */ 1449 { 1450 int round_away; 1451 1452 /* Due to mpfr_set_si below... */ 1453 if (MPFR_UNLIKELY (spec.prec > LONG_MAX)) /* overflow */ 1454 return -1; 1455 1456 switch (spec.rnd_mode) 1457 { 1458 case MPFR_RNDA: 1459 case MPFR_RNDF: /* round_away = 1 needed for %Rg */ 1460 round_away = 1; 1461 break; 1462 case MPFR_RNDZ: 1463 round_away = 0; 1464 break; 1465 case MPFR_RNDD: 1466 round_away = MPFR_IS_NEG (p); 1467 break; 1468 case MPFR_RNDU: 1469 round_away = MPFR_IS_POS (p); 1470 break; 1471 default: 1472 { 1473 /* compare |p| to y = 0.5*10^(-spec.prec) */ 1474 mpfr_t y; 1475 mpfr_exp_t e = MAX (MPFR_PREC (p), 56); 1476 int cmp; 1477 1478 MPFR_ASSERTN (spec.rnd_mode == MPFR_RNDN); 1479 mpfr_init2 (y, e + 8); 1480 1481 do 1482 { 1483 /* find a lower approximation of 1484 0.5*10^(-spec.prec) different from |p| */ 1485 e += 8; 1486 mpfr_set_prec (y, e); 1487 mpfr_set_si (y, -spec.prec, MPFR_RNDN); 1488 mpfr_exp10 (y, y, MPFR_RNDD); 1489 mpfr_div_2ui (y, y, 1, MPFR_RNDN); 1490 cmp = mpfr_cmpabs (y, p); 1491 } 1492 while (cmp == 0); 1493 1494 round_away = cmp < 0; 1495 mpfr_clear (y); 1496 } 1497 break; 1498 } 1499 1500 if (round_away) 1501 /* round away from zero: the last output digit is '1' */ 1502 { 1503 np->fp_leading_zeros = spec.prec - 1; 1504 1505 np->fp_size = 1; 1506 str = (char *) mpfr_allocate_func (1 + np->fp_size); 1507 str[0] = '1'; 1508 str[1] = '\0'; 1509 np->fp_ptr = register_string (np->sl, str); 1510 } 1511 else 1512 /* only zeros in fractional part */ 1513 { 1514 MPFR_ASSERTD (spec.spec == 'f' || spec.spec == 'F'); 1515 np->fp_leading_zeros = spec.prec; 1516 } 1517 } 1518 else /* exp >= -spec.prec */ 1519 /* the most significant digits are the last 1520 spec.prec + exp + 1 digits in fractional part */ 1521 { 1522 char *ptr; 1523 size_t str_len; 1524 1525 MPFR_ASSERTD (exp >= -spec.prec); 1526 if (dec_info == NULL) 1527 { 1528 size_t nsd; 1529 1530 MPFR_ASSERTD (exp <= -1); 1531 MPFR_ASSERTD (spec.prec + (exp + 1) >= 0); 1532 if (MPFR_UNLIKELY (spec.prec + (exp + 1) > (size_t) -1)) 1533 return -1; 1534 nsd = spec.prec + (exp + 1); 1535 /* WARNING: nsd may equal 1, but here we use the 1536 fact that mpfr_get_str can return one digit with 1537 base ten (undocumented feature, see comments in 1538 get_str.c) */ 1539 1540 str = mpfr_get_str_wrapper (&exp, 10, nsd, p, spec); 1541 register_string (np->sl, str); 1542 } 1543 else 1544 { 1545 exp = dec_info->exp; 1546 str = dec_info->str; 1547 } 1548 if (MPFR_IS_NEG (p)) 1549 /* skip sign */ 1550 ++str; 1551 if (exp == 1) 1552 /* round up to 1 */ 1553 { 1554 MPFR_ASSERTD (str[0] == '1'); 1555 np->ip_ptr[0] = '1'; 1556 if (keep_trailing_zeros) 1557 np->fp_leading_zeros = spec.prec; 1558 } 1559 else 1560 { 1561 np->fp_ptr = str; 1562 np->fp_leading_zeros = -exp; 1563 MPFR_ASSERTD (exp <= 0); 1564 1565 str_len = strlen (str); /* the sign has been skipped */ 1566 ptr = str + str_len - 1; /* points to the end of str */ 1567 1568 if (!keep_trailing_zeros) 1569 /* remove trailing zeros, if any */ 1570 { 1571 while (*ptr == '0' && str_len != 0) 1572 { 1573 --ptr; 1574 --str_len; 1575 } 1576 } 1577 1578 MPFR_ASSERTD (str_len > 0); 1579 np->fp_size = str_len; 1580 1581 /* The np->fp_size <= MPFR_INTMAX_MAX test and the 1582 cast to mpfr_uintmax_t below allow one to avoid 1583 integer overflow. */ 1584 if (keep_trailing_zeros 1585 && spec.prec > 0 1586 && np->fp_size <= MPFR_INTMAX_MAX 1587 && ((mpfr_uintmax_t) 1588 np->fp_leading_zeros + np->fp_size) < spec.prec) 1589 { 1590 /* add missing trailing zeros */ 1591 np->fp_trailing_zeros = spec.prec 1592 - np->fp_leading_zeros - np->fp_size; 1593 MPFR_ASSERTD (np->fp_trailing_zeros >= 0); 1594 } 1595 } 1596 } 1597 } 1598 1599 if (spec.alt || np->fp_leading_zeros != 0 || np->fp_size != 0 1600 || np->fp_trailing_zeros != 0) 1601 np->point = MPFR_DECIMAL_POINT; 1602 } 1603 else 1604 /* 1 <= |p| */ 1605 { 1606 size_t str_len; 1607 1608 /* Determine the position of the most significant decimal digit. */ 1609 exp = floor_log10 (p); 1610 MPFR_ASSERTD (exp >= 0); 1611 1612 if (dec_info == NULL) 1613 { 1614 /* %f case */ 1615 mpfr_uintmax_t n; 1616 1617 n = (mpfr_uintmax_t) spec.prec + (exp + 1); 1618 if (MPFR_UNLIKELY (n > (size_t) -1)) 1619 return -1; 1620 str = mpfr_get_str_wrapper (&exp, 10, n, p, spec); 1621 register_string (np->sl, str); 1622 } 1623 else 1624 { 1625 /* %g case */ 1626 exp = dec_info->exp; 1627 str = dec_info->str; 1628 } 1629 np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign */ 1630 str_len = strlen (str); 1631 1632 /* integral part */ 1633 if (exp > str_len) 1634 { 1635 /* When spec.size == 0, mpfr_get_str may be called in a reduced 1636 precision, so that some trailing digits may have been ignored. 1637 When spec.size != 0, this case is also possible in the case 1638 where p is rounded up to the next power of 10: a zero must be 1639 added since the exponent has been increased by 1. */ 1640 np->ip_trailing_digits = exp - str_len; 1641 np->ip_size = str_len; 1642 } 1643 else 1644 np->ip_size = exp; 1645 1646 if (spec.group) 1647 /* thousands separator in integral part */ 1648 np->thousands_sep = MPFR_THOUSANDS_SEPARATOR; 1649 1650 /* fractional part */ 1651 str += np->ip_size; 1652 str_len -= np->ip_size; 1653 if (!keep_trailing_zeros) 1654 /* remove trailing zeros, if any */ 1655 { 1656 char *ptr = str + str_len - 1; /* pointer to the last digit of 1657 str */ 1658 while (*ptr == '0' && str_len != 0) 1659 { 1660 --ptr; 1661 --str_len; 1662 } 1663 } 1664 1665 if (str_len > 0) 1666 /* some non-zero digits in fractional part */ 1667 { 1668 np->point = MPFR_DECIMAL_POINT; 1669 np->fp_ptr = str; 1670 np->fp_size = str_len; 1671 } 1672 1673 /* Warning! str_len has type size_t, which is unsigned. */ 1674 MPFR_ASSERTD (spec.prec >= 0); /* let's recall this */ 1675 if (keep_trailing_zeros && str_len < spec.prec) 1676 /* add missing trailing zeros */ 1677 { 1678 np->point = MPFR_DECIMAL_POINT; 1679 np->fp_trailing_zeros = spec.prec - np->fp_size; 1680 MPFR_ASSERTD (np->fp_trailing_zeros >= 0); 1681 } 1682 1683 if (spec.alt) 1684 /* add decimal point even if no digits follow it */ 1685 np->point = MPFR_DECIMAL_POINT; 1686 } 1687 1688 return 0; 1689 } 1690 1691 /* partition_number determines the different parts of the string 1692 representation of the number p according to the given specification. 1693 partition_number initializes the given structure np, so all previous 1694 information in that variable is lost. 1695 Return the total number of characters to be written. 1696 Return -1 if an error occurred, in that case np's fields are in an 1697 undefined state but all string buffers have been freed. */ 1698 static mpfr_intmax_t 1699 partition_number (struct number_parts *np, mpfr_srcptr p, 1700 struct printf_spec spec) 1701 { 1702 char *str; 1703 mpfr_uintmax_t total; /* can hold the sum of two non-negative 1704 signed integers + 1 */ 1705 int uppercase; 1706 1707 /* WARNING: left justification means right space padding */ 1708 np->pad_type = spec.left ? RIGHT : spec.pad == '0' ? LEADING_ZEROS : LEFT; 1709 np->pad_size = 0; 1710 np->prefix_ptr = NULL; 1711 np->prefix_size = 0; 1712 np->thousands_sep = '\0'; 1713 np->ip_ptr = NULL; 1714 np->ip_size = 0; 1715 np->ip_trailing_digits = 0; 1716 np->point = '\0'; 1717 np->fp_leading_zeros = 0; 1718 np->fp_ptr = NULL; 1719 np->fp_size = 0; 1720 np->fp_trailing_zeros = 0; 1721 np->exp_ptr = NULL; 1722 np->exp_size = 0; 1723 np->sl = (struct string_list *) 1724 mpfr_allocate_func (sizeof (struct string_list)); 1725 init_string_list (np->sl); 1726 1727 uppercase = spec.spec == 'A' || spec.spec == 'E' || spec.spec == 'F' 1728 || spec.spec == 'G'; 1729 1730 /* The sign/space rule is the same for all cases. */ 1731 np->sign = 1732 MPFR_IS_NEG (p) ? '-' : 1733 spec.showsign ? '+' : 1734 spec.space ? ' ' : '\0'; 1735 1736 if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (p))) 1737 { 1738 if (MPFR_IS_NAN (p)) 1739 { 1740 if (np->pad_type == LEADING_ZEROS) 1741 /* don't want "0000nan", change to right justification padding 1742 with left spaces instead */ 1743 np->pad_type = LEFT; 1744 1745 np->ip_size = MPFR_NAN_STRING_LENGTH; 1746 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1747 strcpy (str, uppercase ? MPFR_NAN_STRING_UC : MPFR_NAN_STRING_LC); 1748 np->ip_ptr = register_string (np->sl, str); 1749 } 1750 else if (MPFR_IS_INF (p)) 1751 { 1752 if (np->pad_type == LEADING_ZEROS) 1753 /* don't want "0000inf", change to right justification padding 1754 with left spaces instead */ 1755 np->pad_type = LEFT; 1756 1757 np->ip_size = MPFR_INF_STRING_LENGTH; 1758 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1759 strcpy (str, uppercase ? MPFR_INF_STRING_UC : MPFR_INF_STRING_LC); 1760 np->ip_ptr = register_string (np->sl, str); 1761 } 1762 else 1763 { 1764 MPFR_ASSERTD (MPFR_IS_ZERO (p)); 1765 /* note: for 'g' spec, zero is always displayed with 'f'-style with 1766 precision spec.prec - 1 and the trailing zeros are removed unless 1767 the flag '#' is used. */ 1768 1769 if (spec.spec == 'a' || spec.spec == 'A') 1770 /* prefix part */ 1771 { 1772 np->prefix_size = 2; 1773 str = (char *) mpfr_allocate_func (1 + np->prefix_size); 1774 str[0] = '0'; 1775 str[1] = uppercase ? 'X' : 'x'; 1776 str[2] = '\0'; 1777 np->prefix_ptr = register_string (np->sl, str); 1778 } 1779 1780 /* integral part */ 1781 np->ip_size = 1; 1782 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1783 str[0] = '0'; 1784 str[1] = '\0'; 1785 np->ip_ptr = register_string (np->sl, str); 1786 1787 if (spec.prec < 0) /* empty precision field */ 1788 { 1789 if (spec.spec == 'e' || spec.spec == 'E') 1790 spec.prec = mpfr_get_str_ndigits (10, MPFR_GET_PREC (p)) - 1; 1791 else if (spec.spec == 'f' || spec.spec == 'F' || 1792 spec.spec == 'g' || spec.spec == 'G') 1793 spec.prec = DEFAULT_DECIMAL_PREC; 1794 } 1795 1796 if (spec.prec > 0 1797 && ((spec.spec != 'g' && spec.spec != 'G') || spec.alt)) 1798 /* fractional part */ 1799 { 1800 np->point = MPFR_DECIMAL_POINT; 1801 np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ? 1802 spec.prec - 1 : spec.prec; 1803 MPFR_ASSERTD (np->fp_trailing_zeros >= 0); 1804 } 1805 else if (spec.alt) 1806 np->point = MPFR_DECIMAL_POINT; 1807 1808 if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b' 1809 || spec.spec == 'e' || spec.spec == 'E') 1810 /* exponent part */ 1811 { 1812 np->exp_size = (spec.spec == 'e' || spec.spec == 'E') ? 4 : 3; 1813 str = (char *) mpfr_allocate_func (1 + np->exp_size); 1814 if (spec.spec == 'e' || spec.spec == 'E') 1815 strcpy (str, uppercase ? "E+00" : "e+00"); 1816 else 1817 strcpy (str, uppercase ? "P+0" : "p+0"); 1818 np->exp_ptr = register_string (np->sl, str); 1819 } 1820 } 1821 } 1822 else if (MPFR_UNLIKELY (MPFR_IS_UBF (p))) 1823 { 1824 /* mpfr_get_str does not support UBF, so that UBF numbers are regarded 1825 as special cases here. This is not much a problem since UBF numbers 1826 are internal to MPFR and here, they only for logging. */ 1827 if (np->pad_type == LEADING_ZEROS) 1828 /* change to right justification padding with left spaces */ 1829 np->pad_type = LEFT; 1830 1831 np->ip_size = 3; 1832 str = (char *) mpfr_allocate_func (1 + np->ip_size); 1833 strcpy (str, uppercase ? "UBF" : "ubf"); 1834 np->ip_ptr = register_string (np->sl, str); 1835 /* TODO: output more information (e.g. the exponent) if need be. */ 1836 } 1837 else 1838 { 1839 MPFR_ASSERTD (MPFR_IS_PURE_FP (p)); 1840 if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b') 1841 { 1842 if (regular_ab (np, p, spec) == -1) 1843 goto error; 1844 } 1845 else if (spec.spec == 'f' || spec.spec == 'F') 1846 { 1847 if (spec.prec < 0) 1848 spec.prec = DEFAULT_DECIMAL_PREC; 1849 if (regular_fg (np, p, spec, NULL, 1) == -1) 1850 goto error; 1851 } 1852 else if (spec.spec == 'e' || spec.spec == 'E') 1853 { 1854 if (regular_eg (np, p, spec, NULL, 1) == -1) 1855 goto error; 1856 } 1857 else 1858 /* %g case */ 1859 { 1860 /* Use the C99 rules: 1861 if T > X >= -4 then the conversion is with style 'f'/'F' and 1862 precision T-(X+1). 1863 otherwise, the conversion is with style 'e'/'E' and 1864 precision T-1. 1865 where T is the threshold computed below and X is the exponent 1866 that would be displayed with style 'e' and precision T-1. */ 1867 mpfr_intmax_t threshold; 1868 mpfr_exp_t x, e, k; 1869 struct decimal_info dec_info; 1870 1871 threshold = spec.prec < 0 ? DEFAULT_DECIMAL_PREC : 1872 spec.prec == 0 ? 1 : spec.prec; 1873 MPFR_ASSERTD (threshold >= 1); 1874 1875 /* Here we cannot call mpfr_get_str_wrapper since we need the full 1876 significand in dec_info.str. 1877 Moreover, threshold may be huge while one can know that the 1878 number of digits that are not trailing zeros remains limited; 1879 such a limit occurs in practical cases, e.g. with numbers 1880 representable in the IEEE 754-2008 basic formats. Since the 1881 trailing zeros are not necessarily output, we do not want to 1882 waste time and memory by making mpfr_get_str generate them. 1883 So, let us try to find a smaller threshold for mpfr_get_str. 1884 |p| < 2^EXP(p) = 10^(EXP(p)*log10(2)). So, the integer part 1885 takes at most ceil(EXP(p)*log10(2)) digits (unless p rounds 1886 to the next power of 10, but in this case any threshold will 1887 be OK). So, for the integer part, we will take: 1888 max(0,floor((EXP(p)+2)/3)). 1889 Let k = PREC(p) - EXP(p), so that the last bit of p has 1890 weight 2^(-k). If k <= 0, then p is an integer, otherwise 1891 the fractional part in base 10 may have up to k digits 1892 (this bound is reached if the last bit is 1). 1893 Note: The bound could be improved, but this is not critical. */ 1894 e = MPFR_GET_EXP (p); 1895 k = MPFR_PREC (p) - e; 1896 e = e <= 0 ? k : (e + 2) / 3 + (k <= 0 ? 0 : k); 1897 MPFR_ASSERTD (e >= 1); 1898 1899 if (e > threshold) 1900 e = threshold; 1901 1902 /* error if e does not fit in size_t (for mpfr_get_str) */ 1903 if (e > (size_t) -1) 1904 goto error; 1905 1906 dec_info.str = mpfr_get_str (NULL, &dec_info.exp, 10, 1907 e, p, spec.rnd_mode); 1908 register_string (np->sl, dec_info.str); 1909 /* mpfr_get_str corresponds to a significand between 0.1 and 1, 1910 whereas here we want a significand between 1 and 10. */ 1911 x = dec_info.exp - 1; 1912 1913 if (threshold > x && x >= -4) 1914 { 1915 /* the conversion is with style 'f' */ 1916 spec.prec = threshold - x - 1; 1917 1918 if (regular_fg (np, p, spec, &dec_info, spec.alt) == -1) 1919 goto error; 1920 } 1921 else 1922 { 1923 spec.prec = threshold - 1; 1924 1925 if (regular_eg (np, p, spec, &dec_info, spec.alt) == -1) 1926 goto error; 1927 } 1928 } 1929 } 1930 1931 /* compute the number of characters to be written verifying it is not too 1932 much */ 1933 1934 #define INCR_TOTAL(v) \ 1935 do { \ 1936 MPFR_ASSERTD ((v) >= 0); \ 1937 if (MPFR_UNLIKELY ((v) > MPFR_INTMAX_MAX)) \ 1938 goto error; \ 1939 total += (v); \ 1940 if (MPFR_UNLIKELY (total > MPFR_INTMAX_MAX)) \ 1941 goto error; \ 1942 } while (0) 1943 1944 total = np->sign ? 1 : 0; 1945 INCR_TOTAL (np->prefix_size); 1946 INCR_TOTAL (np->ip_size); 1947 INCR_TOTAL (np->ip_trailing_digits); 1948 MPFR_ASSERTD (np->ip_size + np->ip_trailing_digits >= 1); 1949 if (np->thousands_sep) 1950 /* ' flag, style f and the thousands separator in current locale is not 1951 reduced to the null character */ 1952 INCR_TOTAL ((np->ip_size + np->ip_trailing_digits - 1) / 3); 1953 if (np->point) 1954 ++total; 1955 INCR_TOTAL (np->fp_leading_zeros); 1956 INCR_TOTAL (np->fp_size); 1957 INCR_TOTAL (np->fp_trailing_zeros); 1958 INCR_TOTAL (np->exp_size); 1959 1960 if (spec.width > total) 1961 /* pad with spaces or zeros depending on np->pad_type */ 1962 { 1963 np->pad_size = spec.width - total; 1964 total = spec.width; 1965 } 1966 1967 MPFR_ASSERTD (total > 0 && total <= MPFR_INTMAX_MAX); 1968 return total; 1969 1970 error: 1971 clear_string_list (np->sl); 1972 np->prefix_ptr = NULL; 1973 np->ip_ptr = NULL; 1974 np->fp_ptr = NULL; 1975 np->exp_ptr = NULL; 1976 return -1; 1977 } 1978 1979 /* sprnt_fp prints a mpfr_t according to spec.spec specification. 1980 1981 Return the size of the string (not counting the terminating '\0'). 1982 Return -1 if the built string is too long (i.e. has more than 1983 INT_MAX or MPFR_INTMAX_MAX characters). 1984 1985 If spec.size is 0, we only want the size of the string. 1986 */ 1987 static int 1988 sprnt_fp (struct string_buffer *buf, mpfr_srcptr p, 1989 const struct printf_spec spec) 1990 { 1991 mpfr_intmax_t length, start; 1992 struct number_parts np; 1993 1994 length = partition_number (&np, p, spec); 1995 if (MPFR_UNLIKELY (length < 0)) 1996 { 1997 buf->len = -1; 1998 return -1; 1999 } 2000 2001 if (spec.size == 0) 2002 { 2003 /* This is equivalent to the following code (no need to fill the buffer 2004 and length is known). */ 2005 buffer_incr_len (buf, length); 2006 goto clear_and_exit; 2007 } 2008 2009 MPFR_DBGRES (start = buf->len); 2010 2011 /* right justification padding with left spaces */ 2012 if (np.pad_type == LEFT && np.pad_size != 0) 2013 buffer_pad (buf, ' ', np.pad_size); 2014 2015 /* sign character (may be '-', '+', ' ', or '\0') */ 2016 if (np.sign) 2017 buffer_pad (buf, np.sign, 1); 2018 2019 /* prefix part */ 2020 if (np.prefix_ptr) 2021 buffer_cat (buf, np.prefix_ptr, np.prefix_size); 2022 2023 /* right justification padding with leading zeros */ 2024 if (np.pad_type == LEADING_ZEROS && np.pad_size != 0) 2025 buffer_pad (buf, '0', np.pad_size); 2026 2027 /* integral part (may also be "nan" or "inf") */ 2028 MPFR_ASSERTN (np.ip_ptr != NULL); /* never empty */ 2029 if (MPFR_UNLIKELY (np.thousands_sep)) 2030 { 2031 if (buffer_sandwich (buf, np.ip_ptr, np.ip_size, np.ip_trailing_digits, 2032 np.thousands_sep)) 2033 { 2034 buf->len = -1; 2035 goto clear_and_exit; 2036 } 2037 } 2038 else 2039 { 2040 buffer_cat (buf, np.ip_ptr, np.ip_size); 2041 2042 /* possible trailing zero in integral part (spec.size != 0) */ 2043 MPFR_ASSERTD (np.ip_trailing_digits <= 1); 2044 if (np.ip_trailing_digits != 0) 2045 buffer_pad (buf, '0', 1); 2046 } 2047 2048 /* decimal point */ 2049 if (np.point) 2050 buffer_pad (buf, np.point, 1); 2051 2052 /* leading zeros in fractional part */ 2053 if (np.fp_leading_zeros != 0) 2054 buffer_pad (buf, '0', np.fp_leading_zeros); 2055 2056 /* significant digits in fractional part */ 2057 if (np.fp_ptr) 2058 buffer_cat (buf, np.fp_ptr, np.fp_size); 2059 2060 /* trailing zeros in fractional part */ 2061 if (np.fp_trailing_zeros != 0) 2062 buffer_pad (buf, '0', np.fp_trailing_zeros); 2063 2064 /* exponent part */ 2065 if (np.exp_ptr) 2066 buffer_cat (buf, np.exp_ptr, np.exp_size); 2067 2068 /* left justification padding with right spaces */ 2069 if (np.pad_type == RIGHT && np.pad_size != 0) 2070 buffer_pad (buf, ' ', np.pad_size); 2071 2072 MPFR_ASSERTD (buf->len == -1 || buf->len - start == length); 2073 2074 clear_and_exit: 2075 clear_string_list (np.sl); 2076 return buf->len == -1 ? -1 : length; 2077 } 2078 2079 /* The following internal function implements both mpfr_vasprintf and 2080 mpfr_vsnprintf: 2081 (a) either ptr <> NULL, and then Buf and size are not used, and it 2082 implements mpfr_vasprintf (ptr, fmt, ap) 2083 (b) or ptr = NULL, and it implements mpfr_vsnprintf (Buf, size, fmt, ap) 2084 It returns the number of characters that would have been written had 'size' 2085 been sufficiently large, not counting the terminating null character, or -1 2086 if this number is too large for the return type 'int' (overflow). 2087 */ 2088 int 2089 mpfr_vasnprintf_aux (char **ptr, char *Buf, size_t size, const char *fmt, 2090 va_list ap) 2091 { 2092 struct string_buffer buf; 2093 int nbchar; 2094 2095 /* information on the conversion specification filled by the parser */ 2096 struct printf_spec spec; 2097 /* flag raised when previous part of fmt need to be processed by 2098 gmp_vsnprintf */ 2099 int xgmp_fmt_flag; 2100 /* beginning and end of the previous unprocessed part of fmt */ 2101 const char *start, *end; 2102 /* pointer to arguments for gmp_vasprintf */ 2103 va_list ap2; 2104 2105 MPFR_SAVE_EXPO_DECL (expo); 2106 MPFR_SAVE_EXPO_MARK (expo); 2107 2108 /* FIXME: Once buf.len >= size, switch to size = 0 for efficiency and 2109 avoid potential DoS? i.e. we no longer need to generate the strings 2110 (potentially huge), just compute the lengths. */ 2111 2112 buffer_init (&buf, ptr != NULL || size != 0 ? 4096 : 0); 2113 xgmp_fmt_flag = 0; 2114 va_copy (ap2, ap); 2115 start = fmt; 2116 while (*fmt != '\0') 2117 { 2118 int overflow = 0; 2119 2120 /* Look for the next format specification */ 2121 while (*fmt != '\0' && *fmt != '%') 2122 ++fmt; 2123 2124 if (*fmt == '\0') 2125 break; 2126 2127 if (*++fmt == '%') 2128 /* %%: go one step further otherwise the second '%' would be 2129 considered as a new conversion specification introducing 2130 character */ 2131 { 2132 ++fmt; 2133 xgmp_fmt_flag = 1; 2134 continue; 2135 } 2136 2137 end = fmt - 1; 2138 2139 /* format string analysis */ 2140 specinfo_init (&spec); 2141 fmt = parse_flags (fmt, &spec); 2142 2143 READ_INT (ap, fmt, spec.width); 2144 if (spec.width < 0) /* integer read via '*', no overflow */ 2145 { 2146 spec.left = 1; 2147 /* Since the type of the integer is int, spec.width >= INT_MIN, 2148 so that an overflow is possible here only if mpfr_intmax_t 2149 has the same size of int. The INT_MIN < - MPFR_INTMAX_MAX 2150 test allows the compiler to optimize when it is false. */ 2151 if (MPFR_UNLIKELY (INT_MIN < - MPFR_INTMAX_MAX && 2152 spec.width < - MPFR_INTMAX_MAX)) 2153 overflow = 1; 2154 else 2155 spec.width = - spec.width; 2156 } 2157 /* Note: We will make sure that spec.width is not used in case of 2158 overflow. */ 2159 MPFR_ASSERTD (overflow || spec.width >= 0); 2160 2161 if (*fmt == '.') 2162 { 2163 ++fmt; 2164 READ_INT (ap, fmt, spec.prec); 2165 /* A negative value is possible with ".*" and it will be regarded 2166 as a missing precision (ISO C). We need to make sure that such 2167 a value is representable in an int (see its use below). */ 2168 if (spec.prec < 0) 2169 spec.prec = -1; 2170 } 2171 else 2172 spec.prec = -1; /* missing precision */ 2173 MPFR_ASSERTD (spec.prec >= -1); 2174 2175 fmt = parse_arg_type (fmt, &spec); 2176 if (spec.arg_type == UNSUPPORTED) 2177 /* the current architecture doesn't support the type corresponding to 2178 the format specifier; according to the ISO C99 standard, the 2179 behavior is undefined. We choose to print the format specifier as a 2180 literal string, what may be printed after this string is 2181 undefined. */ 2182 continue; 2183 else if (spec.arg_type == MPFR_ARG) 2184 { 2185 switch (*fmt) 2186 { 2187 case '\0': 2188 break; 2189 case '*': 2190 ++fmt; 2191 spec.rnd_mode = (mpfr_rnd_t) va_arg (ap, int); 2192 break; 2193 case 'D': 2194 ++fmt; 2195 spec.rnd_mode = MPFR_RNDD; 2196 break; 2197 case 'U': 2198 ++fmt; 2199 spec.rnd_mode = MPFR_RNDU; 2200 break; 2201 case 'Y': 2202 ++fmt; 2203 spec.rnd_mode = MPFR_RNDA; 2204 break; 2205 case 'Z': 2206 ++fmt; 2207 spec.rnd_mode = MPFR_RNDZ; 2208 break; 2209 case 'N': 2210 ++fmt; 2211 MPFR_FALLTHROUGH; 2212 default: 2213 spec.rnd_mode = MPFR_RNDN; 2214 } 2215 } 2216 2217 spec.spec = *fmt; 2218 if (!specinfo_is_valid (spec)) 2219 /* the format specifier is invalid; according to the ISO C99 standard, 2220 the behavior is undefined. We choose to print the invalid format 2221 specifier as a literal string, what may be printed after this 2222 string is undefined. */ 2223 continue; 2224 2225 if (*fmt != '\0') 2226 fmt++; 2227 2228 /* Format processing */ 2229 if (spec.spec == '\0') 2230 /* end of the format string */ 2231 break; 2232 else if (spec.spec == 'n') 2233 /* put the number of characters written so far in the location pointed 2234 by the next va_list argument; the types of pointer accepted are the 2235 same as in GMP (except unsupported quad_t) plus pointer to a mpfr_t 2236 so as to be able to accept the same format strings. */ 2237 { 2238 void *p; 2239 2240 p = va_arg (ap, void *); 2241 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf); 2242 va_end (ap2); 2243 start = fmt; 2244 2245 switch (spec.arg_type) 2246 { 2247 case CHAR_ARG: 2248 *(char *) p = (char) buf.len; 2249 break; 2250 case SHORT_ARG: 2251 *(short *) p = (short) buf.len; 2252 break; 2253 case LONG_ARG: 2254 *(long *) p = (long) buf.len; 2255 break; 2256 #ifdef HAVE_LONG_LONG 2257 case LONG_LONG_ARG: 2258 *(long long *) p = (long long) buf.len; 2259 break; 2260 #endif 2261 #ifdef _MPFR_H_HAVE_INTMAX_T 2262 case INTMAX_ARG: 2263 *(intmax_t *) p = (intmax_t) buf.len; 2264 break; 2265 #endif 2266 case SIZE_ARG: 2267 *(size_t *) p = buf.len; 2268 break; 2269 case PTRDIFF_ARG: 2270 *(ptrdiff_t *) p = (ptrdiff_t) buf.len; 2271 break; 2272 case MPF_ARG: 2273 mpf_set_ui ((mpf_ptr) p, (unsigned long) buf.len); 2274 break; 2275 case MPQ_ARG: 2276 mpq_set_ui ((mpq_ptr) p, (unsigned long) buf.len, 1L); 2277 break; 2278 case MP_LIMB_ARG: 2279 *(mp_limb_t *) p = (mp_limb_t) buf.len; 2280 break; 2281 case MP_LIMB_ARRAY_ARG: 2282 { 2283 mp_limb_t *q = (mp_limb_t *) p; 2284 mp_size_t n; 2285 n = va_arg (ap, mp_size_t); 2286 if (n < 0) 2287 n = -n; 2288 else if (n == 0) 2289 break; 2290 2291 /* we assume here that mp_limb_t is wider than int */ 2292 *q = (mp_limb_t) buf.len; 2293 while (--n != 0) 2294 { 2295 q++; 2296 *q = MPFR_LIMB_ZERO; 2297 } 2298 } 2299 break; 2300 case MPZ_ARG: 2301 mpz_set_ui ((mpz_ptr) p, (unsigned long) buf.len); 2302 break; 2303 2304 case MPFR_ARG: 2305 mpfr_set_ui ((mpfr_ptr) p, (unsigned long) buf.len, 2306 spec.rnd_mode); 2307 break; 2308 2309 default: 2310 *(int *) p = (int) buf.len; 2311 } 2312 va_copy (ap2, ap); /* after the switch, due to MP_LIMB_ARRAY_ARG 2313 case */ 2314 } 2315 else if (spec.arg_type == MPFR_PREC_ARG) 2316 /* output mpfr_prec_t variable */ 2317 { 2318 char *s; 2319 char format[MPFR_PREC_FORMAT_SIZE + 12]; /* e.g. "%0#+ -'*.*ld\0" */ 2320 size_t length; 2321 mpfr_prec_t prec; 2322 2323 /* FIXME: With buf.size = 0 and a huge width or precision, this 2324 can uselessly take much memory. And even with buf.size != 0, 2325 this would take more memory than necessary and need a large 2326 buffer_cat. A solution: compute a bound on the maximum 2327 number of significant digits, and handle the additional 2328 characters separately. Moreover, if buf.size = 0 or size != 0, 2329 gmp_snprintf should be called instead of gmp_asprintf, 2330 outputting data directly to the buffer when applicable. 2331 See also: https://sourceware.org/bugzilla/show_bug.cgi?id=23432 2332 Add testcases. */ 2333 2334 prec = va_arg (ap, mpfr_prec_t); 2335 2336 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf); 2337 va_end (ap2); 2338 va_copy (ap2, ap); 2339 start = fmt; 2340 2341 /* The restriction to INT_MAX is a limitation due to the fact 2342 that *.* is used below. If the width or precision field is 2343 larger than INT_MAX, then there is a real overflow on the 2344 return value due to the padding characters, thus the error 2345 is correct. The only minor drawback is that some variables 2346 corresponding to the 'n' conversion specifier with a type 2347 larger than int may not be set. This is not a bug, as there 2348 are no strong guarantees for such variables in case of error. 2349 FIXME: If size = 0 and max(spec.width,spec.prec) is large 2350 enough, there is no need to call gmp_asprintf since we are 2351 just interested in the length, which should be this maximum; 2352 in particular, this should avoid the overflow issue. */ 2353 if (overflow || spec.width > INT_MAX || spec.prec > INT_MAX) 2354 { 2355 buf.len = -1; 2356 goto error; 2357 } 2358 2359 /* Recalled from above. */ 2360 MPFR_ASSERTD (spec.width >= 0); 2361 MPFR_ASSERTD (spec.prec >= -1); 2362 2363 /* construct format string, like "%*.*hd" "%*.*d" or "%*.*ld" */ 2364 sprintf (format, "%%%s%s%s%s%s%s*.*" MPFR_PREC_FORMAT_TYPE "%c", 2365 spec.pad == '0' ? "0" : "", 2366 spec.alt ? "#" : "", 2367 spec.showsign ? "+" : "", 2368 spec.space ? " " : "", 2369 spec.left ? "-" : "", 2370 spec.group ? "'" : "", 2371 spec.spec); 2372 MPFR_LOG_MSG (("MPFR_PREC_ARG: format for gmp_asprintf: \"%s\"\n", 2373 format)); 2374 MPFR_LOG_MSG (("MPFR_PREC_ARG: width = %d, prec = %d, value = %" 2375 MPFR_PREC_FORMAT_TYPE "d\n", 2376 (int) spec.width, (int) spec.prec, prec)); 2377 length = gmp_asprintf (&s, format, 2378 (int) spec.width, (int) spec.prec, prec); 2379 MPFR_ASSERTN (length >= 0); /* guaranteed by GMP 6 */ 2380 buffer_cat (&buf, s, length); 2381 mpfr_free_str (s); 2382 } 2383 else if (spec.arg_type == MPFR_ARG) 2384 /* output a mpfr_t variable */ 2385 { 2386 mpfr_srcptr p; 2387 2388 if (spec.spec != 'a' && spec.spec != 'A' 2389 && spec.spec != 'b' 2390 && spec.spec != 'e' && spec.spec != 'E' 2391 && spec.spec != 'f' && spec.spec != 'F' 2392 && spec.spec != 'g' && spec.spec != 'G') 2393 /* The format specifier is invalid; skip the invalid format 2394 specifier so as to print it as a literal string. What may 2395 be printed after this string is undefined. */ 2396 continue; 2397 2398 p = va_arg (ap, mpfr_srcptr); 2399 2400 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf); 2401 va_end (ap2); 2402 va_copy (ap2, ap); 2403 start = fmt; 2404 2405 if (overflow) 2406 { 2407 buf.len = -1; 2408 goto error; 2409 } 2410 2411 if (ptr == NULL) 2412 spec.size = size; 2413 sprnt_fp (&buf, p, spec); 2414 } 2415 else 2416 /* gmp_printf specification, step forward in the va_list */ 2417 { 2418 CONSUME_VA_ARG (spec, ap); 2419 xgmp_fmt_flag = 1; 2420 } 2421 } 2422 2423 if (start != fmt) 2424 FLUSH (xgmp_fmt_flag, start, fmt, ap2, &buf); 2425 2426 va_end (ap2); 2427 2428 if (buf.len == -1 || buf.len > INT_MAX) /* overflow */ 2429 goto overflow; 2430 2431 nbchar = buf.len; 2432 MPFR_ASSERTD (nbchar >= 0); 2433 2434 if (ptr != NULL) /* implement mpfr_vasprintf */ 2435 { 2436 MPFR_ASSERTD (nbchar == strlen (buf.start)); 2437 *ptr = (char *) mpfr_reallocate_func (buf.start, buf.size, nbchar + 1); 2438 } 2439 else if (size != 0) /* implement mpfr_vsnprintf */ 2440 { 2441 if (nbchar < size) 2442 { 2443 strncpy (Buf, buf.start, nbchar); 2444 Buf[nbchar] = '\0'; 2445 } 2446 else 2447 { 2448 strncpy (Buf, buf.start, size - 1); 2449 Buf[size-1] = '\0'; 2450 } 2451 mpfr_free_func (buf.start, buf.size); 2452 } 2453 2454 MPFR_SAVE_EXPO_FREE (expo); 2455 return nbchar; /* return the number of characters that would have 2456 been written had 'size' been sufficiently large, 2457 not counting the terminating null character */ 2458 2459 error: 2460 va_end (ap2); 2461 if (buf.len == -1) /* overflow */ 2462 { 2463 overflow: 2464 MPFR_LOG_MSG (("Overflow\n", 0)); 2465 MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, MPFR_FLAGS_ERANGE); 2466 #ifdef EOVERFLOW 2467 MPFR_LOG_MSG (("Setting errno to EOVERFLOW\n", 0)); 2468 errno = EOVERFLOW; 2469 #endif 2470 } 2471 2472 MPFR_SAVE_EXPO_FREE (expo); 2473 if (ptr != NULL) /* implement mpfr_vasprintf */ 2474 *ptr = NULL; 2475 if (ptr != NULL || size != 0) 2476 mpfr_free_func (buf.start, buf.size); 2477 2478 return -1; 2479 } 2480 2481 #else /* HAVE_STDARG */ 2482 2483 /* Avoid an empty translation unit (see ISO C99, 6.9) */ 2484 typedef int foo; 2485 2486 #endif /* HAVE_STDARG */ 2487
Indexes created Fri Jun 05 00:26:10 UTC 2026