?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / mpfr / mpfr-3.1.3 / src / vasprintf.c
blob2d209dc1a6d947822dd6f1f738fb9ba21618a568
1 /* mpfr_vasprintf -- main function for the printf functions family
2 plus helper macros & functions.
3
4 Copyright 2007-2015 Free Software Foundation, Inc.
5 Contributed by the AriC 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 dependent).
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 /* An integer overflow is normally not possible since MPFR_EXP_MIN
888 is twice as large as MPFR_EMIN_MIN. */
889 MPFR_ASSERTN (exp > (MPFR_EXP_MIN + 3) / 4);
890 exp = (exp - 1) * 4;
891 }
892 else
893 /* EXP is the exponent for decimal point BEFORE the first digit, we
894 want the exponent for decimal point AFTER the first digit. */
895 {
896 /* An integer overflow is normally not possible since MPFR_EXP_MIN
897 is twice as large as MPFR_EMIN_MIN. */
898 MPFR_ASSERTN (exp > MPFR_EXP_MIN);
899 --exp;
900 }
901 }
902 else if (next_base_power_p (p, base, spec.rnd_mode))
903 {
904 str = (char *)(*__gmp_allocate_func) (2);
905 str[0] = '1';
906 str[1] = '\0';
907 np->ip_ptr = register_string (np->sl, str);
908
909 exp = MPFR_GET_EXP (p);
910 }
911 else if (base == 2)
912 {
913 str = (char *)(*__gmp_allocate_func) (2);
914 str[0] = '1';
915 str[1] = '\0';
916 np->ip_ptr = register_string (np->sl, str);
917
918 exp = MPFR_GET_EXP (p) - 1;
919 }
920 else
921 {
922 int digit;
923 mp_limb_t msl = MPFR_MANT (p)[MPFR_LIMB_SIZE (p) - 1];
924 int rnd_bit = GMP_NUMB_BITS - 5;
925
926 /* pick up the 4 first bits */
927 digit = msl >> (rnd_bit+1);
928 if (spec.rnd_mode == MPFR_RNDA
929 || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p))
930 || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p))
931 || (spec.rnd_mode == MPFR_RNDN
932 && (msl & (MPFR_LIMB_ONE << rnd_bit))))
933 digit++;
934 MPFR_ASSERTD ((0 <= digit) && (digit <= 15));
935
936 str = (char *)(*__gmp_allocate_func) (1 + np->ip_size);
937 str[0] = num_to_text [digit];
938 str[1] = '\0';
939 np->ip_ptr = register_string (np->sl, str);
940
941 exp = MPFR_GET_EXP (p) - 4;
942 }
943
944 if (uppercase)
945 /* All digits in upper case */
946 {
947 char *s1 = str;
948 while (*s1)
949 {
950 switch (*s1)
951 {
952 case 'a':
953 *s1 = 'A';
954 break;
955 case 'b':
956 *s1 = 'B';
957 break;
958 case 'c':
959 *s1 = 'C';
960 break;
961 case 'd':
962 *s1 = 'D';
963 break;
964 case 'e':
965 *s1 = 'E';
966 break;
967 case 'f':
968 *s1 = 'F';
969 break;
970 }
971 s1++;
972 }
973 }
974
975 if (spec.spec == 'b' || spec.prec != 0)
976 /* compute the number of digits in fractional part */
977 {
978 char *ptr;
979 size_t str_len;
980
981 /* the sign has been skipped, skip also the first digit */
982 ++str;
983 str_len = strlen (str);
984 ptr = str + str_len - 1; /* points to the end of str */
985
986 if (spec.prec < 0)
987 /* remove trailing zeros, if any */
988 {
989 while ((*ptr == '0') && (str_len != 0))
990 {
991 --ptr;
992 --str_len;
993 }
994 }
995
996 if (str_len > INT_MAX)
997 /* too many digits in fractional part */
998 return -1;
999
1000 if (str_len != 0)
1001 /* there are some non-zero digits in fractional part */
1002 {
1003 np->fp_ptr = str;
1004 np->fp_size = str_len;
1005 if ((int) str_len < spec.prec)
1006 np->fp_trailing_zeros = spec.prec - str_len;
1007 }
1008 }
1009
1010 /* decimal point */
1011 if ((np->fp_size != 0) || spec.alt)
1012 np->point = MPFR_DECIMAL_POINT;
1013
1014 /* the exponent part contains the character 'p', or 'P' plus the sign
1015 character plus at least one digit and only as many more digits as
1016 necessary to represent the exponent.
1017 We assume that |EXP| < 10^INT_MAX. */
1018 np->exp_size = 3;
1019 {
1020 mpfr_uexp_t x;
1021
1022 x = SAFE_ABS (mpfr_uexp_t, exp);
1023 while (x > 9)
1024 {
1025 np->exp_size++;
1026 x /= 10;
1027 }
1028 }
1029 str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1030 np->exp_ptr = register_string (np->sl, str);
1031 {
1032 char exp_fmt[8]; /* contains at most 7 characters like in "p%+.1i",
1033 or "P%+.2li" */
1034
1035 exp_fmt[0] = uppercase ? 'P' : 'p';
1036 exp_fmt[1] = '\0';
1037 strcat (exp_fmt, "%+.1" MPFR_EXP_FSPEC "d");
1038
1039 if (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)
1040 return -1;
1041 }
1042
1043 return 0;
1044 }
1045
1046 /* Determine the different parts of the string representation of the regular
1047 number P when spec.spec is 'e', 'E', 'g', or 'G'.
1048 DEC_INFO contains the previously computed exponent and string or is NULL.
1049
1050 return -1 if some field > INT_MAX */
1051 static int
1052 regular_eg (struct number_parts *np, mpfr_srcptr p,
1053 const struct printf_spec spec, struct decimal_info *dec_info)
1054 {
1055 char *str;
1056 mpfr_exp_t exp;
1057
1058 const int uppercase = spec.spec == 'E' || spec.spec == 'G';
1059 const int spec_g = spec.spec == 'g' || spec.spec == 'G';
1060 const int keep_trailing_zeros = (spec_g && spec.alt)
1061 || (!spec_g && (spec.prec > 0));
1062
1063 /* sign */
1064 if (MPFR_IS_NEG (p))
1065 np->sign = '-';
1066 else if (spec.showsign || spec.space)
1067 np->sign = spec.showsign ? '+' : ' ';
1068
1069 /* integral part */
1070 np->ip_size = 1;
1071 if (dec_info == NULL)
1072 {
1073 size_t nsd;
1074
1075 /* Number of significant digits:
1076 - if no given precision, then let mpfr_get_str determine it,
1077 - if a precision is specified, then one digit before decimal point
1078 plus SPEC.PREC after it.
1079 We use the fact here that mpfr_get_str allows us to ask for only one
1080 significant digit when the base is not a power of 2. */
1081 nsd = (spec.prec < 0) ? 0 : spec.prec + np->ip_size;
1082 str = mpfr_get_str (0, &exp, 10, nsd, p, spec.rnd_mode);
1083 register_string (np->sl, str);
1084 }
1085 else
1086 {
1087 exp = dec_info->exp;
1088 str = dec_info->str;
1089 }
1090 np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign if any */
1091
1092 if (spec.prec != 0)
1093 /* compute the number of digits in fractional part */
1094 {
1095 char *ptr;
1096 size_t str_len;
1097
1098 /* the sign has been skipped, skip also the first digit */
1099 ++str;
1100 str_len = strlen (str);
1101 ptr = str + str_len - 1; /* points to the end of str */
1102
1103 if (!keep_trailing_zeros)
1104 /* remove trailing zeros, if any */
1105 {
1106 while ((*ptr == '0') && (str_len != 0))
1107 {
1108 --ptr;
1109 --str_len;
1110 }
1111 }
1112
1113 if (str_len > INT_MAX)
1114 /* too many digits in fractional part */
1115 return -1;
1116
1117 if (str_len != 0)
1118 /* there are some non-zero digits in fractional part */
1119 {
1120 np->fp_ptr = str;
1121 np->fp_size = str_len;
1122 if ((!spec_g || spec.alt) && (spec.prec > 0)
1123 && ((int)str_len < spec.prec))
1124 /* add missing trailing zeros */
1125 np->fp_trailing_zeros = spec.prec - str_len;
1126 }
1127 }
1128
1129 /* decimal point */
1130 if (np->fp_size != 0 || spec.alt)
1131 np->point = MPFR_DECIMAL_POINT;
1132
1133 /* EXP is the exponent for decimal point BEFORE the first digit, we want
1134 the exponent for decimal point AFTER the first digit.
1135 Here, no possible overflow because exp < MPFR_EXP (p) / 3 */
1136 exp--;
1137
1138 /* the exponent part contains the character 'e', or 'E' plus the sign
1139 character plus at least two digits and only as many more digits as
1140 necessary to represent the exponent.
1141 We assume that |EXP| < 10^INT_MAX. */
1142 np->exp_size = 3;
1143 {
1144 mpfr_uexp_t x;
1145
1146 x = SAFE_ABS (mpfr_uexp_t, exp);
1147 while (x > 9)
1148 {
1149 np->exp_size++;
1150 x /= 10;
1151 }
1152 }
1153 if (np->exp_size < 4)
1154 np->exp_size = 4;
1155
1156 str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1157 np->exp_ptr = register_string (np->sl, str);
1158
1159 {
1160 char exp_fmt[8]; /* e.g. "e%+.2i", or "E%+.2li" */
1161
1162 exp_fmt[0] = uppercase ? 'E' : 'e';
1163 exp_fmt[1] = '\0';
1164 strcat (exp_fmt, "%+.2" MPFR_EXP_FSPEC "d");
1165
1166 if (sprintf (str, exp_fmt, (mpfr_eexp_t) exp) < 0)
1167 return -1;
1168 }
1169
1170 return 0;
1171 }
1172
1173 /* Determine the different parts of the string representation of the regular
1174 number P when spec.spec is 'f', 'F', 'g', or 'G'.
1175 DEC_INFO contains the previously computed exponent and string or is NULL.
1176
1177 return -1 if some field of number_parts is greater than INT_MAX */
1178 static int
1179 regular_fg (struct number_parts *np, mpfr_srcptr p,
1180 const struct printf_spec spec, struct decimal_info *dec_info)
1181 {
1182 mpfr_exp_t exp;
1183 char * str;
1184 const int spec_g = (spec.spec == 'g' || spec.spec == 'G');
1185 const int keep_trailing_zeros = !spec_g || spec.alt;
1186
1187 /* WARNING: an empty precision field is forbidden (it means precision = 6
1188 and it should have been changed to 6 before the function call) */
1189 MPFR_ASSERTD (spec.prec >= 0);
1190
1191 /* sign */
1192 if (MPFR_IS_NEG (p))
1193 np->sign = '-';
1194 else if (spec.showsign || spec.space)
1195 np->sign = spec.showsign ? '+' : ' ';
1196
1197 if (MPFR_GET_EXP (p) <= 0)
1198 /* 0 < |p| < 1 */
1199 {
1200 /* Most of the time, integral part is 0 */
1201 np->ip_size = 1;
1202 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1203 str[0] = '0';
1204 str[1] = '\0';
1205 np->ip_ptr = register_string (np->sl, str);
1206
1207 if (spec.prec == 0)
1208 /* only two possibilities: either 1 or 0. */
1209 {
1210 mpfr_t y;
1211 /* y = abs(p) */
1212 MPFR_ALIAS (y, p, 1, MPFR_EXP (p));
1213
1214 if (spec.rnd_mode == MPFR_RNDA
1215 || (spec.rnd_mode == MPFR_RNDD && MPFR_IS_NEG (p))
1216 || (spec.rnd_mode == MPFR_RNDU && MPFR_IS_POS (p))
1217 || (spec.rnd_mode == MPFR_RNDN && mpfr_cmp_d (y, 0.5) > 0))
1218 /* rounded up to 1: one digit '1' in integral part.
1219 note that 0.5 is rounded to 0 with RNDN (round ties to even) */
1220 np->ip_ptr[0] = '1';
1221 }
1222 else
1223 {
1224 /* exp = position of the most significant decimal digit. */
1225 exp = floor_log10 (p);
1226 MPFR_ASSERTD (exp < 0);
1227
1228 if (exp < -spec.prec)
1229 /* only the last digit may be non zero */
1230 {
1231 int round_away;
1232 switch (spec.rnd_mode)
1233 {
1234 case MPFR_RNDA:
1235 round_away = 1;
1236 break;
1237 case MPFR_RNDD:
1238 round_away = MPFR_IS_NEG (p);
1239 break;
1240 case MPFR_RNDU:
1241 round_away = MPFR_IS_POS (p);
1242 break;
1243 case MPFR_RNDN:
1244 {
1245 /* compare |p| to y = 0.5*10^(-spec.prec) */
1246 mpfr_t y;
1247 mpfr_exp_t e = MAX (MPFR_PREC (p), 56);
1248 mpfr_init2 (y, e + 8);
1249 do
1250 {
1251 /* find a lower approximation of
1252 0.5*10^(-spec.prec) different from |p| */
1253 e += 8;
1254 mpfr_set_prec (y, e);
1255 mpfr_set_si (y, -spec.prec, MPFR_RNDN);
1256 mpfr_exp10 (y, y, MPFR_RNDD);
1257 mpfr_div_2ui (y, y, 1, MPFR_RNDN);
1258 } while (mpfr_cmpabs (y, p) == 0);
1259
1260 round_away = mpfr_cmpabs (y, p) < 0;
1261 mpfr_clear (y);
1262 }
1263 break;
1264 default:
1265 round_away = 0;
1266 }
1267
1268 if (round_away)
1269 /* round away from zero: the last output digit is '1' */
1270 {
1271 np->fp_leading_zeros = spec.prec - 1;
1272
1273 np->fp_size = 1;
1274 str =
1275 (char *) (*__gmp_allocate_func) (1 + np->fp_size);
1276 str[0] = '1';
1277 str[1] = '\0';
1278 np->fp_ptr = register_string (np->sl, str);
1279 }
1280 else
1281 /* only zeros in fractional part */
1282 {
1283 MPFR_ASSERTD (!spec_g);
1284 np->fp_leading_zeros = spec.prec;
1285 }
1286 }
1287 else
1288 /* the most significant digits are the last
1289 spec.prec + exp + 1 digits in fractional part */
1290 {
1291 char *ptr;
1292 size_t str_len;
1293 if (dec_info == NULL)
1294 {
1295 size_t nsd = spec.prec + exp + 1;
1296 /* WARNING: nsd may equal 1, but here we use the
1297 fact that mpfr_get_str can return one digit with
1298 base ten (undocumented feature, see comments in
1299 get_str.c) */
1300
1301 str = mpfr_get_str (NULL, &exp, 10, nsd, p, spec.rnd_mode);
1302 register_string (np->sl, str);
1303 }
1304 else
1305 {
1306 exp = dec_info->exp;
1307 str = dec_info->str;
1308 }
1309 if (MPFR_IS_NEG (p))
1310 /* skip sign */
1311 ++str;
1312 if (exp == 1)
1313 /* round up to 1 */
1314 {
1315 MPFR_ASSERTD (str[0] == '1');
1316 np->ip_ptr[0] = '1';
1317 if (!spec_g || spec.alt)
1318 np->fp_leading_zeros = spec.prec;
1319 }
1320 else
1321 {
1322 np->fp_ptr = str;
1323 np->fp_leading_zeros = -exp;
1324 MPFR_ASSERTD (exp <= 0);
1325
1326 str_len = strlen (str); /* the sign has been skipped */
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)
1333 {
1334 --ptr;
1335 --str_len;
1336 }
1337 }
1338
1339 if (str_len > INT_MAX)
1340 /* too many digits in fractional part */
1341 return -1;
1342
1343 MPFR_ASSERTD (str_len > 0);
1344 np->fp_size = str_len;
1345
1346 if ((!spec_g || spec.alt)
1347 && spec.prec > 0
1348 && (np->fp_leading_zeros + np->fp_size < spec.prec))
1349 /* add missing trailing zeros */
1350 np->fp_trailing_zeros = spec.prec - np->fp_leading_zeros
1351 - np->fp_size;
1352 }
1353 }
1354 }
1355
1356 if (spec.alt || np->fp_leading_zeros != 0 || np->fp_size != 0
1357 || np->fp_trailing_zeros != 0)
1358 np->point = MPFR_DECIMAL_POINT;
1359 }
1360 else
1361 /* 1 <= |p| */
1362 {
1363 size_t str_len;
1364
1365 /* Determine the position of the most significant decimal digit. */
1366 exp = floor_log10 (p);
1367 MPFR_ASSERTD (exp >= 0);
1368 if (exp > INT_MAX)
1369 /* P is too large to print all its integral part digits */
1370 return -1;
1371
1372 if (dec_info == NULL)
1373 { /* this case occurs with mpfr_printf ("%.0RUf", x) with x=9.5 */
1374 str =
1375 mpfr_get_str (NULL, &exp, 10, spec.prec+exp+1, p, spec.rnd_mode);
1376 register_string (np->sl, str);
1377 }
1378 else
1379 {
1380 exp = dec_info->exp;
1381 str = dec_info->str;
1382 }
1383 np->ip_ptr = MPFR_IS_NEG (p) ? ++str : str; /* skip sign */
1384 str_len = strlen (str);
1385
1386 /* integral part */
1387 if (exp > str_len)
1388 /* mpfr_get_str gives no trailing zero when p is rounded up to the next
1389 power of 10 (p integer, so no fractional part) */
1390 {
1391 np->ip_trailing_zeros = exp - str_len;
1392 np->ip_size = str_len;
1393 }
1394 else
1395 np->ip_size = exp;
1396
1397 if (spec.group)
1398 /* thousands separator in integral part */
1399 np->thousands_sep = MPFR_THOUSANDS_SEPARATOR;
1400
1401 /* fractional part */
1402 str += np->ip_size;
1403 str_len -= np->ip_size;
1404 if (!keep_trailing_zeros)
1405 /* remove trailing zeros, if any */
1406 {
1407 char *ptr = str + str_len - 1; /* pointer to the last digit of
1408 str */
1409 while ((*ptr == '0') && (str_len != 0))
1410 {
1411 --ptr;
1412 --str_len;
1413 }
1414 }
1415
1416 if (str_len > 0)
1417 /* some nonzero digits in fractional part */
1418 {
1419 if (str_len > INT_MAX)
1420 /* too many digits in fractional part */
1421 return -1;
1422
1423 np->point = MPFR_DECIMAL_POINT;
1424 np->fp_ptr = str;
1425 np->fp_size = str_len;
1426 }
1427
1428 if (keep_trailing_zeros && str_len < spec.prec)
1429 /* add missing trailing zeros */
1430 {
1431 np->point = MPFR_DECIMAL_POINT;
1432 np->fp_trailing_zeros = spec.prec - np->fp_size;
1433 }
1434
1435 if (spec.alt)
1436 /* add decimal point even if no digits follow it */
1437 np->point = MPFR_DECIMAL_POINT;
1438 }
1439
1440 return 0;
1441 }
1442
1443 /* partition_number determines the different parts of the string
1444 representation of the number p according to the given specification.
1445 partition_number initializes the given structure np, so all previous
1446 information in that variable is lost.
1447 return the total number of characters to be written.
1448 return -1 if an error occured, in that case np's fields are in an undefined
1449 state but all string buffers have been freed. */
1450 static int
1451 partition_number (struct number_parts *np, mpfr_srcptr p,
1452 struct printf_spec spec)
1453 {
1454 char *str;
1455 long total;
1456 int uppercase;
1457
1458 /* WARNING: left justification means right space padding */
1459 np->pad_type = spec.left ? RIGHT : spec.pad == '0' ? LEADING_ZEROS : LEFT;
1460 np->pad_size = 0;
1461 np->sign = '\0';
1462 np->prefix_ptr =NULL;
1463 np->prefix_size = 0;
1464 np->thousands_sep = '\0';
1465 np->ip_ptr = NULL;
1466 np->ip_size = 0;
1467 np->ip_trailing_zeros = 0;
1468 np->point = '\0';
1469 np->fp_leading_zeros = 0;
1470 np->fp_ptr = NULL;
1471 np->fp_size = 0;
1472 np->fp_trailing_zeros = 0;
1473 np->exp_ptr = NULL;
1474 np->exp_size = 0;
1475 np->sl = (struct string_list *)
1476 (*__gmp_allocate_func) (sizeof (struct string_list));
1477 init_string_list (np->sl);
1478
1479 uppercase = spec.spec == 'A' || spec.spec == 'E' || spec.spec == 'F'
1480 || spec.spec == 'G';
1481
1482 if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (p)))
1483 {
1484 if (MPFR_IS_NAN (p))
1485 {
1486 if (np->pad_type == LEADING_ZEROS)
1487 /* don't want "0000nan", change to right justification padding
1488 with left spaces instead */
1489 np->pad_type = LEFT;
1490
1491 if (uppercase)
1492 {
1493 np->ip_size = MPFR_NAN_STRING_LENGTH;
1494 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1495 strcpy (str, MPFR_NAN_STRING_UC);
1496 np->ip_ptr = register_string (np->sl, str);
1497 }
1498 else
1499 {
1500 np->ip_size = MPFR_NAN_STRING_LENGTH;
1501 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1502 strcpy (str, MPFR_NAN_STRING_LC);
1503 np->ip_ptr = register_string (np->sl, str);
1504 }
1505 }
1506 else if (MPFR_IS_INF (p))
1507 {
1508 if (np->pad_type == LEADING_ZEROS)
1509 /* don't want "0000inf", change to right justification padding
1510 with left spaces instead */
1511 np->pad_type = LEFT;
1512
1513 if (MPFR_IS_NEG (p))
1514 np->sign = '-';
1515
1516 if (uppercase)
1517 {
1518 np->ip_size = MPFR_INF_STRING_LENGTH;
1519 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1520 strcpy (str, MPFR_INF_STRING_UC);
1521 np->ip_ptr = register_string (np->sl, str);
1522 }
1523 else
1524 {
1525 np->ip_size = MPFR_INF_STRING_LENGTH;
1526 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1527 strcpy (str, MPFR_INF_STRING_LC);
1528 np->ip_ptr = register_string (np->sl, str);
1529 }
1530 }
1531 else
1532 /* p == 0 */
1533 {
1534 /* note: for 'g' spec, zero is always displayed with 'f'-style with
1535 precision spec.prec - 1 and the trailing zeros are removed unless
1536 the flag '#' is used. */
1537 if (MPFR_IS_NEG (p))
1538 /* signed zero */
1539 np->sign = '-';
1540 else if (spec.showsign || spec.space)
1541 np->sign = spec.showsign ? '+' : ' ';
1542
1543 if (spec.spec == 'a' || spec.spec == 'A')
1544 /* prefix part */
1545 {
1546 np->prefix_size = 2;
1547 str = (char *) (*__gmp_allocate_func) (1 + np->prefix_size);
1548 str[0] = '0';
1549 str[1] = uppercase ? 'X' : 'x';
1550 str[2] = '\0';
1551 np->prefix_ptr = register_string (np->sl, str);
1552 }
1553
1554 /* integral part */
1555 np->ip_size = 1;
1556 str = (char *) (*__gmp_allocate_func) (1 + np->ip_size);
1557 str[0] = '0';
1558 str[1] = '\0';
1559 np->ip_ptr = register_string (np->sl, str);
1560
1561 if (spec.prec > 0
1562 && ((spec.spec != 'g' && spec.spec != 'G') || spec.alt))
1563 /* fractional part */
1564 {
1565 np->point = MPFR_DECIMAL_POINT;
1566 np->fp_trailing_zeros = (spec.spec == 'g' || spec.spec == 'G') ?
1567 spec.prec - 1 : spec.prec;
1568 }
1569 else if (spec.alt)
1570 np->point = MPFR_DECIMAL_POINT;
1571
1572 if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b'
1573 || spec.spec == 'e' || spec.spec == 'E')
1574 /* exponent part */
1575 {
1576 np->exp_size = (spec.spec == 'e' || spec.spec == 'E') ? 4 : 3;
1577 str = (char *) (*__gmp_allocate_func) (1 + np->exp_size);
1578 if (spec.spec == 'e' || spec.spec == 'E')
1579 strcpy (str, uppercase ? "E+00" : "e+00");
1580 else
1581 strcpy (str, uppercase ? "P+0" : "p+0");
1582 np->exp_ptr = register_string (np->sl, str);
1583 }
1584 }
1585 }
1586 else
1587 /* regular p, p != 0 */
1588 {
1589 if (spec.spec == 'a' || spec.spec == 'A' || spec.spec == 'b')
1590 {
1591 if (regular_ab (np, p, spec) == -1)
1592 goto error;
1593 }
1594 else if (spec.spec == 'f' || spec.spec == 'F')
1595 {
1596 if (spec.prec == -1)
1597 spec.prec = 6;
1598 if (regular_fg (np, p, spec, NULL) == -1)
1599 goto error;
1600 }
1601 else if (spec.spec == 'e' || spec.spec == 'E')
1602 {
1603 if (regular_eg (np, p, spec, NULL) == -1)
1604 goto error;
1605 }
1606 else
1607 /* %g case */
1608 {
1609 /* Use the C99 rules:
1610 if T > X >= -4 then the conversion is with style 'f'/'F' and
1611 precision T-(X+1).
1612 otherwise, the conversion is with style 'e'/'E' and
1613 precision T-1.
1614 where T is the threshold computed below and X is the exponent
1615 that would be displayed with style 'e' and precision T-1. */
1616 int threshold;
1617 mpfr_exp_t x;
1618 struct decimal_info dec_info;
1619
1620 threshold = (spec.prec < 0) ? 6 : (spec.prec == 0) ? 1 : spec.prec;
1621 dec_info.str = mpfr_get_str (NULL, &dec_info.exp, 10, threshold,
1622 p, spec.rnd_mode);
1623 register_string (np->sl, dec_info.str);
1624 /* mpfr_get_str corresponds to a significand between 0.1 and 1,
1625 whereas here we want a significand between 1 and 10. */
1626 x = dec_info.exp - 1;
1627
1628 if (threshold > x && x >= -4)
1629 {
1630 /* the conversion is with style 'f' */
1631 spec.prec = threshold - x - 1;
1632
1633 if (regular_fg (np, p, spec, &dec_info) == -1)
1634 goto error;
1635 }
1636 else
1637 {
1638 spec.prec = threshold - 1;
1639
1640 if (regular_eg (np, p, spec, &dec_info) == -1)
1641 goto error;
1642 }
1643 }
1644 }
1645
1646 /* compute the number of characters to be written verifying it is not too
1647 much */
1648 total = np->sign ? 1 : 0;
1649 total += np->prefix_size;
1650 total += np->ip_size;
1651 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1652 goto error;
1653 total += np->ip_trailing_zeros;
1654 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1655 goto error;
1656 if (np->thousands_sep)
1657 /* ' flag, style f and the thousands separator in current locale is not
1658 reduced to the null character */
1659 total += (np->ip_size + np->ip_trailing_zeros) / 3;
1660 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1661 goto error;
1662 if (np->point)
1663 ++total;
1664 total += np->fp_leading_zeros;
1665 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1666 goto error;
1667 total += np->fp_size;
1668 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1669 goto error;
1670 total += np->fp_trailing_zeros;
1671 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1672 goto error;
1673 total += np->exp_size;
1674 if (MPFR_UNLIKELY (total < 0 || total > INT_MAX))
1675 goto error;
1676
1677 if (spec.width > total)
1678 /* pad with spaces or zeros depending on np->pad_type */
1679 {
1680 np->pad_size = spec.width - total;
1681 total += np->pad_size; /* here total == spec.width,
1682 so 0 < total < INT_MAX */
1683 }
1684
1685 return total;
1686
1687 error:
1688 clear_string_list (np->sl);
1689 np->prefix_ptr = NULL;
1690 np->ip_ptr = NULL;
1691 np->fp_ptr = NULL;
1692 np->exp_ptr = NULL;
1693 return -1;
1694 }
1695
1696 /* sprnt_fp prints a mpfr_t according to spec.spec specification.
1697
1698 return the size of the string (not counting the terminating '\0')
1699 return -1 if the built string is too long (i.e. has more than
1700 INT_MAX characters). */
1701 static int
1702 sprnt_fp (struct string_buffer *buf, mpfr_srcptr p,
1703 const struct printf_spec spec)
1704 {
1705 int length;
1706 struct number_parts np;
1707
1708 length = partition_number (&np, p, spec);
1709 if (length < 0)
1710 return -1;
1711
1712 /* right justification padding with left spaces */
1713 if (np.pad_type == LEFT && np.pad_size != 0)
1714 buffer_pad (buf, ' ', np.pad_size);
1715
1716 /* sign character (may be '-', '+', or ' ') */
1717 if (np.sign)
1718 buffer_pad (buf, np.sign, 1);
1719
1720 /* prefix part */
1721 if (np.prefix_ptr)
1722 buffer_cat (buf, np.prefix_ptr, np.prefix_size);
1723
1724 /* right justification padding with leading zeros */
1725 if (np.pad_type == LEADING_ZEROS && np.pad_size != 0)
1726 buffer_pad (buf, '0', np.pad_size);
1727
1728 /* integral part (may also be "nan" or "inf") */
1729 MPFR_ASSERTN (np.ip_ptr != NULL); /* never empty */
1730 if (MPFR_UNLIKELY (np.thousands_sep))
1731 buffer_sandwich (buf, np.ip_ptr, np.ip_size, np.ip_trailing_zeros,
1732 np.thousands_sep);
1733 else
1734 {
1735 buffer_cat (buf, np.ip_ptr, np.ip_size);
1736
1737 /* trailing zeros in integral part */
1738 if (np.ip_trailing_zeros != 0)
1739 buffer_pad (buf, '0', np.ip_trailing_zeros);
1740 }
1741
1742 /* decimal point */
1743 if (np.point)
1744 buffer_pad (buf, np.point, 1);
1745
1746 /* leading zeros in fractional part */
1747 if (np.fp_leading_zeros != 0)
1748 buffer_pad (buf, '0', np.fp_leading_zeros);
1749
1750 /* significant digits in fractional part */
1751 if (np.fp_ptr)
1752 buffer_cat (buf, np.fp_ptr, np.fp_size);
1753
1754 /* trailing zeros in fractional part */
1755 if (np.fp_trailing_zeros != 0)
1756 buffer_pad (buf, '0', np.fp_trailing_zeros);
1757
1758 /* exponent part */
1759 if (np.exp_ptr)
1760 buffer_cat (buf, np.exp_ptr, np.exp_size);
1761
1762 /* left justication padding with right spaces */
1763 if (np.pad_type == RIGHT && np.pad_size != 0)
1764 buffer_pad (buf, ' ', np.pad_size);
1765
1766 clear_string_list (np.sl);
1767 return length;
1768 }
1769
1770 int
1771 mpfr_vasprintf (char **ptr, const char *fmt, va_list ap)
1772 {
1773 struct string_buffer buf;
1774 size_t nbchar;
1775
1776 /* informations on the conversion specification filled by the parser */
1777 struct printf_spec spec;
1778 /* flag raised when previous part of fmt need to be processed by
1779 gmp_vsnprintf */
1780 int xgmp_fmt_flag;
1781 /* beginning and end of the previous unprocessed part of fmt */
1782 const char *start, *end;
1783 /* pointer to arguments for gmp_vasprintf */
1784 va_list ap2;
1785
1786 MPFR_SAVE_EXPO_DECL (expo);
1787 MPFR_SAVE_EXPO_MARK (expo);
1788
1789 nbchar = 0;
1790 buffer_init (&buf, 4096);
1791 xgmp_fmt_flag = 0;
1792 va_copy (ap2, ap);
1793 start = fmt;
1794 while (*fmt)
1795 {
1796 /* Look for the next format specification */
1797 while ((*fmt) && (*fmt != '%'))
1798 ++fmt;
1799
1800 if (*fmt == '\0')
1801 break;
1802
1803 if (*++fmt == '%')
1804 /* %%: go one step further otherwise the second '%' would be
1805 considered as a new conversion specification introducing
1806 character */
1807 {
1808 ++fmt;
1809 xgmp_fmt_flag = 1;
1810 continue;
1811 }
1812
1813 end = fmt - 1;
1814
1815 /* format string analysis */
1816 specinfo_init (&spec);
1817 fmt = parse_flags (fmt, &spec);
1818
1819 READ_INT (ap, fmt, spec, width, width_analysis);
1820 width_analysis:
1821 if (spec.width < 0)
1822 {
1823 spec.left = 1;
1824 spec.width = -spec.width;
1825 MPFR_ASSERTN (spec.width < INT_MAX);
1826 }
1827 if (*fmt == '.')
1828 {
1829 const char *f = ++fmt;
1830 READ_INT (ap, fmt, spec, prec, prec_analysis);
1831 prec_analysis:
1832 if (f == fmt)
1833 spec.prec = -1;
1834 }
1835 else
1836 spec.prec = -1;
1837
1838 fmt = parse_arg_type (fmt, &spec);
1839 if (spec.arg_type == UNSUPPORTED)
1840 /* the current architecture doesn't support this type */
1841 {
1842 goto error;
1843 }
1844 else if (spec.arg_type == MPFR_ARG)
1845 {
1846 switch (*fmt)
1847 {
1848 case '\0':
1849 break;
1850 case '*':
1851 ++fmt;
1852 spec.rnd_mode = (mpfr_rnd_t) va_arg (ap, int);
1853 break;
1854 case 'D':
1855 ++fmt;
1856 spec.rnd_mode = MPFR_RNDD;
1857 break;
1858 case 'U':
1859 ++fmt;
1860 spec.rnd_mode = MPFR_RNDU;
1861 break;
1862 case 'Y':
1863 ++fmt;
1864 spec.rnd_mode = MPFR_RNDA;
1865 break;
1866 case 'Z':
1867 ++fmt;
1868 spec.rnd_mode = MPFR_RNDZ;
1869 break;
1870 case 'N':
1871 ++fmt;
1872 default:
1873 spec.rnd_mode = MPFR_RNDN;
1874 }
1875 }
1876
1877 spec.spec = *fmt;
1878 if (!specinfo_is_valid (spec))
1879 goto error;
1880
1881 if (*fmt)
1882 fmt++;
1883
1884 /* Format processing */
1885 if (spec.spec == '\0')
1886 /* end of the format string */
1887 break;
1888 else if (spec.spec == 'n')
1889 /* put the number of characters written so far in the location pointed
1890 by the next va_list argument; the types of pointer accepted are the
1891 same as in GMP (except unsupported quad_t) plus pointer to a mpfr_t
1892 so as to be able to accept the same format strings. */
1893 {
1894 void *p;
1895 size_t nchar;
1896
1897 p = va_arg (ap, void *);
1898 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
1899 va_end (ap2);
1900 start = fmt;
1901 nchar = buf.curr - buf.start;
1902
1903 switch (spec.arg_type)
1904 {
1905 case CHAR_ARG:
1906 *(char *) p = (char) nchar;
1907 break;
1908 case SHORT_ARG:
1909 *(short *) p = (short) nchar;
1910 break;
1911 case LONG_ARG:
1912 *(long *) p = (long) nchar;
1913 break;
1914 #ifdef HAVE_LONG_LONG
1915 case LONG_LONG_ARG:
1916 *(long long *) p = (long long) nchar;
1917 break;
1918 #endif
1919 #ifdef _MPFR_H_HAVE_INTMAX_T
1920 case INTMAX_ARG:
1921 *(intmax_t *) p = (intmax_t) nchar;
1922 break;
1923 #endif
1924 case SIZE_ARG:
1925 *(size_t *) p = nchar;
1926 break;
1927 case PTRDIFF_ARG:
1928 *(ptrdiff_t *) p = (ptrdiff_t) nchar;
1929 break;
1930 case MPF_ARG:
1931 mpf_set_ui ((mpf_ptr) p, (unsigned long) nchar);
1932 break;
1933 case MPQ_ARG:
1934 mpq_set_ui ((mpq_ptr) p, (unsigned long) nchar, 1L);
1935 break;
1936 case MP_LIMB_ARG:
1937 *(mp_limb_t *) p = (mp_limb_t) nchar;
1938 break;
1939 case MP_LIMB_ARRAY_ARG:
1940 {
1941 mp_limb_t *q = (mp_limb_t *) p;
1942 mp_size_t n;
1943 n = va_arg (ap, mp_size_t);
1944 if (n < 0)
1945 n = -n;
1946 else if (n == 0)
1947 break;
1948
1949 /* we assume here that mp_limb_t is wider than int */
1950 *q = (mp_limb_t) nchar;
1951 while (--n != 0)
1952 {
1953 q++;
1954 *q = (mp_limb_t) 0;
1955 }
1956 }
1957 break;
1958 case MPZ_ARG:
1959 mpz_set_ui ((mpz_ptr) p, (unsigned long) nchar);
1960 break;
1961
1962 case MPFR_ARG:
1963 mpfr_set_ui ((mpfr_ptr) p, (unsigned long) nchar,
1964 spec.rnd_mode);
1965 break;
1966
1967 default:
1968 *(int *) p = (int) nchar;
1969 }
1970 va_copy (ap2, ap); /* after the switch, due to MP_LIMB_ARRAY_ARG
1971 case */
1972 }
1973 else if (spec.arg_type == MPFR_PREC_ARG)
1974 /* output mpfr_prec_t variable */
1975 {
1976 char *s;
1977 char format[MPFR_PREC_FORMAT_SIZE + 6]; /* see examples below */
1978 size_t length;
1979 mpfr_prec_t prec;
1980 prec = va_arg (ap, mpfr_prec_t);
1981
1982 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
1983 va_end (ap2);
1984 va_copy (ap2, ap);
1985 start = fmt;
1986
1987 /* construct format string, like "%*.*hd" "%*.*d" or "%*.*ld" */
1988 format[0] = '%';
1989 format[1] = '*';
1990 format[2] = '.';
1991 format[3] = '*';
1992 format[4] = '\0';
1993 strcat (format, MPFR_PREC_FORMAT_TYPE);
1994 format[4 + MPFR_PREC_FORMAT_SIZE] = spec.spec;
1995 format[5 + MPFR_PREC_FORMAT_SIZE] = '\0';
1996 length = gmp_asprintf (&s, format, spec.width, spec.prec, prec);
1997 if (buf.size <= INT_MAX - length)
1998 {
1999 buffer_cat (&buf, s, length);
2000 mpfr_free_str (s);
2001 }
2002 else
2003 {
2004 mpfr_free_str (s);
2005 goto overflow_error;
2006 }
2007 }
2008 else if (spec.arg_type == MPFR_ARG)
2009 /* output a mpfr_t variable */
2010 {
2011 mpfr_srcptr p;
2012
2013 p = va_arg (ap, mpfr_srcptr);
2014
2015 FLUSH (xgmp_fmt_flag, start, end, ap2, &buf);
2016 va_end (ap2);
2017 va_copy (ap2, ap);
2018 start = fmt;
2019
2020 switch (spec.spec)
2021 {
2022 case 'a':
2023 case 'A':
2024 case 'b':
2025 case 'e':
2026 case 'E':
2027 case 'f':
2028 case 'F':
2029 case 'g':
2030 case 'G':
2031 if (sprnt_fp (&buf, p, spec) < 0)
2032 goto overflow_error;
2033 break;
2034
2035 default:
2036 /* unsupported specifier */
2037 goto error;
2038 }
2039 }
2040 else
2041 /* gmp_printf specification, step forward in the va_list */
2042 {
2043 CONSUME_VA_ARG (spec, ap);
2044 xgmp_fmt_flag = 1;
2045 }
2046 }
2047
2048 if (start != fmt)
2049 FLUSH (xgmp_fmt_flag, start, fmt, ap2, &buf);
2050
2051 va_end (ap2);
2052 nbchar = buf.curr - buf.start;
2053 MPFR_ASSERTD (nbchar == strlen (buf.start));
2054 buf.start =
2055 (char *) (*__gmp_reallocate_func) (buf.start, buf.size, nbchar + 1);
2056 buf.size = nbchar + 1; /* update needed for __gmp_free_func below when
2057 nbchar is too large (overflow_error) */
2058 *ptr = buf.start;
2059
2060 /* If nbchar is larger than INT_MAX, the ISO C99 standard is silent, but
2061 POSIX says concerning the snprintf() function:
2062 "[EOVERFLOW] The value of n is greater than {INT_MAX} or the
2063 number of bytes needed to hold the output excluding the
2064 terminating null is greater than {INT_MAX}." See:
2065 http://www.opengroup.org/onlinepubs/009695399/functions/fprintf.html
2066 But it doesn't say anything concerning the other printf-like functions.
2067 A defect report has been submitted to austin-review-l (item 2532).
2068 So, for the time being, we return a negative value and set the erange
2069 flag, and set errno to EOVERFLOW in POSIX system. */
2070 if (nbchar <= INT_MAX)
2071 {
2072 MPFR_SAVE_EXPO_FREE (expo);
2073 return nbchar;
2074 }
2075
2076 overflow_error:
2077 MPFR_SAVE_EXPO_UPDATE_FLAGS(expo, MPFR_FLAGS_ERANGE);
2078 #ifdef EOVERFLOW
2079 errno = EOVERFLOW;
2080 #endif
2081
2082 error:
2083 MPFR_SAVE_EXPO_FREE (expo);
2084 *ptr = NULL;
2085 (*__gmp_free_func) (buf.start, buf.size);
2086
2087 return -1;
2088 }
2089
2090 #endif /* HAVE_STDARG */
LuaTeX git mirror