← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/decimal.c

Remove ulint and uchar from innochecksum.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/decimal.c
97
97
      implementation-defined.
98
98
*/
99
99
 
 
100
#include "config.h"
100
101
#include <alloca.h>
101
102
#include <m_string.h>
102
103
#include <m_ctype.h>
404
405
    for (; frac>0; frac-=DIG_PER_DEC1)
405
406
    {
406
407
      dec1 x=*buf++;
407
 
      for (i=min(frac, DIG_PER_DEC1); i; i--)
 
408
      for (i=cmin(frac, DIG_PER_DEC1); i; i--)
408
409
      {
409
410
        dec1 y=x/DIG_MASK;
410
 
        *s1++='0'+(uchar)y;
 
411
        *s1++='0'+(unsigned char)y;
411
412
        x-=y*DIG_MASK;
412
413
        x*=10;
413
414
      }
427
428
    for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1)
428
429
    {
429
430
      dec1 x=*--buf;
430
 
      for (i=min(intg, DIG_PER_DEC1); i; i--)
 
431
      for (i=cmin(intg, DIG_PER_DEC1); i; i--)
431
432
      {
432
433
        dec1 y=x/10;
433
 
        *--s='0'+(uchar)(x-y*10);
 
434
        *--s='0'+(unsigned char)(x-y*10);
434
435
        x=y;
435
436
      }
436
437
    }
1176
1177
 
1177
1178
                7E F2 04 37 2D FB 2D
1178
1179
*/
1179
 
int decimal2bin(decimal_t *from, uchar *to, int precision, int frac)
 
1180
int decimal2bin(decimal_t *from, unsigned char *to, int precision, int frac)
1180
1181
{
1181
1182
  dec1 mask=from->sign ? -1 : 0, *buf1=from->buf, *stop1;
1182
1183
  int error=E_DEC_OK, intg=precision-frac,
1192
1193
      fsize1=frac1*sizeof(dec1)+dig2bytes[frac1x];
1193
1194
  const int orig_isize0= isize0;
1194
1195
  const int orig_fsize0= fsize0;
1195
 
  uchar *orig_to= to;
 
1196
  unsigned char *orig_to= to;
1196
1197
 
1197
1198
  buf1= remove_leading_zeroes(from, &from_intg);
1198
1199
 
1282
1283
  }
1283
1284
  if (fsize0 > fsize1)
1284
1285
  {
1285
 
    uchar *to_end= orig_to + orig_fsize0 + orig_isize0;
 
1286
    unsigned char *to_end= orig_to + orig_fsize0 + orig_isize0;
1286
1287
 
1287
1288
    while (fsize0-- > fsize1 && to < to_end)
1288
 
      *to++= (uchar)mask;
 
1289
      *to++= (unsigned char)mask;
1289
1290
  }
1290
1291
  orig_to[0]^= 0x80;
1291
1292
 
1311
1312
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
1312
1313
*/
1313
1314
 
1314
 
int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale)
 
1315
int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale)
1315
1316
{
1316
1317
  int error=E_DEC_OK, intg=precision-scale,
1317
1318
      intg0=intg/DIG_PER_DEC1, frac0=scale/DIG_PER_DEC1,
1318
1319
      intg0x=intg-intg0*DIG_PER_DEC1, frac0x=scale-frac0*DIG_PER_DEC1,
1319
1320
      intg1=intg0+(intg0x>0), frac1=frac0+(frac0x>0);
1320
1321
  dec1 *buf=to->buf, mask=(*from & 0x80) ? 0 : -1;
1321
 
  const uchar *stop;
1322
 
  uchar *d_copy;
 
1322
  const unsigned char *stop;
 
1323
  unsigned char *d_copy;
1323
1324
  int bin_size= decimal_bin_size(precision, scale);
1324
1325
 
1325
1326
  sanity(to);
1326
 
  d_copy= (uchar*) alloca(bin_size);
 
1327
  d_copy= (unsigned char*) alloca(bin_size);
1327
1328
  memcpy(d_copy, from, bin_size);
1328
1329
  d_copy[0]^= 0x80;
1329
1330
  from= d_copy;
1501
1502
 
1502
1503
  if (to != from || intg1>intg0)
1503
1504
  {
1504
 
    dec1 *p0= buf0+intg0+max(frac1, frac0);
1505
 
    dec1 *p1= buf1+intg1+max(frac1, frac0);
 
1505
    dec1 *p0= buf0+intg0+cmax(frac1, frac0);
 
1506
    dec1 *p1= buf1+intg1+cmax(frac1, frac0);
1506
1507
 
1507
1508
    while (buf0 < p0)
1508
1509
      *(--p1) = *(--p0);
1513
1514
    buf0=to->buf;
1514
1515
    buf1=to->buf;
1515
1516
    to->sign=from->sign;
1516
 
    to->intg=min(intg0, len)*DIG_PER_DEC1;
 
1517
    to->intg=cmin(intg0, len)*DIG_PER_DEC1;
1517
1518
  }
1518
1519
 
1519
1520
  if (frac0 > frac1)
1615
1616
        scale=frac0*DIG_PER_DEC1;
1616
1617
        error=E_DEC_TRUNCATED; /* XXX */
1617
1618
      }
1618
 
      for (buf1=to->buf+intg0+max(frac0,0); buf1 > to->buf; buf1--)
 
1619
      for (buf1=to->buf+intg0+cmax(frac0,0); buf1 > to->buf; buf1--)
1619
1620
      {
1620
1621
        buf1[0]=buf1[-1];
1621
1622
      }
1634
1635
        /* making 'zero' with the proper scale */
1635
1636
        dec1 *p0= to->buf + frac0 + 1;
1636
1637
        to->intg=1;
1637
 
        to->frac= max(scale, 0);
 
1638
        to->frac= cmax(scale, 0);
1638
1639
        to->sign= 0;
1639
1640
        for (buf1= to->buf; buf1<p0; buf1++)
1640
1641
          *buf1= 0;
1683
1684
{
1684
1685
  switch (op) {
1685
1686
  case '-':
1686
 
    return ROUND_UP(max(from1->intg, from2->intg)) +
1687
 
           ROUND_UP(max(from1->frac, from2->frac));
 
1687
    return ROUND_UP(cmax(from1->intg, from2->intg)) +
 
1688
           ROUND_UP(cmax(from1->frac, from2->frac));
1688
1689
  case '+':
1689
 
    return ROUND_UP(max(from1->intg, from2->intg)+1) +
1690
 
           ROUND_UP(max(from1->frac, from2->frac));
 
1690
    return ROUND_UP(cmax(from1->intg, from2->intg)+1) +
 
1691
           ROUND_UP(cmax(from1->frac, from2->frac));
1691
1692
  case '*':
1692
1693
    return ROUND_UP(from1->intg+from2->intg)+
1693
1694
           ROUND_UP(from1->frac)+ROUND_UP(from2->frac);
1702
1703
{
1703
1704
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1704
1705
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac),
1705
 
      frac0=max(frac1, frac2), intg0=max(intg1, intg2), error;
 
1706
      frac0=cmax(frac1, frac2), intg0=cmax(intg1, intg2), error;
1706
1707
  dec1 *buf1, *buf2, *buf0, *stop, *stop2, x, carry;
1707
1708
 
1708
1709
  sanity(to);
1727
1728
  buf0=to->buf+intg0+frac0;
1728
1729
 
1729
1730
  to->sign=from1->sign;
1730
 
  to->frac=max(from1->frac, from2->frac);
 
1731
  to->frac=cmax(from1->frac, from2->frac);
1731
1732
  to->intg=intg0*DIG_PER_DEC1;
1732
1733
  if (unlikely(error))
1733
1734
  {
1738
1739
    set_if_smaller(intg2, intg0);
1739
1740
  }
1740
1741
 
1741
 
  /* part 1 - max(frac) ... min (frac) */
 
1742
  /* part 1 - cmax(frac) ... cmin(frac) */
1742
1743
  if (frac1 > frac2)
1743
1744
  {
1744
1745
    buf1=from1->buf+intg1+frac1;
1756
1757
  while (buf1 > stop)
1757
1758
    *--buf0=*--buf1;
1758
1759
 
1759
 
  /* part 2 - min(frac) ... min(intg) */
 
1760
  /* part 2 - cmin(frac) ... cmin(intg) */
1760
1761
  carry=0;
1761
1762
  while (buf1 > stop2)
1762
1763
  {
1763
1764
    ADD(*--buf0, *--buf1, *--buf2, carry);
1764
1765
  }
1765
1766
 
1766
 
  /* part 3 - min(intg) ... max(intg) */
 
1767
  /* part 3 - cmin(intg) ... cmax(intg) */
1767
1768
  buf1= intg1 > intg2 ? ((stop=from1->buf)+intg1-intg2) :
1768
1769
                        ((stop=from2->buf)+intg2-intg1) ;
1769
1770
  while (buf1 > stop)
1784
1785
{
1785
1786
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1786
1787
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac);
1787
 
  int frac0=max(frac1, frac2), error;
 
1788
  int frac0=cmax(frac1, frac2), error;
1788
1789
  dec1 *buf1, *buf2, *buf0, *stop1, *stop2, *start1, *start2, carry=0;
1789
1790
 
1790
1791
  /* let carry:=1 if from2 > from1 */
1859
1860
  FIX_INTG_FRAC_ERROR(to->len, intg1, frac0, error);
1860
1861
  buf0=to->buf+intg1+frac0;
1861
1862
 
1862
 
  to->frac=max(from1->frac, from2->frac);
 
1863
  to->frac=cmax(from1->frac, from2->frac);
1863
1864
  to->intg=intg1*DIG_PER_DEC1;
1864
1865
  if (unlikely(error))
1865
1866
  {
1870
1871
  }
1871
1872
  carry=0;
1872
1873
 
1873
 
  /* part 1 - max(frac) ... min (frac) */
 
1874
  /* part 1 - cmax(frac) ... cmin(frac) */
1874
1875
  if (frac1 > frac2)
1875
1876
  {
1876
1877
    buf1=start1+intg1+frac1;
1894
1895
    }
1895
1896
  }
1896
1897
 
1897
 
  /* part 2 - min(frac) ... intg2 */
 
1898
  /* part 2 - cmin(frac) ... intg2 */
1898
1899
  while (buf2 > start2)
1899
1900
  {
1900
1901
    SUB(*--buf0, *--buf1, *--buf2, carry);
2150
2151
  {
2151
2152
    /* we're calculating N1 % N2.
2152
2153
       The result will have
2153
 
         frac=max(frac1, frac2), as for subtraction
 
2154
         frac=cmax(frac1, frac2), as for subtraction
2154
2155
         intg=intg2
2155
2156
    */
2156
2157
    to->sign=from1->sign;
2157
 
    to->frac=max(from1->frac, from2->frac);
 
2158
    to->frac=cmax(from1->frac, from2->frac);
2158
2159
    frac0=0;
2159
2160
  }
2160
2161
  else
2278
2279
    /*
2279
2280
      now the result is in tmp1, it has
2280
2281
        intg=prec1-frac1
2281
 
        frac=max(frac1, frac2)=to->frac
 
2282
        frac=cmax(frac1, frac2)=to->frac
2282
2283
    */
2283
2284
    if (dcarry)
2284
2285
      *--start1=dcarry;
2316
2317
      }
2317
2318
      assert(intg0 <= ROUND_UP(from2->intg));
2318
2319
      stop1=start1+frac0+intg0;
2319
 
      to->intg=min(intg0*DIG_PER_DEC1, from2->intg);
 
2320
      to->intg=cmin(intg0*DIG_PER_DEC1, from2->intg);
2320
2321
    }
2321
2322
    if (unlikely(intg0+frac0 > to->len))
2322
2323
    {
2506
2507
  {
2507
2508
    printf("0x");
2508
2509
    for (i=0; i < size; i++)
2509
 
      printf("%02x", ((uchar *)buf)[i]);
 
2510
      printf("%02x", ((unsigned char *)buf)[i]);
2510
2511
  }
2511
2512
  res=bin2decimal(buf, &a, p, s);
2512
2513
  printf(" => res=%d ", res);