~drizzle-trunk/drizzle/development

#include "config.h"

#include <alloca.h>

#include <m_ctype.h>

#include <storage/myisam/myisampack.h>

#include <mystrings/decimal.h>

#include <drizzled/util/test.h>

typedef int64_t      dec2;

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

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

          assert((carry) <= 1);                                    \

/**

  Swap the contents of two variables.

 */

#define swap_variables(TYPE, a, b) \

  do {                             \

    TYPE dummy;                    \

    dummy= a;                      \

    a= b;                          \

    b= dummy;                      \

  } while (0)

 

 

  assert(precision && precision >= frac);

    const int firstdigits= intpart % DIG_PER_DEC1;

    const int lastdigits= frac % DIG_PER_DEC1;

    assert(intg > 0);

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

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

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

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

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

  assert(from >= dec->buf);

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

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

  assert(end >= dec->buf);

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

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

      assert(to >= dec->buf);

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

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

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

  assert(new_point >= 0);

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

  char *s= from, *s1;

  char *end_of_string = *end;

  char *endp;

  while (s < end_of_string && my_isspace(&my_charset_utf8_general_ci, *s))

  while (s < end_of_string && my_isdigit(&my_charset_utf8_general_ci, *s))

    while (endp < end_of_string && my_isdigit(&my_charset_utf8_general_ci, *endp))

  *end= endp;

    const int64_t exponent= my_strtoll10(endp+1, (char**) &end_of_string,

  return(res);

static int ull2dec(uint64_t from, decimal_t *to)

  uint64_t x=from;

    uint64_t y=x/DIG_BASE;

int uint64_t2decimal(uint64_t from, decimal_t *to)

int int64_t2decimal(int64_t from, decimal_t *to)

int decimal2uint64_t(decimal_t *from, uint64_t *to)

  uint64_t x=0;

    uint64_t y=x;

    if (unlikely(y > ((uint64_t) UINT64_MAX/DIG_BASE) || x < y))

      *to=UINT64_MAX;

int decimal2int64_t(decimal_t *from, int64_t *to)

  int64_t x=0;

    int64_t y=x;

      because |INT64_MIN| > INT64_MAX

    if (unlikely(y < (INT64_MIN/DIG_BASE) || x > y))

      *to= from->sign ? INT64_MIN : INT64_MAX;

  if (unlikely(from->sign==0 && x == INT64_MIN))

    *to= INT64_MAX;

int decimal2bin(decimal_t *from, unsigned char *to, int precision, int frac)

  unsigned char *orig_to= to;

      default: assert(0);

    assert(sizeof(dec1) == 4);

      default: assert(0);

    unsigned char *to_end= orig_to + orig_fsize0 + orig_isize0;

      *to++= (unsigned char)mask;

  assert(to == orig_to + orig_fsize0 + orig_isize0);

int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale)

  const unsigned char *stop;

  unsigned char *d_copy;

  d_copy= (unsigned char*) alloca(bin_size);

      default: assert(0);

    if (((uint64_t)*buf) >= (uint64_t) powers10[intg0x+1])

    assert(sizeof(dec1) == 4);

    if (((uint32_t)*buf) > DIG_MAX)

  assert(to->intg >=0);

    assert(sizeof(dec1) == 4);

    if (((uint32_t)*buf) > DIG_MAX)

      default: assert(0);

    if (((uint32_t)*buf) > DIG_MAX)

  assert(scale >= 0 && precision > 0 && scale <= precision);

  assert(scale >= 0 && precision > 0 && scale <= precision);

  default: assert(0);