163d1a8abSmrg /* Local definitions for the decNumber C Library. 2*ec02198aSmrg Copyright (C) 2007-2020 Free Software Foundation, Inc. 363d1a8abSmrg Contributed by IBM Corporation. Author Mike Cowlishaw. 463d1a8abSmrg 563d1a8abSmrg This file is part of GCC. 663d1a8abSmrg 763d1a8abSmrg GCC is free software; you can redistribute it and/or modify it under 863d1a8abSmrg the terms of the GNU General Public License as published by the Free 963d1a8abSmrg Software Foundation; either version 3, or (at your option) any later 1063d1a8abSmrg version. 1163d1a8abSmrg 1263d1a8abSmrg GCC is distributed in the hope that it will be useful, but WITHOUT ANY 1363d1a8abSmrg WARRANTY; without even the implied warranty of MERCHANTABILITY or 1463d1a8abSmrg FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1563d1a8abSmrg for more details. 1663d1a8abSmrg 1763d1a8abSmrg Under Section 7 of GPL version 3, you are granted additional 1863d1a8abSmrg permissions described in the GCC Runtime Library Exception, version 1963d1a8abSmrg 3.1, as published by the Free Software Foundation. 2063d1a8abSmrg 2163d1a8abSmrg You should have received a copy of the GNU General Public License and 2263d1a8abSmrg a copy of the GCC Runtime Library Exception along with this program; 2363d1a8abSmrg see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 2463d1a8abSmrg <http://www.gnu.org/licenses/>. */ 2563d1a8abSmrg 2663d1a8abSmrg /* ------------------------------------------------------------------ */ 2763d1a8abSmrg /* decNumber package local type, tuning, and macro definitions */ 2863d1a8abSmrg /* ------------------------------------------------------------------ */ 2963d1a8abSmrg /* This header file is included by all modules in the decNumber */ 3063d1a8abSmrg /* library, and contains local type definitions, tuning parameters, */ 3163d1a8abSmrg /* etc. It should not need to be used by application programs. */ 3263d1a8abSmrg /* decNumber.h or one of decDouble (etc.) must be included first. */ 3363d1a8abSmrg /* ------------------------------------------------------------------ */ 3463d1a8abSmrg 3563d1a8abSmrg #if !defined(DECNUMBERLOC) 3663d1a8abSmrg #define DECNUMBERLOC 3763d1a8abSmrg #define DECVERSION "decNumber 3.61" /* Package Version [16 max.] */ 3863d1a8abSmrg #define DECNLAUTHOR "Mike Cowlishaw" /* Who to blame */ 3963d1a8abSmrg 4063d1a8abSmrg #include <stdlib.h> /* for abs */ 4163d1a8abSmrg #include <string.h> /* for memset, strcpy */ 4263d1a8abSmrg #include "dconfig.h" /* for WORDS_BIGENDIAN */ 4363d1a8abSmrg 4463d1a8abSmrg /* Conditional code flag -- set this to match hardware platform */ 4563d1a8abSmrg /* 1=little-endian, 0=big-endian */ 4663d1a8abSmrg #if WORDS_BIGENDIAN 4763d1a8abSmrg #define DECLITEND 0 4863d1a8abSmrg #else 4963d1a8abSmrg #define DECLITEND 1 5063d1a8abSmrg #endif 5163d1a8abSmrg 5263d1a8abSmrg #if !defined(DECLITEND) 5363d1a8abSmrg #define DECLITEND 1 /* 1=little-endian, 0=big-endian */ 5463d1a8abSmrg #endif 5563d1a8abSmrg 5663d1a8abSmrg /* Conditional code flag -- set this to 1 for best performance */ 5763d1a8abSmrg #if !defined(DECUSE64) 5863d1a8abSmrg #define DECUSE64 1 /* 1=use int64s, 0=int32 & smaller only */ 5963d1a8abSmrg #endif 6063d1a8abSmrg 6163d1a8abSmrg /* Conditional check flags -- set these to 0 for best performance */ 6263d1a8abSmrg #if !defined(DECCHECK) 6363d1a8abSmrg #define DECCHECK 0 /* 1 to enable robust checking */ 6463d1a8abSmrg #endif 6563d1a8abSmrg #if !defined(DECALLOC) 6663d1a8abSmrg #define DECALLOC 0 /* 1 to enable memory accounting */ 6763d1a8abSmrg #endif 6863d1a8abSmrg #if !defined(DECTRACE) 6963d1a8abSmrg #define DECTRACE 0 /* 1 to trace certain internals, etc. */ 7063d1a8abSmrg #endif 7163d1a8abSmrg 7263d1a8abSmrg /* Tuning parameter for decNumber (arbitrary precision) module */ 7363d1a8abSmrg #if !defined(DECBUFFER) 7463d1a8abSmrg #define DECBUFFER 36 /* Size basis for local buffers. This */ 7563d1a8abSmrg /* should be a common maximum precision */ 7663d1a8abSmrg /* rounded up to a multiple of 4; must */ 7763d1a8abSmrg /* be zero or positive. */ 7863d1a8abSmrg #endif 7963d1a8abSmrg 8063d1a8abSmrg /* ---------------------------------------------------------------- */ 8163d1a8abSmrg /* Definitions for all modules (general-purpose) */ 8263d1a8abSmrg /* ---------------------------------------------------------------- */ 8363d1a8abSmrg 8463d1a8abSmrg /* Local names for common types -- for safety, decNumber modules do */ 8563d1a8abSmrg /* not use int or long directly. */ 8663d1a8abSmrg #define Flag uint8_t 8763d1a8abSmrg #define Byte int8_t 8863d1a8abSmrg #define uByte uint8_t 8963d1a8abSmrg #define Short int16_t 9063d1a8abSmrg #define uShort uint16_t 9163d1a8abSmrg #define Int int32_t 9263d1a8abSmrg #define uInt uint32_t 9363d1a8abSmrg #define Unit decNumberUnit 9463d1a8abSmrg #if DECUSE64 9563d1a8abSmrg #define Long int64_t 9663d1a8abSmrg #define uLong uint64_t 9763d1a8abSmrg #endif 9863d1a8abSmrg 9963d1a8abSmrg /* Development-use definitions */ 10063d1a8abSmrg typedef long int LI; /* for printf arguments only */ 10163d1a8abSmrg #define DECNOINT 0 /* 1 to check no internal use of 'int' */ 10263d1a8abSmrg /* or stdint types */ 10363d1a8abSmrg #if DECNOINT 10463d1a8abSmrg /* if these interfere with your C includes, do not set DECNOINT */ 10563d1a8abSmrg #define int ? /* enable to ensure that plain C 'int' */ 10663d1a8abSmrg #define long ?? /* .. or 'long' types are not used */ 10763d1a8abSmrg #endif 10863d1a8abSmrg 10963d1a8abSmrg /* Shared lookup tables */ 11063d1a8abSmrg extern const uByte DECSTICKYTAB[10]; /* re-round digits if sticky */ 11163d1a8abSmrg extern const uInt DECPOWERS[10]; /* powers of ten table */ 11263d1a8abSmrg /* The following are included from decDPD.h */ 11363d1a8abSmrg #include "decDPDSymbols.h" 11463d1a8abSmrg extern const uShort DPD2BIN[1024]; /* DPD -> 0-999 */ 11563d1a8abSmrg extern const uShort BIN2DPD[1000]; /* 0-999 -> DPD */ 11663d1a8abSmrg extern const uInt DPD2BINK[1024]; /* DPD -> 0-999000 */ 11763d1a8abSmrg extern const uInt DPD2BINM[1024]; /* DPD -> 0-999000000 */ 11863d1a8abSmrg extern const uByte DPD2BCD8[4096]; /* DPD -> ddd + len */ 11963d1a8abSmrg extern const uByte BIN2BCD8[4000]; /* 0-999 -> ddd + len */ 12063d1a8abSmrg extern const uShort BCD2DPD[2458]; /* 0-0x999 -> DPD (0x999=2457)*/ 12163d1a8abSmrg 12263d1a8abSmrg /* LONGMUL32HI -- set w=(u*v)>>32, where w, u, and v are uInts */ 12363d1a8abSmrg /* (that is, sets w to be the high-order word of the 64-bit result; */ 12463d1a8abSmrg /* the low-order word is simply u*v.) */ 12563d1a8abSmrg /* This version is derived from Knuth via Hacker's Delight; */ 12663d1a8abSmrg /* it seems to optimize better than some others tried */ 12763d1a8abSmrg #define LONGMUL32HI(w, u, v) { \ 12863d1a8abSmrg uInt u0, u1, v0, v1, w0, w1, w2, t; \ 12963d1a8abSmrg u0=u & 0xffff; u1=u>>16; \ 13063d1a8abSmrg v0=v & 0xffff; v1=v>>16; \ 13163d1a8abSmrg w0=u0*v0; \ 13263d1a8abSmrg t=u1*v0 + (w0>>16); \ 13363d1a8abSmrg w1=t & 0xffff; w2=t>>16; \ 13463d1a8abSmrg w1=u0*v1 + w1; \ 13563d1a8abSmrg (w)=u1*v1 + w2 + (w1>>16);} 13663d1a8abSmrg 13763d1a8abSmrg /* ROUNDUP -- round an integer up to a multiple of n */ 13863d1a8abSmrg #define ROUNDUP(i, n) ((((i)+(n)-1)/n)*n) 13963d1a8abSmrg #define ROUNDUP4(i) (((i)+3)&~3) /* special for n=4 */ 14063d1a8abSmrg 14163d1a8abSmrg /* ROUNDDOWN -- round an integer down to a multiple of n */ 14263d1a8abSmrg #define ROUNDDOWN(i, n) (((i)/n)*n) 14363d1a8abSmrg #define ROUNDDOWN4(i) ((i)&~3) /* special for n=4 */ 14463d1a8abSmrg 14563d1a8abSmrg /* References to multi-byte sequences under different sizes; these */ 14663d1a8abSmrg /* require locally declared variables, but do not violate strict */ 14763d1a8abSmrg /* aliasing or alignment (as did the UINTAT simple cast to uInt). */ 14863d1a8abSmrg /* Variables needed are uswork, uiwork, etc. [so do not use at same */ 14963d1a8abSmrg /* level in an expression, e.g., UBTOUI(x)==UBTOUI(y) may fail]. */ 15063d1a8abSmrg 15163d1a8abSmrg /* Return a uInt, etc., from bytes starting at a char* or uByte* */ 15263d1a8abSmrg #define UBTOUS(b) (memcpy((void *)&uswork, b, 2), uswork) 15363d1a8abSmrg #define UBTOUI(b) (memcpy((void *)&uiwork, b, 4), uiwork) 15463d1a8abSmrg 15563d1a8abSmrg /* Store a uInt, etc., into bytes starting at a char* or uByte*. */ 15663d1a8abSmrg /* Has to use uiwork because i may be an expression. */ 15763d1a8abSmrg #define UBFROMUS(b, i) (uswork=(i), memcpy(b, (void *)&uswork, 2)) 15863d1a8abSmrg #define UBFROMUI(b, i) (uiwork=(i), memcpy(b, (void *)&uiwork, 4)) 15963d1a8abSmrg 16063d1a8abSmrg /* X10 and X100 -- multiply integer i by 10 or 100 */ 16163d1a8abSmrg /* [shifts are usually faster than multiply; could be conditional] */ 16263d1a8abSmrg #define X10(i) (((i)<<1)+((i)<<3)) 16363d1a8abSmrg #define X100(i) (((i)<<2)+((i)<<5)+((i)<<6)) 16463d1a8abSmrg 16563d1a8abSmrg /* MAXI and MINI -- general max & min (not in ANSI) for integers */ 16663d1a8abSmrg #define MAXI(x,y) ((x)<(y)?(y):(x)) 16763d1a8abSmrg #define MINI(x,y) ((x)>(y)?(y):(x)) 16863d1a8abSmrg 16963d1a8abSmrg /* Useful constants */ 17063d1a8abSmrg #define BILLION 1000000000 /* 10**9 */ 17163d1a8abSmrg /* CHARMASK: 0x30303030 for ASCII/UTF8; 0xF0F0F0F0 for EBCDIC */ 17263d1a8abSmrg #define CHARMASK ((((((((uInt)'0')<<8)+'0')<<8)+'0')<<8)+'0') 17363d1a8abSmrg 17463d1a8abSmrg 17563d1a8abSmrg /* ---------------------------------------------------------------- */ 17663d1a8abSmrg /* Definitions for arbitary-precision modules (only valid after */ 17763d1a8abSmrg /* decNumber.h has been included) */ 17863d1a8abSmrg /* ---------------------------------------------------------------- */ 17963d1a8abSmrg 18063d1a8abSmrg /* Limits and constants */ 18163d1a8abSmrg #define DECNUMMAXP 999999999 /* maximum precision code can handle */ 18263d1a8abSmrg #define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto */ 18363d1a8abSmrg #define DECNUMMINE -999999999 /* minimum adjusted exponent ditto */ 18463d1a8abSmrg #if (DECNUMMAXP != DEC_MAX_DIGITS) 18563d1a8abSmrg #error Maximum digits mismatch 18663d1a8abSmrg #endif 18763d1a8abSmrg #if (DECNUMMAXE != DEC_MAX_EMAX) 18863d1a8abSmrg #error Maximum exponent mismatch 18963d1a8abSmrg #endif 19063d1a8abSmrg #if (DECNUMMINE != DEC_MIN_EMIN) 19163d1a8abSmrg #error Minimum exponent mismatch 19263d1a8abSmrg #endif 19363d1a8abSmrg 19463d1a8abSmrg /* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN */ 19563d1a8abSmrg /* digits, and D2UTABLE -- the initializer for the D2U table */ 19663d1a8abSmrg #if DECDPUN==1 19763d1a8abSmrg #define DECDPUNMAX 9 19863d1a8abSmrg #define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, \ 19963d1a8abSmrg 18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, \ 20063d1a8abSmrg 33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, \ 20163d1a8abSmrg 48,49} 20263d1a8abSmrg #elif DECDPUN==2 20363d1a8abSmrg #define DECDPUNMAX 99 20463d1a8abSmrg #define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10, \ 20563d1a8abSmrg 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18, \ 20663d1a8abSmrg 18,19,19,20,20,21,21,22,22,23,23,24,24,25} 20763d1a8abSmrg #elif DECDPUN==3 20863d1a8abSmrg #define DECDPUNMAX 999 20963d1a8abSmrg #define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7, \ 21063d1a8abSmrg 8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \ 21163d1a8abSmrg 13,14,14,14,15,15,15,16,16,16,17} 21263d1a8abSmrg #elif DECDPUN==4 21363d1a8abSmrg #define DECDPUNMAX 9999 21463d1a8abSmrg #define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6, \ 21563d1a8abSmrg 6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \ 21663d1a8abSmrg 11,11,11,12,12,12,12,13} 21763d1a8abSmrg #elif DECDPUN==5 21863d1a8abSmrg #define DECDPUNMAX 99999 21963d1a8abSmrg #define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5, \ 22063d1a8abSmrg 5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9, \ 22163d1a8abSmrg 9,9,10,10,10,10} 22263d1a8abSmrg #elif DECDPUN==6 22363d1a8abSmrg #define DECDPUNMAX 999999 22463d1a8abSmrg #define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4, \ 22563d1a8abSmrg 4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8, \ 22663d1a8abSmrg 8,8,8,8,8,9} 22763d1a8abSmrg #elif DECDPUN==7 22863d1a8abSmrg #define DECDPUNMAX 9999999 22963d1a8abSmrg #define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3, \ 23063d1a8abSmrg 4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7, \ 23163d1a8abSmrg 7,7,7,7,7,7} 23263d1a8abSmrg #elif DECDPUN==8 23363d1a8abSmrg #define DECDPUNMAX 99999999 23463d1a8abSmrg #define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3, \ 23563d1a8abSmrg 3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6, \ 23663d1a8abSmrg 6,6,6,6,6,7} 23763d1a8abSmrg #elif DECDPUN==9 23863d1a8abSmrg #define DECDPUNMAX 999999999 23963d1a8abSmrg #define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3, \ 24063d1a8abSmrg 3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5, \ 24163d1a8abSmrg 5,5,6,6,6,6} 24263d1a8abSmrg #elif defined(DECDPUN) 24363d1a8abSmrg #error DECDPUN must be in the range 1-9 24463d1a8abSmrg #endif 24563d1a8abSmrg 24663d1a8abSmrg /* ----- Shared data (in decNumber.c) ----- */ 24763d1a8abSmrg /* Public lookup table used by the D2U macro (see below) */ 24863d1a8abSmrg #define DECMAXD2U 49 24963d1a8abSmrg extern const uByte d2utable[DECMAXD2U+1]; 25063d1a8abSmrg 25163d1a8abSmrg /* ----- Macros ----- */ 25263d1a8abSmrg /* ISZERO -- return true if decNumber dn is a zero */ 25363d1a8abSmrg /* [performance-critical in some situations] */ 25463d1a8abSmrg #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ 25563d1a8abSmrg 25663d1a8abSmrg /* D2U -- return the number of Units needed to hold d digits */ 25763d1a8abSmrg /* (runtime version, with table lookaside for small d) */ 25863d1a8abSmrg #if DECDPUN==8 25963d1a8abSmrg #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+7)>>3)) 26063d1a8abSmrg #elif DECDPUN==4 26163d1a8abSmrg #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+3)>>2)) 26263d1a8abSmrg #else 26363d1a8abSmrg #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) 26463d1a8abSmrg #endif 26563d1a8abSmrg /* SD2U -- static D2U macro (for compile-time calculation) */ 26663d1a8abSmrg #define SD2U(d) (((d)+DECDPUN-1)/DECDPUN) 26763d1a8abSmrg 26863d1a8abSmrg /* MSUDIGITS -- returns digits in msu, from digits, calculated */ 26963d1a8abSmrg /* using D2U */ 27063d1a8abSmrg #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) 27163d1a8abSmrg 27263d1a8abSmrg /* D2N -- return the number of decNumber structs that would be */ 27363d1a8abSmrg /* needed to contain that number of digits (and the initial */ 27463d1a8abSmrg /* decNumber struct) safely. Note that one Unit is included in the */ 27563d1a8abSmrg /* initial structure. Used for allocating space that is aligned on */ 27663d1a8abSmrg /* a decNumber struct boundary. */ 27763d1a8abSmrg #define D2N(d) \ 27863d1a8abSmrg ((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber)) 27963d1a8abSmrg 28063d1a8abSmrg /* TODIGIT -- macro to remove the leading digit from the unsigned */ 28163d1a8abSmrg /* integer u at column cut (counting from the right, LSD=0) and */ 28263d1a8abSmrg /* place it as an ASCII character into the character pointed to by */ 28363d1a8abSmrg /* c. Note that cut must be <= 9, and the maximum value for u is */ 28463d1a8abSmrg /* 2,000,000,000 (as is needed for negative exponents of */ 28563d1a8abSmrg /* subnormals). The unsigned integer pow is used as a temporary */ 28663d1a8abSmrg /* variable. */ 28763d1a8abSmrg #define TODIGIT(u, cut, c, pow) { \ 28863d1a8abSmrg *(c)='0'; \ 28963d1a8abSmrg pow=DECPOWERS[cut]*2; \ 29063d1a8abSmrg if ((u)>pow) { \ 29163d1a8abSmrg pow*=4; \ 29263d1a8abSmrg if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ 29363d1a8abSmrg pow/=2; \ 29463d1a8abSmrg if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ 29563d1a8abSmrg pow/=2; \ 29663d1a8abSmrg } \ 29763d1a8abSmrg if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ 29863d1a8abSmrg pow/=2; \ 29963d1a8abSmrg if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ 30063d1a8abSmrg } 30163d1a8abSmrg 30263d1a8abSmrg /* ---------------------------------------------------------------- */ 30363d1a8abSmrg /* Definitions for fixed-precision modules (only valid after */ 30463d1a8abSmrg /* decSingle.h, decDouble.h, or decQuad.h has been included) */ 30563d1a8abSmrg /* ---------------------------------------------------------------- */ 30663d1a8abSmrg 30763d1a8abSmrg /* bcdnum -- a structure describing a format-independent finite */ 30863d1a8abSmrg /* number, whose coefficient is a string of bcd8 uBytes */ 30963d1a8abSmrg typedef struct { 31063d1a8abSmrg uByte *msd; /* -> most significant digit */ 31163d1a8abSmrg uByte *lsd; /* -> least ditto */ 31263d1a8abSmrg uInt sign; /* 0=positive, DECFLOAT_Sign=negative */ 31363d1a8abSmrg Int exponent; /* Unadjusted signed exponent (q), or */ 31463d1a8abSmrg /* DECFLOAT_NaN etc. for a special */ 31563d1a8abSmrg } bcdnum; 31663d1a8abSmrg 31763d1a8abSmrg /* Test if exponent or bcdnum exponent must be a special, etc. */ 31863d1a8abSmrg #define EXPISSPECIAL(exp) ((exp)>=DECFLOAT_MinSp) 31963d1a8abSmrg #define EXPISINF(exp) (exp==DECFLOAT_Inf) 32063d1a8abSmrg #define EXPISNAN(exp) (exp==DECFLOAT_qNaN || exp==DECFLOAT_sNaN) 32163d1a8abSmrg #define NUMISSPECIAL(num) (EXPISSPECIAL((num)->exponent)) 32263d1a8abSmrg 32363d1a8abSmrg /* Refer to a 32-bit word or byte in a decFloat (df) by big-endian */ 32463d1a8abSmrg /* (array) notation (the 0 word or byte contains the sign bit), */ 32563d1a8abSmrg /* automatically adjusting for endianness; similarly address a word */ 32663d1a8abSmrg /* in the next-wider format (decFloatWider, or dfw) */ 32763d1a8abSmrg #define DECWORDS (DECBYTES/4) 32863d1a8abSmrg #define DECWWORDS (DECWBYTES/4) 32963d1a8abSmrg #if DECLITEND 33063d1a8abSmrg #define DFBYTE(df, off) ((df)->bytes[DECBYTES-1-(off)]) 33163d1a8abSmrg #define DFWORD(df, off) ((df)->words[DECWORDS-1-(off)]) 33263d1a8abSmrg #define DFWWORD(dfw, off) ((dfw)->words[DECWWORDS-1-(off)]) 33363d1a8abSmrg #else 33463d1a8abSmrg #define DFBYTE(df, off) ((df)->bytes[off]) 33563d1a8abSmrg #define DFWORD(df, off) ((df)->words[off]) 33663d1a8abSmrg #define DFWWORD(dfw, off) ((dfw)->words[off]) 33763d1a8abSmrg #endif 33863d1a8abSmrg 33963d1a8abSmrg /* Tests for sign or specials, directly on DECFLOATs */ 34063d1a8abSmrg #define DFISSIGNED(df) (DFWORD(df, 0)&0x80000000) 34163d1a8abSmrg #define DFISSPECIAL(df) ((DFWORD(df, 0)&0x78000000)==0x78000000) 34263d1a8abSmrg #define DFISINF(df) ((DFWORD(df, 0)&0x7c000000)==0x78000000) 34363d1a8abSmrg #define DFISNAN(df) ((DFWORD(df, 0)&0x7c000000)==0x7c000000) 34463d1a8abSmrg #define DFISQNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7c000000) 34563d1a8abSmrg #define DFISSNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7e000000) 34663d1a8abSmrg 34763d1a8abSmrg /* Shared lookup tables */ 34863d1a8abSmrg #include "decCommonSymbols.h" 34963d1a8abSmrg extern const uInt DECCOMBMSD[64]; /* Combination field -> MSD */ 35063d1a8abSmrg extern const uInt DECCOMBFROM[48]; /* exp+msd -> Combination */ 35163d1a8abSmrg 35263d1a8abSmrg /* Private generic (utility) routine */ 35363d1a8abSmrg #if DECCHECK || DECTRACE 35463d1a8abSmrg extern void decShowNum(const bcdnum *, const char *); 35563d1a8abSmrg #endif 35663d1a8abSmrg 35763d1a8abSmrg /* Format-dependent macros and constants */ 35863d1a8abSmrg #if defined(DECPMAX) 35963d1a8abSmrg 36063d1a8abSmrg /* Useful constants */ 36163d1a8abSmrg #define DECPMAX9 (ROUNDUP(DECPMAX, 9)/9) /* 'Pmax' in 10**9s */ 36263d1a8abSmrg /* Top words for a zero */ 36363d1a8abSmrg #define SINGLEZERO 0x22500000 36463d1a8abSmrg #define DOUBLEZERO 0x22380000 36563d1a8abSmrg #define QUADZERO 0x22080000 36663d1a8abSmrg /* [ZEROWORD is defined to be one of these in the DFISZERO macro] */ 36763d1a8abSmrg 36863d1a8abSmrg /* Format-dependent common tests: */ 36963d1a8abSmrg /* DFISZERO -- test for (any) zero */ 37063d1a8abSmrg /* DFISCCZERO -- test for coefficient continuation being zero */ 37163d1a8abSmrg /* DFISCC01 -- test for coefficient contains only 0s and 1s */ 37263d1a8abSmrg /* DFISINT -- test for finite and exponent q=0 */ 37363d1a8abSmrg /* DFISUINT01 -- test for sign=0, finite, exponent q=0, and */ 37463d1a8abSmrg /* MSD=0 or 1 */ 37563d1a8abSmrg /* ZEROWORD is also defined here. */ 37663d1a8abSmrg /* In DFISZERO the first test checks the least-significant word */ 37763d1a8abSmrg /* (most likely to be non-zero); the penultimate tests MSD and */ 37863d1a8abSmrg /* DPDs in the signword, and the final test excludes specials and */ 37963d1a8abSmrg /* MSD>7. DFISINT similarly has to allow for the two forms of */ 38063d1a8abSmrg /* MSD codes. DFISUINT01 only has to allow for one form of MSD */ 38163d1a8abSmrg /* code. */ 38263d1a8abSmrg #if DECPMAX==7 38363d1a8abSmrg #define ZEROWORD SINGLEZERO 38463d1a8abSmrg /* [test macros not needed except for Zero] */ 38563d1a8abSmrg #define DFISZERO(df) ((DFWORD(df, 0)&0x1c0fffff)==0 \ 38663d1a8abSmrg && (DFWORD(df, 0)&0x60000000)!=0x60000000) 38763d1a8abSmrg #elif DECPMAX==16 38863d1a8abSmrg #define ZEROWORD DOUBLEZERO 38963d1a8abSmrg #define DFISZERO(df) ((DFWORD(df, 1)==0 \ 39063d1a8abSmrg && (DFWORD(df, 0)&0x1c03ffff)==0 \ 39163d1a8abSmrg && (DFWORD(df, 0)&0x60000000)!=0x60000000)) 39263d1a8abSmrg #define DFISINT(df) ((DFWORD(df, 0)&0x63fc0000)==0x22380000 \ 39363d1a8abSmrg ||(DFWORD(df, 0)&0x7bfc0000)==0x6a380000) 39463d1a8abSmrg #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbfc0000)==0x22380000) 39563d1a8abSmrg #define DFISCCZERO(df) (DFWORD(df, 1)==0 \ 39663d1a8abSmrg && (DFWORD(df, 0)&0x0003ffff)==0) 39763d1a8abSmrg #define DFISCC01(df) ((DFWORD(df, 0)&~0xfffc9124)==0 \ 39863d1a8abSmrg && (DFWORD(df, 1)&~0x49124491)==0) 39963d1a8abSmrg #elif DECPMAX==34 40063d1a8abSmrg #define ZEROWORD QUADZERO 40163d1a8abSmrg #define DFISZERO(df) ((DFWORD(df, 3)==0 \ 40263d1a8abSmrg && DFWORD(df, 2)==0 \ 40363d1a8abSmrg && DFWORD(df, 1)==0 \ 40463d1a8abSmrg && (DFWORD(df, 0)&0x1c003fff)==0 \ 40563d1a8abSmrg && (DFWORD(df, 0)&0x60000000)!=0x60000000)) 40663d1a8abSmrg #define DFISINT(df) ((DFWORD(df, 0)&0x63ffc000)==0x22080000 \ 40763d1a8abSmrg ||(DFWORD(df, 0)&0x7bffc000)==0x6a080000) 40863d1a8abSmrg #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbffc000)==0x22080000) 40963d1a8abSmrg #define DFISCCZERO(df) (DFWORD(df, 3)==0 \ 41063d1a8abSmrg && DFWORD(df, 2)==0 \ 41163d1a8abSmrg && DFWORD(df, 1)==0 \ 41263d1a8abSmrg && (DFWORD(df, 0)&0x00003fff)==0) 41363d1a8abSmrg 41463d1a8abSmrg #define DFISCC01(df) ((DFWORD(df, 0)&~0xffffc912)==0 \ 41563d1a8abSmrg && (DFWORD(df, 1)&~0x44912449)==0 \ 41663d1a8abSmrg && (DFWORD(df, 2)&~0x12449124)==0 \ 41763d1a8abSmrg && (DFWORD(df, 3)&~0x49124491)==0) 41863d1a8abSmrg #endif 41963d1a8abSmrg 42063d1a8abSmrg /* Macros to test if a certain 10 bits of a uInt or pair of uInts */ 42163d1a8abSmrg /* are a canonical declet [higher or lower bits are ignored]. */ 42263d1a8abSmrg /* declet is at offset 0 (from the right) in a uInt: */ 42363d1a8abSmrg #define CANONDPD(dpd) (((dpd)&0x300)==0 || ((dpd)&0x6e)!=0x6e) 42463d1a8abSmrg /* declet is at offset k (a multiple of 2) in a uInt: */ 42563d1a8abSmrg #define CANONDPDOFF(dpd, k) (((dpd)&(0x300<<(k)))==0 \ 42663d1a8abSmrg || ((dpd)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k))) 42763d1a8abSmrg /* declet is at offset k (a multiple of 2) in a pair of uInts: */ 42863d1a8abSmrg /* [the top 2 bits will always be in the more-significant uInt] */ 42963d1a8abSmrg #define CANONDPDTWO(hi, lo, k) (((hi)&(0x300>>(32-(k))))==0 \ 43063d1a8abSmrg || ((hi)&(0x6e>>(32-(k))))!=(0x6e>>(32-(k))) \ 43163d1a8abSmrg || ((lo)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k))) 43263d1a8abSmrg 43363d1a8abSmrg /* Macro to test whether a full-length (length DECPMAX) BCD8 */ 43463d1a8abSmrg /* coefficient, starting at uByte u, is all zeros */ 43563d1a8abSmrg /* Test just the LSWord first, then the remainder as a sequence */ 43663d1a8abSmrg /* of tests in order to avoid same-level use of UBTOUI */ 43763d1a8abSmrg #if DECPMAX==7 43863d1a8abSmrg #define ISCOEFFZERO(u) ( \ 43963d1a8abSmrg UBTOUI((u)+DECPMAX-4)==0 \ 44063d1a8abSmrg && UBTOUS((u)+DECPMAX-6)==0 \ 44163d1a8abSmrg && *(u)==0) 44263d1a8abSmrg #elif DECPMAX==16 44363d1a8abSmrg #define ISCOEFFZERO(u) ( \ 44463d1a8abSmrg UBTOUI((u)+DECPMAX-4)==0 \ 44563d1a8abSmrg && UBTOUI((u)+DECPMAX-8)==0 \ 44663d1a8abSmrg && UBTOUI((u)+DECPMAX-12)==0 \ 44763d1a8abSmrg && UBTOUI(u)==0) 44863d1a8abSmrg #elif DECPMAX==34 44963d1a8abSmrg #define ISCOEFFZERO(u) ( \ 45063d1a8abSmrg UBTOUI((u)+DECPMAX-4)==0 \ 45163d1a8abSmrg && UBTOUI((u)+DECPMAX-8)==0 \ 45263d1a8abSmrg && UBTOUI((u)+DECPMAX-12)==0 \ 45363d1a8abSmrg && UBTOUI((u)+DECPMAX-16)==0 \ 45463d1a8abSmrg && UBTOUI((u)+DECPMAX-20)==0 \ 45563d1a8abSmrg && UBTOUI((u)+DECPMAX-24)==0 \ 45663d1a8abSmrg && UBTOUI((u)+DECPMAX-28)==0 \ 45763d1a8abSmrg && UBTOUI((u)+DECPMAX-32)==0 \ 45863d1a8abSmrg && UBTOUS(u)==0) 45963d1a8abSmrg #endif 46063d1a8abSmrg 46163d1a8abSmrg /* Macros and masks for the exponent continuation field and MSD */ 46263d1a8abSmrg /* Get the exponent continuation from a decFloat *df as an Int */ 46363d1a8abSmrg #define GETECON(df) ((Int)((DFWORD((df), 0)&0x03ffffff)>>(32-6-DECECONL))) 46463d1a8abSmrg /* Ditto, from the next-wider format */ 46563d1a8abSmrg #define GETWECON(df) ((Int)((DFWWORD((df), 0)&0x03ffffff)>>(32-6-DECWECONL))) 46663d1a8abSmrg /* Get the biased exponent similarly */ 46763d1a8abSmrg #define GETEXP(df) ((Int)(DECCOMBEXP[DFWORD((df), 0)>>26]+GETECON(df))) 46863d1a8abSmrg /* Get the unbiased exponent similarly */ 46963d1a8abSmrg #define GETEXPUN(df) ((Int)GETEXP(df)-DECBIAS) 47063d1a8abSmrg /* Get the MSD similarly (as uInt) */ 47163d1a8abSmrg #define GETMSD(df) (DECCOMBMSD[DFWORD((df), 0)>>26]) 47263d1a8abSmrg 47363d1a8abSmrg /* Compile-time computes of the exponent continuation field masks */ 47463d1a8abSmrg /* full exponent continuation field: */ 47563d1a8abSmrg #define ECONMASK ((0x03ffffff>>(32-6-DECECONL))<<(32-6-DECECONL)) 47663d1a8abSmrg /* same, not including its first digit (the qNaN/sNaN selector): */ 47763d1a8abSmrg #define ECONNANMASK ((0x01ffffff>>(32-6-DECECONL))<<(32-6-DECECONL)) 47863d1a8abSmrg 47963d1a8abSmrg /* Macros to decode the coefficient in a finite decFloat *df into */ 48063d1a8abSmrg /* a BCD string (uByte *bcdin) of length DECPMAX uBytes. */ 48163d1a8abSmrg 48263d1a8abSmrg /* In-line sequence to convert least significant 10 bits of uInt */ 48363d1a8abSmrg /* dpd to three BCD8 digits starting at uByte u. Note that an */ 48463d1a8abSmrg /* extra byte is written to the right of the three digits because */ 48563d1a8abSmrg /* four bytes are moved at a time for speed; the alternative */ 48663d1a8abSmrg /* macro moves exactly three bytes (usually slower). */ 48763d1a8abSmrg #define dpd2bcd8(u, dpd) memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 4) 48863d1a8abSmrg #define dpd2bcd83(u, dpd) memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 3) 48963d1a8abSmrg 49063d1a8abSmrg /* Decode the declets. After extracting each one, it is decoded */ 49163d1a8abSmrg /* to BCD8 using a table lookup (also used for variable-length */ 49263d1a8abSmrg /* decode). Each DPD decode is 3 bytes BCD8 plus a one-byte */ 49363d1a8abSmrg /* length which is not used, here). Fixed-length 4-byte moves */ 49463d1a8abSmrg /* are fast, however, almost everywhere, and so are used except */ 49563d1a8abSmrg /* for the final three bytes (to avoid overrun). The code below */ 49663d1a8abSmrg /* is 36 instructions for Doubles and about 70 for Quads, even */ 49763d1a8abSmrg /* on IA32. */ 49863d1a8abSmrg 49963d1a8abSmrg /* Two macros are defined for each format: */ 50063d1a8abSmrg /* GETCOEFF extracts the coefficient of the current format */ 50163d1a8abSmrg /* GETWCOEFF extracts the coefficient of the next-wider format. */ 50263d1a8abSmrg /* The latter is a copy of the next-wider GETCOEFF using DFWWORD. */ 50363d1a8abSmrg 50463d1a8abSmrg #if DECPMAX==7 50563d1a8abSmrg #define GETCOEFF(df, bcd) { \ 50663d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 50763d1a8abSmrg *(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \ 50863d1a8abSmrg dpd2bcd8(bcd+1, sourhi>>10); \ 50963d1a8abSmrg dpd2bcd83(bcd+4, sourhi);} 51063d1a8abSmrg #define GETWCOEFF(df, bcd) { \ 51163d1a8abSmrg uInt sourhi=DFWWORD(df, 0); \ 51263d1a8abSmrg uInt sourlo=DFWWORD(df, 1); \ 51363d1a8abSmrg *(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \ 51463d1a8abSmrg dpd2bcd8(bcd+1, sourhi>>8); \ 51563d1a8abSmrg dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \ 51663d1a8abSmrg dpd2bcd8(bcd+7, sourlo>>20); \ 51763d1a8abSmrg dpd2bcd8(bcd+10, sourlo>>10); \ 51863d1a8abSmrg dpd2bcd83(bcd+13, sourlo);} 51963d1a8abSmrg 52063d1a8abSmrg #elif DECPMAX==16 52163d1a8abSmrg #define GETCOEFF(df, bcd) { \ 52263d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 52363d1a8abSmrg uInt sourlo=DFWORD(df, 1); \ 52463d1a8abSmrg *(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \ 52563d1a8abSmrg dpd2bcd8(bcd+1, sourhi>>8); \ 52663d1a8abSmrg dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \ 52763d1a8abSmrg dpd2bcd8(bcd+7, sourlo>>20); \ 52863d1a8abSmrg dpd2bcd8(bcd+10, sourlo>>10); \ 52963d1a8abSmrg dpd2bcd83(bcd+13, sourlo);} 53063d1a8abSmrg #define GETWCOEFF(df, bcd) { \ 53163d1a8abSmrg uInt sourhi=DFWWORD(df, 0); \ 53263d1a8abSmrg uInt sourmh=DFWWORD(df, 1); \ 53363d1a8abSmrg uInt sourml=DFWWORD(df, 2); \ 53463d1a8abSmrg uInt sourlo=DFWWORD(df, 3); \ 53563d1a8abSmrg *(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \ 53663d1a8abSmrg dpd2bcd8(bcd+1, sourhi>>4); \ 53763d1a8abSmrg dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \ 53863d1a8abSmrg dpd2bcd8(bcd+7, sourmh>>16); \ 53963d1a8abSmrg dpd2bcd8(bcd+10, sourmh>>6); \ 54063d1a8abSmrg dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \ 54163d1a8abSmrg dpd2bcd8(bcd+16, sourml>>18); \ 54263d1a8abSmrg dpd2bcd8(bcd+19, sourml>>8); \ 54363d1a8abSmrg dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \ 54463d1a8abSmrg dpd2bcd8(bcd+25, sourlo>>20); \ 54563d1a8abSmrg dpd2bcd8(bcd+28, sourlo>>10); \ 54663d1a8abSmrg dpd2bcd83(bcd+31, sourlo);} 54763d1a8abSmrg 54863d1a8abSmrg #elif DECPMAX==34 54963d1a8abSmrg #define GETCOEFF(df, bcd) { \ 55063d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 55163d1a8abSmrg uInt sourmh=DFWORD(df, 1); \ 55263d1a8abSmrg uInt sourml=DFWORD(df, 2); \ 55363d1a8abSmrg uInt sourlo=DFWORD(df, 3); \ 55463d1a8abSmrg *(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \ 55563d1a8abSmrg dpd2bcd8(bcd+1, sourhi>>4); \ 55663d1a8abSmrg dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \ 55763d1a8abSmrg dpd2bcd8(bcd+7, sourmh>>16); \ 55863d1a8abSmrg dpd2bcd8(bcd+10, sourmh>>6); \ 55963d1a8abSmrg dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \ 56063d1a8abSmrg dpd2bcd8(bcd+16, sourml>>18); \ 56163d1a8abSmrg dpd2bcd8(bcd+19, sourml>>8); \ 56263d1a8abSmrg dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \ 56363d1a8abSmrg dpd2bcd8(bcd+25, sourlo>>20); \ 56463d1a8abSmrg dpd2bcd8(bcd+28, sourlo>>10); \ 56563d1a8abSmrg dpd2bcd83(bcd+31, sourlo);} 56663d1a8abSmrg 56763d1a8abSmrg #define GETWCOEFF(df, bcd) {??} /* [should never be used] */ 56863d1a8abSmrg #endif 56963d1a8abSmrg 57063d1a8abSmrg /* Macros to decode the coefficient in a finite decFloat *df into */ 57163d1a8abSmrg /* a base-billion uInt array, with the least-significant */ 57263d1a8abSmrg /* 0-999999999 'digit' at offset 0. */ 57363d1a8abSmrg 57463d1a8abSmrg /* Decode the declets. After extracting each one, it is decoded */ 57563d1a8abSmrg /* to binary using a table lookup. Three tables are used; one */ 57663d1a8abSmrg /* the usual DPD to binary, the other two pre-multiplied by 1000 */ 57763d1a8abSmrg /* and 1000000 to avoid multiplication during decode. These */ 57863d1a8abSmrg /* tables can also be used for multiplying up the MSD as the DPD */ 57963d1a8abSmrg /* code for 0 through 9 is the identity. */ 58063d1a8abSmrg #define DPD2BIN0 DPD2BIN /* for prettier code */ 58163d1a8abSmrg 58263d1a8abSmrg #if DECPMAX==7 58363d1a8abSmrg #define GETCOEFFBILL(df, buf) { \ 58463d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 58563d1a8abSmrg (buf)[0]=DPD2BIN0[sourhi&0x3ff] \ 58663d1a8abSmrg +DPD2BINK[(sourhi>>10)&0x3ff] \ 58763d1a8abSmrg +DPD2BINM[DECCOMBMSD[sourhi>>26]];} 58863d1a8abSmrg 58963d1a8abSmrg #elif DECPMAX==16 59063d1a8abSmrg #define GETCOEFFBILL(df, buf) { \ 59163d1a8abSmrg uInt sourhi, sourlo; \ 59263d1a8abSmrg sourlo=DFWORD(df, 1); \ 59363d1a8abSmrg (buf)[0]=DPD2BIN0[sourlo&0x3ff] \ 59463d1a8abSmrg +DPD2BINK[(sourlo>>10)&0x3ff] \ 59563d1a8abSmrg +DPD2BINM[(sourlo>>20)&0x3ff]; \ 59663d1a8abSmrg sourhi=DFWORD(df, 0); \ 59763d1a8abSmrg (buf)[1]=DPD2BIN0[((sourhi<<2) | (sourlo>>30))&0x3ff] \ 59863d1a8abSmrg +DPD2BINK[(sourhi>>8)&0x3ff] \ 59963d1a8abSmrg +DPD2BINM[DECCOMBMSD[sourhi>>26]];} 60063d1a8abSmrg 60163d1a8abSmrg #elif DECPMAX==34 60263d1a8abSmrg #define GETCOEFFBILL(df, buf) { \ 60363d1a8abSmrg uInt sourhi, sourmh, sourml, sourlo; \ 60463d1a8abSmrg sourlo=DFWORD(df, 3); \ 60563d1a8abSmrg (buf)[0]=DPD2BIN0[sourlo&0x3ff] \ 60663d1a8abSmrg +DPD2BINK[(sourlo>>10)&0x3ff] \ 60763d1a8abSmrg +DPD2BINM[(sourlo>>20)&0x3ff]; \ 60863d1a8abSmrg sourml=DFWORD(df, 2); \ 60963d1a8abSmrg (buf)[1]=DPD2BIN0[((sourml<<2) | (sourlo>>30))&0x3ff] \ 61063d1a8abSmrg +DPD2BINK[(sourml>>8)&0x3ff] \ 61163d1a8abSmrg +DPD2BINM[(sourml>>18)&0x3ff]; \ 61263d1a8abSmrg sourmh=DFWORD(df, 1); \ 61363d1a8abSmrg (buf)[2]=DPD2BIN0[((sourmh<<4) | (sourml>>28))&0x3ff] \ 61463d1a8abSmrg +DPD2BINK[(sourmh>>6)&0x3ff] \ 61563d1a8abSmrg +DPD2BINM[(sourmh>>16)&0x3ff]; \ 61663d1a8abSmrg sourhi=DFWORD(df, 0); \ 61763d1a8abSmrg (buf)[3]=DPD2BIN0[((sourhi<<6) | (sourmh>>26))&0x3ff] \ 61863d1a8abSmrg +DPD2BINK[(sourhi>>4)&0x3ff] \ 61963d1a8abSmrg +DPD2BINM[DECCOMBMSD[sourhi>>26]];} 62063d1a8abSmrg 62163d1a8abSmrg #endif 62263d1a8abSmrg 62363d1a8abSmrg /* Macros to decode the coefficient in a finite decFloat *df into */ 62463d1a8abSmrg /* a base-thousand uInt array (of size DECLETS+1, to allow for */ 62563d1a8abSmrg /* the MSD), with the least-significant 0-999 'digit' at offset 0.*/ 62663d1a8abSmrg 62763d1a8abSmrg /* Decode the declets. After extracting each one, it is decoded */ 62863d1a8abSmrg /* to binary using a table lookup. */ 62963d1a8abSmrg #if DECPMAX==7 63063d1a8abSmrg #define GETCOEFFTHOU(df, buf) { \ 63163d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 63263d1a8abSmrg (buf)[0]=DPD2BIN[sourhi&0x3ff]; \ 63363d1a8abSmrg (buf)[1]=DPD2BIN[(sourhi>>10)&0x3ff]; \ 63463d1a8abSmrg (buf)[2]=DECCOMBMSD[sourhi>>26];} 63563d1a8abSmrg 63663d1a8abSmrg #elif DECPMAX==16 63763d1a8abSmrg #define GETCOEFFTHOU(df, buf) { \ 63863d1a8abSmrg uInt sourhi, sourlo; \ 63963d1a8abSmrg sourlo=DFWORD(df, 1); \ 64063d1a8abSmrg (buf)[0]=DPD2BIN[sourlo&0x3ff]; \ 64163d1a8abSmrg (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \ 64263d1a8abSmrg (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \ 64363d1a8abSmrg sourhi=DFWORD(df, 0); \ 64463d1a8abSmrg (buf)[3]=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \ 64563d1a8abSmrg (buf)[4]=DPD2BIN[(sourhi>>8)&0x3ff]; \ 64663d1a8abSmrg (buf)[5]=DECCOMBMSD[sourhi>>26];} 64763d1a8abSmrg 64863d1a8abSmrg #elif DECPMAX==34 64963d1a8abSmrg #define GETCOEFFTHOU(df, buf) { \ 65063d1a8abSmrg uInt sourhi, sourmh, sourml, sourlo; \ 65163d1a8abSmrg sourlo=DFWORD(df, 3); \ 65263d1a8abSmrg (buf)[0]=DPD2BIN[sourlo&0x3ff]; \ 65363d1a8abSmrg (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \ 65463d1a8abSmrg (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \ 65563d1a8abSmrg sourml=DFWORD(df, 2); \ 65663d1a8abSmrg (buf)[3]=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \ 65763d1a8abSmrg (buf)[4]=DPD2BIN[(sourml>>8)&0x3ff]; \ 65863d1a8abSmrg (buf)[5]=DPD2BIN[(sourml>>18)&0x3ff]; \ 65963d1a8abSmrg sourmh=DFWORD(df, 1); \ 66063d1a8abSmrg (buf)[6]=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \ 66163d1a8abSmrg (buf)[7]=DPD2BIN[(sourmh>>6)&0x3ff]; \ 66263d1a8abSmrg (buf)[8]=DPD2BIN[(sourmh>>16)&0x3ff]; \ 66363d1a8abSmrg sourhi=DFWORD(df, 0); \ 66463d1a8abSmrg (buf)[9]=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \ 66563d1a8abSmrg (buf)[10]=DPD2BIN[(sourhi>>4)&0x3ff]; \ 66663d1a8abSmrg (buf)[11]=DECCOMBMSD[sourhi>>26];} 66763d1a8abSmrg #endif 66863d1a8abSmrg 66963d1a8abSmrg 67063d1a8abSmrg /* Macros to decode the coefficient in a finite decFloat *df and */ 67163d1a8abSmrg /* add to a base-thousand uInt array (as for GETCOEFFTHOU). */ 67263d1a8abSmrg /* After the addition then most significant 'digit' in the array */ 67363d1a8abSmrg /* might have a value larger then 10 (with a maximum of 19). */ 67463d1a8abSmrg #if DECPMAX==7 67563d1a8abSmrg #define ADDCOEFFTHOU(df, buf) { \ 67663d1a8abSmrg uInt sourhi=DFWORD(df, 0); \ 67763d1a8abSmrg (buf)[0]+=DPD2BIN[sourhi&0x3ff]; \ 67863d1a8abSmrg if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \ 67963d1a8abSmrg (buf)[1]+=DPD2BIN[(sourhi>>10)&0x3ff]; \ 68063d1a8abSmrg if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \ 68163d1a8abSmrg (buf)[2]+=DECCOMBMSD[sourhi>>26];} 68263d1a8abSmrg 68363d1a8abSmrg #elif DECPMAX==16 68463d1a8abSmrg #define ADDCOEFFTHOU(df, buf) { \ 68563d1a8abSmrg uInt sourhi, sourlo; \ 68663d1a8abSmrg sourlo=DFWORD(df, 1); \ 68763d1a8abSmrg (buf)[0]+=DPD2BIN[sourlo&0x3ff]; \ 68863d1a8abSmrg if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \ 68963d1a8abSmrg (buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff]; \ 69063d1a8abSmrg if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \ 69163d1a8abSmrg (buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff]; \ 69263d1a8abSmrg if (buf[2]>999) {buf[2]-=1000; buf[3]++;} \ 69363d1a8abSmrg sourhi=DFWORD(df, 0); \ 69463d1a8abSmrg (buf)[3]+=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \ 69563d1a8abSmrg if (buf[3]>999) {buf[3]-=1000; buf[4]++;} \ 69663d1a8abSmrg (buf)[4]+=DPD2BIN[(sourhi>>8)&0x3ff]; \ 69763d1a8abSmrg if (buf[4]>999) {buf[4]-=1000; buf[5]++;} \ 69863d1a8abSmrg (buf)[5]+=DECCOMBMSD[sourhi>>26];} 69963d1a8abSmrg 70063d1a8abSmrg #elif DECPMAX==34 70163d1a8abSmrg #define ADDCOEFFTHOU(df, buf) { \ 70263d1a8abSmrg uInt sourhi, sourmh, sourml, sourlo; \ 70363d1a8abSmrg sourlo=DFWORD(df, 3); \ 70463d1a8abSmrg (buf)[0]+=DPD2BIN[sourlo&0x3ff]; \ 70563d1a8abSmrg if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \ 70663d1a8abSmrg (buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff]; \ 70763d1a8abSmrg if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \ 70863d1a8abSmrg (buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff]; \ 70963d1a8abSmrg if (buf[2]>999) {buf[2]-=1000; buf[3]++;} \ 71063d1a8abSmrg sourml=DFWORD(df, 2); \ 71163d1a8abSmrg (buf)[3]+=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \ 71263d1a8abSmrg if (buf[3]>999) {buf[3]-=1000; buf[4]++;} \ 71363d1a8abSmrg (buf)[4]+=DPD2BIN[(sourml>>8)&0x3ff]; \ 71463d1a8abSmrg if (buf[4]>999) {buf[4]-=1000; buf[5]++;} \ 71563d1a8abSmrg (buf)[5]+=DPD2BIN[(sourml>>18)&0x3ff]; \ 71663d1a8abSmrg if (buf[5]>999) {buf[5]-=1000; buf[6]++;} \ 71763d1a8abSmrg sourmh=DFWORD(df, 1); \ 71863d1a8abSmrg (buf)[6]+=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \ 71963d1a8abSmrg if (buf[6]>999) {buf[6]-=1000; buf[7]++;} \ 72063d1a8abSmrg (buf)[7]+=DPD2BIN[(sourmh>>6)&0x3ff]; \ 72163d1a8abSmrg if (buf[7]>999) {buf[7]-=1000; buf[8]++;} \ 72263d1a8abSmrg (buf)[8]+=DPD2BIN[(sourmh>>16)&0x3ff]; \ 72363d1a8abSmrg if (buf[8]>999) {buf[8]-=1000; buf[9]++;} \ 72463d1a8abSmrg sourhi=DFWORD(df, 0); \ 72563d1a8abSmrg (buf)[9]+=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \ 72663d1a8abSmrg if (buf[9]>999) {buf[9]-=1000; buf[10]++;} \ 72763d1a8abSmrg (buf)[10]+=DPD2BIN[(sourhi>>4)&0x3ff]; \ 72863d1a8abSmrg if (buf[10]>999) {buf[10]-=1000; buf[11]++;} \ 72963d1a8abSmrg (buf)[11]+=DECCOMBMSD[sourhi>>26];} 73063d1a8abSmrg #endif 73163d1a8abSmrg 73263d1a8abSmrg 73363d1a8abSmrg /* Set a decFloat to the maximum positive finite number (Nmax) */ 73463d1a8abSmrg #if DECPMAX==7 73563d1a8abSmrg #define DFSETNMAX(df) \ 73663d1a8abSmrg {DFWORD(df, 0)=0x77f3fcff;} 73763d1a8abSmrg #elif DECPMAX==16 73863d1a8abSmrg #define DFSETNMAX(df) \ 73963d1a8abSmrg {DFWORD(df, 0)=0x77fcff3f; \ 74063d1a8abSmrg DFWORD(df, 1)=0xcff3fcff;} 74163d1a8abSmrg #elif DECPMAX==34 74263d1a8abSmrg #define DFSETNMAX(df) \ 74363d1a8abSmrg {DFWORD(df, 0)=0x77ffcff3; \ 74463d1a8abSmrg DFWORD(df, 1)=0xfcff3fcf; \ 74563d1a8abSmrg DFWORD(df, 2)=0xf3fcff3f; \ 74663d1a8abSmrg DFWORD(df, 3)=0xcff3fcff;} 74763d1a8abSmrg #endif 74863d1a8abSmrg 74963d1a8abSmrg /* [end of format-dependent macros and constants] */ 75063d1a8abSmrg #endif 75163d1a8abSmrg 75263d1a8abSmrg #else 75363d1a8abSmrg #error decNumberLocal included more than once 75463d1a8abSmrg #endif 755