stdio-common/printf_fphex.c

   1 /* Print floating point number in hexadecimal notation according to
   2    ISO C 9X.
   3    Copyright (C) 1997 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Library General Public License as
   9    published by the Free Software Foundation; either version 2 of the
  10    License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Library General Public License for more details.
  16
  17    You should have received a copy of the GNU Library General Public
  18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <ctype.h>
  23 #include <ieee754.h>
  24 #include <math.h>
  25 #include <printf.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include "_itoa.h"
  30 #include <locale/localeinfo.h>
  31
  32 /* #define NDEBUG 1*/           /* Undefine this for debugging assertions.  */
  33 #include <assert.h>
  34
  35 /* This defines make it possible to use the same code for GNU C library and
  36    the GNU I/O library.  */
  37 #ifdef USE_IN_LIBIO
  38 # include <libioP.h>
  39 # define PUT(f, s, n) _IO_sputn (f, s, n)
  40 # define PAD(f, c, n) _IO_padn (f, c, n)
  41 /* We use this file GNU C library and GNU I/O library.  So make
  42    names equal.  */
  43 # undef putc
  44 # define putc(c, f) _IO_putc_unlocked (c, f)
  45 # define size_t     _IO_size_t
  46 # define FILE        _IO_FILE
  47 #else   /* ! USE_IN_LIBIO */
  48 # define PUT(f, s, n) fwrite (s, 1, n, f)
  49 # define PAD(f, c, n) __printf_pad (f, c, n)
  50 ssize_t __printf_pad __P ((FILE *, char pad, int n)); /* In vfprintf.c.  */
  51 #endif  /* USE_IN_LIBIO */
  52 \f
  53 /* Macros for doing the actual output.  */
  54
  55 #define outchar(ch)                                                           \
  56   do                                                                          \
  57     {                                                                         \
  58       register const int outc = (ch);                                         \
  59       if (putc (outc, fp) == EOF)                                             \
  60         return -1;                                                            \
  61       ++done;                                                                 \
  62     } while (0)
  63
  64 #define PRINT(ptr, len)                                                       \
  65   do                                                                          \
  66     {                                                                         \
  67        int outlen = (len);                                                    \
  68        const char *cp = (ptr);                                                \
  69        while (outlen-- > 0)                                                   \
  70          outchar (*cp++);                                                     \
  71     } while (0)
  72
  73 #define PADN(ch, len)                                                         \
  74   do                                                                          \
  75     {                                                                         \
  76       if (PAD (fp, ch, len) != len)                                           \
  77         return -1;                                                            \
  78       done += len;                                                            \
  79     }                                                                         \
  80   while (0)
  81
  82 #ifndef MIN
  83 # define MIN(a,b) ((a)<(b)?(a):(b))
  84 #endif
  85 \f
  86
  87 int
  88 __printf_fphex (FILE *fp,
  89                 const struct printf_info *info,
  90                 const void *const *args)
  91 {
  92   /* The floating-point value to output.  */
  93   union
  94     {
  95       union ieee754_double dbl;
  96       union ieee854_long_double ldbl;
  97     }
  98   fpnum;
  99
 100   /* Locale-dependent representation of decimal point.  */
 101   wchar_t decimal;
 102
 103   /* "NaN" or "Inf" for the special cases.  */
 104   const char *special = NULL;
 105
 106   /* Buffer for the generated number string for the mantissa.  The
 107      maximal size for the mantissa is 64 bits.  */
 108   char numbuf[16];
 109   char *numstr;
 110   char *numend;
 111   int negative;
 112
 113   /* The maximal exponent of two in decimal notation has 5 digits.  */
 114   char expbuf[5];
 115   char *expstr;
 116   int expnegative;
 117   int exponent;
 118
 119   /* Non-zero is mantissa is zero.  */
 120   int zero_mantissa;
 121
 122   /* The leading digit before the decimal point.  */
 123   char leading;
 124
 125   /* Precision.  */
 126   int precision = info->prec;
 127
 128   /* Width.  */
 129   int width = info->width;
 130
 131   /* Number of characters written.  */
 132   int done = 0;
 133
 134
 135   /* Figure out the decimal point character.  */
 136   if (info->extra == 0)
 137     {
 138       if (mbtowc (&decimal, _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT),
 139                   strlen (_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT))) <= 0)
 140         decimal = (wchar_t) *_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
 141     }
 142   else
 143     {
 144       if (mbtowc (&decimal, _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT),
 145                   strlen (_NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT))) <= 0)
 146         decimal = (wchar_t) *_NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT);
 147     }
 148   /* Give default value.  */
 149   if (decimal == L'\0')
 150     decimal = L'.';
 151
 152
 153   /* Fetch the argument value.  */
 154   if (info->is_long_double && sizeof (long double) > sizeof (double))
 155     {
 156       fpnum.ldbl.d = *(const long double *) args[0];
 157
 158       /* Check for special values: not a number or infinity.  */
 159       if (__isnanl (fpnum.ldbl.d))
 160         {
 161           special = isupper (info->spec) ? "NAN" : "nan";
 162           negative = 0;
 163         }
 164       else
 165         {
 166           if (__isinfl (fpnum.ldbl.d))
 167             special = isupper (info->spec) ? "INF" : "inf";
 168
 169           negative = signbit (fpnum.ldbl.d);
 170         }
 171     }
 172   else
 173     {
 174       fpnum.dbl.d = *(const double *) args[0];
 175
 176       /* Check for special values: not a number or infinity.  */
 177       if (__isnan (fpnum.dbl.d))
 178         {
 179           special = isupper (info->spec) ? "NAN" : "nan";
 180           negative = 0;
 181         }
 182       else
 183         {
 184           if (__isinf (fpnum.dbl.d))
 185             special = isupper (info->spec) ? "INF" : "inf";
 186
 187           negative = signbit (fpnum.dbl.d);
 188         }
 189     }
 190
 191   if (special)
 192     {
 193       int width = info->width;
 194
 195       if (negative || info->showsign || info->space)
 196         --width;
 197       width -= 3;
 198
 199       if (!info->left && width > 0)
 200         PADN (' ', width);
 201
 202       if (negative)
 203         outchar ('-');
 204       else if (info->showsign)
 205         outchar ('+');
 206       else if (info->space)
 207         outchar (' ');
 208
 209       PRINT (special, 3);
 210
 211       if (info->left && width > 0)
 212         PADN (' ', width);
 213
 214       return done;
 215     }
 216
 217   /* We are handling here only 64 and 80 bit IEEE foating point
 218      numbers.  */
 219   if (info->is_long_double == 0 || sizeof (double) == sizeof (long double))
 220     {
 221       /* We have 52 bits of mantissa plus one implicit digit.  Since
 222          52 bits are representable without rest using hexadecimal
 223          digits we use only the implicit digits for the number before
 224          the decimal point.  */
 225       unsigned long long int num;
 226
 227       num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32
 228              | fpnum.dbl.ieee.mantissa1);
 229
 230       zero_mantissa = num == 0;
 231
 232       if (sizeof (unsigned long int) > 6)
 233         numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
 234                              info->spec == 'A');
 235       else
 236         numstr = _itoa (num, numbuf + sizeof numbuf, 16,
 237                         info->spec == 'A');
 238
 239       /* Fill with zeroes.  */
 240       while (numstr > numbuf + (sizeof numbuf - 52 / 4))
 241         *--numstr = '0';
 242
 243       leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1';
 244
 245       exponent = fpnum.dbl.ieee.exponent;
 246
 247       if (exponent == 0 ? !zero_mantissa : exponent < IEEE754_DOUBLE_BIAS)
 248         {
 249           expnegative = 1;
 250           exponent = -(exponent - IEEE754_DOUBLE_BIAS);
 251         }
 252       else
 253         {
 254           expnegative = 0;
 255           if (exponent != 0)
 256             exponent -= IEEE754_DOUBLE_BIAS;
 257         }
 258     }
 259   else
 260     {
 261       /* The "strange" 80 bit format on ix86 and m68k has an explicit
 262          leading digit in the 64 bit mantissa.  */
 263       unsigned long long int num;
 264
 265       assert (sizeof (long double) == 12);
 266
 267       num = (((unsigned long long int) fpnum.ldbl.ieee.mantissa0) << 32
 268              | fpnum.ldbl.ieee.mantissa1);
 269
 270       zero_mantissa = num == 0;
 271
 272       if (sizeof (unsigned long int) > 6)
 273         numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
 274                              info->spec == 'A');
 275       else
 276         numstr = _itoa (num, numbuf + sizeof numbuf, 16, info->spec == 'A');
 277
 278       /* Fill with zeroes.  */
 279       while (numstr > numbuf + (sizeof numbuf - 64 / 4))
 280         *--numstr = '0';
 281
 282       /* We use a full nibble for the leading digit.  */
 283       leading = *numstr++;
 284
 285       /* We have 3 bits from the mantissa in the leading nibble.  */
 286       exponent = fpnum.ldbl.ieee.exponent;
 287
 288       if (exponent == 0 ? !zero_mantissa
 289           : exponent < IEEE854_LONG_DOUBLE_BIAS + 3)
 290         {
 291           expnegative = 1;
 292           exponent = -(exponent - (IEEE854_LONG_DOUBLE_BIAS + 3));
 293         }
 294       else
 295         {
 296           expnegative = 0;
 297           if (exponent != 0)
 298             exponent -= IEEE854_LONG_DOUBLE_BIAS + 3;
 299         }
 300     }
 301
 302   /* Look for trailing zeroes.  */
 303   if (! zero_mantissa)
 304     {
 305       numend = numbuf + sizeof numbuf;
 306       while (numend[-1] == '0')
 307         --numend;
 308
 309       if (precision == -1)
 310         precision = numend - numstr;
 311       else if (precision < numend - numstr
 312                && (numstr[precision] > '8'
 313                    || (('A' < '0' || 'a' < '0')
 314                        && numstr[precision] < '0')
 315                    || (numstr[precision] == '8'
 316                        && (precision + 1 < numend - numstr
 317                            /* Round to even.  */
 318                            || (precision > 0
 319                                && ((numstr[precision - 1] & 1)
 320                                    ^ (isdigit (numstr[precision - 1]) == 0)))
 321                            || (precision == 0
 322                                && ((leading & 1)
 323                                    ^ (isdigit (leading) == 0)))))))
 324         {
 325           /* Round up.  */
 326           int cnt = precision;
 327           while (--cnt >= 0)
 328             {
 329               char ch = numstr[cnt];
 330               /* We assume that the digits and the letters are ordered
 331                  like in ASCII.  This is true for the rest of GNU, too.  */
 332               if (ch == '9')
 333                 {
 334                   numstr[cnt] = info->spec;     /* This is tricky,
 335                                                    think about it!  */
 336                   break;
 337                 }
 338               else if (tolower (ch) < 'f')
 339                 {
 340                   ++numstr[cnt];
 341                   break;
 342                 }
 343               else
 344                 numstr[cnt] = '0';
 345             }
 346           if (cnt < 0)
 347             {
 348               /* The mantissa so far was fff...f  Now increment the
 349                  leading digit.  Here it is again possible that we
 350                  get an overflow.  */
 351               if (leading == '9')
 352                 leading = info->spec;
 353               else if (tolower (leading) < 'f')
 354                 ++leading;
 355               else
 356                 {
 357                   leading = 1;
 358                   if (expnegative)
 359                     {
 360                       exponent += 4;
 361                       if (exponent >= 0)
 362                         expnegative = 0;
 363                     }
 364                   else
 365                     exponent += 4;
 366                 }
 367             }
 368         }
 369     }
 370   else
 371     numend = numstr;
 372
 373   /* Now we can compute the exponent string.  */
 374   expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
 375
 376   /* Now we have all information to compute the size.  */
 377   width -= ((negative || info->showsign || info->space)
 378             /* Sign.  */
 379             + 2    + 1 + 1 + precision + 1 + 1
 380             /* 0x    h   .   hhh         P   ExpoSign.  */
 381             + ((expbuf + sizeof expbuf) - expstr));
 382             /* Exponent.  */
 383
 384   /* A special case if when the mantissa is zero and the `#' is not
 385      given.  In this case we must not print the decimal point.  */
 386   if (zero_mantissa && precision == 0 && !info->alt)
 387     ++width;            /* This nihilates the +1 for the decimal-point
 388                            character in the following equation.  */
 389
 390   if (!info->left && width > 0)
 391     PADN (' ', width);
 392
 393   if (negative)
 394     outchar ('-');
 395   else if (info->showsign)
 396     outchar ('+');
 397   else if (info->space)
 398     outchar (' ');
 399
 400   outchar ('0');
 401   outchar (info->spec == 'A' ? 'X' : 'x');
 402   outchar (leading);
 403
 404   if (!zero_mantissa || precision > 0 || info->alt)
 405     outchar (decimal);
 406
 407   if (!zero_mantissa || precision > 0)
 408     {
 409       PRINT (numstr, MIN (numend - numstr, precision));
 410       if (precision > numend - numstr)
 411         PADN ('0', precision - (numend - numstr));
 412     }
 413
 414   if (info->left && info->pad == '0' && width > 0)
 415     PADN ('0', width);
 416
 417   outchar (info->spec == 'A' ? 'P' : 'p');
 418
 419   outchar (expnegative ? '-' : '+');
 420
 421   PRINT (expstr, (expbuf + sizeof expbuf) - expstr);
 422
 423   if (info->left && info->pad != '0' && width > 0)
 424     PADN (info->pad, width);
 425
 426   return done;
 427 }