contrib/mpfr/src/vasprintf.c

   1 /* mpfr_vasprintf -- main function for the printf functions family
   2    plus helper macros & functions.
   3
   4 Copyright 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   5 Contributed by the Arenaire and Caramel 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 http://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 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 /* The mpfr_printf-like functions are defined only if <stdarg.h> exists */
  29 #ifdef HAVE_STDARG
  30
  31 #include <stdarg.h>
  32
  33 #ifndef HAVE_VA_COPY
  34 # ifdef HAVE___VA_COPY
  35 #  define va_copy(dst,src) __va_copy(dst, src)
  36 # else
  37 /* autoconf manual advocates this fallback.
  38    This is also the solution chosen by gmp */
  39 #  define va_copy(dst,src) \
  40   do { memcpy(&(dst), &(src), sizeof(va_list)); } while (0)
  41 # endif /* HAVE___VA_COPY */
  42 #endif /* HAVE_VA_COPY */
  43
  44 #ifdef HAVE_WCHAR_H
  45 #include <wchar.h>
  46 #endif
  47
  48 #if defined (__cplusplus)
  49 #include <cstddef>
  50 #define __STDC_LIMIT_MACROS   /* SIZE_MAX defined with <stdint.h> inclusion */
  51 #else
  52 #include <stddef.h>             /* for ptrdiff_t */
  53 #endif
  54
  55 #define MPFR_NEED_LONGLONG_H
  56 #include "mpfr-intmax.h"
  57 #include "mpfr-impl.h"
  58
  59 /* Define a length modifier corresponding to mpfr_prec_t.
  60    We use literal string instead of literal character so as to permit future
  61    extension to long long int ("ll"). */
  62 #if   _MPFR_PREC_FORMAT == 1
  63 #define MPFR_PREC_FORMAT_TYPE "h"
  64 #define MPFR_PREC_FORMAT_SIZE 1
  65 #elif _MPFR_PREC_FORMAT == 2
  66 #define MPFR_PREC_FORMAT_TYPE ""
  67 #define MPFR_PREC_FORMAT_SIZE 0
  68 #elif _MPFR_PREC_FORMAT == 3
  69 #define MPFR_PREC_FORMAT_TYPE "l"
  70 #define MPFR_PREC_FORMAT_SIZE 1
  71 #else
  72 #error "mpfr_prec_t size not supported"
  73 #endif
  74
  75 /* Output for special values defined in the C99 standard */
  76 #define MPFR_NAN_STRING_LC "nan"
  77 #define MPFR_NAN_STRING_UC "NAN"
  78 #define MPFR_NAN_STRING_LENGTH 3
  79 #define MPFR_INF_STRING_LC "inf"
  80 #define MPFR_INF_STRING_UC "INF"
  81 #define MPFR_INF_STRING_LENGTH 3
  82
  83 /* The implicit \0 is useless, but we do not write num_to_text[16]
  84    otherwise g++ complains. */
  85 static const char num_to_text[] = "0123456789abcdef";
  86
  87 /* some macro and functions for parsing format string */
  88
  89 /* Read an integer; saturate to INT_MAX. */
  90 #define READ_INT(ap, format, specinfo, field, label_out)                \
  91   do {                                                                  \
  92     while (*(format))                                                   \
  93       {                                                                 \
  94         int _i;                                                         \
  95         switch (*(format))                                              \
  96           {                                                             \
  97           case '0':                                                     \
  98           case '1':                                                     \
  99           case '2':                                                     \
 100           case '3':                                                     \
 101           case '4':                                                     \
 102           case '5':                                                     \
 103           case '6':                                                     \
 104           case '7':                                                     \
 105           case '8':                                                     \
 106           case '9':                                                     \
 107             specinfo.field = (specinfo.field <= INT_MAX / 10) ?         \
 108               specinfo.field * 10 : INT_MAX;                            \
 109             _i = *(format) - '0';                                       \
 110             MPFR_ASSERTN (_i >= 0 && _i <= 9);                          \
 111             specinfo.field = (specinfo.field <= INT_MAX - _i) ?         \
 112               specinfo.field + _i : INT_MAX;                            \
 113             ++(format);                                                 \
 114             break;                                                      \
 115           case '*':                                                     \
 116             specinfo.field = va_arg ((ap), int);                        \
 117             ++(format);                                                 \
 118           default:                                                      \
 119             goto label_out;                                             \
 120           }                                                             \
 121       }                                                                 \
 122   } while (0)
 123
 124 /* arg_t contains all the types described by the 'type' field of the
 125    format string */
 126 enum arg_t
 127   {
 128     NONE,
 129     CHAR_ARG,
 130     SHORT_ARG,
 131     LONG_ARG,
 132     LONG_LONG_ARG,
 133     INTMAX_ARG,
 134     SIZE_ARG,
 135     PTRDIFF_ARG,
 136     LONG_DOUBLE_ARG,
 137     MPF_ARG,
 138     MPQ_ARG,
 139     MP_LIMB_ARG,
 140     MP_LIMB_ARRAY_ARG,
 141     MPZ_ARG,
 142     MPFR_PREC_ARG,
 143     MPFR_ARG,
 144     UNSUPPORTED
 145   };
 146
 147 /* Each conversion specification of the format string will be translated in a
 148    printf_spec structure by the parser.
 149    This structure is adapted from the GNU libc one. */
 150 struct printf_spec
 151 {
 152   unsigned int alt:1;           /* # flag */
 153   unsigned int space:1;         /* Space flag */
 154   unsigned int left:1;          /* - flag */
 155   unsigned int showsign:1;      /* + flag */
 156   unsigned int group:1;         /* ' flag */
 157
 158   int width;                    /* Width */
 159   int prec;                     /* Precision */
 160
 161   enum arg_t arg_type;          /* Type of argument */
 162   mpfr_rnd_t rnd_mode;            /* Rounding mode */
 163   char spec;                    /* Conversion specifier */
 164
 165   char pad;                     /* Padding character */
 166 };
 167
 168 static void
 169 specinfo_init (struct printf_spec *specinfo)
 170 {
 171   specinfo->alt = 0;
 172   specinfo->space = 0;
 173   specinfo->left = 0;
 174   specinfo->showsign = 0;
 175   specinfo->group = 0;
 176   specinfo->width = 0;
 177   specinfo->prec = 0;
 178   specinfo->arg_type = NONE;
 179   specinfo->rnd_mode = MPFR_RNDN;
 180   specinfo->spec = '\0';
 181   specinfo->pad = ' ';
 182 }
 183
 184 #define FLOATING_POINT_ARG_TYPE(at) \
 185   ((at) == MPFR_ARG || (at) == MPF_ARG || (at) == LONG_DOUBLE_ARG)
 186
 187 #define INTEGER_LIKE_ARG_TYPE(at)                                       \
 188   ((at) == SHORT_ARG || (at) == LONG_ARG || (at) == LONG_LONG_ARG       \
 189    || (at) == INTMAX_ARG  || (at) == MPFR_PREC_ARG || (at) == MPZ_ARG   \
 190    || (at) == MPQ_ARG || (at) == MP_LIMB_ARG || (at) == MP_LIMB_ARRAY_ARG \
 191    || (at) == CHAR_ARG || (at) == SIZE_ARG || (at) == PTRDIFF_ARG)
 192
 193 static int
 194 specinfo_is_valid (struct printf_spec spec)
 195 {
 196   switch (spec.spec)
 197     {
 198     case 'n':
 199       return -1;
 200
 201     case 'a':    case 'A':
 202     case 'e':    case 'E':
 203     case 'f':    case 'F':
 204     case 'g':    case 'G':
 205       return (spec.arg_type == NONE
 206               || FLOATING_POINT_ARG_TYPE (spec.arg_type));
 207
 208     case 'b':
 209       return spec.arg_type == MPFR_ARG;
 210
 211     case 'd':    case 'i':
 212     case 'u':    case 'o':
 213     case 'x':    case 'X':
 214       return (spec.arg_type == NONE
 215               || INTEGER_LIKE_ARG_TYPE (spec.arg_type));
 216
 217     case 'c':
 218     case 's':
 219       return (spec.arg_type == NONE || spec.arg_type == LONG_ARG);
 220
 221     case 'p':
 222       return spec.arg_type == NONE;
 223
 224     default:
 225       return 0;
 226     }
 227 }
 228
 229 static const char *
 230 parse_flags (const char *format, struct printf_spec *specinfo)
 231 {
 232   while (*format)
 233     {
 234       switch (*format)
 235         {
 236         case '0':
 237           specinfo->pad = '0';
 238           ++format;
 239           break;
 240         case '#':
 241           specinfo->alt = 1;
 242           ++format;
 243           break;
 244         case '+':
 245           specinfo->showsign = 1;
 246           ++format;
 247           break;
 248         case ' ':
 249           specinfo->space = 1;
 250           ++format;
 251           break;
 252         case '-':
 253           specinfo->left = 1;
 254           ++format;
 255           break;
 256         case '\'':
 257           /* Single UNIX Specification for thousand separator */
 258           specinfo->group = 1;
 259           ++format;
 260           break;
 261         default:
 262           return format;
 263         }
 264     }
 265   return format;
 266 }
 267
 268 static const char *
 269 parse_arg_type (const char *format, struct printf_spec *specinfo)
 270 {
 271   switch (*format)
 272     {
 273     case '\0':
 274       break;
 275     case 'h':
 276       if (*++format == 'h')
 277 #ifndef NPRINTF_HH
 278         {
 279           ++format;
 280           specinfo->arg_type = CHAR_ARG;
 281         }
 282 #else
 283         specinfo->arg_type = UNSUPPORTED;
 284 #endif
 285       else
 286         specinfo->arg_type = SHORT_ARG;
 287       break;
 288     case 'l':
 289       if (*++format == 'l')
 290         {
 291           ++format;
 292 #if defined (HAVE_LONG_LONG) && !defined(NPRINTF_LL)
 293           specinfo->arg_type = LONG_LONG_ARG;
 294 #else
 295           specinfo->arg_type = UNSUPPORTED;
 296 #endif
 297           break;
 298         }
 299       else
 300         {
 301           specinfo->arg_type = LONG_ARG;
 302           break;
 303         }
 304     case 'j':
 305       ++format;
 306 #if defined(_MPFR_H_HAVE_INTMAX_T) && !defined(NPRINTF_J)
 307       specinfo->arg_type = INTMAX_ARG;
 308 #else
 309       specinfo->arg_type = UNSUPPORTED;
 310 #endif
 311       break;
 312     case 'z':
 313       ++format;
 314       specinfo->arg_type = SIZE_ARG;
 315       break;
 316     case 't':
 317       ++format;
 318 #ifndef NPRINTF_T
 319       specinfo->arg_type = PTRDIFF_ARG;
 320 #else
 321       specinfo->arg_type = UNSUPPORTED;
 322 #endif
 323       break;
 324     case 'L':
 325       ++format;
 326 #ifndef NPRINTF_L
 327       specinfo->arg_type = LONG_DOUBLE_ARG;
 328 #else
 329       specinfo->arg_type = UNSUPPORTED;
 330 #endif
 331       break;
 332     case 'F':
 333       ++format;
 334       specinfo->arg_type = MPF_ARG;
 335       break;
 336     case 'Q':
 337       ++format;
 338       specinfo->arg_type = MPQ_ARG;
 339       break;
 340     case 'M':
 341       ++format;
 342       /* The 'M' specifier was added in gmp 4.2.0 */
 343       specinfo->arg_type = MP_LIMB_ARG;
 344       break;
 345     case 'N':
 346       ++format;
 347       specinfo->arg_type = MP_LIMB_ARRAY_ARG;
 348       break;
 349     case 'Z':
 350       ++format;
 351       specinfo->arg_type = MPZ_ARG;
 352       break;
 353
 354       /* mpfr specific specifiers */
 355     case 'P':
 356       ++format;
 357       specinfo->arg_type = MPFR_PREC_ARG;
 358       break;
 359     case 'R':
 360       ++format;
 361       specinfo->arg_type = MPFR_ARG;
 362     }
 363   return format;
 364 }
 365
 366
 367 /* some macros and functions filling the buffer */
 368
 369 /* CONSUME_VA_ARG removes from va_list AP the type expected by SPECINFO */
 370
 371 /* With a C++ compiler wchar_t and enumeration in va_list are converted to
 372    integer type : int, unsigned int, long or unsigned long (unfortunately,
 373    this is implementation dependant).
 374    We follow gmp which assumes in print/doprnt.c that wchar_t is converted
 375    to int (because wchar_t <= int).
 376    For wint_t, we assume that the case WINT_MAX < INT_MAX yields an
 377    integer promotion. */
 378 #ifdef HAVE_WCHAR_H
 379 #if defined(WINT_MAX) && WINT_MAX < INT_MAX
 380 typedef int    mpfr_va_wint;  /* integer promotion */
 381 #else
 382 typedef wint_t mpfr_va_wint;
 383 #endif
 384 #define CASE_LONG_ARG(specinfo, ap)                                     \
 385   case LONG_ARG:                                                        \
 386   if (((specinfo).spec == 'd') || ((specinfo).spec == 'i')              \
 387       || ((specinfo).spec == 'o') || ((specinfo).spec == 'u')           \
 388       || ((specinfo).spec == 'x') || ((specinfo).spec == 'X'))          \
 389     (void) va_arg ((ap), long);                                         \
 390   else if ((specinfo).spec == 'c')                                      \
 391     (void) va_arg ((ap), mpfr_va_wint);                                 \
 392   else if ((specinfo).spec == 's')                                      \
 393     (void) va_arg ((ap), int); /* we assume integer promotion */        \
 394   break;
 395 #else
 396 #define CASE_LONG_ARG(specinfo, ap)             \
 397   case LONG_ARG:                                \
 398   (void) va_arg ((ap), long);                   \
 399   break;
 400 #endif
 401
 402 #if defined(_MPFR_H_HAVE_INTMAX_T)
 403 #define CASE_INTMAX_ARG(specinfo, ap)           \
 404   case INTMAX_ARG:                              \
 405   (void) va_arg ((ap), intmax_t);               \
 406   break;
 407 #else
 408 #define CASE_INTMAX_ARG(specinfo, ap)
 409 #endif
 410
 411 #ifdef HAVE_LONG_LONG
 412 #define CASE_LONG_LONG_ARG(specinfo, ap)        \
 413   case LONG_LONG_ARG:                           \
 414   (void) va_arg ((ap), long long);              \
 415   break;
 416 #else
 417 #define CASE_LONG_LONG_ARG(specinfo, ap)
 418 #endif
 419
 420 #define CONSUME_VA_ARG(specinfo, ap)            \
 421   do {                                          \
 422     switch ((specinfo).arg_type)                \
 423       {                                         \
 424       case CHAR_ARG:                            \
 425       case SHORT_ARG:                           \
 426         (void) va_arg ((ap), int);              \
 427         break;                                  \
 428       CASE_LONG_ARG (specinfo, ap)              \
 429       CASE_LONG_LONG_ARG (specinfo, ap)         \
 430       CASE_INTMAX_ARG (specinfo, ap)            \
 431       case SIZE_ARG:                            \
 432         (void) va_arg ((ap), size_t);           \
 433         break;                                  \
 434       case PTRDIFF_ARG:                         \
 435         (void) va_arg ((ap), ptrdiff_t);        \
 436         break;                                  \
 437       case LONG_DOUBLE_ARG:                     \
 438         (void) va_arg ((ap), long double);      \
 439         break;                                  \
 440       case MPF_ARG:                             \
 441         (void) va_arg ((ap), mpf_srcptr);       \
 442         break;                                  \
 443       case MPQ_ARG:                             \
 444         (void) va_arg ((ap), mpq_srcptr);       \
 445         break;                                  \
 446       case MP_LIMB_ARG:                         \
 447         (void) va_arg ((ap), mp_limb_t);        \
 448         break;                                  \
 449       case MP_LIMB_ARRAY_ARG:                   \
 450         (void) va_arg ((ap), mpfr_limb_ptr);    \
 451         (void) va_arg ((ap), mp_size_t);        \
 452         break;                                  \
 453       case MPZ_ARG:                             \
 454         (void) va_arg ((ap), mpz_srcptr);       \
 455         break;                                  \
 456       default:                                  \
 457         switch ((specinfo).spec)                \
 458           {                                     \
 459           case 'd':                             \
 460           case 'i':                             \
 461           case 'o':                             \
 462           case 'u':                             \
 463           case 'x':                             \
 464           case 'X':                             \
 465           case 'c':                             \
 466             (void) va_arg ((ap), int);          \
 467             break;                              \
 468           case 'f':                             \
 469           case 'F':                             \
 470           case 'e':                             \
 471           case 'E':                             \
 472           case 'g':                             \
 473           case 'G':                             \
 474           case 'a':                             \
 475           case 'A':                             \
 476             (void) va_arg ((ap), double);       \
 477             break;                              \
 478           case 's':                             \
 479             (void) va_arg ((ap), char *);       \
 480             break;                              \
 481           case 'p':                             \
 482             (void) va_arg ((ap), void *);       \
 483           }                                     \
 484       }                                         \
 485   } while (0)
 486
 487 /* process the format part which does not deal with mpfr types,
 488    jump to external label 'error' if gmp_asprintf return -1. */
 489 #define FLUSH(flag, start, end, ap, buf_ptr)                            \
 490   do {                                                                  \
 491     const size_t n = (end) - (start);                                   \
 492     if ((flag))                                                         \
 493       /* previous specifiers are understood by gmp_printf */            \
 494       {                                                                 \
 495         MPFR_TMP_DECL (marker);                                         \
 496         char *fmt_copy;                                                 \
 497         MPFR_TMP_MARK (marker);                                         \
 498         fmt_copy = (char*) MPFR_TMP_ALLOC (n + 1);                      \
 499         strncpy (fmt_copy, (start), n);                                 \
 500         fmt_copy[n] = '\0';                                             \
 501         if (sprntf_gmp ((buf_ptr), (fmt_copy), (ap)) == -1)             \
 502           {                                                             \
 503             MPFR_TMP_FREE (marker);                                     \
 504             goto error;                                                 \
 505           }                                                             \
 506         (flag) = 0;                                                     \
 507         MPFR_TMP_FREE (marker);                                         \
 508       }                                                                 \
 509     else if ((start) != (end))                                          \
 510       /* no conversion specification, just simple characters */         \
 511       buffer_cat ((buf_ptr), (start), n);                               \
 512   } while (0)
 513
 514 struct string_buffer
 515 {
 516   char *start;                  /* beginning of the buffer */
 517   char *curr;                   /* null terminating character */
 518   size_t size;                  /* buffer capacity */
 519 };
 520
 521 static void
 522 buffer_init (struct string_buffer *b, size_t s)
 523 {
 524   b->start = (char *) (*__gmp_allocate_func) (s);
 525   b->start[0] = '\0';
 526   b->curr = b->start;
 527   b->size = s;
 528 }
 529
 530 /* Increase buffer size by a number of character being the least multiple of
 531    4096 greater than LEN+1. */
 532 static void
 533 buffer_widen (struct string_buffer *b, size_t len)
 534 {
 535   const size_t pos = b->curr - b->start;
 536   const size_t n = 0x1000 + (len & ~((size_t) 0xfff));
 537   MPFR_ASSERTD (pos < b->size);
 538
 539   MPFR_ASSERTN ((len & ~((size_t) 4095)) <= (size_t)(SIZE_MAX - 4096));
 540   MPFR_ASSERTN (b->size < SIZE_MAX - n);
 541
 542   b->start =
 543     (char *) (*__gmp_reallocate_func) (b->start, b->size, b->size + n);
 544   b->size += n;
 545   b->curr = b->start + pos;
 546
 547   MPFR_ASSERTD (pos < b->size);
 548   MPFR_ASSERTD (*b->curr == '\0');
 549 }
 550
 551 /* Concatenate the LEN first characters of the string S to the buffer B and
 552    expand it if needed. */
 553 static void
 554 buffer_cat (struct string_buffer *b, const char *s, size_t len)
 555 {
 556   MPFR_ASSERTD (len != 0);
 557   MPFR_ASSERTD (len <= strlen (s));
 558
 559   if (MPFR_UNLIKELY ((b->curr + len) >= (b->start + b->size)))
 560     buffer_widen (b, len);
 561
 562   strncat (b->curr, s, len);
 563   b->curr += len;
 564
 565   MPFR_ASSERTD (b->curr < b->start + b->size);
 566   MPFR_ASSERTD (*b->curr == '\0');
 567 }
 568
 569 /* Add N characters C to the end of buffer B */
 570 static void
 571 buffer_pad (struct string_buffer *b, const char c, const size_t n)
 572 {
 573   MPFR_ASSERTD (n != 0);
 574
 575   MPFR_ASSERTN (b->size < SIZE_MAX - n - 1);
 576   if (MPFR_UNLIKELY ((b->curr + n + 1) > (b->start + b->size)))
 577     buffer_widen (b, n);
 578
 579   if (n == 1)
 580     *b->curr = c;
 581   else
 582     memset (b->curr, c, n);
 583   b->curr += n;
 584   *b->curr = '\0';
 585
 586   MPFR_ASSERTD (b->curr < b->start + b->size);
 587 }
 588
 589 /* Form a string by concatenating the first LEN characters of STR to TZ
 590    zero(s), insert into one character C each 3 characters starting from end
 591    to begining and concatenate the result to the buffer B. */
 592 static void
 593 buffer_sandwich (struct string_buffer *b, char *str, size_t len,
 594                  const size_t tz, const char c)
 595 {
 596   const size_t step = 3;
 597   const size_t size = len + tz;
 598   const size_t r = size % step == 0 ? step : size % step;
 599   const size_t q = size % step == 0 ? size / step - 1 : size / step;
 600   size_t i;
 601
 602   MPFR_ASSERTD (size != 0);
 603   if (c == '\0')
 604     {
 605       buffer_cat (b, str, len);
 606       buffer_pad (b, '0', tz);
 607       return;
 608     }
 609
 610   MPFR_ASSERTN (b->size < SIZE_MAX - size - 1 - q);
 611   MPFR_ASSERTD (len <= strlen (str));
 612   if (MPFR_UNLIKELY ((b->curr + size + 1 + q) > (b->start + b->size)))
 613     buffer_widen (b, size + q);
 614
 615   /* first R significant digits */
 616   memcpy (b->curr, str, r);
 617   b->curr += r;
 618   str += r;
 619   len -= r;
 620
 621   /* blocks of thousands. Warning: STR might end in the middle of a block */
 622   for (i = 0; i < q; ++i)
 623     {
 624       *b->curr++ = c;
 625       if (MPFR_LIKELY (len > 0))
 626         {
 627           if (MPFR_LIKELY (len >= step))
 628             /* step significant digits */
 629             {
 630               memcpy (b->curr, str, step);
 631               len -= step;
 632             }
 633           else
 634             /* last digits in STR, fill up thousand block with zeros */
 635             {
 636               memcpy (b->curr, str, len);
 637               memset (b->curr + len, '0', step - len);
 638               len = 0;
 639             }
 640         }
 641       else
 642         /* trailing zeros */
 643         memset (b->curr, '0', step);
 644
 645       b->curr += step;
 646       str += step;
 647     }
 648
 649   *b->curr = '\0';
 650
 651   MPFR_ASSERTD (b->curr < b->start + b->size);
 652 }
 653
 654 /* let gmp_xprintf process the part it can understand */
 655 static int
 656 sprntf_gmp (struct string_buffer *b, const char *fmt, va_list ap)
 657 {
 658   int length;
 659   char *s;
 660
 661   length = gmp_vasprintf (&s, fmt, ap);
 662   if (length > 0)
 663     buffer_cat (b, s, length);
 664
 665   mpfr_free_str (s);
 666   return length;
 667 }
 668
 669 /* Helper struct and functions for temporary strings management */
 670 /* struct for easy string clearing */
 671 struct string_list
 672 {
 673   char *string;
 674   struct string_list *next; /* NULL in last node */
 675 };
 676
 677 /* initialisation */
 678 static void
 679 init_string_list (struct string_list *sl)
 680 {
 681   sl->string = NULL;
 682   sl->next = NULL;
 683 }
 684
 685 /* clear all strings in the list */
 686 static void
 687 clear_string_list (struct string_list *sl)
 688 {
 689   struct string_list *n;
 690
 691   while (sl)
 692     {
 693       if (sl->string)
 694         mpfr_free_str (sl->string);
 695       n = sl->next;
 696       (*__gmp_free_func) (sl, sizeof(struct string_list));
 697       sl = n;
 698     }
 699 }
 700
 701 /* add a string in the list */
 702 static char *
 703 register_string (struct string_list *sl, char *new_string)
 704 {
 705   /* look for the last node */
 706   while (sl->next)
 707     sl = sl->next;
 708
 709   sl->next = (struct string_list*)
 710     (*__gmp_allocate_func) (sizeof (struct string_list));
 711
 712   sl = sl->next;
 713   sl->next = NULL;
 714   return sl->string = new_string;
 715 }
 716
 717 /* padding type: where are the padding characters */
 718 enum pad_t
 719   {
 720     LEFT,          /* spaces in left hand side for right justification */
 721     LEADING_ZEROS, /* padding with '0' characters in integral part */
 722     RIGHT          /* spaces in right hand side for left justification */
 723   };
 724
 725 /* number_parts details how much characters are needed in each part of a float
 726    print.  */
 727 struct number_parts
 728 {
 729   enum pad_t pad_type;    /* Padding type */
 730   size_t pad_size;        /* Number of padding characters */
 731
 732   char sign;              /* Sign character */
 733
 734   char *prefix_ptr;       /* Pointer to prefix part */
 735   size_t prefix_size;     /* Number of characters in *prefix_ptr */
 736
 737   char thousands_sep;     /* Thousands separator (only with style 'f') */
 738
 739   char *ip_ptr;           /* Pointer to integral part characters*/
 740   size_t ip_size;         /* Number of digits in *ip_ptr */
 741   int ip_trailing_zeros;  /* Number of additional null digits in integral
 742                              part */
 743
 744   char point;             /* Decimal point character */
 745
 746   int fp_leading_zeros;   /* Number of additional leading zeros in fractional
 747                              part */
 748   char *fp_ptr;           /* Pointer to fractional part characters */
 749   size_t fp_size;         /* Number of digits in *fp_ptr */
 750   int fp_trailing_zeros;  /* Number of additional trailing zeros in fractional
 751                              part */
 752
 753   char *exp_ptr;          /* Pointer to exponent part */
 754   size_t exp_size;        /* Number of characters in *exp_ptr */
 755
 756   struct string_list *sl; /* List of string buffers in use: we need such a
 757                              mechanism because fp_ptr may point into the same
 758                              string as ip_ptr */
 759 };
 760
 761 /* For a real non zero number x, what is the base exponent f when rounding x
 762    with rounding mode r to r(x) = m*b^f, where m is a digit and 1 <= m < b ?
 763    Return non zero value if x is rounded up to b^f, return zero otherwise */
 764 static int
 765 next_base_power_p (mpfr_srcptr x, int base, mpfr_rnd_t rnd)
 766 {
 767   mpfr_prec_t nbits;
 768   mp_limb_t pm;
 769   mp_limb_t xm;
 770
 771   MPFR_ASSERTD (MPFR_IS_PURE_FP (x));
 772   MPFR_ASSERTD (base == 2 || base == 16);
 773
 774   /* Warning: the decimal point is AFTER THE FIRST DIGIT in this output
 775      representation. */
 776   nbits = base == 2 ? 1 : 4;
 777
 778   if (rnd == MPFR_RNDZ
 779       || (rnd == MPFR_RNDD && MPFR_IS_POS (x))
 780       || (rnd == MPFR_RNDU && MPFR_IS_NEG (x))
 781       || MPFR_PREC (x) <= nbits)
 782     /* no rounding when printing x with 1 digit */
 783     return 0;
 784
 785   xm = MPFR_MANT (x) [MPFR_LIMB_SIZE (x) - 1];
 786   pm = MPFR_LIMB_MASK (GMP_NUMB_BITS - nbits);
 787   if ((xm & ~pm) ^ ~pm)
 788     /* do no round up if some of the nbits first bits are 0s. */
 789     return 0;
 790
 791   if (rnd == MPFR_RNDN)
 792     /* mask for rounding bit */
 793     pm = (MPFR_LIMB_ONE << (GMP_NUMB_BITS - nbits - 1));
 794
 795   /* round up if some remaining bits are 1 */
 796   /* warning: the return value must be an int */
 797   return xm & pm ? 1 : 0;
 798 }
 799
 800 /* Record information from mpfr_get_str() so as to avoid multiple
 801    calls to this expensive function. */
 802 struct decimal_info
 803 {
 804   mpfr_exp_t exp;
 805   char *str;
 806 };
 807
 808 /* For a real non zero number x, what is the exponent f so that
 809    10^f <= x < 10^(f+1). */
 810 static mpfr_exp_t
 811 floor_log10 (mpfr_srcptr x)
 812 {
 813   mpfr_t y;
 814   mpfr_exp_t exp;
 815
 816   /* make sure first that y can represent a mpfr_exp_t exactly
 817      and can compare with x */
 818   mpfr_prec_t prec = sizeof (mpfr_exp_t) * CHAR_BIT;
 819   mpfr_init2 (y, MAX (prec, MPFR_PREC (x)));
 820
 821   exp = mpfr_ceil_mul (MPFR_GET_EXP (x), 10, 1) - 1;
 822   mpfr_set_exp_t (y, exp, MPFR_RNDU);
 823   /* The following call to mpfr_ui_pow should be fast: y is an integer
 824      (not too large), so that mpfr_pow_z will be used internally. */
 825   mpfr_ui_pow (y, 10, y, MPFR_RNDU);
 826   if (mpfr_cmpabs (x, y) < 0)
 827     exp--;
 828
 829   mpfr_clear (y);
 830   return exp;
 831 }
 832
 833 /* Determine the different parts of the string representation of the regular
 834    number P when SPEC.SPEC is 'a', 'A', or 'b'.
 835
 836    return -1 if some field > INT_MAX */
 837 static int
 838 regular_ab (struct number_parts *np, mpfr_srcptr p,
 839             const struct printf_spec spec)
 840 {
 841   int uppercase;
 842   int base;
 843   char *str;
 844   mpfr_exp_t exp;
 845
 846   uppercase = spec.spec == 'A';
 847
 848   /* sign */
 849   if (MPFR_IS_NEG (p))
 850     np->sign = '-';
 851   else if (spec.showsign || spec.space)
 852     np->sign = spec.showsign ? '+' : ' ';
 853
 854   if (spec.spec == 'a' || spec.spec == 'A')
 855     /* prefix part */
 856     {
 857       np->prefix_size = 2;
 858       str = (char *) (*__gmp_allocate_func) (1 + np->prefix_size);
 859       str[0] = '0';
 860       str[1] = uppercase ? 'X' : 'x';
 861       str[2] = '\0';
 862       np->prefix_ptr = register_string (np->sl, str);
 863     }
 864
 865   /* integral part */
 866   np->ip_size = 1;
 867   base = (spec.spec == 'b') ? 2 : 16;
 868
 869   if (spec.prec != 0)
 870     {
 871       size_t nsd;
 872
 873       /* Number of significant digits:
 874          - if no given precision, let mpfr_get_str determine it;
 875          - if a non-zero precision is specified, then one digit before decimal
 876          point plus SPEC.PREC after it. */
 877       nsd = spec.prec < 0 ? 0 : spec.prec + np->ip_size;
 878       str = mpfr_get_str (0, &exp, base, nsd, p, spec.rnd_mode);
 879       register_string (np->sl, str);
 880       np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str;  /* skip sign if any */
 881
 882       if (base == 16)
 883         /* EXP is the exponent for radix sixteen with decimal point BEFORE the
 884            first digit, we want the exponent for radix two and the decimal
 885            point AFTER the first digit. */
 886         {
 887           MPFR_ASSERTN (exp > MPFR_EMIN_MIN /4); /* possible overflow */
 888           exp = (exp - 1) * 4;
 889         }
 890       else
 891         /* EXP is the exponent for decimal point BEFORE the first digit, we
 892            want the exponent for decimal point AFTER the first digit. */
 893         {
 894           MPFR_ASSERTN (exp > MPFR_EMIN_MIN); /* possible overflow */
 895           --exp;
 896         }
 897     }
 898   else if (next_base_power_p (p, base, spec.rnd_mode))
 899     {
 900       str = (char *)(*__gmp_allocate_func) (2);
 901       str[0] = '1';
 902       str[1] = '\0';
 903       np->ip_ptr = register_string (np->sl, str);
 904
 905       exp = MPFR_GET_EXP (p);
 906     }
 907   else if (base == 2)
 908     {
 909       str = (char *)(*__gmp_allocate_func) (2);
 910       str[0] = '1';
 911       str[1] = '\0';
 912       np->ip_ptr = register_string (np->sl, str);
 913
 914       exp = MPFR_GET_EXP (p) - 1;
 915     }
 916   else
 917     {
 918       int digit;
 919       mp_limb_t msl = MPFR_MANT (p)[MPFR_LIMB_SIZE (p) - 1];
 920       int rnd_bit = GMP_NUMB_BITS - 5;
 921
 922       /* pick up the 4 first bits */
 923       digit = msl >> (rnd_bit+1);
 924       if (spec.rnd_mode == MPFR_RNDA
 925           || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p))
 926           || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p))
 927           || (spec.rnd_mode == MPFR_RNDN
 928               && (msl & (MPFR_LIMB_ONE << rnd_bit))))
 929         digit++;
 930       MPFR_ASSERTD ((0 <= digit) && (digit <= 15));
 931
 932       str = (char *)(*__gmp_allocate_func) (1 + np->ip_size);
 933       str[0] = num_to_text [digit];
 934       str[1] = '\0';
 935       np->ip_ptr = register_string (np->sl, str);
 936
 937       exp = MPFR_GET_EXP (p) - 4;
 938     }
 939
 940   if (uppercase)
 941     /* All digits in upper case */
 942     {
 943       char *s1 = str;
 944       while (*s1)
 945         {
 946           switch (*s1)
 947             {
 948             case 'a':
 949               *s1 = 'A';
 950               break;
 951             case 'b':
 952               *s1 = 'B';
 953               break;
 954             case 'c':
 955               *s1 = 'C';
 956               break;
 957             case 'd':
 958               *s1 = 'D';
 959               break;
 960             case 'e':
 961               *s1 = 'E';
 962               break;
 963             case 'f':
 964               *s1 = 'F';
 965               break;
 966             }
 967           s1++;
 968         }
 969     }
 970
 971   if (spec.spec == 'b' || spec.prec != 0)
 972     /* compute the number of digits in fractional part */
 973     {
 974       char *ptr;
 975       size_t str_len;
 976
 977       /* the sign has been skipped, skip also the first digit */
 978       ++str;
 979       str_len = strlen (str);
 980       ptr = str + str_len - 1; /* points to the end of str */
 981
 982       if (spec.prec < 0)
 983         /* remove trailing zeros, if any */
 984         {
 985           while ((*ptr == '0') && (str_len != 0))
 986             {
 987               --ptr;
 988               --str_len;
 989             }
 990         }
 991
 992       if (str_len > INT_MAX)
 993         /* too many digits in fractional part */
 994         return -1;
 995
 996       if (str_len != 0)
 997         /* there are some non-zero digits in fractional part */
 998         {
 999           np->fp_ptr = str;
1000           np->fp_size = str_len;
1001           if ((int) str_len < spec.prec)
1002             np->fp_trailing_zeros = spec.prec - str_len;
1003         }
1004     }
1005
1006   /* decimal point */
1007   if ((np->fp_size != 0) || spec.alt)
1008     np->point = MPFR_DECIMAL_POINT;
1009
1010   /* the exponent part contains the character 'p', or 'P' plus the sign
1011      character plus at least one digit and only as many more digits as
1012      necessary to represent the exponent.
1013      We assume that |EXP| < 10^INT_MAX. */
1014   np->exp_size = 3;
1015   {
1016     mpfr_uexp_t x;
1017
1018     x = SAFE_ABS (mpfr_uexp_t, exp);
1019     while (x > 9)
1020       {
1021         np->exp_size++;
1022         x /= 10;
1023       }
1024   }
1025   str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1026   np->exp_ptr = register_string (np->sl, str);
1027   {
1028     char exp_fmt[8];  /* contains at most 7 characters like in "p%+.1i",
1029                          or "P%+.2li" */
1030
1031     exp_fmt[0] = uppercase ? 'P' : 'p';
1032     exp_fmt[1] = '\0';
1033     strcat (exp_fmt, "%+.1" MPFR_EXP_FSPEC "d");
1034
1035     if (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)
1036       return -1;
1037   }
1038
1039   return 0;
1040 }
1041
1042 /* Determine the different parts of the string representation of the regular
1043    number P when SPEC.SPEC is 'e', 'E', 'g', or 'G'.
1044    DEC_INFO contains the previously computed exponent and string or is NULL.
1045
1046    return -1 if some field > INT_MAX */
1047 static int
1048 regular_eg (struct number_parts *np, mpfr_srcptr p,
1049             const struct printf_spec spec, struct decimal_info *dec_info)
1050 {
1051   char *str;
1052   mpfr_exp_t exp;
1053
1054   const int uppercase = spec.spec == 'E' || spec.spec == 'G';
1055   const int spec_g = spec.spec == 'g' || spec.spec == 'G';
1056   const int keep_trailing_zeros = (spec_g && spec.alt)
1057     || (!spec_g && (spec.prec > 0));
1058
1059   /* sign */
1060   if (MPFR_IS_NEG (p))
1061     np->sign = '-';
1062   else if (spec.showsign || spec.space)
1063     np->sign = spec.showsign ? '+' : ' ';
1064
1065   /* integral part */
1066   np->ip_size = 1;
1067   if (dec_info == NULL)
1068     {
1069       size_t nsd;
1070
1071       /* Number of significant digits:
1072          - if no given precision, then let mpfr_get_str determine it,
1073          - if a precision is specified, then one digit before decimal point
1074          plus SPEC.PREC after it.
1075          We use the fact here that mpfr_get_str allows us to ask for only one
1076          significant digit when the base is not a power of 2. */
1077       nsd = (spec.prec < 0) ? 0 : spec.prec + np->ip_size;
1078       str = mpfr_get_str (0, &exp, 10, nsd, p, spec.rnd_mode);
1079       register_string (np->sl, str);
1080     }
1081   else
1082     {
1083       exp = dec_info->exp;
1084       str = dec_info->str;
1085     }
1086   np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str;  /* skip sign if any */
1087
1088   if (spec.prec != 0)
1089     /* compute the number of digits in fractional part */
1090     {
1091       char *ptr;
1092       size_t str_len;
1093
1094       /* the sign has been skipped, skip also the first digit */
1095       ++str;
1096       str_len = strlen (str);
1097       ptr = str + str_len - 1; /* points to the end of str */
1098
1099       if (!keep_trailing_zeros)
1100         /* remove trailing zeros, if any */
1101         {
1102           while ((*ptr == '0') && (str_len != 0))
1103             {
1104               --ptr;
1105               --str_len;
1106             }
1107         }
1108
1109       if (str_len > INT_MAX)
1110         /* too many digits in fractional part */
1111         return -1;
1112
1113       if (str_len != 0)
1114         /* there are some non-zero digits in fractional part */
1115         {
1116           np->fp_ptr = str;
1117           np->fp_size = str_len;
1118           if ((!spec_g || spec.alt) && (spec.prec > 0)
1119               && ((int)str_len < spec.prec))
1120             /* add missing trailing zeros */
1121             np->fp_trailing_zeros = spec.prec - str_len;
1122         }
1123     }
1124
1125   /* decimal point */
1126   if (np->fp_size != 0 || spec.alt)
1127     np->point = MPFR_DECIMAL_POINT;
1128
1129   /* EXP is the exponent for decimal point BEFORE the first digit, we want
1130      the exponent for decimal point AFTER the first digit.
1131      Here, no possible overflow because exp < MPFR_EXP (p) / 3 */
1132   exp--;
1133
1134   /* the exponent part contains the character 'e', or 'E' plus the sign
1135      character plus at least two digits and only as many more digits as
1136      necessary to represent the exponent.
1137      We assume that |EXP| < 10^INT_MAX. */
1138   np->exp_size = 3;
1139   {
1140     mpfr_uexp_t x;
1141
1142     x = SAFE_ABS (mpfr_uexp_t, exp);
1143     while (x > 9)
1144       {
1145         np->exp_size++;
1146         x /= 10;
1147       }
1148   }
1149   if (np->exp_size < 4)
1150     np->exp_size = 4;
1151
1152   str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1153   np->exp_ptr = register_string (np->sl, str);
1154
1155   {
1156     char exp_fmt[8];  /* e.g. "e%+.2i", or "E%+.2li" */
1157
1158     exp_fmt[0] = uppercase ? 'E' : 'e';
1159     exp_fmt[1] = '\0';
1160     strcat (exp_fmt, "%+.2" MPFR_EXP_FSPEC "d");
1161
1162     if (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)
1163       return -1;
1164   }
1165
1166   return 0;
1167 }
1168
1169 /* Determine the different parts of the string representation of the regular
1170    number P when SPEC.SPEC is 'f', 'F', 'g', or 'G'.
1171    DEC_INFO contains the previously computed exponent and string or is NULL.
1172
1173    return -1 if some field of number_parts is greater than INT_MAX */
1174 static int
1175 regular_fg (struct number_parts *np, mpfr_srcptr p,
1176             const struct printf_spec spec, struct decimal_info *dec_info)
1177 {
1178   mpfr_exp_t exp;
1179   char * str;
1180   const int spec_g = (spec.spec == 'g' || spec.spec == 'G');
1181   const int keep_trailing_zeros = spec_g && spec.alt;
1182
1183   /* WARNING: an empty precision field is forbidden (it means precision = 6
1184      and it should have been changed to 6 before the function call) */
1185   MPFR_ASSERTD (spec.prec >= 0);
1186
1187   /* sign */
1188   if (MPFR_IS_NEG (p))
1189     np->sign = '-';
1190   else if (spec.showsign || spec.space)
1191     np->sign = spec.showsign ? '+' : ' ';
1192
1193   if (MPFR_GET_EXP (p) <= 0)
1194     /* 0 < |p| < 1 */
1195     {
1196       /* Most of the time, integral part is 0 */
1197       np->ip_size = 1;
1198       str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1199       str[0] = '0';
1200       str[1] = '\0';
1201       np->ip_ptr = register_string (np->sl, str);
1202
1203       if (spec.prec == 0)
1204         /* only two possibilities: either 1 or 0. */
1205         {
1206           mpfr_t y;
1207           /* y = abs(p) */
1208           MPFR_ALIAS (y, p, 1, MPFR_EXP (p));
1209
1210           if (spec.rnd_mode == MPFR_RNDA
1211               || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p))
1212               || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p))
1213               || (spec.rnd_mode == MPFR_RNDN && mpfr_cmp_d (y, 0.5) > 0))
1214             /* rounded up to 1: one digit '1' in integral part.
1215                note that 0.5 is rounded to 0 with RNDN (round ties to even) */
1216             np->ip_ptr[0] = '1';
1217         }
1218       else
1219         {
1220           /* exp =  position of the most significant decimal digit. */
1221           exp = floor_log10 (p);
1222           MPFR_ASSERTD (exp < 0);
1223
1224           if (exp < -spec.prec)
1225             /* only the last digit may be non zero */
1226             {
1227               int round_away;
1228               switch (spec.rnd_mode)
1229                 {
1230                 case MPFR_RNDA:
1231                   round_away = 1;
1232                   break;
1233                 case MPFR_RNDD:
1234                   round_away = MPFR_IS_NEG (p);
1235                   break;
1236                 case MPFR_RNDU:
1237                   round_away = MPFR_IS_POS (p);
1238                   break;
1239                 case MPFR_RNDN:
1240                   {
1241                     /* compare |p| to y = 0.5*10^(-spec.prec) */
1242                     mpfr_t y;
1243                     mpfr_exp_t e = MAX (MPFR_PREC (p), 56);
1244                     mpfr_init2 (y, e + 8);
1245                     do
1246                       {
1247                         /* find a lower approximation of
1248                            0.5*10^(-spec.prec) different from |p| */
1249                         e += 8;
1250                         mpfr_set_prec (y, e);
1251                         mpfr_set_si (y, -spec.prec, MPFR_RNDN);
1252                         mpfr_exp10 (y, y, MPFR_RNDD);
1253                         mpfr_div_2ui (y, y, 1, MPFR_RNDN);
1254                       } while (mpfr_cmpabs (y, p) == 0);
1255
1256                     round_away = mpfr_cmpabs (y, p) < 0;
1257                     mpfr_clear (y);
1258                   }
1259                   break;
1260                 default:
1261                   round_away = 0;
1262                 }
1263
1264               if (round_away)
1265                 /* round away from zero: the last output digit is '1' */
1266                 {
1267                   np->fp_leading_zeros = spec.prec - 1;
1268
1269                   np->fp_size = 1;
1270                   str =
1271                     (char *) (*__gmp_allocate_func) (1 + np->fp_size);
1272                   str[0] = '1';
1273                   str[1] = '\0';
1274                   np->fp_ptr = register_string (np->sl, str);
1275                 }
1276               else
1277                 /* only zeros in fractional part */
1278                 {
1279                   MPFR_ASSERTD (!spec_g);
1280                   np->fp_leading_zeros = spec.prec;
1281                 }
1282             }
1283           else
1284             /* the most significant digits are the last
1285                spec.prec + exp + 1 digits in fractional part */
1286             {
1287               char *ptr;
1288               size_t str_len;
1289               if (dec_info == NULL)
1290                 {
1291                   size_t nsd = spec.prec + exp + 1;
1292                   /* WARNING: nsd may equal 1, but here we use the
1293                      fact that mpfr_get_str can return one digit with
1294                      base ten (undocumented feature, see comments in
1295                      get_str.c) */
1296
1297                   str = mpfr_get_str (NULL, &exp, 10, nsd, p, spec.rnd_mode);
1298                   register_string (np->sl, str);
1299                 }
1300               else
1301                 {
1302                   exp = dec_info->exp;
1303                   str = dec_info->str;
1304                 }
1305               if (MPFR_IS_NEG (p))
1306                 ++str;
1307               if (exp == 1)
1308                 /* round up to 1 */
1309                 {
1310                   MPFR_ASSERTD (str[0] == '1');
1311                   np->ip_ptr[0] = '1';
1312                   if (!spec_g || spec.alt)
1313                     np->fp_leading_zeros = spec.prec;
1314                 }
1315               else
1316                 {
1317                   /* skip sign */
1318                   np->fp_ptr = str;
1319                   np->fp_leading_zeros = -exp;
1320                   MPFR_ASSERTD (exp <= 0);
1321
1322                   str_len = strlen (str); /* the sign has been skipped */
1323                   ptr = str + str_len - 1; /* points to the end of str */
1324
1325                   if (!keep_trailing_zeros)
1326                     /* remove trailing zeros, if any */
1327                     {
1328                       while ((*ptr == '0') && str_len)
1329                         {
1330                           --ptr;
1331                           --str_len;
1332                         }
1333                     }
1334
1335                   if (str_len > INT_MAX)
1336                     /* too many digits in fractional part */
1337                     return -1;
1338
1339                   MPFR_ASSERTD (str_len > 0);
1340                   np->fp_size = str_len;
1341
1342                   if ((!spec_g || spec.alt)
1343                       && spec.prec > 0
1344                       && (np->fp_leading_zeros + np->fp_size < spec.prec))
1345                     /* add missing trailing zeros */
1346                     np->fp_trailing_zeros = spec.prec - np->fp_leading_zeros
1347                       - np->fp_size;
1348                 }
1349             }
1350         }
1351
1352       if (spec.alt || np->fp_leading_zeros != 0 || np->fp_size != 0
1353           || np->fp_trailing_zeros != 0)
1354         np->point = MPFR_DECIMAL_POINT;
1355     }
1356   else
1357     /* 1 <= |p| */
1358     {
1359       size_t nsd;  /* Number of significant digits */
1360
1361       /* Determine the position of the most significant decimal digit. */
1362       exp = floor_log10 (p);
1363       MPFR_ASSERTD (exp >= 0);
1364       if (exp > INT_MAX)
1365         /* P is too large to print all its integral part digits */
1366         return -1;
1367
1368       np->ip_size = exp + 1;
1369
1370       nsd = spec.prec + np->ip_size;
1371       if (dec_info == NULL)
1372         {
1373           str = mpfr_get_str (NULL, &exp, 10, nsd, p, spec.rnd_mode);
1374           register_string (np->sl, str);
1375         }
1376       else
1377         {
1378           exp = dec_info->exp;
1379           str = dec_info->str;
1380         }
1381       np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign */
1382
1383       if (spec.group)
1384         /* thousands separator in integral part */
1385         np->thousands_sep = MPFR_THOUSANDS_SEPARATOR;
1386
1387       if (nsd == 0 || (spec_g && !spec.alt))
1388         /* compute how much non-zero digits in integral and fractional
1389            parts */
1390         {
1391           size_t str_len;
1392           str_len = strlen (str); /* note: the sign has been skipped */
1393
1394           if (exp > str_len)
1395             /* mpfr_get_str doesn't give the trailing zeros when p is a
1396                multiple of 10 (p integer, so no fractional part) */
1397             {
1398               np->ip_trailing_zeros = exp - str_len;
1399               np->ip_size = str_len;
1400               if (spec.alt)
1401                 np->point = MPFR_DECIMAL_POINT;
1402             }
1403           else
1404             /* str may contain some digits which are in fractional part */
1405             {
1406               char *ptr;
1407
1408               ptr = str + str_len - 1; /* points to the end of str */
1409               str_len -= np->ip_size;  /* number of digits in fractional
1410                                           part */
1411
1412               if (!keep_trailing_zeros)
1413                 /* remove trailing zeros, if any */
1414                 {
1415                   while ((*ptr == '0') && (str_len != 0))
1416                     {
1417                       --ptr;
1418                       --str_len;
1419                     }
1420                 }
1421
1422               if (str_len > INT_MAX)
1423                 /* too many digits in fractional part */
1424                 return -1;
1425
1426               if (str_len != 0)
1427                 /* some digits in fractional part */
1428                 {
1429                   np->point = MPFR_DECIMAL_POINT;
1430                   np->fp_ptr = str + np->ip_size;
1431                   np->fp_size = str_len;
1432                 }
1433             }
1434         }
1435       else
1436         /* spec.prec digits in fractional part */
1437         {
1438           if (np->ip_size == exp - 1)
1439             /* the absolute value of the number has been rounded up to a power
1440                of ten.
1441                Insert an additional zero in integral part and put the rest of
1442                them in fractional part. */
1443             np->ip_trailing_zeros = 1;
1444
1445           if (spec.prec != 0)
1446             {
1447               MPFR_ASSERTD (np->ip_size + np->ip_trailing_zeros == exp);
1448               MPFR_ASSERTD (np->ip_size + spec.prec == nsd);
1449
1450               np->point = MPFR_DECIMAL_POINT;
1451               np->fp_ptr = str + np->ip_size;
1452               np->fp_size = spec.prec;
1453             }
1454           else if (spec.alt)
1455             np->point = MPFR_DECIMAL_POINT;
1456         }
1457     }
1458
1459   return 0;
1460 }
1461
1462 /* partition_number determines the different parts of the string
1463    representation of the number p according to the given specification.
1464    partition_number initializes the given structure np, so all previous
1465    information in that variable is lost.
1466    return the total number of characters to be written.
1467    return -1 if an error occured, in that case np's fields are in an undefined
1468    state but all string buffers have been freed. */
1469 static int
1470 partition_number (struct number_parts *np, mpfr_srcptr p,
1471                   struct printf_spec spec)
1472 {
1473   char *str;
1474   long total;
1475   int uppercase;
1476
1477   /* WARNING: left justification means right space padding */
1478   np->pad_type = spec.left ? RIGHT : spec.pad == '0' ? LEADING_ZEROS : LEFT;
1479   np->pad_size = 0;
1480   np->sign = '\0';
1481   np->prefix_ptr =NULL;
1482   np->prefix_size = 0;
1483   np->thousands_sep = '\0';
1484   np->ip_ptr = NULL;
1485   np->ip_size = 0;
1486   np->ip_trailing_zeros = 0;
1487   np->point = '\0';
1488   np->fp_leading_zeros = 0;
1489   np->fp_ptr = NULL;
1490   np->fp_size = 0;
1491   np->fp_trailing_zeros = 0;
1492   np->exp_ptr = NULL;
1493   np->exp_size = 0;
1494   np->sl = (struct string_list *)
1495     (*__gmp_allocate_func) (sizeof (struct string_list));
1496   init_string_list (np->sl);
1497
1498   uppercase = spec.spec == 'A' || spec.spec == 'E' || spec.spec == 'F'
1499     || spec.spec == 'G';
1500
1501   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (p)))
1502     {
1503       if (MPFR_IS_NAN (p))
1504         {
1505           if (np->pad_type == LEADING_ZEROS)
1506             /* don't want "0000nan", change to right justification padding
1507                with left spaces instead */
1508             np->pad_type = LEFT;
1509
1510           if (uppercase)
1511             {
1512               np->ip_size = MPFR_NAN_STRING_LENGTH;
1513               str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1514               strcpy (str, MPFR_NAN_STRING_UC);
1515               np->ip_ptr = register_string (np->sl, str);
1516             }
1517           else
1518             {
1519               np->ip_size = MPFR_NAN_STRING_LENGTH;
1520               str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1521               strcpy (str, MPFR_NAN_STRING_LC);
1522               np->ip_ptr = register_string (np->sl, str);
1523             }
1524         }
1525       else if (MPFR_IS_INF (p))
1526         {
1527           if (np->pad_type == LEADING_ZEROS)
1528             /* don't want "0000inf", change to right justification padding
1529                with left spaces instead */
1530             np->pad_type = LEFT;
1531
1532           if (MPFR_IS_NEG (p))
1533             np->sign = '-';
1534
1535           if (uppercase)
1536             {
1537               np->ip_size = MPFR_INF_STRING_LENGTH;
1538               str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1539               strcpy (str, MPFR_INF_STRING_UC);
1540               np->ip_ptr = register_string (np->sl, str);
1541             }
1542           else
1543             {
1544               np->ip_size = MPFR_INF_STRING_LENGTH;
1545               str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1546               strcpy (str, MPFR_INF_STRING_LC);
1547               np->ip_ptr = register_string (np->sl, str);
1548             }
1549         }
1550       else
1551         /* p == 0 */
1552         {
1553           /* note: for 'g' spec, zero is always displayed with 'f'-style with
1554              precision spec.prec - 1 and the trailing zeros are removed unless
1555              the flag '#' is used. */
1556           if (MPFR_IS_NEG (p))
1557             /* signed zero */
1558             np->sign = '-';
1559           else if (spec.showsign || spec.space)
1560             np->sign = spec.showsign ? '+' : ' ';
1561
1562           if (spec.spec == 'a' || spec.spec == 'A')
1563             /* prefix part */
1564             {
1565               np->prefix_size = 2;
1566               str = (char *) (*__gmp_allocate_func) (1 + np->prefix_size);
1567               str[0] = '0';
1568               str[1] = uppercase ? 'X' : 'x';
1569               str[2] = '\0';
1570               np->prefix_ptr = register_string (np->sl, str);
1571             }
1572
1573           /* integral part */
1574           np->ip_size = 1;
1575           str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1576           str[0] = '0';
1577           str[1] = '\0';
1578           np->ip_ptr = register_string (np->sl, str);
1579
1580           if (spec.prec > 0
1581               && ((spec.spec != 'g' && spec.spec != 'G') || spec.alt))
1582             /* fractional part */
1583             {
1584               np->point = MPFR_DECIMAL_POINT;
1585               np->fp_trailing_zeros = (spec.spec == 'g' && spec.spec == 'G') ?
1586                 spec.prec - 1 : spec.prec;
1587             }
1588           else if (spec.alt)
1589             np->point = MPFR_DECIMAL_POINT;
1590
1591           if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b'
1592               || spec.spec == 'e' || spec.spec == 'E')
1593             /* exponent part */
1594             {
1595               np->exp_size = (spec.spec == 'e' || spec.spec == 'E') ? 4 : 3;
1596               str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1597               if (spec.spec == 'e' || spec.spec == 'E')
1598                 strcpy (str, uppercase ? "E+00" : "e+00");
1599               else
1600                 strcpy (str, uppercase ? "P+0" : "p+0");
1601               np->exp_ptr = register_string (np->sl, str);
1602             }
1603         }
1604     }
1605   else
1606     /* regular p, p != 0 */
1607     {
1608       if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b')
1609         {
1610           if (regular_ab (np, p, spec) == -1)
1611             goto error;
1612         }
1613       else if (spec.spec == 'f' || spec.spec == 'F')
1614         {
1615           if (spec.prec == -1)
1616             spec.prec = 6;
1617           if (regular_fg (np, p, spec, NULL) == -1)
1618             goto error;
1619         }
1620       else if (spec.spec == 'e' || spec.spec == 'E')
1621         {
1622           if (regular_eg (np, p, spec, NULL) == -1)
1623             goto error;
1624         }
1625       else
1626         /* %g case */
1627         {
1628           /* Use the C99 rules:
1629              if T > X >= -4 then the conversion is with style 'f'/'F' and
1630              precision T-(X+1).
1631              otherwise, the conversion is with style 'e'/'E' and
1632              precision T-1.
1633              where T is the threshold computed below and X is the exponent
1634              that would be displayed with style 'e' and precision T-1. */
1635           int threshold;
1636           mpfr_exp_t x;
1637           struct decimal_info dec_info;
1638
1639           threshold = (spec.prec < 0) ? 6 : (spec.prec == 0) ? 1 : spec.prec;
1640           dec_info.str = mpfr_get_str (NULL, &dec_info.exp, 10, threshold,
1641                                         p, spec.rnd_mode);
1642           register_string (np->sl, dec_info.str);
1643           /* mpfr_get_str corresponds to a significand between 0.1 and 1,
1644              whereas here we want a significand between 1 and 10. */
1645           x = dec_info.exp - 1;
1646
1647           if (threshold > x && x >= -4)
1648             {
1649               /* the conversion is with style 'f' */
1650               spec.prec = threshold - x - 1;
1651
1652               if (regular_fg (np, p, spec, &dec_info) == -1)
1653                 goto error;
1654             }
1655           else
1656             {
1657               spec.prec = threshold - 1;
1658
1659               if (regular_eg (np, p, spec, &dec_info) == -1)
1660                 goto error;
1661             }
1662         }
1663     }
1664
1665   /* compute the number of characters to be written verifying it is not too
1666      much */
1667   total = np->sign ? 1 : 0;
1668   total += np->prefix_size;
1669   total += np->ip_size;
1670   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1671     goto error;
1672   total += np->ip_trailing_zeros;
1673   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1674     goto error;
1675   if (np->thousands_sep)
1676     /* ' flag, style f and the thousands separator in current locale is not
1677        reduced to the null character */
1678     total += (np->ip_size + np->ip_trailing_zeros) / 3;
1679   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1680     goto error;
1681   if (np->point)
1682     ++total;
1683   total += np->fp_leading_zeros;
1684   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1685     goto error;
1686   total += np->fp_size;
1687   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1688     goto error;
1689   total += np->fp_trailing_zeros;
1690   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1691     goto error;
1692   total += np->exp_size;
1693   if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1694     goto error;
1695
1696   if (spec.width > total)
1697     /* pad with spaces or zeros depending on np->pad_type */
1698     {
1699       np->pad_size = spec.width - total;
1700       total += np->pad_size; /* here total == spec.width,
1701                                 so 0 < total < INT_MAX */
1702     }
1703
1704   return total;
1705
1706  error:
1707   clear_string_list (np->sl);
1708   np->prefix_ptr = NULL;
1709   np->ip_ptr = NULL;
1710   np->fp_ptr = NULL;
1711   np->exp_ptr = NULL;
1712   return -1;
1713 }
1714
1715 /* sprnt_fp prints a mpfr_t according to spec.spec specification.
1716
1717    return the size of the string (not counting the terminating '\0')
1718    return -1 if the built string is too long (i.e. has more than
1719    INT_MAX characters). */
1720 static int
1721 sprnt_fp (struct string_buffer *buf, mpfr_srcptr p,
1722           const struct printf_spec spec)
1723 {
1724   int length;
1725   struct number_parts np;
1726
1727   length = partition_number (&np, p, spec);
1728   if (length < 0)
1729     return -1;
1730
1731   /* right justification padding with left spaces */
1732   if (np.pad_type == LEFT && np.pad_size != 0)
1733     buffer_pad (buf, ' ', np.pad_size);
1734
1735   /* sign character (may be '-', '+', or ' ') */
1736   if (np.sign)
1737     buffer_pad (buf, np.sign, 1);
1738
1739   /* prefix part */
1740   if (np.prefix_ptr)
1741     buffer_cat (buf, np.prefix_ptr, np.prefix_size);
1742
1743   /* right justification  padding with leading zeros */
1744   if (np.pad_type == LEADING_ZEROS && np.pad_size != 0)
1745     buffer_pad (buf, '0', np.pad_size);
1746
1747   /* integral part (may also be "nan" or "inf") */
1748   MPFR_ASSERTN (np.ip_ptr != NULL); /* never empty */
1749   if (MPFR_UNLIKELY (np.thousands_sep))
1750     buffer_sandwich (buf, np.ip_ptr, np.ip_size, np.ip_trailing_zeros,
1751                      np.thousands_sep);
1752   else
1753     {
1754       buffer_cat (buf, np.ip_ptr, np.ip_size);
1755
1756       /* trailing zeros in integral part */
1757       if (np.ip_trailing_zeros != 0)
1758         buffer_pad (buf, '0', np.ip_trailing_zeros);
1759     }
1760
1761   /* decimal point */
1762   if (np.point)
1763     buffer_pad (buf, np.point, 1);
1764
1765   /* leading zeros in fractional part */
1766   if (np.fp_leading_zeros != 0)
1767     buffer_pad (buf, '0', np.fp_leading_zeros);
1768
1769   /* significant digits in fractional part */
1770   if (np.fp_ptr)
1771     buffer_cat (buf, np.fp_ptr, np.fp_size);
1772
1773   /* trailing zeros in fractional part */
1774   if (np.fp_trailing_zeros != 0)
1775     buffer_pad (buf, '0', np.fp_trailing_zeros);
1776
1777   /* exponent part */
1778   if (np.exp_ptr)
1779     buffer_cat (buf, np.exp_ptr, np.exp_size);
1780
1781   /* left justication padding with right spaces */
1782   if (np.pad_type == RIGHT && np.pad_size != 0)
1783     buffer_pad (buf, ' ', np.pad_size);
1784
1785   clear_string_list (np.sl);
1786   return length;
1787 }
1788
1789 int
1790 mpfr_vasprintf (char **ptr, const char *fmt, va_list ap)
1791 {
1792   struct string_buffer buf;
1793   size_t nbchar;
1794
1795   /* informations on the conversion specification filled by the parser */
1796   struct printf_spec spec;
1797   /* flag raised when previous part of fmt need to be processed by
1798      gmp_vsnprintf */
1799   int xgmp_fmt_flag;
1800   /* beginning and end of the previous unprocessed part of fmt */
1801   const char *start, *end;
1802   /* pointer to arguments for gmp_vasprintf */
1803   va_list ap2;
1804
1805   MPFR_SAVE_EXPO_DECL (expo);
1806   MPFR_SAVE_EXPO_MARK (expo);
1807
1808   nbchar = 0;
1809   buffer_init (&buf, 4096);
1810   xgmp_fmt_flag = 0;
1811   va_copy (ap2, ap);
1812   start = fmt;
1813   while (*fmt)
1814     {
1815       /* Look for the next format specification */
1816       while ((*fmt) && (*fmt != '%'))
1817         ++fmt;
1818
1819       if (*fmt == '\0')
1820         break;
1821
1822       if (*++fmt == '%')
1823         /* %%: go one step further otherwise the second '%' would be
1824            considered as a new conversion specification introducing
1825            character */
1826         {
1827           ++fmt;
1828           xgmp_fmt_flag = 1;
1829           continue;
1830         }
1831
1832       end = fmt - 1;
1833
1834       /* format string analysis */
1835       specinfo_init (&spec);
1836       fmt = parse_flags (fmt, &spec);
1837
1838       READ_INT (ap, fmt, spec, width, width_analysis);
1839     width_analysis:
1840       if (spec.width < 0)
1841         {
1842           spec.left = 1;
1843           spec.width = -spec.width;
1844           MPFR_ASSERTN (spec.width < INT_MAX);
1845         }
1846       if (*fmt == '.')
1847         {
1848           const char *f = ++fmt;
1849           READ_INT (ap, fmt, spec, prec, prec_analysis);
1850         prec_analysis:
1851           if (f == fmt)
1852             spec.prec = -1;
1853         }
1854       else
1855         spec.prec = -1;
1856
1857       fmt = parse_arg_type (fmt, &spec);
1858       if (spec.arg_type == UNSUPPORTED)
1859         /* the current architecture doesn't support this type */
1860         {
1861           goto error;
1862         }
1863       else if (spec.arg_type == MPFR_ARG)
1864         {
1865           switch (*fmt)
1866             {
1867             case '\0':
1868               break;
1869             case '*':
1870               ++fmt;
1871               spec.rnd_mode = (mpfr_rnd_t) va_arg (ap, int);
1872               break;
1873             case 'D':
1874               ++fmt;
1875               spec.rnd_mode = MPFR_RNDD;
1876               break;
1877             case 'U':
1878               ++fmt;
1879               spec.rnd_mode = MPFR_RNDU;
1880               break;
1881             case 'Y':
1882               ++fmt;
1883               spec.rnd_mode = MPFR_RNDA;
1884               break;
1885             case 'Z':
1886               ++fmt;
1887               spec.rnd_mode = MPFR_RNDZ;
1888               break;
1889             case 'N':
1890               ++fmt;
1891             default:
1892               spec.rnd_mode = MPFR_RNDN;
1893             }
1894         }
1895
1896       spec.spec = *fmt;
1897       if (!specinfo_is_valid (spec))
1898         goto error;
1899
1900       if (*fmt)
1901         fmt++;
1902
1903       /* Format processing */
1904       if (spec.spec == '\0')
1905         /* end of the format string */
1906         break;
1907       else if (spec.spec == 'n')
1908         /* put the number of characters written so far in the location pointed
1909            by the next va_list argument; the types of pointer accepted are the
1910            same as in GMP (except unsupported quad_t) plus pointer to a mpfr_t
1911            so as to be able to accept the same format strings. */
1912         {
1913           void *p;
1914           size_t nchar;
1915
1916           p = va_arg (ap, void *);
1917           FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
1918           va_end (ap2);
1919           start = fmt;
1920           nchar = buf.curr - buf.start;
1921
1922           switch (spec.arg_type)
1923             {
1924             case CHAR_ARG:
1925               *(char *) p = (char) nchar;
1926               break;
1927             case SHORT_ARG:
1928               *(short *) p = (short) nchar;
1929               break;
1930             case LONG_ARG:
1931               *(long *) p = (long) nchar;
1932               break;
1933 #ifdef HAVE_LONG_LONG
1934             case LONG_LONG_ARG:
1935               *(long long *) p = (long long) nchar;
1936               break;
1937 #endif
1938 #ifdef _MPFR_H_HAVE_INTMAX_T
1939             case INTMAX_ARG:
1940               *(intmax_t *) p = (intmax_t) nchar;
1941               break;
1942 #endif
1943             case SIZE_ARG:
1944               *(size_t *) p = nchar;
1945               break;
1946             case PTRDIFF_ARG:
1947               *(ptrdiff_t *) p = (ptrdiff_t) nchar;
1948               break;
1949             case MPF_ARG:
1950               mpf_set_ui ((mpf_ptr) p, (unsigned long) nchar);
1951               break;
1952             case MPQ_ARG:
1953               mpq_set_ui ((mpq_ptr) p, (unsigned long) nchar, 1L);
1954               break;
1955             case MP_LIMB_ARG:
1956               *(mp_limb_t *) p = (mp_limb_t) nchar;
1957               break;
1958             case MP_LIMB_ARRAY_ARG:
1959               {
1960                 mp_limb_t *q = (mp_limb_t *) p;
1961                 mp_size_t n;
1962                 n = va_arg (ap, mp_size_t);
1963                 if (n < 0)
1964                   n = -n;
1965                 else if (n == 0)
1966                   break;
1967
1968                 /* we assume here that mp_limb_t is wider than int */
1969                 *q = (mp_limb_t) nchar;
1970                 while (--n != 0)
1971                   {
1972                     q++;
1973                     *q = (mp_limb_t) 0;
1974                   }
1975               }
1976               break;
1977             case MPZ_ARG:
1978               mpz_set_ui ((mpz_ptr) p, (unsigned long) nchar);
1979               break;
1980
1981             case MPFR_ARG:
1982               mpfr_set_ui ((mpfr_ptr) p, (unsigned long) nchar,
1983                            spec.rnd_mode);
1984               break;
1985
1986             default:
1987               *(int *) p = (int) nchar;
1988             }
1989           va_copy (ap2, ap); /* after the switch, due to MP_LIMB_ARRAY_ARG
1990                                 case */
1991         }
1992       else if (spec.arg_type == MPFR_PREC_ARG)
1993         /* output mpfr_prec_t variable */
1994         {
1995           char *s;
1996           char format[MPFR_PREC_FORMAT_SIZE + 6]; /* see examples below */
1997           size_t length;
1998           mpfr_prec_t prec;
1999           prec = va_arg (ap, mpfr_prec_t);
2000
2001           FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
2002           va_end (ap2);
2003           va_copy (ap2, ap);
2004           start = fmt;
2005
2006           /* construct format string, like "%*.*hu" "%*.*u" or "%*.*lu" */
2007           format[0] = '%';
2008           format[1] = '*';
2009           format[2] = '.';
2010           format[3] = '*';
2011           format[4] = '\0';
2012           strcat (format, MPFR_PREC_FORMAT_TYPE);
2013           format[4 + MPFR_PREC_FORMAT_SIZE] = spec.spec;
2014           format[5 + MPFR_PREC_FORMAT_SIZE] = '\0';
2015           length = gmp_asprintf (&s, format, spec.width, spec.prec, prec);
2016           if (buf.size <= INT_MAX - length)
2017             {
2018               buffer_cat (&buf, s, length);
2019               mpfr_free_str (s);
2020             }
2021           else
2022             {
2023               mpfr_free_str (s);
2024               goto overflow_error;
2025             }
2026         }
2027       else if (spec.arg_type == MPFR_ARG)
2028         /* output a mpfr_t variable */
2029         {
2030           mpfr_srcptr p;
2031
2032           p = va_arg (ap, mpfr_srcptr);
2033
2034           FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
2035           va_end (ap2);
2036           va_copy (ap2, ap);
2037           start = fmt;
2038
2039           switch (spec.spec)
2040             {
2041             case 'a':
2042             case 'A':
2043             case 'b':
2044             case 'e':
2045             case 'E':
2046             case 'f':
2047             case 'F':
2048             case 'g':
2049             case 'G':
2050               if (sprnt_fp (&buf, p, spec) < 0)
2051                 goto overflow_error;
2052               break;
2053
2054             default:
2055               /* unsupported specifier */
2056               goto error;
2057             }
2058         }
2059       else
2060         /* gmp_printf specification, step forward in the va_list */
2061         {
2062           CONSUME_VA_ARG (spec, ap);
2063           xgmp_fmt_flag = 1;
2064         }
2065     }
2066
2067   if (start != fmt)
2068     FLUSH (xgmp_fmt_flag, start, fmt, ap2, &buf);
2069
2070   va_end (ap2);
2071   nbchar = buf.curr - buf.start;
2072   MPFR_ASSERTD (nbchar == strlen (buf.start));
2073   buf.start =
2074     (char *) (*__gmp_reallocate_func) (buf.start, buf.size, nbchar + 1);
2075   buf.size = nbchar + 1; /* update needed for __gmp_free_func below when
2076                             nbchar is too large (overflow_error) */
2077   *ptr = buf.start;
2078
2079   /* If nbchar is larger than INT_MAX, the ISO C99 standard is silent, but
2080      POSIX says concerning the snprintf() function:
2081      "[EOVERFLOW] The value of n is greater than {INT_MAX} or the
2082      number of bytes needed to hold the output excluding the
2083      terminating null is greater than {INT_MAX}." See:
2084      http://www.opengroup.org/onlinepubs/009695399/functions/fprintf.html
2085      But it doesn't say anything concerning the other printf-like functions.
2086      A defect report has been submitted to austin-review-l (item 2532).
2087      So, for the time being, we return a negative value and set the erange
2088      flag, and set errno to EOVERFLOW in POSIX system. */
2089   if (nbchar <= INT_MAX)
2090     {
2091       MPFR_SAVE_EXPO_FREE (expo);
2092       return nbchar;
2093     }
2094
2095  overflow_error:
2096   MPFR_SAVE_EXPO_UPDATE_FLAGS(expo, MPFR_FLAGS_ERANGE);
2097 #ifdef EOVERFLOW
2098   errno = EOVERFLOW;
2099 #endif
2100
2101  error:
2102   MPFR_SAVE_EXPO_FREE (expo);
2103   *ptr = NULL;
2104   (*__gmp_free_func) (buf.start, buf.size);
2105
2106   return -1;
2107 }
2108
2109 #endif /* HAVE_STDARG */