sdcc/device/lib/pic14/libc/_ftoa.c

   1 /*-------------------------------------------------------------------------
   2    x_ftoa.c - wrapper function to use _convert_float
   3
   4    Copyright (C) 2004, Vangelis Rokas <vrokas at otenet.gr>
   5
   6    Modifications for PIC14 by
   7    Copyright (C) 2019 Gonzalo Pérez de Olaguer Córdoba <salo@gpoc.es>
   8
   9    This library is free software; you can redistribute it and/or modify it
  10    under the terms of the GNU General Public License as published by the
  11    Free Software Foundation; either version 2, or (at your option) any
  12    later version.
  13
  14    This library is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this library; see the file COPYING. If not, write to the
  21    Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
  22    MA 02110-1301, USA.
  23
  24    As a special exception, if you link this library with other files,
  25    some of which are compiled with SDCC, to produce an executable,
  26    this library does not by itself cause the resulting executable to
  27    be covered by the GNU General Public License. This exception does
  28    not however invalidate any other reasons why the executable file
  29    might be covered by the GNU General Public License.
  30 -------------------------------------------------------------------------*/
  31
  32 #define __SDCC_FLOAT_LIB
  33 #include <float.h>
  34 #include <stdlib.h>
  35
  36 union {
  37     unsigned long l;
  38     float f;
  39 } lf;
  40 int e2;
  41 int e10;
  42
  43 #define M       lf.l    /* mantissa */
  44 #define F       lf.f    /* float */
  45 #define E2      e2      /* exponent base 2 */
  46 #define E10     e10     /* exponent base 10 */
  47
  48 /* While processing decimal output we consider the mantissa as a
  49  * fixed point number with the integer part in bits 31:28 and the
  50  * fractional part in bits 27:0.
  51  */
  52 #define MANT_UNIT       (1UL << 28)
  53
  54 static char *S; /* the output string */
  55
  56 static void _div2 (void)
  57 {
  58     M = ((M + 1) >> 1);
  59 }
  60
  61 static void _mul2 (void)
  62 {
  63     M = (M << 1);
  64 }
  65
  66 static void _div5 (void)
  67 {
  68     M = ((M + 2) / 5);
  69 }
  70
  71 static void _mul5 (void)
  72 {
  73     M = (M + (M << 2));
  74 }
  75
  76 static void _div10 (void)
  77 {
  78     M = ((M + 5) / 10);
  79 }
  80
  81 static void _mul10 (void)
  82 {
  83     M = ((M + (M << 2)) << 1);
  84 }
  85
  86 static void _round (int x)
  87 {
  88     if (x >= 0)
  89     {
  90         unsigned long r = M;
  91         M = (MANT_UNIT >> 1);
  92         while (x > 0)
  93         {
  94             _div10();
  95             --x;
  96         }
  97         M += r;
  98         if (M >= 10 * MANT_UNIT)
  99         {
 100             _div10();
 101             ++E10;
 102         }
 103     }
 104 }
 105
 106 static void _put_char (char c)
 107 {
 108     *S++ = c;
 109 }
 110
 111 static void _put_digit (void)
 112 {
 113     _put_char( '0' + ((M >> 28) & 0x0f));
 114     M &= 0x0fffffffUL;
 115     _mul10();
 116 }
 117
 118 void _ftoa (float value, char *str, unsigned char prec)
 119 {
 120     F = value;
 121     S = str;
 122
 123     /* output sign */
 124     if (SIGN(M))
 125         _put_char('-');
 126
 127     E2 = EXP(M);
 128     M = MANT(M);
 129
 130     /* infinity or not a number */
 131     if (E2 == 255)
 132     {
 133         if (M == HIDDEN)
 134         {
 135             /* infinity */
 136             _put_char('i');
 137             _put_char('n');
 138             _put_char('F');
 139         }
 140         else
 141         {
 142             /* not a number */
 143             _put_char('n');
 144             _put_char('a');
 145             _put_char('n');
 146         }
 147         _put_char('\0');
 148         return;
 149     }
 150
 151     /* zero or denormal number */
 152     if (E2 == 0)
 153     {
 154         if (M == HIDDEN)
 155         {
 156             /* zero */
 157             _put_char('0');
 158             E10 = prec & PREC_P;
 159             if (E10)
 160             {
 161                 _put_char('.');
 162                 while (E10--)
 163                     _put_char('0');
 164             }
 165             if (prec & PREC_E)
 166             {
 167                 _put_char('E2');
 168                 _put_char('+');
 169                 _put_char('0');
 170                 _put_char('0');
 171             }
 172             _put_char('\0');
 173             return;
 174         }
 175         else
 176         {
 177             /* denormal number: value = (M - HIDDEN) * pow (2, - 149) */
 178             M &= ~HIDDEN;
 179             E2 = 1;
 180             while (M < HIDDEN)
 181             {
 182                  _mul2();
 183                  --E2;
 184             }
 185         }
 186     }
 187
 188     /* Now we have a normalized number with value = M * pow (2, E2 - 150)
 189      * where (1 << 23) <= M < (1 << 24) and -22 <= E2 < 255
 190      *
 191      * We adjust it to make M a base2 fixed point value with the implicit
 192      * decimal point at bit 28 (so bits 31:28 are the integer part and
 193      * bits 27:0 are the fractional part) and E2 is the unbiased base2
 194      * exponent.
 195      *
 196      * Then we convert it to M * pow (10, E10)
 197      */
 198     M <<= (28-23);      /* now MANT_UNIT <= M < 2 * MANT_UNIT */
 199     E2 -= EXCESS + 1;       /* now -149 <= E2 < 128 */
 200     E10 = 0;        /* base 10 exponent */
 201     while (E2 > 0)
 202     {
 203         if (M < 5 * MANT_UNIT)
 204         {
 205             _mul2();
 206         }
 207         else
 208         {
 209             _div5();
 210             ++E10;
 211         }
 212         --E2;
 213     }
 214     while (E2 < 0)
 215     {
 216         if (M < 2 * MANT_UNIT)
 217         {
 218             _mul5();
 219             --E10;
 220         }
 221         else
 222         {
 223             _div2();
 224         }
 225         ++E2;
 226     }
 227     while (M < MANT_UNIT)
 228     {
 229         _mul10();
 230         --E10;
 231     }
 232     /* Now we have a number with value = M * pow (10, E10)
 233      * where 1 <= M < 10 with fixed point after bit 28.
 234      */
 235     /* Format G: use format E10 if exp < -4 or exp >= prec; format F otherwise. */
 236     if ((prec & (PREC_E|PREC_F)) == 0)
 237     {
 238         if (E10 < -4 || E10 >= prec)
 239             prec |= PREC_E;
 240         else
 241             prec |= PREC_F;
 242     }
 243     /* Format E: [-]d.dddE+-dd rounded to 'prec' fractional digits (prec >= 0) */
 244     if (prec & PREC_E)
 245     {
 246         _round(prec & PREC_P);
 247         _put_digit();
 248         E2 = prec & PREC_P;
 249         if (E2 > 0)
 250         {
 251             _put_char('.');
 252             while (E2 > 0)
 253             {
 254                 _put_digit();
 255                 --E2;
 256             }
 257         }
 258         _put_char('E');
 259         if (E10 < 0)
 260         {
 261             _put_char('-');
 262             E10 = - E10;
 263         }
 264         else
 265         {
 266             _put_char('+');
 267         }
 268         _uitoa (E10, S, 10);
 269     }
 270     /* Format F: [-]ddd.ddd rounded to 'prec' fractional digits (prec >= 0) */
 271     else
 272     {
 273         _round(E10 + (prec & PREC_P));
 274         /* Print the integer part */
 275         if (E10 >= 0)
 276         {
 277             while (E10 >= 0)
 278             {
 279                 _put_digit();
 280                 --E10;
 281             }
 282         }
 283         else
 284         {
 285             _put_char('0');
 286         }
 287         E2 = prec & PREC_P;
 288         if (E2 > 0)
 289         {
 290             /* Print the fractional part */
 291             _put_char('.');
 292             while (E2 > 0)
 293             {
 294                 if (E10 < -1)
 295                 {
 296                     _put_char('0');
 297                     ++E10;
 298                 }
 299                 else
 300                 {
 301                     _put_digit();
 302                 }
 303                 --E2;
 304             }
 305         }
 306         _put_char('\0');
 307     }
 308 }