~drizzle-trunk/drizzle/development

 

 ***************************************************************/

 

#include <m_string.h>  /* for memcpy and NOT_FIXED_DEC */

 

/**

                      (including the terminating '\0').

   @param error       if not NULL, points to a location where the status of

                      conversion is stored upon return.

                             The output string in this case is always '0'.

   @return            number of written characters (excluding terminating '\0')

*/

 

{

  int decpt, sign, len, i;

  char *res, *src, *end, *dst= to;

  char buf[DTOA_BUFF_SIZE];

  

  res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));

 

    *to++= '0';

    *to= '\0';

    if (error != NULL)

    return 1;

  }

 

    if (len <= decpt)

      *dst++= '.';

    

      *dst++= '0';

  }

  

  *dst= '\0';

  if (error != NULL)

 

  dtoa_free(res, buf, sizeof(buf));

 

                      'width + 1' bytes.

   @param error       if not NULL, points to a location where the status of

                      conversion is stored upon return.

                             The output string in this case is always '0'.

   @return            number of written characters (excluding terminating '\0')

 

*/

 

size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,

{

  int decpt, sign, len, exp_len;

  char *res, *src, *end, *dst= to, *dend= dst + width;

  char buf[DTOA_BUFF_SIZE];

  

  /* We want to remove '-' from equations early */

  if (x < 0.)

    width--;

 

            &decpt, &sign, &end, buf, sizeof(buf));

  if (decpt == DTOA_OVERFLOW)

  {

    *to++= '0';

    *to= '\0';

    if (error != NULL)

    return 1;

  }

 

  if (error != NULL)

 

  src= res;

  len= end - res;

      if (width < decpt)

      {

        if (error != NULL)

        width= decpt;

      }

      

    {

      /* Overflow */

      if (error != NULL)

      width= 0;

    }

      

{

  char buf[DTOA_BUFF_SIZE];

  double res;

 

  res= my_strtod_int(str, end, error, buf, sizeof(buf));

  return (*error == 0) ? res : (res < 0 ? -DBL_MAX : DBL_MAX);

  file.

*/

 

 

typedef union { double d; ULong L[2]; } U;

 

#endif

#endif /*Flt_Rounds*/

 

#define rounded_product(a,b) a*= b

#define rounded_quotient(a,b) a/= b

 

 

#define Kmax 15

 

                          2*sizeof(int) + y->wds*sizeof(ULong))

 

/* Arbitrary-length integer */

  double aadj, aadj1, adj, rv, rv0;

  Long L;

  ULong y, z;

#ifdef SET_INEXACT

  int inexact, oldinexact;

#endif

  Stack_alloc alloc;

 

  *error= 0;

 

  alloc.begin= alloc.free= buf;

  }

  bd0= 0;

  if (nd <= DBL_DIG

      )

  {

    if (!e)

    {

      if (e <= Ten_pmax)

      {

        /* rv = */ rounded_product(dval(rv), tens[e]);

        goto ret;

      }

          A fancier test would sometimes let us do

          this for larger i values.

        */

        e-= i;

        dval(rv)*= tens[i];

        /* rv = */ rounded_product(dval(rv), tens[e]);

#ifndef Inaccurate_Divide

    else if (e >= -Ten_pmax)

    {

      /* rv = */ rounded_quotient(dval(rv), tens[-e]);

      goto ret;

    }

    oldinexact= get_inexact();

#endif

  scale= 0;

 

  /* Get starting approximation = rv * 10**e1 */

 

 ovfl:

        *error= EOVERFLOW;

        /* Can't trust HUGE_VAL */

        word0(rv)= Exp_mask;

        word1(rv)= 0;

#ifdef SET_INEXACT

        /* set overflow bit */

        dval(rv0)= 1e300;

    else

      bd2-= bbe;

    bs2= bb2;

    j= bbe - scale;

    i= j + bbbits - 1;  /* logb(rv) */

    if (i < Emin)  /* denormal */

    dsign= delta->sign;

    delta->sign= 0;

    i= cmp(delta, bs);

 

    if (i < 0)

    {

    {

      aadj*= 0.5;

      aadj1= dsign ? aadj : -aadj;

      if (Flt_Rounds == 0)

        aadj1+= 0.5;

    }

    y= word0(rv) & Exp_mask;

 

          1 ==> like 0, but with Steele & White stopping rule;

                e.g. with IEEE P754 arithmetic , mode 0 gives

                1e23 whereas mode 1 gives 9.999999999999999e22.

                return value similar to that of ecvt, except

                that trailing zeros are suppressed.

          3 ==> through ndigits past the decimal point.  This

          4,5 ==> similar to 2 and 3, respectively, but (in

                round-nearest mode) with the tests of mode 0 to

                possibly return a shorter string that rounds to d.

          6-9 ==> Debugging modes similar to mode - 4:  don't try

                fast floating-point estimate (if applicable).

 

    to hold the suppressed trailing zeros.

  */

 

    j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,

    spec_case, try_quick;

  Long L;

  int denorm;

  ULong x;

  double d2, ds, eps;

  char *s, *s0;

  Stack_alloc alloc;

  

  alloc.begin= alloc.free= buf;

    return res;

  }

  

 

  b= d2b(dval(d), &be, &bbits, &alloc);

  if ((i= (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))))

  if (mode < 0 || mode > 9)

    mode= 0;

 

  try_quick= 1;

 

  if (mode > 5)

  {

  }

  s= s0= dtoa_alloc(i, &alloc);

 

  if (ilim >= 0 && ilim <= Quick_max && try_quick)

  {

    /* Try to get by with floating-point arithmetic. */

    {

      L= (Long)(dval(d) / ds);

      dval(d)-= L*ds;

      *s++= '0' + (int)L;

      if (!dval(d))

      {