Annotation of OpenXM_contrib/gmp/printf/doprntf.c, Revision 1.1
1.1 ! ohara 1: /* __gmp_doprnt_mpf -- mpf 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, 2002 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 the GNU Lesser General Public License as published by
! 13: the Free Software Foundation; either version 2.1 of the License, or (at your
! 14: option) any later version.
! 15:
! 16: The GNU MP Library is distributed in the hope that it will be useful, but
! 17: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 18: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
! 19: License for more details.
! 20:
! 21: You should have received a copy of the GNU Lesser General Public License
! 22: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
! 23: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
! 24: MA 02111-1307, USA. */
! 25:
! 26: #include "config.h"
! 27:
! 28: #if HAVE_STDARG
! 29: #include <stdarg.h> /* for va_list and hence doprnt_funs_t */
! 30: #else
! 31: #include <varargs.h>
! 32: #endif
! 33:
! 34: #include <ctype.h>
! 35: #include <string.h>
! 36: #include <stdio.h>
! 37: #include <stdlib.h>
! 38:
! 39: #if HAVE_LOCALE_H
! 40: #include <locale.h> /* for localeconv */
! 41: #endif
! 42:
! 43: #include "gmp.h"
! 44: #include "gmp-impl.h"
! 45:
! 46:
! 47: /* change this to "#define TRACE(x) x" for diagnostics */
! 48: #define TRACE(x)
! 49:
! 50:
! 51: /* The separate of __gmp_doprnt_float_digits and __gmp_doprnt_float is so
! 52: some C++ can do the mpf_get_str and release it in case of an exception */
! 53:
! 54: #define DIGIT_VALUE(c) \
! 55: (isdigit (c) ? (c) - '0' \
! 56: : islower (c) ? (c) - 'a' + 10 \
! 57: : (c) - 'A' + 10)
! 58:
! 59: int
! 60: __gmp_doprnt_mpf (const struct doprnt_funs_t *funs,
! 61: void *data,
! 62: const struct doprnt_params_t *p,
! 63: mpf_srcptr f)
! 64: {
! 65: int prec, ndigits, free_size, len, newlen, justify, justlen, explen;
! 66: int showbaselen, sign, signlen, intlen, intzeros, pointlen;
! 67: int fraczeros, fraclen, preczeros;
! 68: char *s, *free_ptr;
! 69: mp_exp_t exp;
! 70: char exponent[BITS_PER_MP_LIMB + 10];
! 71: const char *showbase;
! 72: const char *point;
! 73: int retval = 0;
! 74:
! 75: TRACE (printf ("__gmp_doprnt_float\n");
! 76: printf (" conv=%d prec=%d\n", p->conv, p->prec));
! 77:
! 78: prec = p->prec;
! 79: if (prec <= -1)
! 80: {
! 81: /* all digits */
! 82: ndigits = 0;
! 83:
! 84: /* arrange the fixed/scientific decision on a "prec" implied by how
! 85: many significant digits there are */
! 86: if (p->conv == DOPRNT_CONV_GENERAL)
! 87: MPF_SIGNIFICANT_DIGITS (prec, PREC(f), ABS(p->base));
! 88: }
! 89: else
! 90: {
! 91: switch (p->conv) {
! 92: case DOPRNT_CONV_FIXED:
! 93: /* Precision is digits after the radix point. Try not to generate
! 94: too many more than will actually be required. If f>=1 then
! 95: overestimate the integer part, and add prec. If f<1 then
! 96: underestimate the zeros between the radix point and the first
! 97: digit and subtract that from prec. In either case add 2 so the
! 98: round to nearest can be applied accurately. */
! 99: ndigits = prec + 2
! 100: + EXP(f) * (__mp_bases[ABS(p->base)].chars_per_limb + (EXP(f)>=0));
! 101: ndigits = MAX (ndigits, 1);
! 102: break;
! 103:
! 104: case DOPRNT_CONV_SCIENTIFIC:
! 105: /* precision is digits after the radix point, and there's one digit
! 106: before */
! 107: ndigits = prec + 1;
! 108: break;
! 109:
! 110: default:
! 111: ASSERT (0);
! 112: /*FALLTHRU*/
! 113:
! 114: case DOPRNT_CONV_GENERAL:
! 115: /* precision is total digits, but be sure to ask mpf_get_str for at
! 116: least 1, not 0 */
! 117: ndigits = MAX (prec, 1);
! 118: break;
! 119: }
! 120: }
! 121: TRACE (printf (" ndigits %d\n", ndigits));
! 122:
! 123: s = mpf_get_str (NULL, &exp, p->base, ndigits, f);
! 124: len = strlen (s);
! 125: free_ptr = s;
! 126: free_size = len + 1;
! 127: TRACE (printf (" s %s\n", s);
! 128: printf (" exp %ld\n", exp);
! 129: printf (" len %d\n", len));
! 130:
! 131: /* For fixed mode check the ndigits formed above was in fact enough for
! 132: the integer part plus p->prec after the radix point. */
! 133: ASSERT ((p->conv == DOPRNT_CONV_FIXED && p->prec > -1)
! 134: ? ndigits >= MAX (1, exp + p->prec + 2) : 1);
! 135:
! 136: sign = p->sign;
! 137: if (s[0] == '-')
! 138: {
! 139: sign = s[0];
! 140: s++, len--;
! 141: }
! 142: signlen = (sign != '\0');
! 143: TRACE (printf (" sign %c signlen %d\n", sign, signlen));
! 144:
! 145: switch (p->conv) {
! 146: case DOPRNT_CONV_FIXED:
! 147: if (prec <= -1)
! 148: prec = MAX (0, len-exp); /* retain all digits */
! 149:
! 150: /* Truncate if necessary so fraction will be at most prec digits. */
! 151: ASSERT (prec >= 0);
! 152: newlen = exp + prec;
! 153: if (newlen < 0)
! 154: {
! 155: /* first non-zero digit is below target prec, and at least one zero
! 156: digit in between, so print zero */
! 157: len = 0;
! 158: exp = 0;
! 159: }
! 160: else if (len <= newlen)
! 161: {
! 162: /* already got few enough digits */
! 163: }
! 164: else
! 165: {
! 166: /* discard excess digits and round to nearest */
! 167:
! 168: const char *num_to_text = (p->base >= 0
! 169: ? "0123456789abcdefghijklmnopqrstuvwxyz"
! 170: : "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
! 171: int base = ABS(p->base);
! 172: int n;
! 173:
! 174: ASSERT (base <= 36);
! 175:
! 176: len = newlen;
! 177: n = DIGIT_VALUE (s[len]);
! 178: TRACE (printf (" rounding with %d\n", n));
! 179: if (n >= (base + 1) / 2)
! 180: {
! 181: /* propagate a carry */
! 182: for (;;)
! 183: {
! 184: if (len == 0)
! 185: {
! 186: s[0] = '1';
! 187: len = 1;
! 188: exp++;
! 189: break;
! 190: }
! 191: n = DIGIT_VALUE (s[len-1]);
! 192: ASSERT (n >= 0 && n < base);
! 193: n++;
! 194: if (n != base)
! 195: {
! 196: TRACE (printf (" storing now %d\n", n));
! 197: s[len-1] = num_to_text[n];
! 198: break;
! 199: }
! 200: len--;
! 201: }
! 202: }
! 203: else
! 204: {
! 205: /* truncate only, strip any trailing zeros now exposed */
! 206: while (len > 0 && s[len-1] == '0')
! 207: len--;
! 208: }
! 209:
! 210: /* Can have newlen==0, in which case the truncate was just to check
! 211: for a carry turning it into "1". If we're left with len==0 then
! 212: adjust exp to match. */
! 213: if (len == 0)
! 214: exp = 0;
! 215: }
! 216:
! 217: fixed:
! 218: ASSERT (len == 0 ? exp == 0 : 1);
! 219: if (exp <= 0)
! 220: {
! 221: TRACE (printf (" fixed 0.000sss\n"));
! 222: intlen = 0;
! 223: intzeros = 1;
! 224: fraczeros = -exp;
! 225: fraclen = len;
! 226: }
! 227: else
! 228: {
! 229: TRACE (printf (" fixed sss.sss or sss000\n"));
! 230: intlen = MIN (len, exp);
! 231: intzeros = exp - intlen;
! 232: fraczeros = 0;
! 233: fraclen = len - intlen;
! 234: }
! 235: explen = 0;
! 236: break;
! 237:
! 238: case DOPRNT_CONV_SCIENTIFIC:
! 239: {
! 240: int expval;
! 241: char expsign;
! 242:
! 243: if (prec <= -1)
! 244: prec = MAX (0, len-1); /* retain all digits */
! 245:
! 246: scientific:
! 247: TRACE (printf (" scientific s.sss\n"));
! 248:
! 249: intlen = MIN (1, len);
! 250: intzeros = (intlen == 0 ? 1 : 0);
! 251: fraczeros = 0;
! 252: fraclen = len - intlen;
! 253:
! 254: expval = (exp-intlen);
! 255: if (p->exptimes4)
! 256: expval <<= 2;
! 257:
! 258: /* Split out the sign since %o or %x in expfmt give negatives as twos
! 259: complement, not with a sign. */
! 260: expsign = (expval >= 0 ? '+' : '-');
! 261: expval = ABS (expval);
! 262:
! 263: #if HAVE_VSNPRINTF
! 264: explen = snprintf (exponent, sizeof(exponent),
! 265: p->expfmt, expsign, expval);
! 266: /* test for < sizeof-1 since a glibc 2.0.x return of sizeof-1 might
! 267: mean truncation */
! 268: ASSERT (explen >= 0 && explen < sizeof(exponent)-1);
! 269: #else
! 270: sprintf (exponent, p->expfmt, expsign, expval);
! 271: explen = strlen (exponent);
! 272: ASSERT (explen < sizeof(exponent));
! 273: #endif
! 274: TRACE (printf (" expfmt %s gives %s\n", p->expfmt, exponent));
! 275: }
! 276: break;
! 277:
! 278: default:
! 279: ASSERT (0);
! 280: /*FALLTHRU*/ /* to stop variables looking uninitialized */
! 281:
! 282: case DOPRNT_CONV_GENERAL:
! 283: /* The exponent for "scientific" will be exp-1, choose scientific if
! 284: this is < -4 or >= prec (and minimum 1 for prec). For f==0 will have
! 285: exp==0 and get the desired "fixed". This rule follows glibc. For
! 286: fixed there's no need to truncate, the desired ndigits will already
! 287: be as required. */
! 288: if (exp-1 < -4 || exp-1 >= MAX (1, prec))
! 289: goto scientific;
! 290: else
! 291: goto fixed;
! 292: }
! 293:
! 294: TRACE (printf (" intlen %d intzeros %d fraczeros %d fraclen %d\n",
! 295: intlen, intzeros, fraczeros, fraclen));
! 296: ASSERT (p->prec <= -1
! 297: ? intlen + fraclen == strlen (s)
! 298: : intlen + fraclen <= strlen (s));
! 299:
! 300: if (p->showtrailing)
! 301: {
! 302: /* Pad to requested precision with trailing zeros, for general this is
! 303: all digits, for fixed and scientific just the fraction. */
! 304: preczeros = prec - (fraczeros + fraclen
! 305: + (p->conv == DOPRNT_CONV_GENERAL
! 306: ? intlen + intzeros : 0));
! 307: preczeros = MAX (0, preczeros);
! 308: }
! 309: else
! 310: preczeros = 0;
! 311: TRACE (printf (" prec=%d showtrailing=%d, pad with preczeros %d\n",
! 312: prec, p->showtrailing, preczeros));
! 313:
! 314: /* radix point if needed, or if forced */
! 315: point = ".";
! 316: pointlen = ((fraczeros + fraclen + preczeros) != 0 || p->showpoint != 0);
! 317: #if HAVE_LOCALECONV
! 318: if (pointlen)
! 319: {
! 320: point = localeconv()->decimal_point;
! 321: pointlen = strlen (point);
! 322: }
! 323: #endif
! 324: TRACE (printf (" point |%s| pointlen %d\n", point, pointlen));
! 325:
! 326: /* Notice the test for a non-zero value is done after any truncation for
! 327: DOPRNT_CONV_FIXED. */
! 328: showbase = NULL;
! 329: showbaselen = 0;
! 330: switch (p->showbase) {
! 331: default:
! 332: ASSERT (0);
! 333: /*FALLTHRU*/
! 334: case DOPRNT_SHOWBASE_NO:
! 335: break;
! 336: case DOPRNT_SHOWBASE_NONZERO:
! 337: if (intlen == 0 && fraclen == 0)
! 338: break;
! 339: /*FALLTHRU*/
! 340: case DOPRNT_SHOWBASE_YES:
! 341: switch (p->base) {
! 342: case 16: showbase = "0x"; showbaselen = 2; break;
! 343: case -16: showbase = "0X"; showbaselen = 2; break;
! 344: case 8: showbase = "0"; showbaselen = 1; break;
! 345: }
! 346: break;
! 347: }
! 348: TRACE (printf (" showbase %s showbaselen %d\n",
! 349: showbase == NULL ? "" : showbase, showbaselen));
! 350:
! 351: /* left over field width */
! 352: justlen = p->width - (signlen + showbaselen + intlen + intzeros + pointlen
! 353: + fraczeros + fraclen + preczeros + explen);
! 354: TRACE (printf (" justlen %d fill 0x%X\n", justlen, p->fill));
! 355:
! 356: justify = p->justify;
! 357: if (justlen <= 0) /* no justifying if exceed width */
! 358: justify = DOPRNT_JUSTIFY_NONE;
! 359:
! 360: TRACE (printf (" justify type %d intlen %d pointlen %d fraclen %d\n",
! 361: justify, intlen, pointlen, fraclen));
! 362:
! 363: if (justify == DOPRNT_JUSTIFY_RIGHT) /* pad for right */
! 364: DOPRNT_REPS (p->fill, justlen);
! 365:
! 366: if (signlen) /* sign */
! 367: DOPRNT_REPS (sign, 1);
! 368:
! 369: DOPRNT_MEMORY_MAYBE (showbase, showbaselen); /* base */
! 370:
! 371: if (justify == DOPRNT_JUSTIFY_INTERNAL) /* pad for internal */
! 372: DOPRNT_REPS (p->fill, justlen);
! 373:
! 374: DOPRNT_MEMORY (s, intlen); /* integer */
! 375: DOPRNT_REPS_MAYBE ('0', intzeros);
! 376:
! 377: DOPRNT_MEMORY_MAYBE (point, pointlen); /* point */
! 378:
! 379: DOPRNT_REPS_MAYBE ('0', fraczeros); /* frac */
! 380: DOPRNT_MEMORY_MAYBE (s+intlen, fraclen);
! 381:
! 382: DOPRNT_REPS_MAYBE ('0', preczeros); /* prec */
! 383:
! 384: DOPRNT_MEMORY_MAYBE (exponent, explen); /* exp */
! 385:
! 386: if (justify == DOPRNT_JUSTIFY_LEFT) /* pad for left */
! 387: DOPRNT_REPS (p->fill, justlen);
! 388:
! 389: done:
! 390: (*__gmp_free_func) (free_ptr, free_size);
! 391: return retval;
! 392:
! 393: error:
! 394: retval = -1;
! 395: goto done;
! 396: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to doprntf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / printf