← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/dtoa.cc

  • Committer: Eric Herman
  • Date: 2008-12-07 15:29:44 UTC
  • mto: (656.1.14 devel)
  • mto: This revision was merged to the branch mainline in revision 670.
  • Revision ID: eric@mysql.com-20081207152944-cq1nx1cyi0huqj0f
Added pointer to online version of the FAQ

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/dtoa.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
15
15
 
16
16
/****************************************************************
17
17
 
20
20
 
21
21
  The author of this software is David M. Gay.
22
22
 
23
 
  Copyright (C) 1991, 2000, 2001 by Lucent Technologies.
 
23
  Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
24
24
 
25
25
  Permission to use, copy, modify, and distribute this software for any
26
26
  purpose without fee is hereby granted, provided that this entire notice
35
35
 
36
36
 ***************************************************************/
37
37
 
38
 
#include "config.h"
39
 
 
40
 
#include "drizzled/internal/m_string.h"  /* for memcpy and NOT_FIXED_DEC */
41
 
 
42
 
#include <float.h>
43
 
 
44
 
#include <cstdlib>
45
 
#include <cerrno>
46
 
#include <algorithm>
47
 
 
48
 
using namespace std;
49
 
 
50
 
namespace drizzled
51
 
{
52
 
namespace internal
53
 
{
 
38
#include <mystrings/m_string.h>  /* for memcpy and NOT_FIXED_DEC */
 
39
#include <stdlib.h>
 
40
 
 
41
/**
 
42
   Appears to suffice to not call malloc() in most cases.
 
43
   @todo
 
44
     see if it is possible to get rid of malloc().
 
45
     this constant is sufficient to avoid malloc() on all inputs I have tried.
 
46
*/
 
47
#define DTOA_BUFF_SIZE (420 * sizeof(void *))
54
48
 
55
49
/* Magic value returned by dtoa() to indicate overflow */
56
50
#define DTOA_OVERFLOW 9999
57
51
 
58
 
static double my_strtod_int(const char *, char **, int *);
59
 
static char *dtoa(double, int, int, int *, int *, char **);
 
52
static double my_strtod_int(const char *, char **, int *, char *, size_t);
 
53
static char *dtoa(double, int, int, int *, int *, char **, char *, size_t);
 
54
static void dtoa_free(char *, char *, size_t);
60
55
 
61
56
/**
62
57
   @brief
93
88
{
94
89
  int decpt, sign, len, i;
95
90
  char *res, *src, *end, *dst= to;
 
91
  char buf[DTOA_BUFF_SIZE];
96
92
  assert(precision >= 0 && precision < NOT_FIXED_DEC && to != NULL);
97
93
 
98
 
  res= dtoa(x, 5, precision, &decpt, &sign, &end);
 
94
  res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
99
95
 
100
96
  if (decpt == DTOA_OVERFLOW)
101
97
  {
102
 
    free(res);
 
98
    dtoa_free(res, buf, sizeof(buf));
103
99
    *to++= '0';
104
100
    *to= '\0';
105
101
    if (error != NULL)
135
131
    if (len <= decpt)
136
132
      *dst++= '.';
137
133
 
138
 
    for (i= precision - max(0, (len - decpt)); i > 0; i--)
 
134
    for (i= precision - cmax(0, (len - decpt)); i > 0; i--)
139
135
      *dst++= '0';
140
136
  }
141
137
 
143
139
  if (error != NULL)
144
140
    *error= false;
145
141
 
146
 
  free(res);
 
142
  dtoa_free(res, buf, sizeof(buf));
147
143
 
148
144
  return dst - to;
149
145
}
216
212
{
217
213
  int decpt, sign, len, exp_len;
218
214
  char *res, *src, *end, *dst= to, *dend= dst + width;
 
215
  char buf[DTOA_BUFF_SIZE];
219
216
  bool have_space, force_e_format;
220
217
  assert(width > 0 && to != NULL);
221
218
 
223
220
  if (x < 0.)
224
221
    width--;
225
222
 
226
 
  res= dtoa(x, 4, type == MY_GCVT_ARG_DOUBLE ? min(width, DBL_DIG) : 
227
 
            min(width, FLT_DIG), &decpt, &sign, &end);
228
 
 
 
223
  res= dtoa(x, 4, type == MY_GCVT_ARG_DOUBLE ? width : cmin(width, FLT_DIG),
 
224
            &decpt, &sign, &end, buf, sizeof(buf));
229
225
  if (decpt == DTOA_OVERFLOW)
230
226
  {
231
 
    free(res);
 
227
    dtoa_free(res, buf, sizeof(buf));
232
228
    *to++= '0';
233
229
    *to= '\0';
234
230
    if (error != NULL)
329
325
        decimal point. For this we are calling dtoa with mode=5, passing the
330
326
        number of significant digits = (len-decpt) - (len-width) = width-decpt
331
327
      */
332
 
      free(res);
333
 
      res= dtoa(x, 5, width - decpt, &decpt, &sign, &end);
 
328
      dtoa_free(res, buf, sizeof(buf));
 
329
      res= dtoa(x, 5, width - decpt, &decpt, &sign, &end, buf, sizeof(buf));
334
330
      src= res;
335
331
      len= end - res;
336
332
    }
395
391
    if (width < len)
396
392
    {
397
393
      /* Yes, re-convert with a smaller width */
398
 
      free(res);
399
 
      res= dtoa(x, 4, width, &decpt, &sign, &end);
 
394
      dtoa_free(res, buf, sizeof(buf));
 
395
      res= dtoa(x, 4, width, &decpt, &sign, &end, buf, sizeof(buf));
400
396
      src= res;
401
397
      len= end - res;
402
398
      if (--decpt < 0)
436
432
  }
437
433
 
438
434
end:
439
 
  free(res);
 
435
  dtoa_free(res, buf, sizeof(buf));
440
436
  *dst= '\0';
441
437
 
442
438
  return dst - to;
462
458
 
463
459
double my_strtod(const char *str, char **end, int *error)
464
460
{
 
461
  char buf[DTOA_BUFF_SIZE];
465
462
  double res;
466
463
  assert(str != NULL && end != NULL && *end != NULL && error != NULL);
467
464
 
468
 
  res= my_strtod_int(str, end, error);
 
465
  res= my_strtod_int(str, end, error, buf, sizeof(buf));
469
466
  return (*error == 0) ? res : (res < 0 ? -DBL_MAX : DBL_MAX);
470
467
}
471
468
 
482
479
 *
483
480
 * The author of this software is David M. Gay.
484
481
 *
485
 
 * Copyright (C) 1991, 2000, 2001 by Lucent Technologies.
 
482
 * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
486
483
 *
487
484
 * Permission to use, copy, modify, and distribute this software for any
488
485
 * purpose without fee is hereby granted, provided that this entire notice
594
591
#define Big1 0xffffffff
595
592
#define FFFFFFFF 0xffffffffUL
596
593
 
 
594
/* This is tested to be enough for dtoa */
 
595
 
 
596
#define Kmax 15
 
597
 
 
598
#define Bcopy(x,y) memcpy(&x->sign, &y->sign, \
 
599
                          2*sizeof(int) + y->wds*sizeof(ULong))
 
600
 
597
601
/* Arbitrary-length integer */
598
602
 
599
603
typedef struct Bigint
608
612
  int wds;                 /* current length in 32-bit words */
609
613
} Bigint;
610
614
 
611
 
static Bigint *Bcopy(Bigint* dst, Bigint* src)
 
615
 
 
616
/* A simple stack-memory based allocator for Bigints */
 
617
 
 
618
typedef struct Stack_alloc
612
619
{
613
 
  dst->sign= src->sign;
614
 
  dst->wds= src->wds;
615
 
 
616
 
  assert(dst->maxwds >= src->wds);
617
 
 
618
 
  memcpy(dst->p.x, src->p.x, src->wds*sizeof(ULong));
619
 
 
620
 
  return dst;
621
 
}
622
 
 
623
 
static Bigint *Balloc(int k)
 
620
  char *begin;
 
621
  char *free;
 
622
  char *end;
 
623
  /*
 
624
    Having list of free blocks lets us reduce maximum required amount
 
625
    of memory from ~4000 bytes to < 1680 (tested on x86).
 
626
  */
 
627
  Bigint *freelist[Kmax+1];
 
628
} Stack_alloc;
 
629
 
 
630
 
 
631
/*
 
632
  Try to allocate object on stack, and resort to malloc if all
 
633
  stack memory is used.
 
634
*/
 
635
 
 
636
static Bigint *Balloc(int k, Stack_alloc *alloc)
624
637
{
625
638
  Bigint *rv;
626
 
 
627
 
  /* TODO: some malloc failure checking */
628
 
 
629
 
  int x= 1 << k;
630
 
  rv= (Bigint*) malloc(sizeof(Bigint));
631
 
 
632
 
  rv->p.x= (ULong*)malloc(x * sizeof(ULong));
633
 
 
634
 
  rv->k= k;
635
 
  rv->maxwds= x;
636
 
 
 
639
  if (k <= Kmax &&  alloc->freelist[k])
 
640
  {
 
641
    rv= alloc->freelist[k];
 
642
    alloc->freelist[k]= rv->p.next;
 
643
  }
 
644
  else
 
645
  {
 
646
    int x, len;
 
647
 
 
648
    x= 1 << k;
 
649
    len= sizeof(Bigint) + x * sizeof(ULong);
 
650
 
 
651
    if (alloc->free + len <= alloc->end)
 
652
    {
 
653
      rv= (Bigint*) alloc->free;
 
654
      alloc->free+= len;
 
655
    }
 
656
    else
 
657
      rv= (Bigint*) malloc(len);
 
658
 
 
659
    rv->k= k;
 
660
    rv->maxwds= x;
 
661
  }
637
662
  rv->sign= rv->wds= 0;
638
 
 
 
663
  rv->p.x= (ULong*) (rv + 1);
639
664
  return rv;
640
665
}
641
666
 
645
670
  list. Otherwise call free().
646
671
*/
647
672
 
648
 
static void Bfree(Bigint *v)
649
 
{
650
 
  if(!v)
651
 
    return;
652
 
  free(v->p.x);
653
 
  free(v);
654
 
}
 
673
static void Bfree(Bigint *v, Stack_alloc *alloc)
 
674
{
 
675
  char *gptr= (char*) v;                       /* generic pointer */
 
676
  if (gptr < alloc->begin || gptr >= alloc->end)
 
677
    free(gptr);
 
678
  else if (v->k <= Kmax)
 
679
  {
 
680
    /*
 
681
      Maintain free lists only for stack objects: this way we don't
 
682
      have to bother with freeing lists in the end of dtoa;
 
683
      heap should not be used normally anyway.
 
684
    */
 
685
    v->p.next= alloc->freelist[v->k];
 
686
    alloc->freelist[v->k]= v;
 
687
  }
 
688
}
 
689
 
 
690
 
 
691
/*
 
692
  This is to place return value of dtoa in: tries to use stack
 
693
  as well, but passes by free lists management and just aligns len by
 
694
  sizeof(ULong).
 
695
*/
 
696
 
 
697
static char *dtoa_alloc(int i, Stack_alloc *alloc)
 
698
{
 
699
  char *rv;
 
700
  int aligned_size= (i + sizeof(ULong) - 1) / sizeof(ULong) * sizeof(ULong);
 
701
  if (alloc->free + aligned_size <= alloc->end)
 
702
  {
 
703
    rv= alloc->free;
 
704
    alloc->free+= aligned_size;
 
705
  }
 
706
  else
 
707
    rv= (char *)malloc(i);
 
708
  return rv;
 
709
}
 
710
 
 
711
 
 
712
/*
 
713
  dtoa_free() must be used to free values s returned by dtoa()
 
714
  This is the counterpart of dtoa_alloc()
 
715
*/
 
716
 
 
717
static void dtoa_free(char *gptr, char *buf, size_t buf_size)
 
718
{
 
719
  if (gptr < buf || gptr >= buf + buf_size)
 
720
    free(gptr);
 
721
}
 
722
 
655
723
 
656
724
/* Bigint arithmetic functions */
657
725
 
658
726
/* Multiply by m and add a */
659
727
 
660
 
static Bigint *multadd(Bigint *b, int m, int a)
 
728
static Bigint *multadd(Bigint *b, int m, int a, Stack_alloc *alloc)
661
729
{
662
730
  int i, wds;
663
731
  ULong *x;
679
747
  {
680
748
    if (wds >= b->maxwds)
681
749
    {
682
 
      b1= Balloc(b->k+1);
 
750
      b1= Balloc(b->k+1, alloc);
683
751
      Bcopy(b1, b);
684
 
      Bfree(b);
 
752
      Bfree(b, alloc);
685
753
      b= b1;
686
754
    }
687
755
    b->p.x[wds++]= (ULong) carry;
691
759
}
692
760
 
693
761
 
694
 
static Bigint *s2b(const char *s, int nd0, int nd, ULong y9)
 
762
static Bigint *s2b(const char *s, int nd0, int nd, ULong y9, Stack_alloc *alloc)
695
763
{
696
764
  Bigint *b;
697
765
  int i, k;
699
767
 
700
768
  x= (nd + 8) / 9;
701
769
  for (k= 0, y= 1; x > y; y <<= 1, k++) ;
702
 
  b= Balloc(k);
 
770
  b= Balloc(k, alloc);
703
771
  b->p.x[0]= y9;
704
772
  b->wds= 1;
705
773
 
708
776
  {
709
777
    s+= 9;
710
778
    do
711
 
      b= multadd(b, 10, *s++ - '0');
 
779
      b= multadd(b, 10, *s++ - '0', alloc);
712
780
    while (++i < nd0);
713
781
    s++;
714
782
  }
715
783
  else
716
784
    s+= 10;
717
785
  for(; i < nd; i++)
718
 
    b= multadd(b, 10, *s++ - '0');
 
786
    b= multadd(b, 10, *s++ - '0', alloc);
719
787
  return b;
720
788
}
721
789
 
806
874
 
807
875
/* Convert integer to Bigint number */
808
876
 
809
 
static Bigint *i2b(int i)
 
877
static Bigint *i2b(int i, Stack_alloc *alloc)
810
878
{
811
879
  Bigint *b;
812
880
 
813
 
  b= Balloc(1);
 
881
  b= Balloc(1, alloc);
814
882
  b->p.x[0]= i;
815
883
  b->wds= 1;
816
884
  return b;
819
887
 
820
888
/* Multiply two Bigint numbers */
821
889
 
822
 
static Bigint *mult(Bigint *a, Bigint *b)
 
890
static Bigint *mult(Bigint *a, Bigint *b, Stack_alloc *alloc)
823
891
{
824
892
  Bigint *c;
825
893
  int k, wa, wb, wc;
839
907
  wc= wa + wb;
840
908
  if (wc > a->maxwds)
841
909
    k++;
842
 
  c= Balloc(k);
 
910
  c= Balloc(k, alloc);
843
911
  for (x= c->p.x, xa= x + wc; x < xa; x++)
844
912
    *x= 0;
845
913
  xa= a->p.x;
911
979
 
912
980
#define P5A_MAX (sizeof(p5_a)/sizeof(*p5_a) - 1)
913
981
 
914
 
static Bigint *pow5mult(Bigint *b, int k)
 
982
static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
915
983
{
916
984
  Bigint *b1, *p5, *p51;
917
985
  int i;
918
986
  static int p05[3]= { 5, 25, 125 };
919
987
 
920
988
  if ((i= k & 3))
921
 
    b= multadd(b, p05[i-1], 0);
 
989
    b= multadd(b, p05[i-1], 0, alloc);
922
990
 
923
991
  if (!(k>>= 2))
924
992
    return b;
927
995
  {
928
996
    if (k & 1)
929
997
    {
930
 
      b1= mult(b, p5);
931
 
      Bfree(b);
 
998
      b1= mult(b, p5, alloc);
 
999
      Bfree(b, alloc);
932
1000
      b= b1;
933
1001
    }
934
1002
    if (!(k>>= 1))
937
1005
    if (p5 < p5_a + P5A_MAX)
938
1006
      ++p5;
939
1007
    else if (p5 == p5_a + P5A_MAX)
940
 
      p5= mult(p5, p5);
 
1008
      p5= mult(p5, p5, alloc);
941
1009
    else
942
1010
    {
943
 
      p51= mult(p5, p5);
944
 
      Bfree(p5);
 
1011
      p51= mult(p5, p5, alloc);
 
1012
      Bfree(p5, alloc);
945
1013
      p5= p51;
946
1014
    }
947
1015
  }
949
1017
}
950
1018
 
951
1019
 
952
 
static Bigint *lshift(Bigint *b, int k)
 
1020
static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
953
1021
{
954
1022
  int i, k1, n, n1;
955
1023
  Bigint *b1;
960
1028
  n1= n + b->wds + 1;
961
1029
  for (i= b->maxwds; n1 > i; i<<= 1)
962
1030
    k1++;
963
 
  b1= Balloc(k1);
 
1031
  b1= Balloc(k1, alloc);
964
1032
  x1= b1->p.x;
965
1033
  for (i= 0; i < n; i++)
966
1034
    *x1++= 0;
984
1052
      *x1++= *x++;
985
1053
    while (x < xe);
986
1054
  b1->wds= n1 - 1;
987
 
  Bfree(b);
 
1055
  Bfree(b, alloc);
988
1056
  return b1;
989
1057
}
990
1058
 
1013
1081
}
1014
1082
 
1015
1083
 
1016
 
static Bigint *diff(Bigint *a, Bigint *b)
 
1084
static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
1017
1085
{
1018
1086
  Bigint *c;
1019
1087
  int i, wa, wb;
1023
1091
  i= cmp(a,b);
1024
1092
  if (!i)
1025
1093
  {
1026
 
    c= Balloc(0);
 
1094
    c= Balloc(0, alloc);
1027
1095
    c->wds= 1;
1028
1096
    c->p.x[0]= 0;
1029
1097
    return c;
1037
1105
  }
1038
1106
  else
1039
1107
    i= 0;
1040
 
  c= Balloc(a->k);
 
1108
  c= Balloc(a->k, alloc);
1041
1109
  c->sign= i;
1042
1110
  wa= a->wds;
1043
1111
  xa= a->p.x;
1118
1186
}
1119
1187
 
1120
1188
 
1121
 
static Bigint *d2b(double d, int *e, int *bits)
 
1189
static Bigint *d2b(double d, int *e, int *bits, Stack_alloc *alloc)
1122
1190
{
1123
1191
  Bigint *b;
1124
1192
  int de, k;
1127
1195
#define d0 word0(d)
1128
1196
#define d1 word1(d)
1129
1197
 
1130
 
  b= Balloc(1);
 
1198
  b= Balloc(1, alloc);
1131
1199
  x= b->p.x;
1132
1200
 
1133
1201
  z= d0 & Frac_mask;
1234
1302
     for 0 <= k <= 22).
1235
1303
*/
1236
1304
 
1237
 
static double my_strtod_int(const char *s00, char **se, int *error)
 
1305
static double my_strtod_int(const char *s00, char **se, int *error, char *buf, size_t buf_size)
1238
1306
{
1239
1307
  int scale;
1240
1308
  int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
1247
1315
#ifdef SET_INEXACT
1248
1316
  int inexact, oldinexact;
1249
1317
#endif
 
1318
  Stack_alloc alloc;
1250
1319
 
1251
1320
  c= 0;
1252
1321
  *error= 0;
1253
1322
 
 
1323
  alloc.begin= alloc.free= buf;
 
1324
  alloc.end= buf + buf_size;
 
1325
  memset(alloc.freelist, 0, sizeof(alloc.freelist));
 
1326
 
1254
1327
  sign= nz0= nz= 0;
1255
1328
  dval(rv)= 0.;
1256
1329
  for (s= s00; s < end; s++)
1526
1599
 
1527
1600
  /* Put digits into bd: true value = bd * 10^e */
1528
1601
 
1529
 
  bd0= s2b(s0, nd0, nd, y);
 
1602
  bd0= s2b(s0, nd0, nd, y, &alloc);
1530
1603
 
1531
1604
  for(;;)
1532
1605
  {
1533
 
    bd= Balloc(bd0->k);
 
1606
    bd= Balloc(bd0->k, &alloc);
1534
1607
    Bcopy(bd, bd0);
1535
 
    bb= d2b(dval(rv), &bbe, &bbbits);  /* rv = bb * 2^bbe */
1536
 
    bs= i2b(1);
 
1608
    bb= d2b(dval(rv), &bbe, &bbbits, &alloc);  /* rv = bb * 2^bbe */
 
1609
    bs= i2b(1, &alloc);
1537
1610
 
1538
1611
    if (e >= 0)
1539
1612
    {
1570
1643
    }
1571
1644
    if (bb5 > 0)
1572
1645
    {
1573
 
      bs= pow5mult(bs, bb5);
1574
 
      bb1= mult(bs, bb);
1575
 
      Bfree(bb);
 
1646
      bs= pow5mult(bs, bb5, &alloc);
 
1647
      bb1= mult(bs, bb, &alloc);
 
1648
      Bfree(bb, &alloc);
1576
1649
      bb= bb1;
1577
1650
    }
1578
1651
    if (bb2 > 0)
1579
 
      bb= lshift(bb, bb2);
 
1652
      bb= lshift(bb, bb2, &alloc);
1580
1653
    if (bd5 > 0)
1581
 
      bd= pow5mult(bd, bd5);
 
1654
      bd= pow5mult(bd, bd5, &alloc);
1582
1655
    if (bd2 > 0)
1583
 
      bd= lshift(bd, bd2);
 
1656
      bd= lshift(bd, bd2, &alloc);
1584
1657
    if (bs2 > 0)
1585
 
      bs= lshift(bs, bs2);
1586
 
    delta= diff(bb, bd);
 
1658
      bs= lshift(bs, bs2, &alloc);
 
1659
    delta= diff(bb, bd, &alloc);
1587
1660
    dsign= delta->sign;
1588
1661
    delta->sign= 0;
1589
1662
    i= cmp(delta, bs);
1611
1684
#endif
1612
1685
        break;
1613
1686
      }
1614
 
      delta= lshift(delta, Log2P);
 
1687
      delta= lshift(delta, Log2P, &alloc);
1615
1688
      if (cmp(delta, bs) > 0)
1616
1689
        goto drop_down;
1617
1690
      break;
1752
1825
      }
1753
1826
#endif
1754
1827
 cont:
1755
 
    Bfree(bb);
1756
 
    Bfree(bd);
1757
 
    Bfree(bs);
1758
 
    Bfree(delta);
 
1828
    Bfree(bb, &alloc);
 
1829
    Bfree(bd, &alloc);
 
1830
    Bfree(bs, &alloc);
 
1831
    Bfree(delta, &alloc);
1759
1832
  }
1760
1833
#ifdef SET_INEXACT
1761
1834
  if (inexact)
1785
1858
  }
1786
1859
#endif
1787
1860
 retfree:
1788
 
  Bfree(bb);
1789
 
  Bfree(bd);
1790
 
  Bfree(bs);
1791
 
  Bfree(bd0);
1792
 
  Bfree(delta);
 
1861
  Bfree(bb, &alloc);
 
1862
  Bfree(bd, &alloc);
 
1863
  Bfree(bs, &alloc);
 
1864
  Bfree(bd0, &alloc);
 
1865
  Bfree(delta, &alloc);
1793
1866
 ret:
1794
1867
  *se= (char *)s;
1795
1868
  return sign ? -dval(rv) : dval(rv);
1896
1969
 */
1897
1970
 
1898
1971
static char *dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
1899
 
                  char **rve)
 
1972
                  char **rve, char *buf, size_t buf_size)
1900
1973
{
1901
1974
  /*
1902
1975
    Arguments ndigits, decpt, sign are similar to those
1908
1981
    mode:
1909
1982
          0 ==> shortest string that yields d when read in
1910
1983
                and rounded to nearest.
1911
 
 
1912
1984
          1 ==> like 0, but with Steele & White stopping rule;
1913
1985
                e.g. with IEEE P754 arithmetic , mode 0 gives
1914
1986
                1e23 whereas mode 1 gives 9.999999999999999e22.
1940
2012
  Bigint *b, *b1, *delta, *mlo = NULL, *mhi, *S;
1941
2013
  double d2, ds, eps;
1942
2014
  char *s, *s0;
 
2015
  Stack_alloc alloc;
 
2016
 
 
2017
  alloc.begin= alloc.free= buf;
 
2018
  alloc.end= buf + buf_size;
 
2019
  memset(alloc.freelist, 0, sizeof(alloc.freelist));
1943
2020
 
1944
2021
  if (word0(d) & Sign_bit)
1945
2022
  {
1951
2028
    *sign= 0;
1952
2029
 
1953
2030
  /* If infinity, set decpt to DTOA_OVERFLOW, if 0 set it to 1 */
1954
 
  if ((((word0(d) & Exp_mask) == Exp_mask) && ((*decpt= DTOA_OVERFLOW) != 0)) ||
1955
 
      (!dval(d) && ((*decpt= 1) != 0)))
 
2031
  if (((word0(d) & Exp_mask) == Exp_mask && (*decpt= DTOA_OVERFLOW)) ||
 
2032
      (!dval(d) && (*decpt= 1)))
1956
2033
  {
1957
2034
    /* Infinity, NaN, 0 */
1958
 
    char *res= (char*) malloc(2);
 
2035
    char *res= (char*) dtoa_alloc(2, &alloc);
1959
2036
    res[0]= '0';
1960
2037
    res[1]= '\0';
1961
2038
    if (rve)
1964
2041
  }
1965
2042
 
1966
2043
 
1967
 
  b= d2b(dval(d), &be, &bbits);
 
2044
  b= d2b(dval(d), &be, &bbits, &alloc);
1968
2045
  if ((i= (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))))
1969
2046
  {
1970
2047
    dval(d2)= dval(d);
2079
2156
    if (i <= 0)
2080
2157
      i= 1;
2081
2158
  }
2082
 
  s= s0= (char*)malloc(i+1); /* +1 for trailing '\0' appended
2083
 
                                at end of function */
 
2159
  s= s0= dtoa_alloc(i, &alloc);
2084
2160
 
2085
2161
  if (ilim >= 0 && ilim <= Quick_max && try_quick)
2086
2162
  {
2245
2321
    i = denorm ? be + (Bias + (P-1) - 1 + 1) : 1 + P - bbits;
2246
2322
    b2+= i;
2247
2323
    s2+= i;
2248
 
    mhi= i2b(1);
 
2324
    mhi= i2b(1, &alloc);
2249
2325
  }
2250
2326
  if (m2 > 0 && s2 > 0)
2251
2327
  {
2260
2336
    {
2261
2337
      if (m5 > 0)
2262
2338
      {
2263
 
        mhi= pow5mult(mhi, m5);
2264
 
        b1= mult(mhi, b);
2265
 
        Bfree(b);
 
2339
        mhi= pow5mult(mhi, m5, &alloc);
 
2340
        b1= mult(mhi, b, &alloc);
 
2341
        Bfree(b, &alloc);
2266
2342
        b= b1;
2267
2343
      }
2268
2344
      if ((j= b5 - m5))
2269
 
        b= pow5mult(b, j);
 
2345
        b= pow5mult(b, j, &alloc);
2270
2346
    }
2271
2347
    else
2272
 
      b= pow5mult(b, b5);
 
2348
      b= pow5mult(b, b5, &alloc);
2273
2349
  }
2274
 
  S= i2b(1);
 
2350
  S= i2b(1, &alloc);
2275
2351
  if (s5 > 0)
2276
 
    S= pow5mult(S, s5);
 
2352
    S= pow5mult(S, s5, &alloc);
2277
2353
 
2278
2354
  /* Check for special case that d is a normalized power of 2. */
2279
2355
 
2317
2393
    s2+= i;
2318
2394
  }
2319
2395
  if (b2 > 0)
2320
 
    b= lshift(b, b2);
 
2396
    b= lshift(b, b2, &alloc);
2321
2397
  if (s2 > 0)
2322
 
    S= lshift(S, s2);
 
2398
    S= lshift(S, s2, &alloc);
2323
2399
  if (k_check)
2324
2400
  {
2325
2401
    if (cmp(b,S) < 0)
2326
2402
    {
2327
2403
      k--;
2328
2404
      /* we botched the k estimate */
2329
 
      b= multadd(b, 10, 0);
 
2405
      b= multadd(b, 10, 0, &alloc);
2330
2406
      if (leftright)
2331
 
        mhi= multadd(mhi, 10, 0);
 
2407
        mhi= multadd(mhi, 10, 0, &alloc);
2332
2408
      ilim= ilim1;
2333
2409
    }
2334
2410
  }
2335
2411
  if (ilim <= 0 && (mode == 3 || mode == 5))
2336
2412
  {
2337
 
    if (ilim < 0 || cmp(b,S= multadd(S,5,0)) <= 0)
 
2413
    if (ilim < 0 || cmp(b,S= multadd(S,5,0, &alloc)) <= 0)
2338
2414
    {
2339
2415
      /* no digits, fcvt style */
2340
2416
no_digits:
2349
2425
  if (leftright)
2350
2426
  {
2351
2427
    if (m2 > 0)
2352
 
      mhi= lshift(mhi, m2);
 
2428
      mhi= lshift(mhi, m2, &alloc);
2353
2429
 
2354
2430
    /*
2355
2431
      Compute mlo -- check for special case that d is a normalized power of 2.
2358
2434
    mlo= mhi;
2359
2435
    if (spec_case)
2360
2436
    {
2361
 
      mhi= Balloc(mhi->k);
 
2437
      mhi= Balloc(mhi->k, &alloc);
2362
2438
      Bcopy(mhi, mlo);
2363
 
      mhi= lshift(mhi, Log2P);
 
2439
      mhi= lshift(mhi, Log2P, &alloc);
2364
2440
    }
2365
2441
 
2366
2442
    for (i= 1;;i++)
2368
2444
      dig= quorem(b,S) + '0';
2369
2445
      /* Do we yet have the shortest decimal string that will round to d? */
2370
2446
      j= cmp(b, mlo);
2371
 
      delta= diff(S, mhi);
 
2447
      delta= diff(S, mhi, &alloc);
2372
2448
      j1= delta->sign ? 1 : cmp(b, delta);
2373
 
      Bfree(delta);
 
2449
      Bfree(delta, &alloc);
2374
2450
      if (j1 == 0 && mode != 1 && !(word1(d) & 1)
2375
2451
         )
2376
2452
      {
2389
2465
        }
2390
2466
        if (j1 > 0)
2391
2467
        {
2392
 
          b= lshift(b, 1);
 
2468
          b= lshift(b, 1, &alloc);
2393
2469
          j1= cmp(b, S);
2394
2470
          if ((j1 > 0 || (j1 == 0 && dig & 1))
2395
2471
              && dig++ == '9')
2413
2489
      *s++= dig;
2414
2490
      if (i == ilim)
2415
2491
        break;
2416
 
      b= multadd(b, 10, 0);
 
2492
      b= multadd(b, 10, 0, &alloc);
2417
2493
      if (mlo == mhi)
2418
 
        mlo= mhi= multadd(mhi, 10, 0);
 
2494
        mlo= mhi= multadd(mhi, 10, 0, &alloc);
2419
2495
      else
2420
2496
      {
2421
 
        mlo= multadd(mlo, 10, 0);
2422
 
        mhi= multadd(mhi, 10, 0);
 
2497
        mlo= multadd(mlo, 10, 0, &alloc);
 
2498
        mhi= multadd(mhi, 10, 0, &alloc);
2423
2499
      }
2424
2500
    }
2425
2501
  }
2433
2509
      }
2434
2510
      if (i >= ilim)
2435
2511
        break;
2436
 
      b= multadd(b, 10, 0);
 
2512
      b= multadd(b, 10, 0, &alloc);
2437
2513
    }
2438
2514
 
2439
2515
  /* Round off last digit */
2440
2516
 
2441
 
  b= lshift(b, 1);
 
2517
  b= lshift(b, 1, &alloc);
2442
2518
  j= cmp(b, S);
2443
2519
  if (j > 0 || (j == 0 && dig & 1))
2444
2520
  {
2458
2534
    s++;
2459
2535
  }
2460
2536
ret:
2461
 
  Bfree(S);
 
2537
  Bfree(S, &alloc);
2462
2538
  if (mhi)
2463
2539
  {
2464
2540
    if (mlo && mlo != mhi)
2465
 
      Bfree(mlo);
2466
 
    Bfree(mhi);
 
2541
      Bfree(mlo, &alloc);
 
2542
    Bfree(mhi, &alloc);
2467
2543
  }
2468
2544
ret1:
2469
 
  Bfree(b);
 
2545
  Bfree(b, &alloc);
2470
2546
  *s= 0;
2471
2547
  *decpt= k + 1;
2472
2548
  if (rve)
2473
2549
    *rve= s;
2474
2550
  return s0;
2475
2551
}
2476
 
 
2477
 
} /* namespace internal */
2478
 
} /* namespace drizzled */