ftoa_slow.c

从iccavr7中破解得到的lib库源代码

/* Adapted by Richard F. Man, ImageCraft
 *
 * fcvt() to support printf
 *
 */

// check
// EFG_convert_B.c for original

/* Routines to convert single-precision floating-point values           */
/* in support of printf()                                               */
/* Orginally prepared                    2/ 4/00        E.M.Greene      */
/* Most recent update                    2/ 9/00        E.M.Greene      */

#include <ctype.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#ifndef __SASC
#define OVERFLOW        TRUE
#endif
#define scale_23        (0x800000)              /* = pow(2.0, 23.0)     */

typedef
  struct {
    signed char	mantissa_sign,
		scale_bin;
    char	mantissa_BCD[10],
		exponent_sign,
		scale_BCD[2];}		EFG_data_t;

typedef union {
	float f;
    long i;
} FI_union_t;

static void round_to_n_places(unsigned char *vp, int places, unsigned char *scale)
{
  unsigned char	*sp;

  sp = vp + places;
  *sp += 5;
  for (;;) {
    if ((sp < vp) || (*sp <= 9))
      break;
    *sp -= 10;
    if (sp > vp)
      (*--sp)++;
    else {
	  *vp = 1;
	  (*scale)++;
	}
  }
}

#ifdef __SASC
float my_modf(float y, float *i)
{
  int	n;

  n = y;
  if (i)
    *i = n;
  return (float)(y - n);
}
#endif

static void SP_EFG_convert(long z, EFG_data_t *dp)
{
  char          *sp;
  int           n;
  /* double */ float       mantissa,
                int_digit,
                e10f,
                e10;

  memset(dp, 0, sizeof(EFG_data_t));
  if (z != 0) {
    mantissa = ((double)((z & 0xFFFFFFl) | 0x800000l)) / scale_23;
	/* rfm unused
    if (z < 0)
      dp->mantissa_sign = '-';
	 */
    dp->scale_bin = ((z >> 23) & 0xFF) - 127;
#define LOG10_of_2	0.301030		/* rfm, precompute */
										/* log10(2.0) */
    e10 = dp->scale_bin * LOG10_of_2;
    dp->scale_bin = e10;
    e10f = e10 - dp->scale_bin;
    mantissa *= pow(10.0, e10f);
    if (mantissa >= 10.0) {
      mantissa /= 10;
      dp->scale_bin++;
    }
    else if (mantissa < 1.0) {
      mantissa *= 10;
      dp->scale_bin--;
    }
    sp = dp->mantissa_BCD;
    n = 8;
    do {
#ifdef __SASC
      mantissa = my_modf(mantissa, &int_digit);
#else
      mantissa = modf(mantissa, &int_digit);
#endif
      *sp++ = int_digit;
      mantissa *= 10.0;
    } while (n--);

/* rfm unused
    if ((n = dp->scale_bin) < 0) {
      n = -n;
      dp->exponent_sign = '-';
    }
    dp->scale_BCD[0] = n / 10;
    dp->scale_BCD[1] = n % 10;
*/
  }
}

unsigned char *_fcvt(float v, int ndigits, int *dec_scale, int *sign)
{
  int           i, n;
  FI_union_t    x;
  EFG_data_t    d;
  static unsigned char   sp[8+2];

  memset(sp, '\0', sizeof(sp));
  x.f = v;
  SP_EFG_convert(x.i, &d);
  memcpy(sp, d.mantissa_BCD, 8);
  if (ndigits) {
    n = ndigits + d.scale_bin+1;
    if (0 <= n && n <= 7)
      round_to_n_places(sp, n+1, (unsigned char *)(&d.scale_bin));
    else
      n = 7;
  }
  else
    n = 7;

  /* find the rightmost nonzeroes */
  for (; 0 <= n && sp[n] == 0; --n)
	;
  for (i = 0; i <= n; i++)
    sp[i] += '0';
  sp[n+1] = 0;

  *dec_scale = d.scale_bin + 1;
  *sign = (x.i < 0);    /* what ^%&$&( purpose is served by this????    */
  return sp;
}

char *ftoa(float f, int *status)
{
  int	scale, sign;
  char	*s, *buf;
  static char sbuf[25];	/* buf should be at least 8+3=11 bytes long...	*/

  *status = 0;
  if (f == 0.0) {
    sbuf[0] = '0'; sbuf[1] = '.'; sbuf[2] = '0'; sbuf[3] = 0;
    return sbuf;
  }
  buf = sbuf;
  s = _fcvt(f, 0, &scale, &sign);
  if (sign)
    *buf++ = '-';
  if (scale <= 0) {
    *buf++ = '0';
    *buf++ = '.';
    while (scale) {
      *buf++ = '0';
      scale++;
    }
  }
  else {
    while (scale) {
      if (*s)
        *buf++ = *s++;
      else
        *buf++ = '0';
      scale--;
    }
    *buf++ = '.';
  }
  while (*s)
    *buf++ = *s++;
  *buf = 0;
  return sbuf;
}

#ifdef test
void main()
{
  int	stat;
  char	*s;
  float	val = 0.12345678;

  s = ftoa(val, &stat);
  printf("%.9f = %s\n", val, s);
}
#endif