Subversion Repositories Kolibri OS

/*

FUNCTION

<>, <>---double or float to string

INDEX

	ecvtbuf

INDEX

	fcvtbuf

ANSI_SYNOPSIS

	#include 

	char *ecvtbuf(double <[val]>, int <[chars]>, int *<[decpt]>,

                       int *<[sgn]>, char *<[buf]>);

	char *fcvtbuf(double <[val]>, int <[decimals]>, int *<[decpt]>,

                       int *<[sgn]>, char *<[buf]>);

TRAD_SYNOPSIS

	#include 

	char *ecvtbuf(<[val]>, <[chars]>, <[decpt]>, <[sgn]>, <[buf]>);

	double <[val]>;

	int <[chars]>;

	int *<[decpt]>;

	int *<[sgn]>;

	char *<[buf]>;

	char *fcvtbuf(<[val]>, <[decimals]>, <[decpt]>, <[sgn]>, <[buf]>);

	double <[val]>;

	int <[decimals]>;

	int *<[decpt]>;

	int *<[sgn]>;

	char *<[buf]>;

DESCRIPTION

	<> and <> produce (null-terminated) strings

	of digits representating the <> number <[val]>.

	The only difference between <> and <> is the

	interpretation of the second argument (<[chars]> or

	<[decimals]>). For <>, the second argument <[chars]>

	specifies the total number of characters to write (which is

	also the number of significant digits in the formatted string,

	since these two functions write only digits). For <>,

	the second argument <[decimals]> specifies the number of

	characters to write after the decimal point; all digits for

	the integer part of <[val]> are always included.

	Since <> and <> write only digits in the

	output string, they record the location of the decimal point

	in <<*<[decpt]>>>, and the sign of the number in <<*<[sgn]>>>.

	After formatting a number, <<*<[decpt]>>> contains the number

	of digits to the left of the decimal point.  <<*<[sgn]>>>

	contains <<0>> if the number is positive, and <<1>> if it is

	negative.  For both functions, you supply a pointer <[buf]> to

	an area of memory to hold the converted string.

RETURNS

	Both functions return a pointer to <[buf]>, the string

	containing a character representation of <[val]>.

PORTABILITY

	Neither function is ANSI C.

Supporting OS subroutines required: <>, <>, <>,

<>, <>, <>, <>.

*/

#include <_ansi.h>

#include 

#include 

#include 

#include "mprec.h"

#include "local.h"

static void

_DEFUN (print_f, (ptr, buf, invalue, ndigit, type, dot, mode),

	struct _reent *ptr _AND

	char *buf _AND

	double invalue _AND

	int ndigit _AND

	char type _AND

	int dot _AND

	int mode)

{

  int decpt;

  int sign;

  char *p, *start, *end;

  start = p = _dtoa_r (ptr, invalue, mode, ndigit, &decpt, &sign, &end);

  if (decpt == 9999)

    {

      strcpy (buf, p);

      return;

    }

  while (*p && decpt > 0)

    {

      *buf++ = *p++;

      decpt--;

    }

  /* Even if not in buffer */

  while (decpt > 0)

    {

      *buf++ = '0';

      decpt--;

    }

  if (dot || *p)

    {

      if (p == start)

	*buf++ = '0';

      *buf++ = '.';

      while (decpt < 0 && ndigit > 0)

	{

	  *buf++ = '0';

	  decpt++;

	  ndigit--;

	}

      /* Print rest of stuff */

      while (*p && ndigit > 0)

	{

	  *buf++ = *p++;

	  ndigit--;

	}

      /* And trailing zeros */

      while (ndigit > 0)

	{

	  *buf++ = '0';

	  ndigit--;

	}

    }

  *buf++ = 0;

}

/* Print number in e format with width chars after.

   TYPE is one of 'e' or 'E'.  It may also be one of 'g' or 'G' indicating

   that _gcvt is calling us and we should remove trailing zeroes.

   WIDTH is the number of digits of precision after the decimal point.  */

static void

_DEFUN (print_e, (ptr, buf, invalue, width, type, dot),

	struct _reent *ptr _AND

	char *buf _AND

	double invalue _AND

	int width _AND

	char type _AND

	int dot)

{

  int sign;

  char *end;

  char *p;

  int decpt;

  int top;

  int ndigit = width;

  p = _dtoa_r (ptr, invalue, 2, width + 1, &decpt, &sign, &end);

  if (decpt == 9999)

    {

      strcpy (buf, p);

      return;

    }

  *buf++ = *p++;

  if (dot || ndigit != 0)

    *buf++ = '.';

  while (*p && ndigit > 0)

    {

      *buf++ = *p++;

      ndigit--;

    }

  /* Add trailing zeroes to fill out to ndigits unless this is 'g' format.

     Also, convert g/G to e/E.  */

  if (type == 'g')

    type = 'e';

  else if (type == 'G')

    type = 'E';

  else

    {

      while (ndigit > 0)

	{

	  *buf++ = '0';

	  ndigit--;

	}

    }

  /* Add the exponent.  */

  *buf++ = type;

  decpt--;

  if (decpt < 0)

    {

      *buf++ = '-';

      decpt = -decpt;

    }

  else

    {

      *buf++ = '+';

    }

  if (decpt > 99)

    {

      int top = decpt / 100;

      *buf++ = top + '0';

      decpt -= top * 100;

    }

  top = decpt / 10;

  *buf++ = top + '0';

  decpt -= top * 10;

  *buf++ = decpt + '0';

  *buf++ = 0;

}

#ifndef _REENT_ONLY

/* Undocumented behaviour: when given NULL as a buffer, return a

   pointer to static space in the rent structure.  This is only to

   support ecvt and fcvt, which aren't ANSI anyway.  */

char *

_DEFUN (fcvtbuf, (invalue, ndigit, decpt, sign, fcvt_buf),

	double invalue _AND

	int ndigit _AND

	int *decpt _AND

	int *sign _AND

	char *fcvt_buf)

{

  struct _reent *reent = _REENT;

  char *save;

  char *p;

  char *end;

  int done = 0;

  if (fcvt_buf == NULL)

    {

      if (reent->_cvtlen <= ndigit + 35)

	{

	  if ((fcvt_buf = (char *) _realloc_r (reent, reent->_cvtbuf,

					       ndigit + 36)) == NULL)

	    return NULL;

	  reent->_cvtlen = ndigit + 36;

	  reent->_cvtbuf = fcvt_buf;

	}

      fcvt_buf = reent->_cvtbuf ;

    }

  save = fcvt_buf;

  if (invalue < 1.0 && invalue > -1.0)

    {

      p = _dtoa_r (reent, invalue, 2, ndigit, decpt, sign, &end);

    }

  else

    {

      p = _dtoa_r (reent, invalue, 3, ndigit, decpt, sign, &end);

    }

  /* Now copy */

  done = -*decpt;

  while (p < end)

    {

      *fcvt_buf++ = *p++;

      done++;

    }

  /* And unsuppress the trailing zeroes */

  while (done < ndigit)

    {

      *fcvt_buf++ = '0';

      done++;

    }

  *fcvt_buf++ = 0;

  return save;

}

char *

_DEFUN (ecvtbuf, (invalue, ndigit, decpt, sign, fcvt_buf),

	double invalue _AND

	int ndigit _AND

	int *decpt _AND

	int *sign _AND

	char *fcvt_buf)

{

  struct _reent *reent = _REENT;

  char *save;

  char *p;

  char *end;

  int done = 0;

  if (fcvt_buf == NULL)

    {

      if (reent->_cvtlen <= ndigit)

	{

	  if ((fcvt_buf = (char *) _realloc_r (reent, reent->_cvtbuf,

					       ndigit + 1)) == NULL)

	    return NULL;

	  reent->_cvtlen = ndigit + 1;

	  reent->_cvtbuf = fcvt_buf;

	}

      fcvt_buf = reent->_cvtbuf ;

    }

  save = fcvt_buf;

  p = _dtoa_r (reent, invalue, 2, ndigit, decpt, sign, &end);

  /* Now copy */

  while (p < end)

    {

      *fcvt_buf++ = *p++;

      done++;

    }

  /* And unsuppress the trailing zeroes */

  while (done < ndigit)

    {

      *fcvt_buf++ = '0';

      done++;

    }

  *fcvt_buf++ = 0;

  return save;

}

#endif

char *

_DEFUN (_gcvt, (ptr, invalue, ndigit, buf, type, dot),

	struct _reent *ptr _AND

	double invalue _AND

	int ndigit _AND

	char *buf _AND

	char type _AND

	int dot)

{

  char *save = buf;

  if (invalue < 0)

    {

      invalue = -invalue;

    }

  if (invalue == 0)

    {

      *buf++ = '0';

      *buf = '\0';

    }

  else

    /* Which one to print ?

       ANSI says that anything with more that 4 zeros after the . or more

       than precision digits before is printed in e with the qualification

       that trailing zeroes are removed from the fraction portion.  */

  if (0.0001 >= invalue || invalue >= _mprec_log10 (ndigit))

    {

      /* We subtract 1 from ndigit because in the 'e' format the precision is

	 the number of digits after the . but in 'g' format it is the number

	 of significant digits.

	 We defer changing type to e/E so that print_e() can know it's us

	 calling and thus should remove trailing zeroes.  */

      print_e (ptr, buf, invalue, ndigit - 1, type, dot);

    }

  else

    {

      int decpt;

      int sign;

      char *end;

      char *p;

      if (invalue < 1.0)

	{

	  /* what we want is ndigits after the point */

	  p = _dtoa_r (ptr, invalue, 3, ndigit, &decpt, &sign, &end);

	}

      else

	{

	  p = _dtoa_r (ptr, invalue, 2, ndigit, &decpt, &sign, &end);

	}

      if (decpt == 9999)

	{

	  strcpy (buf, p);

	  return save;

	}

      while (*p && decpt > 0)

	{

	  *buf++ = *p++;

	  decpt--;

	  ndigit--;

	}

      /* Even if not in buffer */

      while (decpt > 0 && ndigit > 0)

	{

	  *buf++ = '0';

	  decpt--;

	  ndigit--;

	}

      if (dot || *p)

	{

	  if (buf == save)

	    *buf++ = '0';

	  *buf++ = '.';

	  while (decpt < 0 && ndigit > 0)

	    {

	      *buf++ = '0';

	      decpt++;

	      ndigit--;

	    }

	  /* Print rest of stuff */

	  while (*p && ndigit > 0)

	    {

	      *buf++ = *p++;

	      ndigit--;

	    }

	  /* And trailing zeros */

	  if (dot)

	    {

	      while (ndigit > 0)

		{

		  *buf++ = '0';

		  ndigit--;

		}

	    }

	}

      *buf++ = 0;

    }

  return save;

}

char *

_DEFUN (_dcvt, (ptr, buffer, invalue, precision, width, type, dot),

	struct _reent *ptr _AND

	char *buffer _AND

	double invalue _AND

	int precision _AND

	int width _AND

	char type _AND

	int dot)

{

  switch (type)

    {

    case 'f':

    case 'F':

      print_f (ptr, buffer, invalue, precision, type, precision == 0 ? dot : 1, 3);

      break;

    case 'g':

    case 'G':

      if (precision == 0)

	precision = 1;

      _gcvt (ptr, invalue, precision, buffer, type, dot);

      break;

    case 'e':

    case 'E':

      print_e (ptr, buffer, invalue, precision, type, dot);

    }

  return buffer;

}