Lines Matching +full:0 +full:- +full:9
29 02110-1301, USA. */
31 /* ------------------------------------------------------------------ */
33 /* ------------------------------------------------------------------ */
38 /* ------------------------------------------------------------------ */
49 /* Conditional code flag -- set this to match hardware platform */
50 /* 1=little-endian, 0=big-endian */
52 #define DECLITEND 0
57 /* Conditional code flag -- set this to 1 for best performance */
58 #define DECUSE64 1 /* 1=use int64s, 0=int32 & smaller only */
60 /* Conditional check flags -- set these to 0 for best performance */
61 #define DECCHECK 0 /* 1 to enable robust checking */
62 #define DECALLOC 0 /* 1 to enable memory accounting */
63 #define DECTRACE 0 /* 1 to trace certain internals, etc. */
71 /* ---------------------------------------------------------------- */
72 /* Definitions for all modules (general-purpose) */
73 /* ---------------------------------------------------------------- */
75 /* Local names for common types -- for safety, decNumber modules do */
90 /* Development-use definitions */
92 #define DECNOINT 0 /* 1 to check no internal use of 'int' */
100 extern const uByte DECSTICKYTAB[10]; /* re-round digits if sticky */
103 extern const uShort DPD2BIN[1024]; /* DPD -> 0-999 */
104 extern const uShort BIN2DPD[1000]; /* 0-999 -> DPD */
105 extern const uInt DPD2BINK[1024]; /* DPD -> 0-999000 */
106 extern const uInt DPD2BINM[1024]; /* DPD -> 0-999000000 */
107 extern const uByte DPD2BCD8[4096]; /* DPD -> ddd + len */
108 extern const uByte BIN2BCD8[4000]; /* 0-999 -> ddd + len */
109 extern const uShort BCD2DPD[2458]; /* 0-0x999 -> DPD (0x999=2457)*/
111 /* LONGMUL32HI -- set w=(u*v)>>32, where w, u, and v are uInts */
112 /* (that is, sets w to be the high-order word of the 64-bit result; */
113 /* the low-order word is simply u*v.) */
118 u0=u & 0xffff; u1=u>>16; \
119 v0=v & 0xffff; v1=v>>16; \
122 w1=t & 0xffff; w2=t>>16; \
126 /* ROUNDUP -- round an integer up to a multiple of n */
127 #define ROUNDUP(i, n) ((((i)+(n)-1)/n)*n)
129 /* ROUNDDOWN -- round an integer down to a multiple of n */
133 /* References to multi-byte sequences under different sizes */
140 /* X10 and X100 -- multiply integer i by 10 or 100 */
145 /* MAXI and MINI -- general max & min (not in ANSI) for integers */
150 #define BILLION 1000000000 /* 10**9 */
151 /* CHARMASK: 0x30303030 for ASCII/UTF8; 0xF0F0F0F0 for EBCDIC */
152 #define CHARMASK ((((((((uInt)'0')<<8)+'0')<<8)+'0')<<8)+'0')
155 /* ---------------------------------------------------------------- */
156 /* Definitions for arbitrary-precision modules (only valid after */
158 /* ---------------------------------------------------------------- */
163 #define DECNUMMINE -999999999 /* minimum adjusted exponent ditto */
174 /* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN */
175 /* digits, and D2UTABLE -- the initializer for the D2U table */
177 #define DECDPUNMAX 9
178 #define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, \
184 #define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10, \
189 #define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7, \
190 8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \
194 #define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6, \
195 6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \
199 #define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5, \
200 5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9, \
201 9,9,10,10,10,10}
204 #define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4, \
206 8,8,8,8,8,9}
209 #define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3, \
214 #define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3, \
217 #elif DECDPUN==9
219 #define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3, \
223 #error DECDPUN must be in the range 1-9
226 /* ----- Shared data (in decNumber.c) ----- */
231 /* ----- Macros ----- */
232 /* ISZERO -- return true if decNumber dn is a zero */
233 /* [performance-critical in some situations] */
236 /* D2U -- return the number of Units needed to hold d digits */
243 #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN)
245 /* SD2U -- static D2U macro (for compile-time calculation) */
246 #define SD2U(d) (((d)+DECDPUN-1)/DECDPUN)
248 /* MSUDIGITS -- returns digits in msu, from digits, calculated */
250 #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN)
252 /* D2N -- return the number of decNumber structs that would be */
258 ((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber))
260 /* TODIGIT -- macro to remove the leading digit from the unsigned */
261 /* integer u at column cut (counting from the right, LSD=0) and */
263 /* c. Note that cut must be <= 9, and the maximum value for u is */
268 *(c)='0'; \
272 if ((u)>=pow) {(u)-=pow; *(c)+=8;} \
274 if ((u)>=pow) {(u)-=pow; *(c)+=4;} \
277 if ((u)>=pow) {(u)-=pow; *(c)+=2;} \
279 if ((u)>=pow) {(u)-=pow; *(c)+=1;} \
282 /* ---------------------------------------------------------------- */
283 /* Definitions for fixed-precision modules (only valid after */
285 /* ---------------------------------------------------------------- */
287 /* bcdnum -- a structure describing a format-independent finite */
290 uByte *msd; /* -> most significant digit */
291 uByte *lsd; /* -> least ditto */
292 uInt sign; /* 0=positive, DECFLOAT_Sign=negative */
301 #define NUMISSPECIAL(num) (EXPISSPECIAL((num)->exponent))
303 /* Refer to a 32-bit word or byte in a decFloat (df) by big-endian */
304 /* (array) notation (the 0 word or byte contains the sign bit), */
306 /* in the next-wider format (decFloatWider, or dfw) */
310 #define DFWORD(df, off) ((df)->words[DECWORDS-1-(off)])
311 #define DFBYTE(df, off) ((df)->bytes[DECBYTES-1-(off)])
312 #define DFWWORD(dfw, off) ((dfw)->words[DECWWORDS-1-(off)])
314 #define DFWORD(df, off) ((df)->words[off])
315 #define DFBYTE(df, off) ((df)->bytes[off])
316 #define DFWWORD(dfw, off) ((dfw)->words[off])
320 #define DFISSIGNED(df) (DFWORD(df, 0)&0x80000000)
321 #define DFISSPECIAL(df) ((DFWORD(df, 0)&0x78000000)==0x78000000)
322 #define DFISINF(df) ((DFWORD(df, 0)&0x7c000000)==0x78000000)
323 #define DFISNAN(df) ((DFWORD(df, 0)&0x7c000000)==0x7c000000)
324 #define DFISQNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7c000000)
325 #define DFISSNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7e000000)
328 extern const uInt DECCOMBMSD[64]; /* Combination field -> MSD */
329 extern const uInt DECCOMBFROM[48]; /* exp+msd -> Combination */
336 /* Format-dependent macros and constants */
340 #define DECPMAX9 (ROUNDUP(DECPMAX, 9)/9) /* 'Pmax' in 10**9s */
342 #define SINGLEZERO 0x22500000
343 #define DOUBLEZERO 0x22380000
344 #define QUADZERO 0x22080000
347 /* Format-dependent common tests: */
348 /* DFISZERO -- test for (any) zero */
349 /* DFISCCZERO -- test for coefficient continuation being zero */
350 /* DFISCC01 -- test for coefficient contains only 0s and 1s */
351 /* DFISINT -- test for finite and exponent q=0 */
352 /* DFISUINT01 -- test for sign=0, finite, exponent q=0, and */
353 /* MSD=0 or 1 */
355 /* In DFISZERO the first test checks the least-significant word */
356 /* (most likely to be non-zero); the penultimate tests MSD and */
364 #define DFISZERO(df) ((DFWORD(df, 0)&0x1c0fffff)==0 \
365 && (DFWORD(df, 0)&0x60000000)!=0x60000000)
368 #define DFISZERO(df) ((DFWORD(df, 1)==0 \
369 && (DFWORD(df, 0)&0x1c03ffff)==0 \
370 && (DFWORD(df, 0)&0x60000000)!=0x60000000))
371 #define DFISINT(df) ((DFWORD(df, 0)&0x63fc0000)==0x22380000 \
372 ||(DFWORD(df, 0)&0x7bfc0000)==0x6a380000)
373 #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbfc0000)==0x22380000)
374 #define DFISCCZERO(df) (DFWORD(df, 1)==0 \
375 && (DFWORD(df, 0)&0x0003ffff)==0)
376 #define DFISCC01(df) ((DFWORD(df, 0)&~0xfffc9124)==0 \
377 && (DFWORD(df, 1)&~0x49124491)==0)
380 #define DFISZERO(df) ((DFWORD(df, 3)==0 \
381 && DFWORD(df, 2)==0 \
382 && DFWORD(df, 1)==0 \
383 && (DFWORD(df, 0)&0x1c003fff)==0 \
384 && (DFWORD(df, 0)&0x60000000)!=0x60000000))
385 #define DFISINT(df) ((DFWORD(df, 0)&0x63ffc000)==0x22080000 \
386 ||(DFWORD(df, 0)&0x7bffc000)==0x6a080000)
387 #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbffc000)==0x22080000)
388 #define DFISCCZERO(df) (DFWORD(df, 3)==0 \
389 && DFWORD(df, 2)==0 \
390 && DFWORD(df, 1)==0 \
391 && (DFWORD(df, 0)&0x00003fff)==0)
393 #define DFISCC01(df) ((DFWORD(df, 0)&~0xffffc912)==0 \
394 && (DFWORD(df, 1)&~0x44912449)==0 \
395 && (DFWORD(df, 2)&~0x12449124)==0 \
396 && (DFWORD(df, 3)&~0x49124491)==0)
401 /* declet is at offset 0 (from the right) in a uInt: */
402 #define CANONDPD(dpd) (((dpd)&0x300)==0 || ((dpd)&0x6e)!=0x6e)
404 #define CANONDPDOFF(dpd, k) (((dpd)&(0x300<<(k)))==0 \
405 || ((dpd)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
407 /* [the top 2 bits will always be in the more-significant uInt] */
408 #define CANONDPDTWO(hi, lo, k) (((hi)&(0x300>>(32-(k))))==0 \
409 || ((hi)&(0x6e>>(32-(k))))!=(0x6e>>(32-(k))) \
410 || ((lo)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
412 /* Macro to test whether a full-length (length DECPMAX) BCD8 */
416 #define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
417 && UINTAT((u)+DECPMAX-7)==0)
419 #define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
420 && (UINTAT((u)+DECPMAX-8)+UINTAT((u)+DECPMAX-12) \
421 +UINTAT((u)+DECPMAX-16))==0)
423 #define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
424 && (UINTAT((u)+DECPMAX-8) +UINTAT((u)+DECPMAX-12) \
425 +UINTAT((u)+DECPMAX-16)+UINTAT((u)+DECPMAX-20) \
426 +UINTAT((u)+DECPMAX-24)+UINTAT((u)+DECPMAX-28) \
427 +UINTAT((u)+DECPMAX-32)+USHORTAT((u)+DECPMAX-34))==0)
432 #define GETECON(df) ((Int)((DFWORD((df), 0)&0x03ffffff)>>(32-6-DECECONL)))
433 /* Ditto, from the next-wider format */
434 #define GETWECON(df) ((Int)((DFWWORD((df), 0)&0x03ffffff)>>(32-6-DECWECONL)))
436 #define GETEXP(df) ((Int)(DECCOMBEXP[DFWORD((df), 0)>>26]+GETECON(df)))
438 #define GETEXPUN(df) ((Int)GETEXP(df)-DECBIAS)
440 #define GETMSD(df) (DECCOMBMSD[DFWORD((df), 0)>>26])
442 /* Compile-time computes of the exponent continuation field masks */
444 #define ECONMASK ((0x03ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
446 #define ECONNANMASK ((0x01ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
451 /* In-line sequence to convert 10 bits at right end of uInt dpd */
457 UINTAT(u)=UINTAT(&DPD2BCD8[((dpd)&0x3ff)*4]);}
460 *(u)=DPD2BCD8[((dpd)&0x3ff)*4]; \
461 *(u+1)=DPD2BCD8[((dpd)&0x3ff)*4+1]; \
462 *(u+2)=DPD2BCD8[((dpd)&0x3ff)*4+2];}
465 /* to BCD8 using a table lookup (also used for variable-length */
466 /* decode). Each DPD decode is 3 bytes BCD8 plus a one-byte */
467 /* length which is not used, here). Fixed-length 4-byte moves */
475 /* GETWCOEFF extracts the coefficient of the next-wider format. */
476 /* The latter is a copy of the next-wider GETCOEFF using DFWWORD. */
480 uInt sourhi=DFWORD(df, 0); \
485 uInt sourhi=DFWWORD(df, 0); \
496 uInt sourhi=DFWORD(df, 0); \
505 uInt sourhi=DFWWORD(df, 0); \
524 uInt sourhi=DFWORD(df, 0); \
545 /* a base-billion uInt array, with the least-significant */
546 /* 0-999999999 'digit' at offset 0. */
550 /* the usual DPD to binary, the other two pre-multiplied by 1000 */
553 /* code for 0 through 9 is the identity. */
558 uInt sourhi=DFWORD(df, 0); \
559 (buf)[0]=DPD2BIN0[sourhi&0x3ff] \
560 +DPD2BINK[(sourhi>>10)&0x3ff] \
567 (buf)[0]=DPD2BIN0[sourlo&0x3ff] \
568 +DPD2BINK[(sourlo>>10)&0x3ff] \
569 +DPD2BINM[(sourlo>>20)&0x3ff]; \
570 sourhi=DFWORD(df, 0); \
571 (buf)[1]=DPD2BIN0[((sourhi<<2) | (sourlo>>30))&0x3ff] \
572 +DPD2BINK[(sourhi>>8)&0x3ff] \
579 (buf)[0]=DPD2BIN0[sourlo&0x3ff] \
580 +DPD2BINK[(sourlo>>10)&0x3ff] \
581 +DPD2BINM[(sourlo>>20)&0x3ff]; \
583 (buf)[1]=DPD2BIN0[((sourml<<2) | (sourlo>>30))&0x3ff] \
584 +DPD2BINK[(sourml>>8)&0x3ff] \
585 +DPD2BINM[(sourml>>18)&0x3ff]; \
587 (buf)[2]=DPD2BIN0[((sourmh<<4) | (sourml>>28))&0x3ff] \
588 +DPD2BINK[(sourmh>>6)&0x3ff] \
589 +DPD2BINM[(sourmh>>16)&0x3ff]; \
590 sourhi=DFWORD(df, 0); \
591 (buf)[3]=DPD2BIN0[((sourhi<<6) | (sourmh>>26))&0x3ff] \
592 +DPD2BINK[(sourhi>>4)&0x3ff] \
598 /* a base-thousand uInt array, with the least-significant 0-999 */
599 /* 'digit' at offset 0. */
605 uInt sourhi=DFWORD(df, 0); \
606 (buf)[0]=DPD2BIN[sourhi&0x3ff]; \
607 (buf)[1]=DPD2BIN[(sourhi>>10)&0x3ff]; \
614 (buf)[0]=DPD2BIN[sourlo&0x3ff]; \
615 (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
616 (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
617 sourhi=DFWORD(df, 0); \
618 (buf)[3]=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \
619 (buf)[4]=DPD2BIN[(sourhi>>8)&0x3ff]; \
626 (buf)[0]=DPD2BIN[sourlo&0x3ff]; \
627 (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
628 (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
630 (buf)[3]=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \
631 (buf)[4]=DPD2BIN[(sourml>>8)&0x3ff]; \
632 (buf)[5]=DPD2BIN[(sourml>>18)&0x3ff]; \
634 (buf)[6]=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \
635 (buf)[7]=DPD2BIN[(sourmh>>6)&0x3ff]; \
636 (buf)[8]=DPD2BIN[(sourmh>>16)&0x3ff]; \
637 sourhi=DFWORD(df, 0); \
638 (buf)[9]=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \
639 (buf)[10]=DPD2BIN[(sourhi>>4)&0x3ff]; \
647 {DFWORD(df, 0)=0x77f3fcff;}
650 {DFWORD(df, 0)=0x77fcff3f; \
651 DFWORD(df, 1)=0xcff3fcff;}
654 {DFWORD(df, 0)=0x77ffcff3; \
655 DFWORD(df, 1)=0xfcff3fcf; \
656 DFWORD(df, 2)=0xf3fcff3f; \
657 DFWORD(df, 3)=0xcff3fcff;}
660 /* [end of format-dependent macros and constants] */