OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [libdecnumber/] [dpd/] [decimal64.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Decimal 64-bit format module for the decNumber C Library.
2
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3
   Contributed by IBM Corporation.  Author Mike Cowlishaw.
4
 
5
   This file is part of GCC.
6
 
7
   GCC is free software; you can redistribute it and/or modify it under
8
   the terms of the GNU General Public License as published by the Free
9
   Software Foundation; either version 2, or (at your option) any later
10
   version.
11
 
12
   In addition to the permissions in the GNU General Public License,
13
   the Free Software Foundation gives you unlimited permission to link
14
   the compiled version of this file into combinations with other
15
   programs, and to distribute those combinations without any
16
   restriction coming from the use of this file.  (The General Public
17
   License restrictions do apply in other respects; for example, they
18
   cover modification of the file, and distribution when not linked
19
   into a combine executable.)
20
 
21
   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
22
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
23
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
24
   for more details.
25
 
26
   You should have received a copy of the GNU General Public License
27
   along with GCC; see the file COPYING.  If not, write to the Free
28
   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
29
   02110-1301, USA.  */
30
 
31
/* ------------------------------------------------------------------ */
32
/* Decimal 64-bit format module                                       */
33
/* ------------------------------------------------------------------ */
34
/* This module comprises the routines for decimal64 format numbers.   */
35
/* Conversions are supplied to and from decNumber and String.         */
36
/*                                                                    */
37
/* This is used when decNumber provides operations, either for all    */
38
/* operations or as a proxy between decNumber and decSingle.          */
39
/*                                                                    */
40
/* Error handling is the same as decNumber (qv.).                     */
41
/* ------------------------------------------------------------------ */
42
#include <string.h>           /* [for memset/memcpy] */
43
#include <stdio.h>            /* [for printf] */
44
 
45
#include "config.h"           /* GCC definitions */
46
#define  DECNUMDIGITS 16      /* make decNumbers with space for 16 */
47
#include "decNumber.h"        /* base number library */
48
#include "decNumberLocal.h"   /* decNumber local types, etc. */
49
#include "decimal64.h"        /* our primary include */
50
 
51
/* Utility routines and tables [in decimal64.c]; externs for C++ */
52
extern const uInt COMBEXP[32], COMBMSD[32];
53
extern const uShort DPD2BIN[1024];
54
extern const uShort BIN2DPD[1000];
55
extern const uByte  BIN2CHAR[4001];
56
 
57
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
58
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
59
 
60
#if DECTRACE || DECCHECK
61
void decimal64Show(const decimal64 *);            /* for debug */
62
extern void decNumberShow(const decNumber *);     /* .. */
63
#endif
64
 
65
/* Useful macro */
66
/* Clear a structure (e.g., a decNumber) */
67
#define DEC_clear(d) memset(d, 0, sizeof(*d))
68
 
69
/* define and include the tables to use for conversions */
70
#define DEC_BIN2CHAR 1
71
#define DEC_DPD2BIN  1
72
#define DEC_BIN2DPD  1             /* used for all sizes */
73
#include "decDPD.h"                /* lookup tables */
74
 
75
/* ------------------------------------------------------------------ */
76
/* decimal64FromNumber -- convert decNumber to decimal64              */
77
/*                                                                    */
78
/*   ds is the target decimal64                                       */
79
/*   dn is the source number (assumed valid)                          */
80
/*   set is the context, used only for reporting errors               */
81
/*                                                                    */
82
/* The set argument is used only for status reporting and for the     */
83
/* rounding mode (used if the coefficient is more than DECIMAL64_Pmax */
84
/* digits or an overflow is detected).  If the exponent is out of the */
85
/* valid range then Overflow or Underflow will be raised.             */
86
/* After Underflow a subnormal result is possible.                    */
87
/*                                                                    */
88
/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
89
/* by reducing its exponent and multiplying the coefficient by a      */
90
/* power of ten, or if the exponent on a zero had to be clamped.      */
91
/* ------------------------------------------------------------------ */
92
decimal64 * decimal64FromNumber(decimal64 *d64, const decNumber *dn,
93
                                decContext *set) {
94
  uInt status=0;            /* status accumulator */
95
  Int ae;                          /* adjusted exponent */
96
  decNumber  dw;                   /* work */
97
  decContext dc;                   /* .. */
98
  uInt *pu;                        /* .. */
99
  uInt comb, exp;                  /* .. */
100
  uInt targar[2]={0, 0};     /* target 64-bit */
101
  #define targhi targar[1]         /* name the word with the sign */
102
  #define targlo targar[0]         /* and the other */
103
 
104
  /* If the number has too many digits, or the exponent could be */
105
  /* out of range then reduce the number under the appropriate */
106
  /* constraints.  This could push the number to Infinity or zero, */
107
  /* so this check and rounding must be done before generating the */
108
  /* decimal64] */
109
  ae=dn->exponent+dn->digits-1;              /* [0 if special] */
110
  if (dn->digits>DECIMAL64_Pmax              /* too many digits */
111
   || ae>DECIMAL64_Emax                      /* likely overflow */
112
   || ae<DECIMAL64_Emin) {                   /* likely underflow */
113
    decContextDefault(&dc, DEC_INIT_DECIMAL64); /* [no traps] */
114
    dc.round=set->round;                     /* use supplied rounding */
115
    decNumberPlus(&dw, dn, &dc);             /* (round and check) */
116
    /* [this changes -0 to 0, so enforce the sign...] */
117
    dw.bits|=dn->bits&DECNEG;
118
    status=dc.status;                        /* save status */
119
    dn=&dw;                                  /* use the work number */
120
    } /* maybe out of range */
121
 
122
  if (dn->bits&DECSPECIAL) {                      /* a special value */
123
    if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
124
     else {                                       /* sNaN or qNaN */
125
      if ((*dn->lsu!=0 || dn->digits>1)            /* non-zero coefficient */
126
       && (dn->digits<DECIMAL64_Pmax)) {          /* coefficient fits */
127
        decDigitsToDPD(dn, targar, 0);
128
        }
129
      if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
130
       else targhi|=DECIMAL_sNaN<<24;
131
      } /* a NaN */
132
    } /* special */
133
 
134
   else { /* is finite */
135
    if (decNumberIsZero(dn)) {               /* is a zero */
136
      /* set and clamp exponent */
137
      if (dn->exponent<-DECIMAL64_Bias) {
138
        exp=0;                                /* low clamp */
139
        status|=DEC_Clamped;
140
        }
141
       else {
142
        exp=dn->exponent+DECIMAL64_Bias;     /* bias exponent */
143
        if (exp>DECIMAL64_Ehigh) {           /* top clamp */
144
          exp=DECIMAL64_Ehigh;
145
          status|=DEC_Clamped;
146
          }
147
        }
148
      comb=(exp>>5) & 0x18;             /* msd=0, exp top 2 bits .. */
149
      }
150
     else {                             /* non-zero finite number */
151
      uInt msd;                         /* work */
152
      Int pad=0;                 /* coefficient pad digits */
153
 
154
      /* the dn is known to fit, but it may need to be padded */
155
      exp=(uInt)(dn->exponent+DECIMAL64_Bias);    /* bias exponent */
156
      if (exp>DECIMAL64_Ehigh) {                  /* fold-down case */
157
        pad=exp-DECIMAL64_Ehigh;
158
        exp=DECIMAL64_Ehigh;                      /* [to maximum] */
159
        status|=DEC_Clamped;
160
        }
161
 
162
      /* fastpath common case */
163
      if (DECDPUN==3 && pad==0) {
164
        uInt dpd[6]={0,0,0,0,0,0};
165
        uInt i;
166
        Int d=dn->digits;
167
        for (i=0; d>0; i++, d-=3) dpd[i]=BIN2DPD[dn->lsu[i]];
168
        targlo =dpd[0];
169
        targlo|=dpd[1]<<10;
170
        targlo|=dpd[2]<<20;
171
        if (dn->digits>6) {
172
          targlo|=dpd[3]<<30;
173
          targhi =dpd[3]>>2;
174
          targhi|=dpd[4]<<8;
175
          }
176
        msd=dpd[5];                /* [did not really need conversion] */
177
        }
178
       else { /* general case */
179
        decDigitsToDPD(dn, targar, pad);
180
        /* save and clear the top digit */
181
        msd=targhi>>18;
182
        targhi&=0x0003ffff;
183
        }
184
 
185
      /* create the combination field */
186
      if (msd>=8) comb=0x18 | ((exp>>7) & 0x06) | (msd & 0x01);
187
             else comb=((exp>>5) & 0x18) | msd;
188
      }
189
    targhi|=comb<<26;              /* add combination field .. */
190
    targhi|=(exp&0xff)<<18;        /* .. and exponent continuation */
191
    } /* finite */
192
 
193
  if (dn->bits&DECNEG) targhi|=0x80000000; /* add sign bit */
194
 
195
  /* now write to storage; this is now always endian */
196
  pu=(uInt *)d64->bytes;           /* overlay */
197
  if (DECLITEND) {
198
    pu[0]=targar[0];                 /* directly store the low int */
199
    pu[1]=targar[1];               /* then the high int */
200
    }
201
   else {
202
    pu[0]=targar[1];                /* directly store the high int */
203
    pu[1]=targar[0];                /* then the low int */
204
    }
205
 
206
  if (status!=0) decContextSetStatus(set, status); /* pass on status */
207
  /* decimal64Show(d64); */
208
  return d64;
209
  } /* decimal64FromNumber */
210
 
211
/* ------------------------------------------------------------------ */
212
/* decimal64ToNumber -- convert decimal64 to decNumber                */
213
/*   d64 is the source decimal64                                      */
214
/*   dn is the target number, with appropriate space                  */
215
/* No error is possible.                                              */
216
/* ------------------------------------------------------------------ */
217
decNumber * decimal64ToNumber(const decimal64 *d64, decNumber *dn) {
218
  uInt msd;                        /* coefficient MSD */
219
  uInt exp;                        /* exponent top two bits */
220
  uInt comb;                       /* combination field */
221
  const uInt *pu;                  /* work */
222
  Int  need;                       /* .. */
223
  uInt sourar[2];                  /* source 64-bit */
224
  #define sourhi sourar[1]         /* name the word with the sign */
225
  #define sourlo sourar[0]         /* and the lower word */
226
 
227
  /* load source from storage; this is endian */
228
  pu=(const uInt *)d64->bytes;     /* overlay */
229
  if (DECLITEND) {
230
    sourlo=pu[0];                   /* directly load the low int */
231
    sourhi=pu[1];                  /* then the high int */
232
    }
233
   else {
234
    sourhi=pu[0];                   /* directly load the high int */
235
    sourlo=pu[1];                  /* then the low int */
236
    }
237
 
238
  comb=(sourhi>>26)&0x1f;          /* combination field */
239
 
240
  decNumberZero(dn);               /* clean number */
241
  if (sourhi&0x80000000) dn->bits=DECNEG; /* set sign if negative */
242
 
243
  msd=COMBMSD[comb];               /* decode the combination field */
244
  exp=COMBEXP[comb];               /* .. */
245
 
246
  if (exp==3) {                    /* is a special */
247
    if (msd==0) {
248
      dn->bits|=DECINF;
249
      return dn;                   /* no coefficient needed */
250
      }
251
    else if (sourhi&0x02000000) dn->bits|=DECSNAN;
252
    else dn->bits|=DECNAN;
253
    msd=0;                          /* no top digit */
254
    }
255
   else {                          /* is a finite number */
256
    dn->exponent=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias; /* unbiased */
257
    }
258
 
259
  /* get the coefficient */
260
  sourhi&=0x0003ffff;              /* clean coefficient continuation */
261
  if (msd) {                       /* non-zero msd */
262
    sourhi|=msd<<18;               /* prefix to coefficient */
263
    need=6;                        /* process 6 declets */
264
    }
265
   else { /* msd=0 */
266
    if (!sourhi) {                 /* top word 0 */
267
      if (!sourlo) return dn;      /* easy: coefficient is 0 */
268
      need=3;                      /* process at least 3 declets */
269
      if (sourlo&0xc0000000) need++; /* process 4 declets */
270
      /* [could reduce some more, here] */
271
      }
272
     else {                        /* some bits in top word, msd=0 */
273
      need=4;                      /* process at least 4 declets */
274
      if (sourhi&0x0003ff00) need++; /* top declet!=0, process 5 */
275
      }
276
    } /*msd=0 */
277
 
278
  decDigitsFromDPD(dn, sourar, need);   /* process declets */
279
  return dn;
280
  } /* decimal64ToNumber */
281
 
282
 
283
/* ------------------------------------------------------------------ */
284
/* to-scientific-string -- conversion to numeric string               */
285
/* to-engineering-string -- conversion to numeric string              */
286
/*                                                                    */
287
/*   decimal64ToString(d64, string);                                  */
288
/*   decimal64ToEngString(d64, string);                               */
289
/*                                                                    */
290
/*  d64 is the decimal64 format number to convert                     */
291
/*  string is the string where the result will be laid out            */
292
/*                                                                    */
293
/*  string must be at least 24 characters                             */
294
/*                                                                    */
295
/*  No error is possible, and no status can be set.                   */
296
/* ------------------------------------------------------------------ */
297
char * decimal64ToEngString(const decimal64 *d64, char *string){
298
  decNumber dn;                         /* work */
299
  decimal64ToNumber(d64, &dn);
300
  decNumberToEngString(&dn, string);
301
  return string;
302
  } /* decimal64ToEngString */
303
 
304
char * decimal64ToString(const decimal64 *d64, char *string){
305
  uInt msd;                        /* coefficient MSD */
306
  Int  exp;                        /* exponent top two bits or full */
307
  uInt comb;                       /* combination field */
308
  char *cstart;                    /* coefficient start */
309
  char *c;                         /* output pointer in string */
310
  const uInt *pu;                  /* work */
311
  char *s, *t;                     /* .. (source, target) */
312
  Int  dpd;                        /* .. */
313
  Int  pre, e;                     /* .. */
314
  const uByte *u;                  /* .. */
315
 
316
  uInt sourar[2];                  /* source 64-bit */
317
  #define sourhi sourar[1]         /* name the word with the sign */
318
  #define sourlo sourar[0]         /* and the lower word */
319
 
320
  /* load source from storage; this is endian */
321
  pu=(const uInt *)d64->bytes;     /* overlay */
322
  if (DECLITEND) {
323
    sourlo=pu[0];                   /* directly load the low int */
324
    sourhi=pu[1];                  /* then the high int */
325
    }
326
   else {
327
    sourhi=pu[0];                   /* directly load the high int */
328
    sourlo=pu[1];                  /* then the low int */
329
    }
330
 
331
  c=string;                        /* where result will go */
332
  if (((Int)sourhi)<0) *c++='-';   /* handle sign */
333
 
334
  comb=(sourhi>>26)&0x1f;          /* combination field */
335
  msd=COMBMSD[comb];               /* decode the combination field */
336
  exp=COMBEXP[comb];               /* .. */
337
 
338
  if (exp==3) {
339
    if (msd==0) {                   /* infinity */
340
      strcpy(c,   "Inf");
341
      strcpy(c+3, "inity");
342
      return string;               /* easy */
343
      }
344
    if (sourhi&0x02000000) *c++='s'; /* sNaN */
345
    strcpy(c, "NaN");              /* complete word */
346
    c+=3;                          /* step past */
347
    if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; /* zero payload */
348
    /* otherwise drop through to add integer; set correct exp */
349
    exp=0; msd=0;            /* setup for following code */
350
    }
351
   else exp=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias;
352
 
353
  /* convert 16 digits of significand to characters */
354
  cstart=c;                        /* save start of coefficient */
355
  if (msd) *c++='0'+(char)msd;     /* non-zero most significant digit */
356
 
357
  /* Now decode the declets.  After extracting each one, it is */
358
  /* decoded to binary and then to a 4-char sequence by table lookup; */
359
  /* the 4-chars are a 1-char length (significant digits, except 000 */
360
  /* has length 0).  This allows us to left-align the first declet */
361
  /* with non-zero content, then remaining ones are full 3-char */
362
  /* length.  We use fixed-length memcpys because variable-length */
363
  /* causes a subroutine call in GCC.  (These are length 4 for speed */
364
  /* and are safe because the array has an extra terminator byte.) */
365
  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
366
                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
367
                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
368
 
369
  dpd=(sourhi>>8)&0x3ff;                     /* declet 1 */
370
  dpd2char;
371
  dpd=((sourhi&0xff)<<2) | (sourlo>>30);     /* declet 2 */
372
  dpd2char;
373
  dpd=(sourlo>>20)&0x3ff;                    /* declet 3 */
374
  dpd2char;
375
  dpd=(sourlo>>10)&0x3ff;                    /* declet 4 */
376
  dpd2char;
377
  dpd=(sourlo)&0x3ff;                        /* declet 5 */
378
  dpd2char;
379
 
380
  if (c==cstart) *c++='0';         /* all zeros -- make 0 */
381
 
382
  if (exp==0) {                     /* integer or NaN case -- easy */
383
    *c='\0';                       /* terminate */
384
    return string;
385
    }
386
 
387
  /* non-0 exponent */
388
  e=0;                              /* assume no E */
389
  pre=c-cstart+exp;
390
  /* [here, pre-exp is the digits count (==1 for zero)] */
391
  if (exp>0 || pre<-5) {    /* need exponential form */
392
    e=pre-1;                       /* calculate E value */
393
    pre=1;                         /* assume one digit before '.' */
394
    } /* exponential form */
395
 
396
  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
397
  s=c-1;                           /* source (LSD) */
398
  if (pre>0) {                      /* ddd.ddd (plain), perhaps with E */
399
    char *dotat=cstart+pre;
400
    if (dotat<c) {                 /* if embedded dot needed... */
401
      t=c;                              /* target */
402
      for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
403
      *t='.';                           /* insert the dot */
404
      c++;                              /* length increased by one */
405
      }
406
 
407
    /* finally add the E-part, if needed; it will never be 0, and has */
408
    /* a maximum length of 3 digits */
409
    if (e!=0) {
410
      *c++='E';                    /* starts with E */
411
      *c++='+';                    /* assume positive */
412
      if (e<0) {
413
        *(c-1)='-';                /* oops, need '-' */
414
        e=-e;                      /* uInt, please */
415
        }
416
      u=&BIN2CHAR[e*4];            /* -> length byte */
417
      memcpy(c, u+4-*u, 4);        /* copy fixed 4 characters [is safe] */
418
      c+=*u;                       /* bump pointer appropriately */
419
      }
420
    *c='\0';                       /* add terminator */
421
    /*printf("res %s\n", string); */
422
    return string;
423
    } /* pre>0 */
424
 
425
  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
426
  t=c+1-pre;
427
  *(t+1)='\0';                          /* can add terminator now */
428
  for (; s>=cstart; s--, t--) *t=*s;    /* shift whole coefficient right */
429
  c=cstart;
430
  *c++='0';                             /* always starts with 0. */
431
  *c++='.';
432
  for (; pre<0; pre++) *c++='0'; /* add any 0's after '.' */
433
  /*printf("res %s\n", string); */
434
  return string;
435
  } /* decimal64ToString */
436
 
437
/* ------------------------------------------------------------------ */
438
/* to-number -- conversion from numeric string                        */
439
/*                                                                    */
440
/*   decimal64FromString(result, string, set);                        */
441
/*                                                                    */
442
/*  result  is the decimal64 format number which gets the result of   */
443
/*          the conversion                                            */
444
/*  *string is the character string which should contain a valid      */
445
/*          number (which may be a special value)                     */
446
/*  set     is the context                                            */
447
/*                                                                    */
448
/* The context is supplied to this routine is used for error handling */
449
/* (setting of status and traps) and for the rounding mode, only.     */
450
/* If an error occurs, the result will be a valid decimal64 NaN.      */
451
/* ------------------------------------------------------------------ */
452
decimal64 * decimal64FromString(decimal64 *result, const char *string,
453
                                decContext *set) {
454
  decContext dc;                             /* work */
455
  decNumber dn;                              /* .. */
456
 
457
  decContextDefault(&dc, DEC_INIT_DECIMAL64); /* no traps, please */
458
  dc.round=set->round;                        /* use supplied rounding */
459
 
460
  decNumberFromString(&dn, string, &dc);     /* will round if needed */
461
 
462
  decimal64FromNumber(result, &dn, &dc);
463
  if (dc.status!=0) {                         /* something happened */
464
    decContextSetStatus(set, dc.status);     /* .. pass it on */
465
    }
466
  return result;
467
  } /* decimal64FromString */
468
 
469
/* ------------------------------------------------------------------ */
470
/* decimal64IsCanonical -- test whether encoding is canonical         */
471
/*   d64 is the source decimal64                                      */
472
/*   returns 1 if the encoding of d64 is canonical, 0 otherwise       */
473
/* No error is possible.                                              */
474
/* ------------------------------------------------------------------ */
475
uint32_t decimal64IsCanonical(const decimal64 *d64) {
476
  decNumber dn;                         /* work */
477
  decimal64 canon;                      /* .. */
478
  decContext dc;                        /* .. */
479
  decContextDefault(&dc, DEC_INIT_DECIMAL64);
480
  decimal64ToNumber(d64, &dn);
481
  decimal64FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
482
  return memcmp(d64, &canon, DECIMAL64_Bytes)==0;
483
  } /* decimal64IsCanonical */
484
 
485
/* ------------------------------------------------------------------ */
486
/* decimal64Canonical -- copy an encoding, ensuring it is canonical   */
487
/*   d64 is the source decimal64                                      */
488
/*   result is the target (may be the same decimal64)                 */
489
/*   returns result                                                   */
490
/* No error is possible.                                              */
491
/* ------------------------------------------------------------------ */
492
decimal64 * decimal64Canonical(decimal64 *result, const decimal64 *d64) {
493
  decNumber dn;                         /* work */
494
  decContext dc;                        /* .. */
495
  decContextDefault(&dc, DEC_INIT_DECIMAL64);
496
  decimal64ToNumber(d64, &dn);
497
  decimal64FromNumber(result, &dn, &dc);/* result will now be canonical */
498
  return result;
499
  } /* decimal64Canonical */
500
 
501
#if DECTRACE || DECCHECK
502
/* Macros for accessing decimal64 fields.  These assume the
503
   argument is a reference (pointer) to the decimal64 structure,
504
   and the decimal64 is in network byte order (big-endian) */
505
/* Get sign */
506
#define decimal64Sign(d)       ((unsigned)(d)->bytes[0]>>7)
507
 
508
/* Get combination field */
509
#define decimal64Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
510
 
511
/* Get exponent continuation [does not remove bias] */
512
#define decimal64ExpCon(d)     ((((d)->bytes[0] & 0x03)<<6)           \
513
                             | ((unsigned)(d)->bytes[1]>>2))
514
 
515
/* Set sign [this assumes sign previously 0] */
516
#define decimal64SetSign(d, b) {                                      \
517
  (d)->bytes[0]|=((unsigned)(b)<<7);}
518
 
519
/* Set exponent continuation [does not apply bias] */
520
/* This assumes range has been checked and exponent previously 0; */
521
/* type of exponent must be unsigned */
522
#define decimal64SetExpCon(d, e) {                                    \
523
  (d)->bytes[0]|=(uint8_t)((e)>>6);                                    \
524
  (d)->bytes[1]|=(uint8_t)(((e)&0x3F)<<2);}
525
 
526
/* ------------------------------------------------------------------ */
527
/* decimal64Show -- display a decimal64 in hexadecimal [debug aid]    */
528
/*   d64 -- the number to show                                        */
529
/* ------------------------------------------------------------------ */
530
/* Also shows sign/cob/expconfields extracted */
531
void decimal64Show(const decimal64 *d64) {
532
  char buf[DECIMAL64_Bytes*2+1];
533
  Int i, j=0;
534
 
535
  if (DECLITEND) {
536
    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
537
      sprintf(&buf[j], "%02x", d64->bytes[7-i]);
538
      }
539
    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
540
           d64->bytes[7]>>7, (d64->bytes[7]>>2)&0x1f,
541
           ((d64->bytes[7]&0x3)<<6)| (d64->bytes[6]>>2));
542
    }
543
   else { /* big-endian */
544
    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
545
      sprintf(&buf[j], "%02x", d64->bytes[i]);
546
      }
547
    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
548
           decimal64Sign(d64), decimal64Comb(d64), decimal64ExpCon(d64));
549
    }
550
  } /* decimal64Show */
551
#endif
552
 
553
/* ================================================================== */
554
/* Shared utility routines and tables                                 */
555
/* ================================================================== */
556
/* define and include the conversion tables to use for shared code */
557
#if DECDPUN==3
558
  #define DEC_DPD2BIN 1
559
#else
560
  #define DEC_DPD2BCD 1
561
#endif
562
#include "decDPD.h"           /* lookup tables */
563
 
564
/* The maximum number of decNumberUnits needed for a working copy of */
565
/* the units array is the ceiling of digits/DECDPUN, where digits is */
566
/* the maximum number of digits in any of the formats for which this */
567
/* is used.  decimal128.h must not be included in this module, so, as */
568
/* a very special case, that number is defined as a literal here. */
569
#define DECMAX754   34
570
#define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
571
 
572
/* ------------------------------------------------------------------ */
573
/* Combination field lookup tables (uInts to save measurable work)    */
574
/*                                                                    */
575
/*      COMBEXP - 2-bit most-significant-bits of exponent             */
576
/*                [11 if an Infinity or NaN]                          */
577
/*      COMBMSD - 4-bit most-significant-digit                        */
578
/*                [0=Infinity, 1=NaN if COMBEXP=11]                   */
579
/*                                                                    */
580
/* Both are indexed by the 5-bit combination field (0-31)             */
581
/* ------------------------------------------------------------------ */
582
const uInt COMBEXP[32]={0, 0, 0, 0, 0, 0, 0, 0,
583
                        1, 1, 1, 1, 1, 1, 1, 1,
584
                        2, 2, 2, 2, 2, 2, 2, 2,
585
                        0, 0, 1, 1, 2, 2, 3, 3};
586
const uInt COMBMSD[32]={0, 1, 2, 3, 4, 5, 6, 7,
587
                        0, 1, 2, 3, 4, 5, 6, 7,
588
                        0, 1, 2, 3, 4, 5, 6, 7,
589
                        8, 9, 8, 9, 8, 9, 0, 1};
590
 
591
/* ------------------------------------------------------------------ */
592
/* decDigitsToDPD -- pack coefficient into DPD form                   */
593
/*                                                                    */
594
/*   dn   is the source number (assumed valid, max DECMAX754 digits)  */
595
/*   targ is 1, 2, or 4-element uInt array, which the caller must     */
596
/*        have cleared to zeros                                       */
597
/*   shift is the number of 0 digits to add on the right (normally 0) */
598
/*                                                                    */
599
/* The coefficient must be known small enough to fit.  The full       */
600
/* coefficient is copied, including the leading 'odd' digit.  This    */
601
/* digit is retrieved and packed into the combination field by the    */
602
/* caller.                                                            */
603
/*                                                                    */
604
/* The target uInts are altered only as necessary to receive the      */
605
/* digits of the decNumber.  When more than one uInt is needed, they  */
606
/* are filled from left to right (that is, the uInt at offset 0 will  */
607
/* end up with the least-significant digits).                         */
608
/*                                                                    */
609
/* shift is used for 'fold-down' padding.                             */
610
/*                                                                    */
611
/* No error is possible.                                              */
612
/* ------------------------------------------------------------------ */
613
#if DECDPUN<=4
614
/* Constant multipliers for divide-by-power-of five using reciprocal */
615
/* multiply, after removing powers of 2 by shifting, and final shift */
616
/* of 17 [we only need up to **4] */
617
static const uInt multies[]={131073, 26215, 5243, 1049, 210};
618
/* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
619
#define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
620
#endif
621
void decDigitsToDPD(const decNumber *dn, uInt *targ, Int shift) {
622
  Int  cut;                   /* work */
623
  Int  n;                     /* output bunch counter */
624
  Int  digits=dn->digits;     /* digit countdown */
625
  uInt dpd;                   /* densely packed decimal value */
626
  uInt bin;                   /* binary value 0-999 */
627
  uInt *uout=targ;            /* -> current output uInt */
628
  uInt  uoff=0;                /* -> current output offset [from right] */
629
  const Unit *inu=dn->lsu;    /* -> current input unit */
630
  Unit  uar[DECMAXUNITS];     /* working copy of units, iff shifted */
631
  #if DECDPUN!=3              /* not fast path */
632
    Unit in;                  /* current unit */
633
  #endif
634
 
635
  if (shift!=0) {              /* shift towards most significant required */
636
    /* shift the units array to the left by pad digits and copy */
637
    /* [this code is a special case of decShiftToMost, which could */
638
    /* be used instead if exposed and the array were copied first] */
639
    const Unit *source;                 /* .. */
640
    Unit  *target, *first;              /* .. */
641
    uInt  next=0;                        /* work */
642
 
643
    source=dn->lsu+D2U(digits)-1;       /* where msu comes from */
644
    target=uar+D2U(digits)-1+D2U(shift);/* where upper part of first cut goes */
645
    cut=DECDPUN-MSUDIGITS(shift);       /* where to slice */
646
    if (cut==0) {                        /* unit-boundary case */
647
      for (; source>=dn->lsu; source--, target--) *target=*source;
648
      }
649
     else {
650
      first=uar+D2U(digits+shift)-1;    /* where msu will end up */
651
      for (; source>=dn->lsu; source--, target--) {
652
        /* split the source Unit and accumulate remainder for next */
653
        #if DECDPUN<=4
654
          uInt quot=QUOT10(*source, cut);
655
          uInt rem=*source-quot*DECPOWERS[cut];
656
          next+=quot;
657
        #else
658
          uInt rem=*source%DECPOWERS[cut];
659
          next+=*source/DECPOWERS[cut];
660
        #endif
661
        if (target<=first) *target=(Unit)next; /* write to target iff valid */
662
        next=rem*DECPOWERS[DECDPUN-cut];       /* save remainder for next Unit */
663
        }
664
      } /* shift-move */
665
    /* propagate remainder to one below and clear the rest */
666
    for (; target>=uar; target--) {
667
      *target=(Unit)next;
668
      next=0;
669
      }
670
    digits+=shift;                 /* add count (shift) of zeros added */
671
    inu=uar;                       /* use units in working array */
672
    }
673
 
674
  /* now densely pack the coefficient into DPD declets */
675
 
676
  #if DECDPUN!=3                   /* not fast path */
677
    in=*inu;                       /* current unit */
678
    cut=0;                          /* at lowest digit */
679
    bin=0;                          /* [keep compiler quiet] */
680
  #endif
681
 
682
  for(n=0; digits>0; n++) {          /* each output bunch */
683
    #if DECDPUN==3                 /* fast path, 3-at-a-time */
684
      bin=*inu;                    /* 3 digits ready for convert */
685
      digits-=3;                   /* [may go negative] */
686
      inu++;                       /* may need another */
687
 
688
    #else                          /* must collect digit-by-digit */
689
      Unit dig;                    /* current digit */
690
      Int j;                       /* digit-in-declet count */
691
      for (j=0; j<3; j++) {
692
        #if DECDPUN<=4
693
          Unit temp=(Unit)((uInt)(in*6554)>>16);
694
          dig=(Unit)(in-X10(temp));
695
          in=temp;
696
        #else
697
          dig=in%10;
698
          in=in/10;
699
        #endif
700
        if (j==0) bin=dig;
701
         else if (j==1)  bin+=X10(dig);
702
         else /* j==2 */ bin+=X100(dig);
703
        digits--;
704
        if (digits==0) break;       /* [also protects *inu below] */
705
        cut++;
706
        if (cut==DECDPUN) {inu++; in=*inu; cut=0;}
707
        }
708
    #endif
709
    /* here there are 3 digits in bin, or have used all input digits */
710
 
711
    dpd=BIN2DPD[bin];
712
 
713
    /* write declet to uInt array */
714
    *uout|=dpd<<uoff;
715
    uoff+=10;
716
    if (uoff<32) continue;         /* no uInt boundary cross */
717
    uout++;
718
    uoff-=32;
719
    *uout|=dpd>>(10-uoff);         /* collect top bits */
720
    } /* n declets */
721
  return;
722
  } /* decDigitsToDPD */
723
 
724
/* ------------------------------------------------------------------ */
725
/* decDigitsFromDPD -- unpack a format's coefficient                  */
726
/*                                                                    */
727
/*   dn is the target number, with 7, 16, or 34-digit space.          */
728
/*   sour is a 1, 2, or 4-element uInt array containing only declets  */
729
/*   declets is the number of (right-aligned) declets in sour to      */
730
/*     be processed.  This may be 1 more than the obvious number in   */
731
/*     a format, as any top digit is prefixed to the coefficient      */
732
/*     continuation field.  It also may be as small as 1, as the      */
733
/*     caller may pre-process leading zero declets.                   */
734
/*                                                                    */
735
/* When doing the 'extra declet' case care is taken to avoid writing  */
736
/* extra digits when there are leading zeros, as these could overflow */
737
/* the units array when DECDPUN is not 3.                             */
738
/*                                                                    */
739
/* The target uInts are used only as necessary to process declets     */
740
/* declets into the decNumber.  When more than one uInt is needed,    */
741
/* they are used from left to right (that is, the uInt at offset 0    */
742
/* provides the least-significant digits).                            */
743
/*                                                                    */
744
/* dn->digits is set, but not the sign or exponent.                   */
745
/* No error is possible [the redundant 888 codes are allowed].        */
746
/* ------------------------------------------------------------------ */
747
void decDigitsFromDPD(decNumber *dn, const uInt *sour, Int declets) {
748
 
749
  uInt  dpd;                       /* collector for 10 bits */
750
  Int   n;                         /* counter */
751
  Unit  *uout=dn->lsu;             /* -> current output unit */
752
  Unit  *last=uout;                /* will be unit containing msd */
753
  const uInt *uin=sour;            /* -> current input uInt */
754
  uInt  uoff=0;                     /* -> current input offset [from right] */
755
 
756
  #if DECDPUN!=3
757
  uInt  bcd;                       /* BCD result */
758
  uInt  nibble;                    /* work */
759
  Unit  out=0;                      /* accumulator */
760
  Int   cut=0;                      /* power of ten in current unit */
761
  #endif
762
  #if DECDPUN>4
763
  uInt const *pow;                 /* work */
764
  #endif
765
 
766
  /* Expand the densely-packed integer, right to left */
767
  for (n=declets-1; n>=0; n--) {   /* count down declets of 10 bits */
768
    dpd=*uin>>uoff;
769
    uoff+=10;
770
    if (uoff>32) {                 /* crossed uInt boundary */
771
      uin++;
772
      uoff-=32;
773
      dpd|=*uin<<(10-uoff);        /* get waiting bits */
774
      }
775
    dpd&=0x3ff;                    /* clear uninteresting bits */
776
 
777
  #if DECDPUN==3
778
    if (dpd==0) *uout=0;
779
     else {
780
      *uout=DPD2BIN[dpd];          /* convert 10 bits to binary 0-999 */
781
      last=uout;                   /* record most significant unit */
782
      }
783
    uout++;
784
    } /* n */
785
 
786
  #else /* DECDPUN!=3 */
787
    if (dpd==0) {                   /* fastpath [e.g., leading zeros] */
788
      /* write out three 0 digits (nibbles); out may have digit(s) */
789
      cut++;
790
      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
791
      if (n==0) break;              /* [as below, works even if MSD=0] */
792
      cut++;
793
      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
794
      cut++;
795
      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
796
      continue;
797
      }
798
 
799
    bcd=DPD2BCD[dpd];              /* convert 10 bits to 12 bits BCD */
800
 
801
    /* now accumulate the 3 BCD nibbles into units */
802
    nibble=bcd & 0x00f;
803
    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
804
    cut++;
805
    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
806
    bcd>>=4;
807
 
808
    /* if this is the last declet and the remaining nibbles in bcd */
809
    /* are 00 then process no more nibbles, because this could be */
810
    /* the 'odd' MSD declet and writing any more Units would then */
811
    /* overflow the unit array */
812
    if (n==0 && !bcd) break;
813
 
814
    nibble=bcd & 0x00f;
815
    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
816
    cut++;
817
    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
818
    bcd>>=4;
819
 
820
    nibble=bcd & 0x00f;
821
    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
822
    cut++;
823
    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
824
    } /* n */
825
  if (cut!=0) {                          /* some more left over */
826
    *uout=out;                          /* write out final unit */
827
    if (out) last=uout;                 /* and note if non-zero */
828
    }
829
  #endif
830
 
831
  /* here, last points to the most significant unit with digits; */
832
  /* inspect it to get the final digits count -- this is essentially */
833
  /* the same code as decGetDigits in decNumber.c */
834
  dn->digits=(last-dn->lsu)*DECDPUN+1;  /* floor of digits, plus */
835
                                        /* must be at least 1 digit */
836
  #if DECDPUN>1
837
  if (*last<10) return;                 /* common odd digit or 0 */
838
  dn->digits++;                         /* must be 2 at least */
839
  #if DECDPUN>2
840
  if (*last<100) return;                /* 10-99 */
841
  dn->digits++;                         /* must be 3 at least */
842
  #if DECDPUN>3
843
  if (*last<1000) return;               /* 100-999 */
844
  dn->digits++;                         /* must be 4 at least */
845
  #if DECDPUN>4
846
  for (pow=&DECPOWERS[4]; *last>=*pow; pow++) dn->digits++;
847
  #endif
848
  #endif
849
  #endif
850
  #endif
851
  return;
852
  } /*decDigitsFromDPD */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.