newlib/libc/stdio/nano-vfprintf_float.c

   1 /*
   2  * Copyright (c) 1990 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Chris Torek.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <newlib.h>
  34
  35 #include <_ansi.h>
  36 #include <reent.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <limits.h>
  41 #include <stdint.h>
  42 #include <math.h>
  43 #include <wchar.h>
  44 #include <sys/lock.h>
  45 #include <stdarg.h>
  46 #include "local.h"
  47 #include "../stdlib/local.h"
  48 #include "fvwrite.h"
  49 #include "vfieeefp.h"
  50 #include "nano-vfprintf_local.h"
  51
  52 char *__cvt (struct _reent *data, _PRINTF_FLOAT_TYPE value, int ndigits,
  53              int flags, char *sign, int *decpt, int ch, int *length,
  54              char *buf);
  55
  56 int __exponent (char *p0, int exp, int fmtch);
  57
  58 #ifdef FLOATING_POINT
  59
  60 /* Using reentrant DATA, convert finite VALUE into a string of digits
  61    with no decimal point, using NDIGITS precision and FLAGS as guides
  62    to whether trailing zeros must be included.  Set *SIGN to nonzero
  63    if VALUE was negative.  Set *DECPT to the exponent plus one.  Set
  64    *LENGTH to the length of the returned string.  CH must be one of
  65    [aAeEfFgG]; if it is [aA], then the return string lives in BUF,
  66    otherwise the return value shares the mprec reentrant storage.  */
  67 char *
  68 __cvt (struct _reent *data, _PRINTF_FLOAT_TYPE value, int ndigits, int flags,
  69        char *sign, int *decpt, int ch, int *length, char *buf)
  70 {
  71   int mode, dsgn;
  72   char *digits, *bp, *rve;
  73   union double_union tmp;
  74
  75   tmp.d = value;
  76   /* This will check for "< 0" and "-0.0".  */
  77   if (word0 (tmp) & Sign_bit)
  78     {
  79       value = -value;
  80       *sign = '-';
  81     }
  82   else
  83     *sign = '\000';
  84
  85   if (ch == 'f' || ch == 'F')
  86     {
  87       /* Ndigits after the decimal point.  */
  88       mode = 3;
  89     }
  90   else
  91     {
  92       /* To obtain ndigits after the decimal point for the 'e'
  93          and 'E' formats, round to ndigits + 1 significant figures.  */
  94       if (ch == 'e' || ch == 'E')
  95         {
  96           ndigits++;
  97         }
  98       /* Ndigits significant digits.  */
  99       mode = 2;
 100     }
 101
 102   digits = _DTOA_R (data, value, mode, ndigits, decpt, &dsgn, &rve);
 103
 104   /* Print trailing zeros.  */
 105   if ((ch != 'g' && ch != 'G') || flags & ALT)
 106     {
 107       bp = digits + ndigits;
 108       if (ch == 'f' || ch == 'F')
 109         {
 110           if (*digits == '0' && value)
 111             *decpt = -ndigits + 1;
 112           bp += *decpt;
 113         }
 114       /* Kludge for __dtoa irregularity.  */
 115       if (value == 0)
 116         rve = bp;
 117       while (rve < bp)
 118         *rve++ = '0';
 119     }
 120   *length = rve - digits;
 121   return (digits);
 122 }
 123
 124 /* This function is copied from exponent in vfprintf.c with support for
 125    C99 formats removed.  We don't use the original function in order to
 126    decouple nano implementation of formatted IO from the Newlib one.  */
 127 int
 128 __exponent (char *p0, int exp, int fmtch)
 129 {
 130   register char *p, *t;
 131   char expbuf[MAXEXPLEN];
 132 #define isa 0
 133
 134   p = p0;
 135   *p++ = isa ? 'p' - 'a' + fmtch : fmtch;
 136   if (exp < 0)
 137     {
 138       exp = -exp;
 139       *p++ = '-';
 140     }
 141   else
 142     *p++ = '+';
 143   t = expbuf + MAXEXPLEN;
 144   if (exp > 9)
 145     {
 146       do
 147         {
 148           *--t = to_char (exp % 10);
 149         }
 150       while ((exp /= 10) > 9);
 151       *--t = to_char (exp);
 152       for (; t < expbuf + MAXEXPLEN; *p++ = *t++);
 153     }
 154   else
 155     {
 156       if (!isa)
 157         *p++ = '0';
 158       *p++ = to_char (exp);
 159     }
 160   return (p - p0);
 161 }
 162
 163 /* Decode and print floating point number specified by "eEfgG".  */
 164 int
 165 _printf_float (struct _reent *data,
 166                struct _prt_data_t *pdata,
 167                FILE * fp,
 168                int (*pfunc) (struct _reent *, FILE *, const char *,
 169                              size_t len), va_list * ap)
 170 {
 171 #define _fpvalue (pdata->_double_)
 172
 173   char *decimal_point = _localeconv_r (data)->decimal_point;
 174   size_t decp_len = strlen (decimal_point);
 175   /* Temporary negative sign for floats.  */
 176   char softsign;
 177   /* Integer value of exponent.  */
 178   int expt;
 179   /* Character count for expstr.  */
 180   int expsize = 0;
 181   /* Actual number of digits returned by cvt.  */
 182   int ndig = 0;
 183   char *cp;
 184   int n;
 185   /* Field size expanded by dprec(not for _printf_float).  */
 186   int realsz;
 187   char code = pdata->code;
 188
 189   if (pdata->flags & LONGDBL)
 190     {
 191       _fpvalue = (double) GET_ARG (N, *ap, _LONG_DOUBLE);
 192     }
 193   else
 194     {
 195       _fpvalue = GET_ARG (N, *ap, double);
 196     }
 197
 198   /* Do this before tricky precision changes.
 199
 200      If the output is infinite or NaN, leading
 201      zeros are not permitted.  Otherwise, scanf
 202      could not read what printf wrote.  */
 203   if (isinf (_fpvalue))
 204     {
 205       if (_fpvalue < 0)
 206         pdata->l_buf[0] = '-';
 207       if (code <= 'G')          /* 'A', 'E', 'F', or 'G'.  */
 208         cp = "INF";
 209       else
 210         cp = "inf";
 211       pdata->size = 3;
 212       pdata->flags &= ~ZEROPAD;
 213       goto print_float;
 214     }
 215   if (isnan (_fpvalue))
 216     {
 217       if (signbit (_fpvalue))
 218         pdata->l_buf[0] = '-';
 219       if (code <= 'G')          /* 'A', 'E', 'F', or 'G'.  */
 220         cp = "NAN";
 221       else
 222         cp = "nan";
 223       pdata->size = 3;
 224       pdata->flags &= ~ZEROPAD;
 225       goto print_float;
 226     }
 227
 228   if (pdata->prec == -1)
 229     {
 230       pdata->prec = DEFPREC;
 231     }
 232   else if ((code == 'g' || code == 'G') && pdata->prec == 0)
 233     {
 234       pdata->prec = 1;
 235     }
 236
 237   pdata->flags |= FPT;
 238
 239   cp = __cvt (data, _fpvalue, pdata->prec, pdata->flags, &softsign,
 240               &expt, code, &ndig, cp);
 241
 242   if (code == 'g' || code == 'G')
 243     {
 244       if (expt <= -4 || expt > pdata->prec)
 245         /* 'e' or 'E'.  */
 246         code -= 2;
 247       else
 248         code = 'g';
 249     }
 250   if (code <= 'e')
 251     {
 252       /* 'a', 'A', 'e', or 'E' fmt.  */
 253       --expt;
 254       expsize = __exponent (pdata->expstr, expt, code);
 255       pdata->size = expsize + ndig;
 256       if (ndig > 1 || pdata->flags & ALT)
 257         ++pdata->size;
 258     }
 259   else
 260     {
 261       if (code == 'f')
 262         {
 263           /* 'f' fmt.  */
 264           if (expt > 0)
 265             {
 266               pdata->size = expt;
 267               if (pdata->prec || pdata->flags & ALT)
 268                 pdata->size += pdata->prec + 1;
 269             }
 270           else
 271             /* "0.X".  */
 272             pdata->size = (pdata->prec || pdata->flags & ALT)
 273               ? pdata->prec + 2 : 1;
 274         }
 275       else if (expt >= ndig)
 276         {
 277           /* Fixed g fmt.  */
 278           pdata->size = expt;
 279           if (pdata->flags & ALT)
 280             ++pdata->size;
 281         }
 282       else
 283         pdata->size = ndig + (expt > 0 ? 1 : 2 - expt);
 284       pdata->lead = expt;
 285     }
 286
 287   if (softsign)
 288     pdata->l_buf[0] = '-';
 289 print_float:
 290   if (_printf_common (data, pdata, &realsz, fp, pfunc) == -1)
 291     goto error;
 292
 293   if ((pdata->flags & FPT) == 0)
 294     {
 295       PRINT (cp, pdata->size);
 296     }
 297   else
 298     {
 299       /* Glue together f_p fragments.  */
 300       if (code >= 'f')
 301         {
 302           /* 'f' or 'g'.  */
 303           if (_fpvalue == 0)
 304             {
 305               /* Kludge for __dtoa irregularity.  */
 306               PRINT ("0", 1);
 307               if (expt < ndig || pdata->flags & ALT)
 308                 {
 309                   PRINT (decimal_point, decp_len);
 310                   PAD (ndig - 1, pdata->zero);
 311                 }
 312             }
 313           else if (expt <= 0)
 314             {
 315               PRINT ("0", 1);
 316               if (expt || ndig || pdata->flags & ALT)
 317                 {
 318                   PRINT (decimal_point, decp_len);
 319                   PAD (-expt, pdata->zero);
 320                   PRINT (cp, ndig);
 321                 }
 322             }
 323           else
 324             {
 325               char *convbuf = cp;
 326               PRINTANDPAD (cp, convbuf + ndig, pdata->lead, pdata->zero);
 327               cp += pdata->lead;
 328               if (expt < ndig || pdata->flags & ALT)
 329                 PRINT (decimal_point, decp_len);
 330               PRINTANDPAD (cp, convbuf + ndig, ndig - expt, pdata->zero);
 331             }
 332         }
 333       else
 334         {
 335           /* 'a', 'A', 'e', or 'E'.  */
 336           if (ndig > 1 || pdata->flags & ALT)
 337             {
 338               PRINT (cp, 1);
 339               cp++;
 340               PRINT (decimal_point, decp_len);
 341               if (_fpvalue)
 342                 {
 343                   PRINT (cp, ndig - 1);
 344                 }
 345               /* "0.[0..]".  */
 346               else
 347                 /* __dtoa irregularity.  */
 348                 PAD (ndig - 1, pdata->zero);
 349             }
 350           else                  /* "XeYYY".  */
 351             PRINT (cp, 1);
 352           PRINT (pdata->expstr, expsize);
 353         }
 354     }
 355
 356   /* Left-adjusting padding (always blank).  */
 357   if (pdata->flags & LADJUST)
 358     PAD (pdata->width - realsz, pdata->blank);
 359
 360   return (pdata->width > realsz ? pdata->width : realsz);
 361 error:
 362   return -1;
 363
 364 #undef _fpvalue
 365 }
 366
 367 #endif