1 /* __gmp_doprnt -- printf style formatted output.
2
3 THE FUNCTIONS IN THIS FILE ARE FOR INTERNAL USE ONLY. THEY'RE ALMOST
4 CERTAIN TO BE SUBJECT TO INCOMPATIBLE CHANGES OR DISAPPEAR COMPLETELY IN
5 FUTURE GNU MP RELEASES.
6
7 Copyright 2001-2003 Free Software Foundation, Inc.
8
9 This file is part of the GNU MP Library.
10
11 The GNU MP Library is free software; you can redistribute it and/or modify
12 it under the terms of either:
13
14 * the GNU Lesser General Public License as published by the Free
15 Software Foundation; either version 3 of the License, or (at your
16 option) any later version.
17
18 or
19
20 * the GNU General Public License as published by the Free Software
21 Foundation; either version 2 of the License, or (at your option) any
22 later version.
23
24 or both in parallel, as here.
25
26 The GNU MP Library is distributed in the hope that it will be useful, but
27 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
28 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
29 for more details.
30
31 You should have received copies of the GNU General Public License and the
32 GNU Lesser General Public License along with the GNU MP Library. If not,
33 see https://www.gnu.org/licenses/. */
34
35 #define _GNU_SOURCE /* for DECIMAL_POINT in glibc langinfo.h */
36
37 #include "config.h" /* needed for the HAVE_, could also move gmp incls */
38
39 #include <stdarg.h>
40 #include <ctype.h> /* for isdigit */
41 #include <stddef.h> /* for ptrdiff_t */
42 #include <string.h>
43 #include <stdio.h> /* for NULL */
44 #include <stdlib.h>
45
46 #if HAVE_INTTYPES_H
47 # include <inttypes.h> /* for intmax_t */
48 #else
49 # if HAVE_STDINT_H
50 # include <stdint.h>
51 # endif
52 #endif
53
54 #if HAVE_LANGINFO_H
55 #include <langinfo.h> /* for nl_langinfo */
56 #endif
57
58 #if HAVE_LOCALE_H
59 #include <locale.h> /* for localeconv */
60 #endif
61
62 #if HAVE_SYS_TYPES_H
63 #include <sys/types.h> /* for quad_t */
64 #endif
65
66 #include "gmp-impl.h"
67
68
69 /* change this to "#define TRACE(x) x" for diagnostics */
70 #define TRACE(x)
71
72
73 /* Should be portable, but in any case this is only used under some ASSERTs. */
74 #define va_equal(x, y) \
75 (memcmp (&(x), &(y), sizeof(va_list)) == 0)
76
77
78 /* printf is convenient because it allows various types to be printed in one
79 fairly compact call, so having gmp_printf support the standard types as
80 well as the gmp ones is important. This ends up meaning all the standard
81 parsing must be duplicated, to get a new routine recognising the gmp
82 extras.
83
84 With the currently favoured handling of mpz etc as Z, Q and F type
85 markers, it's not possible to use glibc register_printf_function since
86 that only accepts new conversion characters, not new types. If Z was a
87 conversion there'd be no way to specify hex, decimal or octal, or
88 similarly with F no way to specify fixed point or scientific format.
89
90 It seems wisest to pass conversions %f, %e and %g of float, double and
91 long double over to the standard printf. It'd be hard to be sure of
92 getting the right handling for NaNs, rounding, etc. Integer conversions
93 %d etc and string conversions %s on the other hand could be easily enough
94 handled within gmp_doprnt, but if floats are going to libc then it's just
95 as easy to send all non-gmp types there.
96
97 "Z" was a type marker for size_t in old glibc, but there seems no need to
98 provide access to that now "z" is standard.
99
100 In GMP 4.1.1 we documented "ll" and "L" as being equivalent, but in C99
101 in fact "ll" is just for long long and "L" just for long double.
102 Apparently GLIBC allows "L" for long long though. This doesn't affect
103 us as such, since both are passed through to the C library. To be
104 consistent with what we said before, the two are treated equivalently
105 here, and it's left to the C library to do what it thinks with them.
106
107 Possibilities:
108
109 "b" might be nice for binary output, and could even be supported for the
110 standard C types too if desired.
111
112 POSIX style "%n$" parameter numbering would be possible, but would need
113 to be handled completely within gmp_doprnt, since the numbering will be
114 all different once the format string it cut into pieces.
115
116 Some options for mpq formatting would be good. Perhaps a non-zero
117 precision field could give a width for the denominator and mean always
118 put a "/". A form "n+p/q" might interesting too, though perhaps that's
119 better left to applications.
120
121 Right now there's no way for an application to know whether types like
122 intmax_t are supported here. If configure is doing its job and the same
123 compiler is used for gmp as for the application then there shouldn't be
124 any problem, but perhaps gmp.h should have some preprocessor symbols to
125 say what libgmp can do. */
126
127
128
129 /* If a gmp format is the very first thing or there are two gmp formats with
130 nothing in between then we'll reach here with this_fmt == last_fmt and we
131 can do nothing in that case.
132
133 last_ap is always replaced after a FLUSH, so it doesn't matter if va_list
134 is a call-by-reference and the funs->format routine modifies it. */
135
136 #define FLUSH() \
137 do { \
138 if (this_fmt == last_fmt) \
139 { \
140 TRACE (printf ("nothing to flush\n")); \
141 ASSERT (va_equal (this_ap, last_ap)); \
142 } \
143 else \
144 { \
145 ASSERT (*this_fmt == '%'); \
146 *this_fmt = '\0'; \
147 TRACE (printf ("flush \"%s\"\n", last_fmt)); \
148 DOPRNT_FORMAT (last_fmt, last_ap); \
149 } \
150 } while (0)
151
152
153 /* Parse up the given format string and do the appropriate output using the
154 given "funs" routines. The data parameter is passed through to those
155 routines. */
156
157 int
__gmp_doprnt(const struct doprnt_funs_t * funs,void * data,const char * orig_fmt,va_list orig_ap)158 __gmp_doprnt (const struct doprnt_funs_t *funs, void *data,
159 const char *orig_fmt, va_list orig_ap)
160 {
161 va_list ap, this_ap, last_ap;
162 size_t alloc_fmt_size, orig_fmt_size;
163 char *fmt, *alloc_fmt, *last_fmt, *this_fmt, *gmp_str;
164 int retval = 0;
165 int type, fchar, *value, seen_precision;
166 struct doprnt_params_t param;
167
168 TRACE (printf ("gmp_doprnt \"%s\"\n", orig_fmt));
169
170 /* Don't modify orig_ap, if va_list is actually an array and hence call by
171 reference. It could be argued that it'd be more efficient to leave the
172 caller to make a copy if it cared, but doing so here is going to be a
173 very small part of the total work, and we may as well keep applications
174 out of trouble. */
175 va_copy (ap, orig_ap);
176
177 /* The format string is chopped up into pieces to be passed to
178 funs->format. Unfortunately that means it has to be copied so each
179 piece can be null-terminated. We're not going to be very fast here, so
180 use __gmp_allocate_func rather than TMP_ALLOC, to avoid overflowing the
181 stack if a long output string is given. */
182 alloc_fmt_size = orig_fmt_size = strlen (orig_fmt) + 1;
183 #if _LONG_LONG_LIMB
184 /* for a long long limb we change %Mx to %llx, so could need an extra 1
185 char for every 3 existing */
186 alloc_fmt_size += alloc_fmt_size / 3;
187 #endif
188 alloc_fmt = __GMP_ALLOCATE_FUNC_TYPE (alloc_fmt_size, char);
189 fmt = alloc_fmt;
190 memcpy (fmt, orig_fmt, orig_fmt_size);
191
192 /* last_fmt and last_ap are just after the last output, and hence where
193 the next output will begin, when that's done */
194 last_fmt = fmt;
195 va_copy (last_ap, ap);
196
197 for (;;)
198 {
199 TRACE (printf ("next: \"%s\"\n", fmt));
200
201 fmt = strchr (fmt, '%');
202 if (fmt == NULL)
203 break;
204
205 /* this_fmt and this_ap are the current '%' sequence being considered */
206 this_fmt = fmt;
207 va_copy (this_ap, ap);
208 fmt++; /* skip the '%' */
209
210 TRACE (printf ("considering\n");
211 printf (" last: \"%s\"\n", last_fmt);
212 printf (" this: \"%s\"\n", this_fmt));
213
214 type = '\0';
215 value = ¶m.width;
216
217 param.base = 10;
218 param.conv = 0;
219 param.expfmt = "e%c%02ld";
220 param.exptimes4 = 0;
221 param.fill = ' ';
222 param.justify = DOPRNT_JUSTIFY_RIGHT;
223 param.prec = 6;
224 param.showbase = DOPRNT_SHOWBASE_NO;
225 param.showpoint = 0;
226 param.showtrailing = 1;
227 param.sign = '\0';
228 param.width = 0;
229 seen_precision = 0;
230
231 /* This loop parses a single % sequence. "break" from the switch
232 means continue with this %, "goto next" means the conversion
233 character has been seen and a new % should be sought. */
234 for (;;)
235 {
236 fchar = *fmt++;
237 if (fchar == '\0')
238 break;
239
240 switch (fchar) {
241
242 case 'a':
243 /* %a behaves like %e, but defaults to all significant digits,
244 and there's no leading zeros on the exponent (which is in
245 fact bit-based) */
246 param.base = 16;
247 param.expfmt = "p%c%ld";
248 goto conv_a;
249 case 'A':
250 param.base = -16;
251 param.expfmt = "P%c%ld";
252 conv_a:
253 param.conv = DOPRNT_CONV_SCIENTIFIC;
254 param.exptimes4 = 1;
255 if (! seen_precision)
256 param.prec = -1; /* default to all digits */
257 param.showbase = DOPRNT_SHOWBASE_YES;
258 param.showtrailing = 1;
259 goto floating_a;
260
261 case 'c':
262 /* Let's assume wchar_t will be promoted to "int" in the call,
263 the same as char will be. */
264 (void) va_arg (ap, int);
265 goto next;
266
267 case 'd':
268 case 'i':
269 case 'u':
270 integer:
271 TRACE (printf ("integer, base=%d\n", param.base));
272 if (! seen_precision)
273 param.prec = -1;
274 switch (type) {
275 case 'j':
276 /* Let's assume uintmax_t is the same size as intmax_t. */
277 #if HAVE_INTMAX_T
278 (void) va_arg (ap, intmax_t);
279 #else
280 ASSERT_FAIL (intmax_t not available);
281 #endif
282 break;
283 case 'l':
284 (void) va_arg (ap, long);
285 break;
286 case 'L':
287 #if HAVE_LONG_LONG
288 (void) va_arg (ap, long long);
289 #else
290 ASSERT_FAIL (long long not available);
291 #endif
292 break;
293 case 'N':
294 {
295 mp_ptr xp;
296 mp_size_t xsize, abs_xsize;
297 mpz_t z;
298 FLUSH ();
299 xp = va_arg (ap, mp_ptr);
300 PTR(z) = xp;
301 xsize = (int) va_arg (ap, mp_size_t);
302 abs_xsize = ABS (xsize);
303 MPN_NORMALIZE (xp, abs_xsize);
304 SIZ(z) = (xsize >= 0 ? abs_xsize : -abs_xsize);
305 ASSERT_CODE (ALLOC(z) = abs_xsize);
306 gmp_str = mpz_get_str (NULL, param.base, z);
307 goto gmp_integer;
308 }
309 /* break; */
310 case 'q':
311 /* quad_t is probably the same as long long, but let's treat
312 it separately just to be sure. Also let's assume u_quad_t
313 will be the same size as quad_t. */
314 #if HAVE_QUAD_T
315 (void) va_arg (ap, quad_t);
316 #else
317 ASSERT_FAIL (quad_t not available);
318 #endif
319 break;
320 case 'Q':
321 FLUSH ();
322 gmp_str = mpq_get_str (NULL, param.base, va_arg(ap, mpq_srcptr));
323 goto gmp_integer;
324 case 't':
325 #if HAVE_PTRDIFF_T
326 (void) va_arg (ap, ptrdiff_t);
327 #else
328 ASSERT_FAIL (ptrdiff_t not available);
329 #endif
330 break;
331 case 'z':
332 (void) va_arg (ap, size_t);
333 break;
334 case 'Z':
335 {
336 int ret;
337 FLUSH ();
338 gmp_str = mpz_get_str (NULL, param.base,
339 va_arg (ap, mpz_srcptr));
340 gmp_integer:
341 ret = __gmp_doprnt_integer (funs, data, ¶m, gmp_str);
342 __GMP_FREE_FUNC_TYPE (gmp_str, strlen(gmp_str)+1, char);
343 DOPRNT_ACCUMULATE (ret);
344 va_copy (last_ap, ap);
345 last_fmt = fmt;
346 }
347 break;
348 default:
349 /* default is an "int", and this includes h=short and hh=char
350 since they're promoted to int in a function call */
351 (void) va_arg (ap, int);
352 break;
353 }
354 goto next;
355
356 case 'E':
357 param.base = -10;
358 param.expfmt = "E%c%02ld";
359 /*FALLTHRU*/
360 case 'e':
361 param.conv = DOPRNT_CONV_SCIENTIFIC;
362 floating:
363 if (param.showbase == DOPRNT_SHOWBASE_NONZERO)
364 {
365 /* # in %e, %f and %g */
366 param.showpoint = 1;
367 param.showtrailing = 1;
368 }
369 floating_a:
370 switch (type) {
371 case 'F':
372 FLUSH ();
373 DOPRNT_ACCUMULATE (__gmp_doprnt_mpf (funs, data, ¶m,
374 GMP_DECIMAL_POINT,
375 va_arg (ap, mpf_srcptr)));
376 va_copy (last_ap, ap);
377 last_fmt = fmt;
378 break;
379 case 'L':
380 #if HAVE_LONG_DOUBLE
381 (void) va_arg (ap, long double);
382 #else
383 ASSERT_FAIL (long double not available);
384 #endif
385 break;
386 default:
387 (void) va_arg (ap, double);
388 break;
389 }
390 goto next;
391
392 case 'f':
393 param.conv = DOPRNT_CONV_FIXED;
394 goto floating;
395
396 case 'F': /* mpf_t */
397 case 'j': /* intmax_t */
398 case 'L': /* long long */
399 case 'N': /* mpn */
400 case 'q': /* quad_t */
401 case 'Q': /* mpq_t */
402 case 't': /* ptrdiff_t */
403 case 'z': /* size_t */
404 case 'Z': /* mpz_t */
405 set_type:
406 type = fchar;
407 break;
408
409 case 'G':
410 param.base = -10;
411 param.expfmt = "E%c%02ld";
412 /*FALLTHRU*/
413 case 'g':
414 param.conv = DOPRNT_CONV_GENERAL;
415 param.showtrailing = 0;
416 goto floating;
417
418 case 'h':
419 if (type != 'h')
420 goto set_type;
421 type = 'H'; /* internal code for "hh" */
422 break;
423
424 case 'l':
425 if (type != 'l')
426 goto set_type;
427 type = 'L'; /* "ll" means "L" */
428 break;
429
430 case 'm':
431 /* glibc strerror(errno), no argument */
432 goto next;
433
434 case 'M': /* mp_limb_t */
435 /* mung format string to l or ll and let plain printf handle it */
436 #if _LONG_LONG_LIMB
437 memmove (fmt+1, fmt, strlen (fmt)+1);
438 fmt[-1] = 'l';
439 fmt[0] = 'l';
440 fmt++;
441 type = 'L';
442 #else
443 fmt[-1] = 'l';
444 type = 'l';
445 #endif
446 break;
447
448 case 'n':
449 {
450 void *p;
451 FLUSH ();
452 p = va_arg (ap, void *);
453 switch (type) {
454 case '\0': * (int *) p = retval; break;
455 case 'F': mpf_set_si ((mpf_ptr) p, (long) retval); break;
456 case 'H': * (char *) p = retval; break;
457 case 'h': * (short *) p = retval; break;
458 #if HAVE_INTMAX_T
459 case 'j': * (intmax_t *) p = retval; break;
460 #else
461 case 'j': ASSERT_FAIL (intmax_t not available); break;
462 #endif
463 case 'l': * (long *) p = retval; break;
464 #if HAVE_QUAD_T && HAVE_LONG_LONG
465 case 'q':
466 ASSERT_ALWAYS (sizeof (quad_t) == sizeof (long long));
467 /*FALLTHRU*/
468 #else
469 case 'q': ASSERT_FAIL (quad_t not available); break;
470 #endif
471 #if HAVE_LONG_LONG
472 case 'L': * (long long *) p = retval; break;
473 #else
474 case 'L': ASSERT_FAIL (long long not available); break;
475 #endif
476 case 'N':
477 {
478 mp_size_t n;
479 n = va_arg (ap, mp_size_t);
480 n = ABS (n);
481 if (n != 0)
482 {
483 * (mp_ptr) p = retval;
484 MPN_ZERO ((mp_ptr) p + 1, n - 1);
485 }
486 }
487 break;
488 case 'Q': mpq_set_si ((mpq_ptr) p, (long) retval, 1L); break;
489 #if HAVE_PTRDIFF_T
490 case 't': * (ptrdiff_t *) p = retval; break;
491 #else
492 case 't': ASSERT_FAIL (ptrdiff_t not available); break;
493 #endif
494 case 'z': * (size_t *) p = retval; break;
495 case 'Z': mpz_set_si ((mpz_ptr) p, (long) retval); break;
496 }
497 }
498 va_copy (last_ap, ap);
499 last_fmt = fmt;
500 goto next;
501
502 case 'o':
503 param.base = 8;
504 goto integer;
505
506 case 'p':
507 case 's':
508 /* "void *" will be good enough for "char *" or "wchar_t *", no
509 need for separate code. */
510 (void) va_arg (ap, const void *);
511 goto next;
512
513 case 'x':
514 param.base = 16;
515 goto integer;
516 case 'X':
517 param.base = -16;
518 goto integer;
519
520 case '%':
521 goto next;
522
523 case '#':
524 param.showbase = DOPRNT_SHOWBASE_NONZERO;
525 break;
526
527 case '\'':
528 /* glibc digit grouping, just pass it through, no support for it
529 on gmp types */
530 break;
531
532 case '+':
533 case ' ':
534 param.sign = fchar;
535 break;
536
537 case '-':
538 param.justify = DOPRNT_JUSTIFY_LEFT;
539 break;
540 case '.':
541 seen_precision = 1;
542 param.prec = -1; /* "." alone means all necessary digits */
543 value = ¶m.prec;
544 break;
545
546 case '*':
547 {
548 int n = va_arg (ap, int);
549
550 if (value == ¶m.width)
551 {
552 /* negative width means left justify */
553 if (n < 0)
554 {
555 param.justify = DOPRNT_JUSTIFY_LEFT;
556 n = -n;
557 }
558 param.width = n;
559 }
560 else
561 {
562 /* don't allow negative precision */
563 param.prec = MAX (0, n);
564 }
565 }
566 break;
567
568 case '0':
569 if (value == ¶m.width)
570 {
571 /* in width field, set fill */
572 param.fill = '0';
573
574 /* for right justify, put the fill after any minus sign */
575 if (param.justify == DOPRNT_JUSTIFY_RIGHT)
576 param.justify = DOPRNT_JUSTIFY_INTERNAL;
577 }
578 else
579 {
580 /* in precision field, set value */
581 *value = 0;
582 }
583 break;
584
585 case '1': case '2': case '3': case '4': case '5':
586 case '6': case '7': case '8': case '9':
587 /* process all digits to form a value */
588 {
589 int n = 0;
590 do {
591 n = n * 10 + (fchar-'0');
592 fchar = *fmt++;
593 } while (isascii (fchar) && isdigit (fchar));
594 fmt--; /* unget the non-digit */
595 *value = n;
596 }
597 break;
598
599 default:
600 /* something invalid */
601 ASSERT (0);
602 goto next;
603 }
604 }
605
606 next:
607 /* Stop parsing the current "%" format, look for a new one. */
608 ;
609 }
610
611 TRACE (printf ("remainder: \"%s\"\n", last_fmt));
612 if (*last_fmt != '\0')
613 DOPRNT_FORMAT (last_fmt, last_ap);
614
615 if (funs->final != NULL)
616 if ((*funs->final) (data) == -1)
617 goto error;
618
619 done:
620 __GMP_FREE_FUNC_TYPE (alloc_fmt, alloc_fmt_size, char);
621 return retval;
622
623 error:
624 retval = -1;
625 goto done;
626 }
627