Retro68/gcc/newlib/libm/test/dcvt.c

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <float.h>
#include <ieeefp.h>
#include <stdlib.h>
#include <string.h>
#define _MAX_CHARS 512

static char *lcset = "0123456789abcdef";

static struct p {
	double pvalue, nvalue;
	int exp;
} powers[] = 
{ 
{ 1e32, 1e-32, 32},
{ 1e16, 1e-16, 16},
{ 1e8, 1e-8, 8},
{ 1e4, 1e-4, 4},
{ 1e2, 1e-2, 2},
{ 1e1, 1e-1, 1 },
{ 1e0, 1e-0, 0 }
};

#define _MAX_PREC 16

static char 
_DEFUN(nextdigit,(value),
double *value)
{
  double tmp;
  
  *value = modf (*value * 10, &tmp) ;
  return  lcset[(int)tmp];
}


static char *
_DEFUN(print_nan,(buffer, value, precision),
       char *buffer _AND
       double value _AND
       int precision)
{
  size_t  i;
  
  if (isnan(value))
    {
      strcpy(buffer, "nan");
      i = 3;
    
    }
  else 
    {
      strcpy(buffer, "infinity");
      i = 8;
    }

  while (i < precision) 
    {
      buffer[i++] = ' ';
    }
  buffer[i++] = 0;
  return buffer;
  
}

/* A convert info struct */
typedef struct 
{
  char *buffer ;		/* Destination of conversion */
  double value;			/* scratch Value to convert */
  double original_value;	/* saved Value to convert */
  int value_neg;		/* OUT: 1 if value initialiy neg */
  int abs_exp;			/* abs Decimal exponent of value */
  int abs_exp_sign;		/* + or - */
  int exp;			/* exp not sgned */
  int type;			/* fFeEgG used in printing before exp */

  int print_trailing_zeros;     /* Print 00's after a . */
  
  int null_idx;  /* Index of the null at the end */
  
/* These ones are read only */
  int decimal_places;		/* the number of digits to print after
				   the decimal */
  int max_digits;		/* total number of digits to print */
  int buffer_size;              /* Size of output buffer */
  
  /* Two sorts of dot ness.
     0  never ever print a dot
     1  print a dot if followed by a digit 
     2  always print a dot, even if no digit following
     */
  enum { dot_never, dot_sometimes, dot_always} dot; /* Print a decimal point, always */
  int dot_idx;			/* where the dot went, or would have gone */
} cvt_info_type;


void
_DEFUN(renormalize,(in),
       cvt_info_type *in)
{

  /* Make sure all numbers are less than 1 */

  while (in->value >= 1.0) 
  {
    in->value = in->value * 0.1;
    in->exp++;
  }

  /* Now we have only numbers between 0 and .9999.., and have adjusted
     exp to account for the shift */  

  if (in->exp >= 0)
  {
    in->abs_exp_sign = '+';
    in->abs_exp = in->exp;
  }
  else 
  {
    in->abs_exp_sign  = '-';
    in->abs_exp = -in->exp;
  }

}

/* This routine looks at original_value, and makes it between 0 and 1,
   modifying exp as it goes
 */

static void 
_DEFUN(normalize,(value, in),
       double value _AND
       cvt_info_type *in)
{
  int j;
  int texp;
  if (value != 0) 
  {
     texp = -1;

  
  if (value < 0.0) 
  {
    in->value_neg =1 ;
    value = - value;
  }
  else 
  {
    in->value_neg = 0;
  }

		
  /* Work out texponent & normalise value */

  /* If value > 1, then shrink it */
  if (value >= 1.0) 
  {
    for (j = 0; j < 6; j++) 
    {
      while (value >= powers[j].pvalue) 
      {
	value /= powers[j].pvalue;
	texp += powers[j].exp;
      }
    }
  }
  else if (value != 0.0) 
  {
    for (j = 0; j < 6; j++) 
    {
      while (value <= powers[j].nvalue) 
      {
	value *= powers[j].pvalue;
	texp -= powers[j].exp;
      }
    }
  }
   }
  
  else
  {
    texp = 0;
  }
  

  in->exp = texp;
  in->value = value;
  in->original_value = value;  
  renormalize(in);
  
}
int
_DEFUN(round,(in, start, now, ch),
       cvt_info_type *in _AND
       char *start _AND
       char *now _AND
       char ch)
{
  double rounder = 5.0;

  char *p;
  int ok = 0;

  now --;

  /* If the next digit to output would have been a '5' run back and */
  /* see if we can create a more rounded number. If we can then do it.
     If not (like when the number was 9.9 and the last char was
     another 9), then we'll have to modify the number and try again */
  if (ch < '5') 
   return 0;
  

  for (p = now;!ok && p >= start; p--) 
  {
    switch (*p) 
    {
    default:
      abort();
    case '.':
      break;
    case '9':
      rounder = rounder * 0.1;
      break;
    case '8':
    case '7':
    case '6':
    case '5':
    case '4':
    case '3':
    case '2':
    case '1':
    case '0':
      p = now;
      while (1) {
	  if (*p == '9') {
	      *p = '0';
	    }
	  else if (*p != '.') {
	      (*p)++;
	      return 0;
	    }
	  p--;
	}
    }

  }

  /* Getting here means that we couldn't round the number in place
     textually - there have been all nines.
     We'll have to add to it and try the conversion again
     eg
     .99999[9] can't be rounded in place, so add 
     .000005   to it giving:
     1.000004   we notice that the result is > 1 so add to exp and
     divide by 10
     .100004
     */

  in->original_value = in->value = in->original_value + rounder;
  normalize(in->original_value , in);
  return 1; 

  
}



void
_DEFUN(_cvte,(in),
       register  cvt_info_type *in)
{
  int buffer_idx  =0;
  int digit = 0;
  
  int after_decimal =0;

  in->buffer[buffer_idx++] = nextdigit(&(in->value));
  digit++;
  in->dot_idx = buffer_idx;

  
  switch (in->dot) 
  {
  case dot_never:
    break;
  case dot_sometimes:
    if (in->decimal_places 
	&& digit < in->max_digits) 
    {
      in->buffer[buffer_idx++] = '.';
    }
    break;
  case dot_always: 
    in->buffer[buffer_idx++] = '.';    
  }

  
  while (buffer_idx < in->buffer_size
	 && after_decimal < in->decimal_places
	 && digit < in->max_digits)
  {
    in->buffer[buffer_idx] = nextdigit(&(in->value));
    after_decimal++;
    buffer_idx++;
    digit++;
    
  }

  if (round(in,
	    in->buffer,
	    in->buffer+buffer_idx,
	    nextdigit(&(in->value)))) 
  {
    _cvte(in);
  }
  else 
  {
    in->buffer[buffer_idx++] = in->type;			
    in->buffer[buffer_idx++] = in->abs_exp_sign;

    if (in->abs_exp >= 100) 
    {
      in->buffer[buffer_idx++] = lcset[in->abs_exp / 100];
      in->abs_exp %= 100;
    }
    in->buffer[buffer_idx++] = lcset[in->abs_exp / 10];
    in->buffer[buffer_idx++] = lcset[in->abs_exp % 10];
  }
  
  in->buffer[buffer_idx++] = 0;
}




/* Produce NNNN.FFFF */
void
_DEFUN(_cvtf,(in),
       cvt_info_type *in)
{
  
  int buffer_idx = 0;		/* Current char being output */
  int after_decimal = 0;
  int digit =0;

  
  in->dot_idx = in->exp + 1;
  
  /* Two sorts of number, NNN.FFF and 0.0000...FFFF */


  /* Print all the digits up to the decimal point */
  
  while (buffer_idx <= in->exp
	 && digit < in->max_digits
	 && buffer_idx < in->buffer_size)
  {
    in->buffer[buffer_idx]  = nextdigit(&(in->value));
    buffer_idx++;
    digit ++;
  }


  /* And the decimal point if we should */
  if (buffer_idx < in->buffer_size) 
  {
    
    switch (in->dot) 
    {
    case dot_never:
      break;
    case dot_sometimes:
      /* Only print a dot if following chars */
      if (in->decimal_places
	  && digit < in->max_digits )
      {
       in->buffer[buffer_idx++] = '.';     
     }
      
      break;
    case dot_always:
      in->buffer[buffer_idx++] = '.';
    }
  
    after_decimal = 0;

    /* And the digits following the point if necessary */

    /* Only print the leading zeros if a dot was possible */
    if (in->dot || in->exp>0) 
    {
     while (buffer_idx < in->buffer_size
	    && (in->abs_exp_sign == '-' && digit < in->abs_exp - 1)
	    && (after_decimal < in->decimal_places)
	    && (digit < in->max_digits))
     {
       in->buffer[buffer_idx] = '0';
       buffer_idx++;
       digit++;
       after_decimal++;
     }
   }
    
    while (buffer_idx < in->buffer_size
	   && after_decimal < in->decimal_places
	   && digit < in->max_digits)
    {
      in->buffer[buffer_idx]  = nextdigit(&(in->value));
      buffer_idx++;
      digit++;
      after_decimal++;
    }
  }

  in->null_idx = buffer_idx;  
  in->buffer[buffer_idx] = 0;
  if (round(in, in->buffer, in->buffer+buffer_idx,
	    nextdigit(&(in->value)))) 
  {
      _cvtf(in);
  }
  


  
}



char *
_DEFUN(_dcvt,(buffer, invalue, precision, width, type, dot),
       char *buffer _AND
       double invalue _AND
       int precision _AND
       int width _AND
       char type _AND
       int dot)
{
  cvt_info_type in;



  in.buffer = buffer;
  in.buffer_size = 512;

  if (!finite(invalue))
  {
    return print_nan(buffer, invalue, precision);
  }    


  normalize(invalue, &in);
    
  in.type = type;
  in.dot = dot? dot_always: dot_sometimes;

  switch (type)
  {
  
  case 'g':
  case 'G':
    /* When formatting a g, the precision refers to the number of
       char positions *total*, this leads to various off by ones */	
  {
    /* A precision of 0 means 1 */
    if (precision == 0)
     precision = 1;
      
    /* A g turns into an e if there are more digits than the
       precision, or it's smaller than e-4 */
    if (in.exp >= precision || in.exp < -4) 
    {
      in.type = (type == 'g' ? 'e' : 'E');
      in.decimal_places = _MAX_CHARS;
      in.max_digits = precision;
      in.print_trailing_zeros = 1;
      _cvte(&in);
    }
    else 
    {
      /* G means total number of chars to print */
      in.decimal_places = _MAX_CHARS;
      in.max_digits = precision;
      in.type = (type == 'g' ? 'f' : 'F');
      in.print_trailing_zeros = 0;
      _cvtf(&in);

   if (!dot) {
       /* trim trailing zeros */
       int j = in.null_idx -1;
       while (j > 0 && in.buffer[j] == '0') 
       {
	 in.buffer[j] = 0;
	 j--;
       }
       /* Stamp on a . if not followed by zeros */
       if (j > 0 && buffer[j] == '.')
	in.buffer[j] = 0;
     }
    }
    
      
    break;
  case 'f':
  case 'F':
    in.decimal_places= precision;
    in.max_digits = _MAX_CHARS;
      in.print_trailing_zeros = 1;    
    _cvtf(&in);
    break;
  case 'e':
  case 'E':
      in.print_trailing_zeros = 1;
    in.decimal_places = precision;
    in.max_digits = _MAX_CHARS;
    _cvte(&in);
    break;
  }

  }


  return buffer;
}




char *
_DEFUN(fcvtbuf,(invalue,ndigit,decpt,sign, fcvt_buf),
       double invalue _AND 
       int ndigit _AND
       int *decpt _AND
       int *sign _AND
       char *fcvt_buf)
{
  cvt_info_type in;
  in.buffer = fcvt_buf;
  in.buffer_size = 512;
    
  if (!finite(invalue))
    {
      return print_nan(fcvt_buf, invalue, ndigit);
    }    

  normalize(invalue, &in);

  in.dot = dot_never;			/* Don't print a decimal point */
  in.max_digits = _MAX_CHARS;
  in.buffer_size = _MAX_CHARS;		/* Take as many as needed */
  in.decimal_places = ndigit;
  _cvtf(&in);
  *decpt = in.dot_idx;
  *sign = in.value_neg;
  return in.buffer;
}


char *
_DEFUN(ecvtbuf,(invalue,ndigit,decpt,sign, fcvt_buf),
       double invalue _AND 
       int ndigit _AND
       int *decpt _AND
       int *sign _AND
       char *fcvt_buf)
{
  cvt_info_type in;
  in.buffer = fcvt_buf;
    
  if (!finite(invalue))
    {
      return print_nan(fcvt_buf, invalue, ndigit);
    }    

  normalize(invalue, &in);


  in.dot = dot_never;			/* Don't print a decimal point */
/* We can work out how many digits go after the decimal point */

  in.buffer_size =_MAX_CHARS;
  in.decimal_places = _MAX_CHARS;
  in.max_digits = ndigit;		/* Take as many as told */
  _cvtf(&in);
  *decpt = in.dot_idx;
  *sign = in.value_neg;
  return in.buffer;
}



char *
_DEFUN(gcvt,(d,ndigit,buf),
   double d _AND
   int ndigit _AND
   char *buf)
{
  return _dcvt(buf, d, ndigit, 0, 'g', 1);
}