~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/*

=======================================================================

  NOTE: this library implements SQL standard "exact numeric" type

  and is not at all generic, but rather intentinally crippled to

  follow the standard :)

=======================================================================

  Quoting the standard

  (SQL:2003, Part 2 Foundations, aka ISO/IEC 9075-2:2003)

4.4.2 Characteristics of numbers, page 27:

  An exact numeric type has a precision P and a scale S. P is a positive

  integer that determines the number of significant digits in a

  particular radix R, where R is either 2 or 10. S is a non-negative

  integer. Every value of an exact numeric type of scale S is of the

  form n*10^{-S}, where n is an integer such that ­-R^P <= n <= R^P.

  [...]

  If an assignment of some number would result in a loss of its most

  significant digit, an exception condition is raised. If least

  significant digits are lost, implementation-defined rounding or

  truncating occurs, with no exception condition being raised.

  [...]

  Whenever an exact or approximate numeric value is assigned to an exact

  numeric value site, an approximation of its value that preserves

  leading significant digits after rounding or truncating is represented

  in the declared type of the target. The value is converted to have the

  precision and scale of the target. The choice of whether to truncate

  or round is implementation-defined.

  [...]

  All numeric values between the smallest and the largest value,

  inclusive, in a given exact numeric type have an approximation

  obtained by rounding or truncation for that type; it is

  implementation-defined which other numeric values have such

  approximations.

5.3 <literal>, page 143

  <exact numeric literal> ::=

    <unsigned integer> [ <period> [ <unsigned integer> ] ]

  | <period> <unsigned integer>

6.1 <data type>, page 165:

  19) The <scale> of an <exact numeric type> shall not be greater than

      the <precision> of the <exact numeric type>.

  20) For the <exact numeric type>s DECIMAL and NUMERIC:

    a) The maximum value of <precision> is implementation-defined.

       <precision> shall not be greater than this value.

    b) The maximum value of <scale> is implementation-defined. <scale>

       shall not be greater than this maximum value.

  21) NUMERIC specifies the data type exact numeric, with the decimal

      precision and scale specified by the <precision> and <scale>.

  22) DECIMAL specifies the data type exact numeric, with the decimal

      scale specified by the <scale> and the implementation-defined

      decimal precision equal to or greater than the value of the

      specified <precision>.

6.26 <numeric value expression>, page 241:

  1) If the declared type of both operands of a dyadic arithmetic

     operator is exact numeric, then the declared type of the result is

     an implementation-defined exact numeric type, with precision and

     scale determined as follows:

   a) Let S1 and S2 be the scale of the first and second operands

      respectively.

   b) The precision of the result of addition and subtraction is

      implementation-defined, and the scale is the maximum of S1 and S2.

   c) The precision of the result of multiplication is

      implementation-defined, and the scale is S1 + S2.

   d) The precision and scale of the result of division are

      implementation-defined.

*/

#include "config.h"

#include "drizzled/definitions.h"

#include "drizzled/internal/m_string.h"

#include "drizzled/charset_info.h"

#include "drizzled/decimal.h"

#include <plugin/myisam/myisampack.h>

#include <drizzled/util/test.h>

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#include <algorithm>

using namespace std;

/*

  Internally decimal numbers are stored base 10^9 (see DIG_BASE below)

  So one variable of type decimal_digit_t is limited:

      0 < decimal_digit <= DIG_MAX < DIG_BASE

  in the struct st_decimal_t:

    intg is the number of *decimal* digits (NOT number of decimal_digit_t's !)

         before the point

    frac - number of decimal digits after the point

    buf is an array of decimal_digit_t's

    len is the length of buf (length of allocated space) in decimal_digit_t's,

        not in bytes

*/

typedef decimal_digit_t dec1;

typedef int64_t      dec2;

#define DIG_PER_DEC1 9

#define DIG_MASK     100000000

#define DIG_BASE     1000000000

#define DIG_MAX      (DIG_BASE-1)

#define ROUND_UP(X)  (((X)+DIG_PER_DEC1-1)/DIG_PER_DEC1)

static const dec1 powers10[DIG_PER_DEC1+1]={

  1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

static const int dig2bytes[DIG_PER_DEC1+1]={0, 1, 1, 2, 2, 3, 3, 4, 4, 4};

static const dec1 frac_max[DIG_PER_DEC1-1]={

  900000000, 990000000, 999000000,

  999900000, 999990000, 999999000,

  999999900, 999999990 };

#ifdef HAVE_purify

#define sanity(d) assert((d)->len > 0)

#else

#define sanity(d) assert((d)->len >0 && ((d)->buf[0] | \

                              (d)->buf[(d)->len-1] | 1))

#endif

#define FIX_INTG_FRAC_ERROR(len, intg1, frac1, error)                   \

        do                                                              \

        {                                                               \

          if (unlikely(intg1+frac1 > (len)))                            \

          {                                                             \

            if (unlikely(intg1 > (len)))                                \

            {                                                           \

              intg1=(len);                                              \

              frac1=0;                                                  \

              error=E_DEC_OVERFLOW;                                     \

            }                                                           \

            else                                                        \

            {                                                           \

              frac1=(len)-intg1;                                        \

              error=E_DEC_TRUNCATED;                                    \

            }                                                           \

          }                                                             \

          else                                                          \

            error=E_DEC_OK;                                             \

        } while(0)

#define ADD(to, from1, from2, carry)  /* assume carry <= 1 */           \

        do                                                              \

        {                                                               \

          dec1 a=(from1)+(from2)+(carry);                               \

          assert((carry) <= 1);                                    \

          if (((carry)= a >= DIG_BASE)) /* no division here! */         \

            a-=DIG_BASE;                                                \

          (to)=a;                                                       \

        } while(0)

#define ADD2(to, from1, from2, carry)                                   \

        do                                                              \

        {                                                               \

          dec2 a=((dec2)(from1))+(from2)+(carry);                       \

          if (((carry)= a >= DIG_BASE))                                 \

            a-=DIG_BASE;                                                \

          if (unlikely(a >= DIG_BASE))                                  \

          {                                                             \

            a-=DIG_BASE;                                                \

            carry++;                                                    \

          }                                                             \

          (to)=(dec1) a;                                                \

        } while(0)

#define SUB(to, from1, from2, carry) /* to=from1-from2 */               \

        do                                                              \

        {                                                               \

          dec1 a=(from1)-(from2)-(carry);                               \

          if (((carry)= a < 0))                                         \

            a+=DIG_BASE;                                                \

          (to)=a;                                                       \

        } while(0)

#define SUB2(to, from1, from2, carry) /* to=from1-from2 */              \

        do                                                              \

        {                                                               \

          dec1 a=(from1)-(from2)-(carry);                               \

          if (((carry)= a < 0))                                         \

            a+=DIG_BASE;                                                \

          if (unlikely(a < 0))                                          \

          {                                                             \

            a+=DIG_BASE;                                                \

            carry++;                                                    \

          }                                                             \

          (to)=a;                                                       \

        } while(0)

/**

  Swap the contents of two variables.

 */

#define swap_variables(TYPE, a, b) \

  do {                             \

    TYPE dummy;                    \

    dummy= a;                      \

    a= b;                          \

    b= dummy;                      \

  } while (0)

/*

  Get maximum value for given precision and scale

  SYNOPSIS

    max_decimal()

    precision/scale - see decimal_bin_size() below

    to              - decimal where where the result will be stored

                      to->buf and to->len must be set.

*/

void max_decimal(int precision, int frac, decimal_t *to)

{

  int intpart;

  dec1 *buf= to->buf;

  assert(precision && precision >= frac);

  to->sign= 0;

  if ((intpart= to->intg= (precision - frac)))

  {

    const int firstdigits= intpart % DIG_PER_DEC1;

    if (firstdigits)

      *buf++= powers10[firstdigits] - 1; /* get 9 99 999 ... */

    for(intpart/= DIG_PER_DEC1; intpart; intpart--)

      *buf++= DIG_MAX;

  }

  if ((to->frac= frac))

  {

    const int lastdigits= frac % DIG_PER_DEC1;

    for(frac/= DIG_PER_DEC1; frac; frac--)

      *buf++= DIG_MAX;

    if (lastdigits)

      *buf= frac_max[lastdigits - 1];

  }

}

static dec1 *remove_leading_zeroes(const decimal_t *from, int *intg_result)

{

  int intg= from->intg, i;

  dec1 *buf0= from->buf;

  i= ((intg - 1) % DIG_PER_DEC1) + 1;

  while (intg > 0 && *buf0 == 0)

  {

    intg-= i;

    i= DIG_PER_DEC1;

    buf0++;

  }

  if (intg > 0)

  {

    for (i= (intg - 1) % DIG_PER_DEC1; *buf0 < powers10[i--]; intg--) ;

    assert(intg > 0);

  }

  else

    intg=0;

  *intg_result= intg;

  return buf0;

}

/*

  Count actual length of fraction part (without ending zeroes)

  SYNOPSIS

    decimal_actual_fraction()

    from    number for processing

*/

int decimal_actual_fraction(decimal_t *from)

{

  int frac= from->frac, i;

  dec1 *buf0= from->buf + ROUND_UP(from->intg) + ROUND_UP(frac) - 1;

  if (frac == 0)

    return 0;

  i= ((frac - 1) % DIG_PER_DEC1 + 1);

  while (frac > 0 && *buf0 == 0)

  {

    frac-= i;

    i= DIG_PER_DEC1;

    buf0--;

  }

  if (frac > 0)

  {

    for (i= DIG_PER_DEC1 - ((frac - 1) % DIG_PER_DEC1); *buf0 % powers10[i++] == 0; frac--) {};

  }

  return frac;

}

/*

  Convert decimal to its printable string representation

  SYNOPSIS

    decimal2string()

      from            - value to convert

      to              - points to buffer where string representation

                        should be stored

      *to_len         - in:  size of to buffer

                        out: length of the actually written string

      fixed_precision - 0 if representation can be variable length and

                        fixed_decimals will not be checked in this case.

                        Put number as with fixed point position with this

                        number of digits (sign counted and decimal point is

                        counted)

      fixed_decimals  - number digits after point.

      filler          - character to fill gaps in case of fixed_precision > 0

  RETURN VALUE

    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW

*/

int decimal2string(const decimal_t *from, char *to, int *to_len,

                   int fixed_precision, int fixed_decimals,

                   char filler)

{

  int len, intg, frac= from->frac, i, intg_len, frac_len, fill;

  /* number digits before decimal point */

  int fixed_intg= (fixed_precision ?

                   (fixed_precision - fixed_decimals) : 0);

  int error=E_DEC_OK;

  char *s=to;

  dec1 *buf, *buf0=from->buf, tmp;

  assert(*to_len >= 2+from->sign);

  /* removing leading zeroes */

  buf0= remove_leading_zeroes(from, &intg);

  if (unlikely(intg+frac==0))

  {

    intg=1;

    tmp=0;

    buf0=&tmp;

  }

  if (!(intg_len= fixed_precision ? fixed_intg : intg))

    intg_len= 1;

  frac_len= fixed_precision ? fixed_decimals : frac;

  len= from->sign + intg_len + test(frac) + frac_len;

  if (fixed_precision)

  {

    if (frac > fixed_decimals)

    {

      error= E_DEC_TRUNCATED;

      frac= fixed_decimals;

    }

    if (intg > fixed_intg)

    {

      error= E_DEC_OVERFLOW;

      intg= fixed_intg;

    }

  }

  else if (unlikely(len > --*to_len)) /* reserve one byte for \0 */

  {

    int j= len-*to_len;

    error= (frac && j <= frac + 1) ? E_DEC_TRUNCATED : E_DEC_OVERFLOW;

    if (frac && j >= frac + 1) j--;

    if (j > frac)

    {

      intg-= j-frac;

      frac= 0;

    }

    else

      frac-=j;

    len= from->sign + intg_len + test(frac) + frac_len;

  }

  *to_len=len;

  s[len]=0;

  if (from->sign)

    *s++='-';

  if (frac)

  {

    char *s1= s + intg_len;

    fill= frac_len - frac;

    buf=buf0+ROUND_UP(intg);

    *s1++='.';

    for (; frac>0; frac-=DIG_PER_DEC1)

    {

      dec1 x=*buf++;

      for (i=min(frac, DIG_PER_DEC1); i; i--)

      {

        dec1 y=x/DIG_MASK;

        *s1++='0'+(unsigned char)y;

        x-=y*DIG_MASK;

        x*=10;

      }

    }

    for(; fill; fill--)

      *s1++=filler;

  }

  fill= intg_len - intg;

  if (intg == 0)

    fill--; /* symbol 0 before digital point */

  for(; fill; fill--)

    *s++=filler;

  if (intg)

  {

    s+=intg;

    for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1)

    {

      dec1 x=*--buf;

      for (i=min(intg, DIG_PER_DEC1); i; i--)

      {

        dec1 y=x/10;

        *--s='0'+(unsigned char)(x-y*10);

        x=y;

      }

    }

  }

  else

    *s= '0';

  return error;

}

/*

  Return bounds of decimal digits in the number

  SYNOPSIS

    digits_bounds()

      from         - decimal number for processing

      start_result - index (from 0 ) of first decimal digits will

                     be written by this address

      end_result   - index of position just after last decimal digit

                     be written by this address

*/

static void digits_bounds(decimal_t *from, int *start_result, int *end_result)

{

  int start, stop, i;

  dec1 *buf_beg= from->buf;

  dec1 *end= from->buf + ROUND_UP(from->intg) + ROUND_UP(from->frac);

  dec1 *buf_end= end - 1;

  /* find non-zero digit from number begining */

  while (buf_beg < end && *buf_beg == 0)

    buf_beg++;

  if (buf_beg >= end)

  {

    /* it is zero */

    *start_result= *end_result= 0;

    return;

  }

  /* find non-zero decimal digit from number begining */

  if (buf_beg == from->buf && from->intg)

  {

    start= DIG_PER_DEC1 - (i= ((from->intg-1) % DIG_PER_DEC1 + 1));

    i--;

  }

  else

  {

    i= DIG_PER_DEC1 - 1;

    start= (int) ((buf_beg - from->buf) * DIG_PER_DEC1);

  }

  if (buf_beg < end)

    for (; *buf_beg < powers10[i--]; start++) ;

  *start_result= start; /* index of first decimal digit (from 0) */

  /* find non-zero digit at the end */

  while (buf_end > buf_beg  && *buf_end == 0)

    buf_end--;

  /* find non-zero decimal digit from the end */

  if (buf_end == end - 1 && from->frac)

  {

    stop= (int) (((buf_end - from->buf) * DIG_PER_DEC1 +

           (i= ((from->frac - 1) % DIG_PER_DEC1 + 1))));

    i= DIG_PER_DEC1 - i + 1;

  }

  else

  {

    stop= (int) ((buf_end - from->buf + 1) * DIG_PER_DEC1);

    i= 1;

  }

  for (; *buf_end % powers10[i++] == 0; stop--) {};

  *end_result= stop; /* index of position after last decimal digit (from 0) */

}

/*

  Left shift for alignment of data in buffer

  SYNOPSIS

    do_mini_left_shift()

    dec     pointer to decimal number which have to be shifted

    shift   number of decimal digits on which it should be shifted

    beg/end bounds of decimal digits (see digits_bounds())

  NOTE

    Result fitting in the buffer should be garanted.

    'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)

*/

static void do_mini_left_shift(decimal_t *dec, int shift, int beg, int last)

{

  dec1 *from= dec->buf + ROUND_UP(beg + 1) - 1;

  dec1 *end= dec->buf + ROUND_UP(last) - 1;

  int c_shift= DIG_PER_DEC1 - shift;

  assert(from >= dec->buf);

  assert(end < dec->buf + dec->len);

  if (beg % DIG_PER_DEC1 < shift)

    *(from - 1)= (*from) / powers10[c_shift];

  for(; from < end; from++)

    *from= ((*from % powers10[c_shift]) * powers10[shift] +

            (*(from + 1)) / powers10[c_shift]);

  *from= (*from % powers10[c_shift]) * powers10[shift];

}

/*

  Right shift for alignment of data in buffer

  SYNOPSIS

    do_mini_left_shift()

    dec     pointer to decimal number which have to be shifted

    shift   number of decimal digits on which it should be shifted

    beg/end bounds of decimal digits (see digits_bounds())

  NOTE

    Result fitting in the buffer should be garanted.

    'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)

*/

static void do_mini_right_shift(decimal_t *dec, int shift, int beg, int last)

{

  dec1 *from= dec->buf + ROUND_UP(last) - 1;

  dec1 *end= dec->buf + ROUND_UP(beg + 1) - 1;

  int c_shift= DIG_PER_DEC1 - shift;

  assert(from < dec->buf + dec->len);

  assert(end >= dec->buf);

  if (DIG_PER_DEC1 - ((last - 1) % DIG_PER_DEC1 + 1) < shift)

    *(from + 1)= (*from % powers10[shift]) * powers10[c_shift];

  for(; from > end; from--)

    *from= (*from / powers10[shift] +

            (*(from - 1) % powers10[shift]) * powers10[c_shift]);

  *from= *from / powers10[shift];

}

/*

  Shift of decimal digits in given number (with rounding if it need)

  SYNOPSIS

    decimal_shift()

    dec       number to be shifted

    shift     number of decimal positions

              shift > 0 means shift to left shift

              shift < 0 meand right shift

  NOTE

    In fact it is multipling on 10^shift.

  RETURN

    E_DEC_OK          OK

    E_DEC_OVERFLOW    operation lead to overflow, number is untoched

    E_DEC_TRUNCATED   number was rounded to fit into buffer

*/

static int decimal_shift(decimal_t *dec, int shift)

{

  /* index of first non zero digit (all indexes from 0) */

  int beg;

  /* index of position after last decimal digit */

  int end;

  /* index of digit position just after point */

  int point= ROUND_UP(dec->intg) * DIG_PER_DEC1;

  /* new point position */

  int new_point= point + shift;

  /* number of digits in result */

  int digits_int, digits_frac;

  /* length of result and new fraction in big digits*/

  int new_len, new_frac_len;

  /* return code */

  int err= E_DEC_OK;

  int new_front;

  if (shift == 0)

    return E_DEC_OK;

  digits_bounds(dec, &beg, &end);

  if (beg == end)

  {

    decimal_make_zero(dec);

    return E_DEC_OK;

  }

  digits_int= new_point - beg;

  set_if_bigger(digits_int, 0);

  digits_frac= end - new_point;

  set_if_bigger(digits_frac, 0);

  if ((new_len= ROUND_UP(digits_int) + (new_frac_len= ROUND_UP(digits_frac))) >

      dec->len)

  {

    int lack= new_len - dec->len;

    int diff;

    if (new_frac_len < lack)

      return E_DEC_OVERFLOW; /* lack more then we have in fraction */

    /* cat off fraction part to allow new number to fit in our buffer */

    err= E_DEC_TRUNCATED;

    new_frac_len-= lack;

    diff= digits_frac - (new_frac_len * DIG_PER_DEC1);

    /* Make rounding method as parameter? */

    decimal_round(dec, dec, end - point - diff, HALF_UP);

    end-= diff;

    digits_frac= new_frac_len * DIG_PER_DEC1;

    if (end <= beg)

    {

      /*

        we lost all digits (they will be shifted out of buffer), so we can

        just return 0

      */

      decimal_make_zero(dec);

      return E_DEC_TRUNCATED;

    }

  }

  if (shift % DIG_PER_DEC1)

  {

    int l_mini_shift, r_mini_shift, mini_shift;

    int do_left;

    /*

      Calculate left/right shift to align decimal digits inside our bug

      digits correctly

    */

    if (shift > 0)

    {

      l_mini_shift= shift % DIG_PER_DEC1;

      r_mini_shift= DIG_PER_DEC1 - l_mini_shift;

      /*

        It is left shift so prefer left shift, but if we have not place from

        left, we have to have it from right, because we checked length of

        result

      */

      do_left= l_mini_shift <= beg;

      assert(do_left || (dec->len * DIG_PER_DEC1 - end) >= r_mini_shift);

    }

    else

    {

      r_mini_shift= (-shift) % DIG_PER_DEC1;

      l_mini_shift= DIG_PER_DEC1 - r_mini_shift;

      /* see comment above */

      do_left= !((dec->len * DIG_PER_DEC1 - end) >= r_mini_shift);

      assert(!do_left || l_mini_shift <= beg);

    }

    if (do_left)

    {

      do_mini_left_shift(dec, l_mini_shift, beg, end);

      mini_shift=- l_mini_shift;

    }

    else

    {

      do_mini_right_shift(dec, r_mini_shift, beg, end);

      mini_shift= r_mini_shift;

    }

    new_point+= mini_shift;

    /*

      If number is shifted and correctly aligned in buffer we can

      finish

    */

    if (!(shift+= mini_shift) && (new_point - digits_int) < DIG_PER_DEC1)

    {

      dec->intg= digits_int;

      dec->frac= digits_frac;

      return err;                 /* already shifted as it should be */

    }

    beg+= mini_shift;

    end+= mini_shift;

  }

  /* if new 'decimal front' is in first digit, we do not need move digits */

  if ((new_front= (new_point - digits_int)) >= DIG_PER_DEC1 ||

      new_front < 0)

  {

    /* need to move digits */

    int d_shift;

    dec1 *to, *barier;

    if (new_front > 0)

    {

      /* move left */

      d_shift= new_front / DIG_PER_DEC1;

      to= dec->buf + (ROUND_UP(beg + 1) - 1 - d_shift);

      barier= dec->buf + (ROUND_UP(end) - 1 - d_shift);

      assert(to >= dec->buf);

      assert(barier + d_shift < dec->buf + dec->len);

      for(; to <= barier; to++)

        *to= *(to + d_shift);

      for(barier+= d_shift; to <= barier; to++)

        *to= 0;

      d_shift= -d_shift;

    }

    else

    {

      /* move right */

      d_shift= (1 - new_front) / DIG_PER_DEC1;

      to= dec->buf + ROUND_UP(end) - 1 + d_shift;

      barier= dec->buf + ROUND_UP(beg + 1) - 1 + d_shift;

      assert(to < dec->buf + dec->len);

      assert(barier - d_shift >= dec->buf);

      for(; to >= barier; to--)

        *to= *(to - d_shift);

      for(barier-= d_shift; to >= barier; to--)

        *to= 0;

    }

    d_shift*= DIG_PER_DEC1;

    beg+= d_shift;

    end+= d_shift;

    new_point+= d_shift;

  }

  /*

    If there are gaps then fill ren with 0.

    Only one of following 'for' loops will work becouse beg <= end

  */

  beg= ROUND_UP(beg + 1) - 1;

  end= ROUND_UP(end) - 1;

  assert(new_point >= 0);

  /* We don't want negative new_point below */

  if (new_point != 0)

    new_point= ROUND_UP(new_point) - 1;

  if (new_point > end)

  {

    do

    {

      dec->buf[new_point]=0;

    } while (--new_point > end);

  }

  else

  {

    for (; new_point < beg; new_point++)

      dec->buf[new_point]= 0;

  }

  dec->intg= digits_int;

  dec->frac= digits_frac;

  return err;

}

/*

  Convert string to decimal

  SYNOPSIS

    internal_str2decl()

      from    - value to convert. Doesn't have to be \0 terminated!

      to      - decimal where where the result will be stored

                to->buf and to->len must be set.

      end     - Pointer to pointer to end of string. Will on return be

		set to the char after the last used character

      fixed   - use to->intg, to->frac as limits for input number

  NOTE

    to->intg and to->frac can be modified even when fixed=1

    (but only decreased, in this case)

  RETURN VALUE

    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_BAD_NUM/E_DEC_OOM

    In case of E_DEC_FATAL_ERROR *to is set to decimal zero

    (to make error handling easier)

*/

int

internal_str2dec(char *from, decimal_t *to, char **end, bool fixed)