URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libdecnumber/] [decCommon.c] - Rev 775
Go to most recent revision | Compare with Previous | Blame | View Log
/* Common code for fixed-size types in the decNumber C Library. Copyright (C) 2007, 2009 Free Software Foundation, Inc. Contributed by IBM Corporation. Author Mike Cowlishaw. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ /* ------------------------------------------------------------------ */ /* decCommon.c -- common code for all three fixed-size types */ /* ------------------------------------------------------------------ */ /* This module comprises code that is shared between all the formats */ /* (decSingle, decDouble, and decQuad); it includes set and extract */ /* of format components, widening, narrowing, and string conversions. */ /* */ /* Unlike decNumber, parameterization takes place at compile time */ /* rather than at runtime. The parameters are set in the decDouble.c */ /* (etc.) files, which then include this one to produce the compiled */ /* code. The functions here, therefore, are code shared between */ /* multiple formats. */ /* ------------------------------------------------------------------ */ /* Names here refer to decFloat rather than to decDouble, etc., and */ /* the functions are in strict alphabetical order. */ /* Constants, tables, and debug function(s) are included only for QUAD */ /* (which will always be compiled if DOUBLE or SINGLE are used). */ /* */ /* Whenever a decContext is used, only the status may be set (using */ /* OR) or the rounding mode read; all other fields are ignored and */ /* untouched. */ #include "decCommonSymbols.h" /* names for simpler testing and default context */ #if DECPMAX==7 #define SINGLE 1 #define DOUBLE 0 #define QUAD 0 #define DEFCONTEXT DEC_INIT_DECIMAL32 #elif DECPMAX==16 #define SINGLE 0 #define DOUBLE 1 #define QUAD 0 #define DEFCONTEXT DEC_INIT_DECIMAL64 #elif DECPMAX==34 #define SINGLE 0 #define DOUBLE 0 #define QUAD 1 #define DEFCONTEXT DEC_INIT_DECIMAL128 #else #error Unexpected DECPMAX value #endif /* Assertions */ #if DECPMAX!=7 && DECPMAX!=16 && DECPMAX!=34 #error Unexpected Pmax (DECPMAX) value for this module #endif /* Assert facts about digit characters, etc. */ #if ('9'&0x0f)!=9 #error This module assumes characters are of the form 0b....nnnn /* where .... are don't care 4 bits and nnnn is 0000 through 1001 */ #endif #if ('9'&0xf0)==('.'&0xf0) #error This module assumes '.' has a different mask than a digit #endif /* Assert ToString lay-out conditions */ #if DECSTRING<DECPMAX+9 #error ToString needs at least 8 characters for lead-in and dot #endif #if DECPMAX+DECEMAXD+5 > DECSTRING #error Exponent form can be too long for ToString to lay out safely #endif #if DECEMAXD > 4 #error Exponent form is too long for ToString to lay out /* Note: code for up to 9 digits exists in archives [decOct] */ #endif /* Private functions used here and possibly in decBasic.c, etc. */ static decFloat * decFinalize(decFloat *, bcdnum *, decContext *); static Flag decBiStr(const char *, const char *, const char *); /* Macros and private tables; those which are not format-dependent */ /* are only included if decQuad is being built. */ /* ------------------------------------------------------------------ */ /* Combination field lookup tables (uInts to save measurable work) */ /* */ /* DECCOMBEXP - 2 most-significant-bits of exponent (00, 01, or */ /* 10), shifted left for format, or DECFLOAT_Inf/NaN */ /* DECCOMBWEXP - The same, for the next-wider format (unless QUAD) */ /* DECCOMBMSD - 4-bit most-significant-digit */ /* [0 if the index is a special (Infinity or NaN)] */ /* DECCOMBFROM - 5-bit combination field from EXP top bits and MSD */ /* (placed in uInt so no shift is needed) */ /* */ /* DECCOMBEXP, DECCOMBWEXP, and DECCOMBMSD are indexed by the sign */ /* and 5-bit combination field (0-63, the second half of the table */ /* identical to the first half) */ /* DECCOMBFROM is indexed by expTopTwoBits*16 + msd */ /* */ /* DECCOMBMSD and DECCOMBFROM are not format-dependent and so are */ /* only included once, when QUAD is being built */ /* ------------------------------------------------------------------ */ static const uInt DECCOMBEXP[64]={ 0, 0, 0, 0, 0, 0, 0, 0, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 0, 0, 1<<DECECONL, 1<<DECECONL, 2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN, 0, 0, 0, 0, 0, 0, 0, 0, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 0, 0, 1<<DECECONL, 1<<DECECONL, 2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN}; #if !QUAD static const uInt DECCOMBWEXP[64]={ 0, 0, 0, 0, 0, 0, 0, 0, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 0, 0, 1<<DECWECONL, 1<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN, 0, 0, 0, 0, 0, 0, 0, 0, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 0, 0, 1<<DECWECONL, 1<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN}; #endif #if QUAD const uInt DECCOMBMSD[64]={ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0}; const uInt DECCOMBFROM[48]={ 0x00000000, 0x04000000, 0x08000000, 0x0C000000, 0x10000000, 0x14000000, 0x18000000, 0x1C000000, 0x60000000, 0x64000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x20000000, 0x24000000, 0x28000000, 0x2C000000, 0x30000000, 0x34000000, 0x38000000, 0x3C000000, 0x68000000, 0x6C000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x40000000, 0x44000000, 0x48000000, 0x4C000000, 0x50000000, 0x54000000, 0x58000000, 0x5C000000, 0x70000000, 0x74000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000}; /* ------------------------------------------------------------------ */ /* Request and include the tables to use for conversions */ /* ------------------------------------------------------------------ */ #define DEC_BCD2DPD 1 /* 0-0x999 -> DPD */ #define DEC_BIN2DPD 1 /* 0-999 -> DPD */ #define DEC_BIN2BCD8 1 /* 0-999 -> ddd, len */ #define DEC_DPD2BCD8 1 /* DPD -> ddd, len */ #define DEC_DPD2BIN 1 /* DPD -> 0-999 */ #define DEC_DPD2BINK 1 /* DPD -> 0-999000 */ #define DEC_DPD2BINM 1 /* DPD -> 0-999000000 */ #include "decDPD.h" /* source of the lookup tables */ #endif /* ----------------------------------------------------------------- */ /* decBiStr -- compare string with pairwise options */ /* */ /* targ is the string to compare */ /* str1 is one of the strings to compare against (length may be 0) */ /* str2 is the other; it must be the same length as str1 */ /* */ /* returns 1 if strings compare equal, (that is, targ is the same */ /* length as str1 and str2, and each character of targ is in one */ /* of str1 or str2 in the corresponding position), or 0 otherwise */ /* */ /* This is used for generic caseless compare, including the awkward */ /* case of the Turkish dotted and dotless Is. Use as (for example): */ /* if (decBiStr(test, "mike", "MIKE")) ... */ /* ----------------------------------------------------------------- */ static Flag decBiStr(const char *targ, const char *str1, const char *str2) { for (;;targ++, str1++, str2++) { if (*targ!=*str1 && *targ!=*str2) return 0; /* *targ has a match in one (or both, if terminator) */ if (*targ=='\0') break; } /* forever */ return 1; } /* decBiStr */ /* ------------------------------------------------------------------ */ /* decFinalize -- adjust and store a final result */ /* */ /* df is the decFloat format number which gets the final result */ /* num is the descriptor of the number to be checked and encoded */ /* [its values, including the coefficient, may be modified] */ /* set is the context to use */ /* returns df */ /* */ /* The num descriptor may point to a bcd8 string of any length; this */ /* string may have leading insignificant zeros. If it has more than */ /* DECPMAX digits then the final digit can be a round-for-reround */ /* digit (i.e., it may include a sticky bit residue). */ /* */ /* The exponent (q) may be one of the codes for a special value and */ /* can be up to 999999999 for conversion from string. */ /* */ /* No error is possible, but Inexact, Underflow, and/or Overflow may */ /* be set. */ /* ------------------------------------------------------------------ */ /* Constant whose size varies with format; also the check for surprises */ static uByte allnines[DECPMAX]= #if SINGLE {9, 9, 9, 9, 9, 9, 9}; #elif DOUBLE {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; #elif QUAD {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; #endif static decFloat * decFinalize(decFloat *df, bcdnum *num, decContext *set) { uByte *ub; /* work */ uInt dpd; /* .. */ uInt uiwork; /* for macros */ uByte *umsd=num->msd; /* local copy */ uByte *ulsd=num->lsd; /* .. */ uInt encode; /* encoding accumulator */ Int length; /* coefficient length */ #if DECCHECK Int clen=ulsd-umsd+1; #if QUAD #define COEXTRA 2 /* extra-long coefficent */ #else #define COEXTRA 0 #endif if (clen<1 || clen>DECPMAX*3+2+COEXTRA) printf("decFinalize: suspect coefficient [length=%ld]\n", (LI)clen); if (num->sign!=0 && num->sign!=DECFLOAT_Sign) printf("decFinalize: bad sign [%08lx]\n", (LI)num->sign); if (!EXPISSPECIAL(num->exponent) && (num->exponent>1999999999 || num->exponent<-1999999999)) printf("decFinalize: improbable exponent [%ld]\n", (LI)num->exponent); /* decShowNum(num, "final"); */ #endif /* A special will have an 'exponent' which is very positive and a */ /* coefficient < DECPMAX */ length=(uInt)(ulsd-umsd+1); /* coefficient length */ if (!NUMISSPECIAL(num)) { Int drop; /* digits to be dropped */ /* skip leading insignificant zeros to calculate an exact length */ /* [this is quite expensive] */ if (*umsd==0) { for (; umsd+3<ulsd && UBTOUI(umsd)==0;) umsd+=4; for (; *umsd==0 && umsd<ulsd;) umsd++; length=ulsd-umsd+1; /* recalculate */ } drop=MAXI(length-DECPMAX, DECQTINY-num->exponent); /* drop can now be > digits for bottom-clamp (subnormal) cases */ if (drop>0) { /* rounding needed */ /* (decFloatQuantize has very similar code to this, so any */ /* changes may need to be made there, too) */ uByte *roundat; /* -> re-round digit */ uByte reround; /* reround value */ /* printf("Rounding; drop=%ld\n", (LI)drop); */ num->exponent+=drop; /* always update exponent */ /* Three cases here: */ /* 1. new LSD is in coefficient (almost always) */ /* 2. new LSD is digit to left of coefficient (so MSD is */ /* round-for-reround digit) */ /* 3. new LSD is to left of case 2 (whole coefficient is sticky) */ /* [duplicate check-stickies code to save a test] */ /* [by-digit check for stickies as runs of zeros are rare] */ if (drop<length) { /* NB lengths not addresses */ roundat=umsd+length-drop; reround=*roundat; for (ub=roundat+1; ub<=ulsd; ub++) { if (*ub!=0) { /* non-zero to be discarded */ reround=DECSTICKYTAB[reround]; /* apply sticky bit */ break; /* [remainder don't-care] */ } } /* check stickies */ ulsd=roundat-1; /* new LSD */ } else { /* edge case */ if (drop==length) { roundat=umsd; reround=*roundat; } else { roundat=umsd-1; reround=0; } for (ub=roundat+1; ub<=ulsd; ub++) { if (*ub!=0) { /* non-zero to be discarded */ reround=DECSTICKYTAB[reround]; /* apply sticky bit */ break; /* [remainder don't-care] */ } } /* check stickies */ *umsd=0; /* coefficient is a 0 */ ulsd=umsd; /* .. */ } if (reround!=0) { /* discarding non-zero */ uInt bump=0; set->status|=DEC_Inexact; /* if adjusted exponent [exp+digits-1] is < EMIN then num is */ /* subnormal -- so raise Underflow */ if (num->exponent<DECEMIN && (num->exponent+(ulsd-umsd+1)-1)<DECEMIN) set->status|=DEC_Underflow; /* next decide whether increment of the coefficient is needed */ if (set->round==DEC_ROUND_HALF_EVEN) { /* fastpath slowest case */ if (reround>5) bump=1; /* >0.5 goes up */ else if (reround==5) /* exactly 0.5000 .. */ bump=*ulsd & 0x01; /* .. up iff [new] lsd is odd */ } /* r-h-e */ else switch (set->round) { case DEC_ROUND_DOWN: { /* no change */ break;} /* r-d */ case DEC_ROUND_HALF_DOWN: { if (reround>5) bump=1; break;} /* r-h-d */ case DEC_ROUND_HALF_UP: { if (reround>=5) bump=1; break;} /* r-h-u */ case DEC_ROUND_UP: { if (reround>0) bump=1; break;} /* r-u */ case DEC_ROUND_CEILING: { /* same as _UP for positive numbers, and as _DOWN for negatives */ if (!num->sign && reround>0) bump=1; break;} /* r-c */ case DEC_ROUND_FLOOR: { /* same as _UP for negative numbers, and as _DOWN for positive */ /* [negative reround cannot occur on 0] */ if (num->sign && reround>0) bump=1; break;} /* r-f */ case DEC_ROUND_05UP: { if (reround>0) { /* anything out there is 'sticky' */ /* bump iff lsd=0 or 5; this cannot carry so it could be */ /* effected immediately with no bump -- but the code */ /* is clearer if this is done the same way as the others */ if (*ulsd==0 || *ulsd==5) bump=1; } break;} /* r-r */ default: { /* e.g., DEC_ROUND_MAX */ set->status|=DEC_Invalid_context; #if DECCHECK printf("Unknown rounding mode: %ld\n", (LI)set->round); #endif break;} } /* switch (not r-h-e) */ /* printf("ReRound: %ld bump: %ld\n", (LI)reround, (LI)bump); */ if (bump!=0) { /* need increment */ /* increment the coefficient; this might end up with 1000... */ /* (after the all nines case) */ ub=ulsd; for(; ub-3>=umsd && UBTOUI(ub-3)==0x09090909; ub-=4) { UBFROMUI(ub-3, 0); /* to 00000000 */ } /* [note ub could now be to left of msd, and it is not safe */ /* to write to the the left of the msd] */ /* now at most 3 digits left to non-9 (usually just the one) */ for (; ub>=umsd; *ub=0, ub--) { if (*ub==9) continue; /* carry */ *ub+=1; break; } if (ub<umsd) { /* had all-nines */ *umsd=1; /* coefficient to 1000... */ /* usually the 1000... coefficient can be used as-is */ if ((ulsd-umsd+1)==DECPMAX) { num->exponent++; } else { /* if coefficient is shorter than Pmax then num is */ /* subnormal, so extend it; this is safe as drop>0 */ /* (or, if the coefficient was supplied above, it could */ /* not be 9); this may make the result normal. */ ulsd++; *ulsd=0; /* [exponent unchanged] */ #if DECCHECK if (num->exponent!=DECQTINY) /* sanity check */ printf("decFinalize: bad all-nines extend [^%ld, %ld]\n", (LI)num->exponent, (LI)(ulsd-umsd+1)); #endif } /* subnormal extend */ } /* had all-nines */ } /* bump needed */ } /* inexact rounding */ length=ulsd-umsd+1; /* recalculate (may be <DECPMAX) */ } /* need round (drop>0) */ /* The coefficient will now fit and has final length unless overflow */ /* decShowNum(num, "rounded"); */ /* if exponent is >=emax may have to clamp, overflow, or fold-down */ if (num->exponent>DECEMAX-(DECPMAX-1)) { /* is edge case */ /* printf("overflow checks...\n"); */ if (*ulsd==0 && ulsd==umsd) { /* have zero */ num->exponent=DECEMAX-(DECPMAX-1); /* clamp to max */ } else if ((num->exponent+length-1)>DECEMAX) { /* > Nmax */ /* Overflow -- these could go straight to encoding, here, but */ /* instead num is adjusted to keep the code cleaner */ Flag needmax=0; /* 1 for finite result */ set->status|=(DEC_Overflow | DEC_Inexact); switch (set->round) { case DEC_ROUND_DOWN: { needmax=1; /* never Infinity */ break;} /* r-d */ case DEC_ROUND_05UP: { needmax=1; /* never Infinity */ break;} /* r-05 */ case DEC_ROUND_CEILING: { if (num->sign) needmax=1; /* Infinity iff non-negative */ break;} /* r-c */ case DEC_ROUND_FLOOR: { if (!num->sign) needmax=1; /* Infinity iff negative */ break;} /* r-f */ default: break; /* Infinity in all other cases */ } if (!needmax) { /* easy .. set Infinity */ num->exponent=DECFLOAT_Inf; *umsd=0; /* be clean: coefficient to 0 */ ulsd=umsd; /* .. */ } else { /* return Nmax */ umsd=allnines; /* use constant array */ ulsd=allnines+DECPMAX-1; num->exponent=DECEMAX-(DECPMAX-1); } } else { /* no overflow but non-zero and may have to fold-down */ Int shift=num->exponent-(DECEMAX-(DECPMAX-1)); if (shift>0) { /* fold-down needed */ /* fold down needed; must copy to buffer in order to pad */ /* with zeros safely; fortunately this is not the worst case */ /* path because cannot have had a round */ uByte buffer[ROUNDUP(DECPMAX+3, 4)]; /* [+3 allows uInt padding] */ uByte *s=umsd; /* source */ uByte *t=buffer; /* safe target */ uByte *tlsd=buffer+(ulsd-umsd)+shift; /* target LSD */ /* printf("folddown shift=%ld\n", (LI)shift); */ for (; s<=ulsd; s+=4, t+=4) UBFROMUI(t, UBTOUI(s)); for (t=tlsd-shift+1; t<=tlsd; t+=4) UBFROMUI(t, 0); /* pad 0s */ num->exponent-=shift; umsd=buffer; ulsd=tlsd; } } /* fold-down? */ length=ulsd-umsd+1; /* recalculate length */ } /* high-end edge case */ } /* finite number */ /*------------------------------------------------------------------*/ /* At this point the result will properly fit the decFloat */ /* encoding, and it can be encoded with no possibility of error */ /*------------------------------------------------------------------*/ /* Following code does not alter coefficient (could be allnines array) */ /* fast path possible when DECPMAX digits */ if (length==DECPMAX) { return decFloatFromBCD(df, num->exponent, umsd, num->sign); } /* full-length */ /* slower path when not a full-length number; must care about length */ /* [coefficient length here will be < DECPMAX] */ if (!NUMISSPECIAL(num)) { /* is still finite */ /* encode the combination field and exponent continuation */ uInt uexp=(uInt)(num->exponent+DECBIAS); /* biased exponent */ uInt code=(uexp>>DECECONL)<<4; /* top two bits of exp */ /* [msd==0] */ /* look up the combination field and make high word */ encode=DECCOMBFROM[code]; /* indexed by (0-2)*16+msd */ encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; /* exponent continuation */ } else encode=num->exponent; /* special [already in word] */ encode|=num->sign; /* add sign */ /* private macro to extract a declet, n (where 0<=n<DECLETS and 0 */ /* refers to the declet from the least significant three digits) */ /* and put the corresponding DPD code into dpd. Access to umsd and */ /* ulsd (pointers to the most and least significant digit of the */ /* variable-length coefficient) is assumed, along with use of a */ /* working pointer, uInt *ub. */ /* As not full-length then chances are there are many leading zeros */ /* [and there may be a partial triad] */ #define getDPDt(dpd, n) ub=ulsd-(3*(n))-2; \ if (ub<umsd-2) dpd=0; \ else if (ub>=umsd) dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)]; \ else {dpd=*(ub+2); if (ub+1==umsd) dpd+=*(ub+1)*16; dpd=BCD2DPD[dpd];} /* place the declets in the encoding words and copy to result (df), */ /* according to endianness; in all cases complete the sign word */ /* first */ #if DECPMAX==7 getDPDt(dpd, 1); encode|=dpd<<10; getDPDt(dpd, 0); encode|=dpd; DFWORD(df, 0)=encode; /* just the one word */ #elif DECPMAX==16 getDPDt(dpd, 4); encode|=dpd<<8; getDPDt(dpd, 3); encode|=dpd>>2; DFWORD(df, 0)=encode; encode=dpd<<30; getDPDt(dpd, 2); encode|=dpd<<20; getDPDt(dpd, 1); encode|=dpd<<10; getDPDt(dpd, 0); encode|=dpd; DFWORD(df, 1)=encode; #elif DECPMAX==34 getDPDt(dpd,10); encode|=dpd<<4; getDPDt(dpd, 9); encode|=dpd>>6; DFWORD(df, 0)=encode; encode=dpd<<26; getDPDt(dpd, 8); encode|=dpd<<16; getDPDt(dpd, 7); encode|=dpd<<6; getDPDt(dpd, 6); encode|=dpd>>4; DFWORD(df, 1)=encode; encode=dpd<<28; getDPDt(dpd, 5); encode|=dpd<<18; getDPDt(dpd, 4); encode|=dpd<<8; getDPDt(dpd, 3); encode|=dpd>>2; DFWORD(df, 2)=encode; encode=dpd<<30; getDPDt(dpd, 2); encode|=dpd<<20; getDPDt(dpd, 1); encode|=dpd<<10; getDPDt(dpd, 0); encode|=dpd; DFWORD(df, 3)=encode; #endif /* printf("Status: %08lx\n", (LI)set->status); */ /* decFloatShow(df, "final2"); */ return df; } /* decFinalize */ /* ------------------------------------------------------------------ */ /* decFloatFromBCD -- set decFloat from exponent, BCD8, and sign */ /* */ /* df is the target decFloat */ /* exp is the in-range unbiased exponent, q, or a special value in */ /* the form returned by decFloatGetExponent */ /* bcdar holds DECPMAX digits to set the coefficient from, one */ /* digit in each byte (BCD8 encoding); the first (MSD) is ignored */ /* if df is a NaN; all are ignored if df is infinite. */ /* All bytes must be in 0-9; results are undefined otherwise. */ /* sig is DECFLOAT_Sign to set the sign bit, 0 otherwise */ /* returns df, which will be canonical */ /* */ /* No error is possible, and no status will be set. */ /* ------------------------------------------------------------------ */ decFloat * decFloatFromBCD(decFloat *df, Int exp, const uByte *bcdar, Int sig) { uInt encode, dpd; /* work */ const uByte *ub; /* .. */ if (EXPISSPECIAL(exp)) encode=exp|sig;/* specials already encoded */ else { /* is finite */ /* encode the combination field and exponent continuation */ uInt uexp=(uInt)(exp+DECBIAS); /* biased exponent */ uInt code=(uexp>>DECECONL)<<4; /* top two bits of exp */ code+=bcdar[0]; /* add msd */ /* look up the combination field and make high word */ encode=DECCOMBFROM[code]|sig; /* indexed by (0-2)*16+msd */ encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; /* exponent continuation */ } /* private macro to extract a declet, n (where 0<=n<DECLETS and 0 */ /* refers to the declet from the least significant three digits) */ /* and put the corresponding DPD code into dpd. */ /* Use of a working pointer, uInt *ub, is assumed. */ #define getDPDb(dpd, n) ub=bcdar+DECPMAX-1-(3*(n))-2; \ dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)]; /* place the declets in the encoding words and copy to result (df), */ /* according to endianness; in all cases complete the sign word */ /* first */ #if DECPMAX==7 getDPDb(dpd, 1); encode|=dpd<<10; getDPDb(dpd, 0); encode|=dpd; DFWORD(df, 0)=encode; /* just the one word */ #elif DECPMAX==16 getDPDb(dpd, 4); encode|=dpd<<8; getDPDb(dpd, 3); encode|=dpd>>2; DFWORD(df, 0)=encode; encode=dpd<<30; getDPDb(dpd, 2); encode|=dpd<<20; getDPDb(dpd, 1); encode|=dpd<<10; getDPDb(dpd, 0); encode|=dpd; DFWORD(df, 1)=encode; #elif DECPMAX==34 getDPDb(dpd,10); encode|=dpd<<4; getDPDb(dpd, 9); encode|=dpd>>6; DFWORD(df, 0)=encode; encode=dpd<<26; getDPDb(dpd, 8); encode|=dpd<<16; getDPDb(dpd, 7); encode|=dpd<<6; getDPDb(dpd, 6); encode|=dpd>>4; DFWORD(df, 1)=encode; encode=dpd<<28; getDPDb(dpd, 5); encode|=dpd<<18; getDPDb(dpd, 4); encode|=dpd<<8; getDPDb(dpd, 3); encode|=dpd>>2; DFWORD(df, 2)=encode; encode=dpd<<30; getDPDb(dpd, 2); encode|=dpd<<20; getDPDb(dpd, 1); encode|=dpd<<10; getDPDb(dpd, 0); encode|=dpd; DFWORD(df, 3)=encode; #endif /* decFloatShow(df, "fromB"); */ return df; } /* decFloatFromBCD */ /* ------------------------------------------------------------------ */ /* decFloatFromPacked -- set decFloat from exponent and packed BCD */ /* */ /* df is the target decFloat */ /* exp is the in-range unbiased exponent, q, or a special value in */ /* the form returned by decFloatGetExponent */ /* packed holds DECPMAX packed decimal digits plus a sign nibble */ /* (all 6 codes are OK); the first (MSD) is ignored if df is a NaN */ /* and all except sign are ignored if df is infinite. For DOUBLE */ /* and QUAD the first (pad) nibble is also ignored in all cases. */ /* All coefficient nibbles must be in 0-9 and sign in A-F; results */ /* are undefined otherwise. */ /* returns df, which will be canonical */ /* */ /* No error is possible, and no status will be set. */ /* ------------------------------------------------------------------ */ decFloat * decFloatFromPacked(decFloat *df, Int exp, const uByte *packed) { uByte bcdar[DECPMAX+2]; /* work [+1 for pad, +1 for sign] */ const uByte *ip; /* .. */ uByte *op; /* .. */ Int sig=0; /* sign */ /* expand coefficient and sign to BCDAR */ #if SINGLE op=bcdar+1; /* no pad digit */ #else op=bcdar; /* first (pad) digit ignored */ #endif for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) { *op++=*ip>>4; *op++=(uByte)(*ip&0x0f); /* [final nibble is sign] */ } op--; /* -> sign byte */ if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign; if (EXPISSPECIAL(exp)) { /* Infinity or NaN */ if (!EXPISINF(exp)) bcdar[1]=0; /* a NaN: ignore MSD */ else memset(bcdar+1, 0, DECPMAX); /* Infinite: coefficient to 0 */ } return decFloatFromBCD(df, exp, bcdar+1, sig); } /* decFloatFromPacked */ /* ------------------------------------------------------------------ */ /* decFloatFromPackedChecked -- set from exponent and packed; checked */ /* */ /* df is the target decFloat */ /* exp is the in-range unbiased exponent, q, or a special value in */ /* the form returned by decFloatGetExponent */ /* packed holds DECPMAX packed decimal digits plus a sign nibble */ /* (all 6 codes are OK); the first (MSD) must be 0 if df is a NaN */ /* and all digits must be 0 if df is infinite. For DOUBLE and */ /* QUAD the first (pad) nibble must be 0. */ /* All coefficient nibbles must be in 0-9 and sign in A-F. */ /* returns df, which will be canonical or NULL if any of the */ /* requirements are not met (if this case df is unchanged); that */ /* is, the input data must be as returned by decFloatToPacked, */ /* except that all six sign codes are acccepted. */ /* */ /* No status will be set. */ /* ------------------------------------------------------------------ */ decFloat * decFloatFromPackedChecked(decFloat *df, Int exp, const uByte *packed) { uByte bcdar[DECPMAX+2]; /* work [+1 for pad, +1 for sign] */ const uByte *ip; /* .. */ uByte *op; /* .. */ Int sig=0; /* sign */ /* expand coefficient and sign to BCDAR */ #if SINGLE op=bcdar+1; /* no pad digit */ #else op=bcdar; /* first (pad) digit here */ #endif for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) { *op=*ip>>4; if (*op>9) return NULL; op++; *op=(uByte)(*ip&0x0f); /* [final nibble is sign] */ if (*op>9 && ip<packed+((DECPMAX+2)/2)-1) return NULL; op++; } op--; /* -> sign byte */ if (*op<=9) return NULL; /* bad sign */ if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign; #if !SINGLE if (bcdar[0]!=0) return NULL; /* bad pad nibble */ #endif if (EXPISNAN(exp)) { /* a NaN */ if (bcdar[1]!=0) return NULL; /* bad msd */ } /* NaN */ else if (EXPISINF(exp)) { /* is infinite */ Int i; for (i=0; i<DECPMAX; i++) { if (bcdar[i+1]!=0) return NULL; /* should be all zeros */ } } /* infinity */ else { /* finite */ /* check the exponent is in range */ if (exp>DECEMAX-DECPMAX+1) return NULL; if (exp<DECEMIN-DECPMAX+1) return NULL; } return decFloatFromBCD(df, exp, bcdar+1, sig); } /* decFloatFromPacked */ /* ------------------------------------------------------------------ */ /* decFloatFromString -- conversion from numeric string */ /* */ /* result is the decFloat format number which gets the result of */ /* the conversion */ /* *string is the character string which should contain a valid */ /* number (which may be a special value), \0-terminated */ /* If there are too many significant digits in the */ /* coefficient it will be rounded. */ /* set is the context */ /* returns result */ /* */ /* The length of the coefficient and the size of the exponent are */ /* checked by this routine, so the correct error (Underflow or */ /* Overflow) can be reported or rounding applied, as necessary. */ /* */ /* There is no limit to the coefficient length for finite inputs; */ /* NaN payloads must be integers with no more than DECPMAX-1 digits. */ /* Exponents may have up to nine significant digits. */ /* */ /* If bad syntax is detected, the result will be a quiet NaN. */ /* ------------------------------------------------------------------ */ decFloat * decFloatFromString(decFloat *result, const char *string, decContext *set) { Int digits; /* count of digits in coefficient */ const char *dotchar=NULL; /* where dot was found [NULL if none] */ const char *cfirst=string; /* -> first character of decimal part */ const char *c; /* work */ uByte *ub; /* .. */ uInt uiwork; /* for macros */ bcdnum num; /* collects data for finishing */ uInt error=DEC_Conversion_syntax; /* assume the worst */ uByte buffer[ROUNDUP(DECSTRING+11, 8)]; /* room for most coefficents, */ /* some common rounding, +3, & pad */ #if DECTRACE /* printf("FromString %s ...\n", string); */ #endif for(;;) { /* once-only 'loop' */ num.sign=0; /* assume non-negative */ num.msd=buffer; /* MSD is here always */ /* detect and validate the coefficient, including any leading, */ /* trailing, or embedded '.' */ /* [could test four-at-a-time here (saving 10% for decQuads), */ /* but that risks storage violation because the position of the */ /* terminator is unknown] */ for (c=string;; c++) { /* -> input character */ if (((unsigned)(*c-'0'))<=9) continue; /* '0' through '9' is good */ if (*c=='\0') break; /* most common non-digit */ if (*c=='.') { if (dotchar!=NULL) break; /* not first '.' */ dotchar=c; /* record offset into decimal part */ continue;} if (c==string) { /* first in string... */ if (*c=='-') { /* valid - sign */ cfirst++; num.sign=DECFLOAT_Sign; continue;} if (*c=='+') { /* valid + sign */ cfirst++; continue;} } /* *c is not a digit, terminator, or a valid +, -, or '.' */ break; } /* c loop */ digits=(uInt)(c-cfirst); /* digits (+1 if a dot) */ if (digits>0) { /* had digits and/or dot */ const char *clast=c-1; /* note last coefficient char position */ Int exp=0; /* exponent accumulator */ if (*c!='\0') { /* something follows the coefficient */ uInt edig; /* unsigned work */ /* had some digits and more to come; expect E[+|-]nnn now */ const char *firstexp; /* exponent first non-zero */ if (*c!='E' && *c!='e') break; c++; /* to (optional) sign */ if (*c=='-' || *c=='+') c++; /* step over sign (c=clast+2) */ if (*c=='\0') break; /* no digits! (e.g., '1.2E') */ for (; *c=='0';) c++; /* skip leading zeros [even last] */ firstexp=c; /* remember start [maybe '\0'] */ /* gather exponent digits */ edig=(uInt)*c-(uInt)'0'; if (edig<=9) { /* [check not bad or terminator] */ exp+=edig; /* avoid initial X10 */ c++; for (;; c++) { edig=(uInt)*c-(uInt)'0'; if (edig>9) break; exp=exp*10+edig; } } /* if not now on the '\0', *c must not be a digit */ if (*c!='\0') break; /* (this next test must be after the syntax checks) */ /* if definitely more than the possible digits for format then */ /* the exponent may have wrapped, so simply set it to a certain */ /* over/underflow value */ if (c>firstexp+DECEMAXD) exp=DECEMAX*2; if (*(clast+2)=='-') exp=-exp; /* was negative */ } /* digits>0 */ if (dotchar!=NULL) { /* had a '.' */ digits--; /* remove from digits count */ if (digits==0) break; /* was dot alone: bad syntax */ exp-=(Int)(clast-dotchar); /* adjust exponent */ /* [the '.' can now be ignored] */ } num.exponent=exp; /* exponent is good; store it */ /* Here when whole string has been inspected and syntax is good */ /* cfirst->first digit or dot, clast->last digit or dot */ error=0; /* no error possible now */ /* if the number of digits in the coefficient will fit in buffer */ /* then it can simply be converted to bcd8 and copied -- decFinalize */ /* will take care of leading zeros and rounding; the buffer is big */ /* enough for all canonical coefficients, including 0.00000nn... */ ub=buffer; if (digits<=(Int)(sizeof(buffer)-3)) { /* [-3 allows by-4s copy] */ c=cfirst; if (dotchar!=NULL) { /* a dot to worry about */ if (*(c+1)=='.') { /* common canonical case */ *ub++=(uByte)(*c-'0'); /* copy leading digit */ c+=2; /* prepare to handle rest */ } else for (; c<=clast;) { /* '.' could be anywhere */ /* as usual, go by fours when safe; NB it has been asserted */ /* that a '.' does not have the same mask as a digit */ if (c<=clast-3 /* safe for four */ && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) { /* test four */ UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); /* to BCD8 */ ub+=4; c+=4; continue; } if (*c=='.') { /* found the dot */ c++; /* step over it .. */ break; /* .. and handle the rest */ } *ub++=(uByte)(*c++-'0'); } } /* had dot */ /* Now no dot; do this by fours (where safe) */ for (; c<=clast-3; c+=4, ub+=4) UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); for (; c<=clast; c++, ub++) *ub=(uByte)(*c-'0'); num.lsd=buffer+digits-1; /* record new LSD */ } /* fits */ else { /* too long for buffer */ /* [This is a rare and unusual case; arbitrary-length input] */ /* strip leading zeros [but leave final 0 if all 0's] */ if (*cfirst=='.') cfirst++; /* step past dot at start */ if (*cfirst=='0') { /* [cfirst always -> digit] */ for (; cfirst<clast; cfirst++) { if (*cfirst!='0') { /* non-zero found */ if (*cfirst=='.') continue; /* [ignore] */ break; /* done */ } digits--; /* 0 stripped */ } /* cfirst */ } /* at least one leading 0 */ /* the coefficient is now as short as possible, but may still */ /* be too long; copy up to Pmax+1 digits to the buffer, then */ /* just record any non-zeros (set round-for-reround digit) */ for (c=cfirst; c<=clast && ub<=buffer+DECPMAX; c++) { /* (see commentary just above) */ if (c<=clast-3 /* safe for four */ && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) { /* four digits */ UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); /* to BCD8 */ ub+=4; c+=3; /* [will become 4] */ continue; } if (*c=='.') continue; /* [ignore] */ *ub++=(uByte)(*c-'0'); } ub--; /* -> LSD */ for (; c<=clast; c++) { /* inspect remaining chars */ if (*c!='0') { /* sticky bit needed */ if (*c=='.') continue; /* [ignore] */ *ub=DECSTICKYTAB[*ub]; /* update round-for-reround */ break; /* no need to look at more */ } } num.lsd=ub; /* record LSD */ /* adjust exponent for dropped digits */ num.exponent+=digits-(Int)(ub-buffer+1); } /* too long for buffer */ } /* digits or dot */ else { /* no digits or dot were found */ if (*c=='\0') break; /* nothing to come is bad */ /* only Infinities and NaNs are allowed, here */ buffer[0]=0; /* default a coefficient of 0 */ num.lsd=buffer; /* .. */ if (decBiStr(c, "infinity", "INFINITY") || decBiStr(c, "inf", "INF")) num.exponent=DECFLOAT_Inf; else { /* should be a NaN */ num.exponent=DECFLOAT_qNaN; /* assume quiet NaN */ if (*c=='s' || *c=='S') { /* probably an sNaN */ c++; num.exponent=DECFLOAT_sNaN; /* assume is in fact sNaN */ } if (*c!='N' && *c!='n') break; /* check caseless "NaN" */ c++; if (*c!='a' && *c!='A') break; /* .. */ c++; if (*c!='N' && *c!='n') break; /* .. */ c++; /* now either nothing, or nnnn payload (no dots), expected */ /* -> start of integer, and skip leading 0s [including plain 0] */ for (cfirst=c; *cfirst=='0';) cfirst++; if (*cfirst!='\0') { /* not empty or all-0, payload */ /* payload found; check all valid digits and copy to buffer as bcd8 */ ub=buffer; for (c=cfirst;; c++, ub++) { if ((unsigned)(*c-'0')>9) break; /* quit if not 0-9 */ if (c-cfirst==DECPMAX-1) break; /* too many digits */ *ub=(uByte)(*c-'0'); /* good bcd8 */ } if (*c!='\0') break; /* not all digits, or too many */ num.lsd=ub-1; /* record new LSD */ } } /* NaN or sNaN */ error=0; /* syntax is OK */ break; /* done with specials */ } /* digits=0 (special expected) */ break; } /* [for(;;) break] */ /* decShowNum(&num, "fromStr"); */ if (error!=0) { set->status|=error; num.exponent=DECFLOAT_qNaN; /* set up quiet NaN */ num.sign=0; /* .. with 0 sign */ buffer[0]=0; /* .. and coefficient */ num.lsd=buffer; /* .. */ /* decShowNum(&num, "oops"); */ } /* decShowNum(&num, "dffs"); */ decFinalize(result, &num, set); /* round, check, and lay out */ /* decFloatShow(result, "fromString"); */ return result; } /* decFloatFromString */ /* ------------------------------------------------------------------ */ /* decFloatFromWider -- conversion from next-wider format */ /* */ /* result is the decFloat format number which gets the result of */ /* the conversion */ /* wider is the decFloatWider format number which will be narrowed */ /* set is the context */ /* returns result */ /* */ /* Narrowing can cause rounding, overflow, etc., but not Invalid */ /* operation (sNaNs are copied and do not signal). */ /* ------------------------------------------------------------------ */ /* narrow-to is not possible for decQuad format numbers; simply omit */ #if !QUAD decFloat * decFloatFromWider(decFloat *result, const decFloatWider *wider, decContext *set) { bcdnum num; /* collects data for finishing */ uByte bcdar[DECWPMAX]; /* room for wider coefficient */ uInt widerhi=DFWWORD(wider, 0); /* top word */ Int exp; GETWCOEFF(wider, bcdar); num.msd=bcdar; /* MSD is here always */ num.lsd=bcdar+DECWPMAX-1; /* LSD is here always */ num.sign=widerhi&0x80000000; /* extract sign [DECFLOAT_Sign=Neg] */ /* decode the wider combination field to exponent */ exp=DECCOMBWEXP[widerhi>>26]; /* decode from wider combination field */ /* if it is a special there's nothing to do unless sNaN; if it's */ /* finite then add the (wider) exponent continuation and unbias */ if (EXPISSPECIAL(exp)) exp=widerhi&0x7e000000; /* include sNaN selector */ else exp+=GETWECON(wider)-DECWBIAS; num.exponent=exp; /* decShowNum(&num, "dffw"); */ return decFinalize(result, &num, set);/* round, check, and lay out */ } /* decFloatFromWider */ #endif /* ------------------------------------------------------------------ */ /* decFloatGetCoefficient -- get coefficient as BCD8 */ /* */ /* df is the decFloat from which to extract the coefficient */ /* bcdar is where DECPMAX bytes will be written, one BCD digit in */ /* each byte (BCD8 encoding); if df is a NaN the first byte will */ /* be zero, and if it is infinite they will all be zero */ /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ /* 0 otherwise) */ /* */ /* No error is possible, and no status will be set. If df is a */ /* special value the array is set to zeros (for Infinity) or to the */ /* payload of a qNaN or sNaN. */ /* ------------------------------------------------------------------ */ Int decFloatGetCoefficient(const decFloat *df, uByte *bcdar) { if (DFISINF(df)) memset(bcdar, 0, DECPMAX); else { GETCOEFF(df, bcdar); /* use macro */ if (DFISNAN(df)) bcdar[0]=0; /* MSD needs correcting */ } return DFISSIGNED(df); } /* decFloatGetCoefficient */ /* ------------------------------------------------------------------ */ /* decFloatGetExponent -- get unbiased exponent */ /* */ /* df is the decFloat from which to extract the exponent */ /* returns the exponent, q. */ /* */ /* No error is possible, and no status will be set. If df is a */ /* special value the first seven bits of the decFloat are returned, */ /* left adjusted and with the first (sign) bit set to 0 (followed by */ /* 25 0 bits). e.g., -sNaN would return 0x7e000000 (DECFLOAT_sNaN). */ /* ------------------------------------------------------------------ */ Int decFloatGetExponent(const decFloat *df) { if (DFISSPECIAL(df)) return DFWORD(df, 0)&0x7e000000; return GETEXPUN(df); } /* decFloatGetExponent */ /* ------------------------------------------------------------------ */ /* decFloatSetCoefficient -- set coefficient from BCD8 */ /* */ /* df is the target decFloat (and source of exponent/special value) */ /* bcdar holds DECPMAX digits to set the coefficient from, one */ /* digit in each byte (BCD8 encoding); the first (MSD) is ignored */ /* if df is a NaN; all are ignored if df is infinite. */ /* sig is DECFLOAT_Sign to set the sign bit, 0 otherwise */ /* returns df, which will be canonical */ /* */ /* No error is possible, and no status will be set. */ /* ------------------------------------------------------------------ */ decFloat * decFloatSetCoefficient(decFloat *df, const uByte *bcdar, Int sig) { uInt exp; /* for exponent */ uByte bcdzero[DECPMAX]; /* for infinities */ /* Exponent/special code is extracted from df */ if (DFISSPECIAL(df)) { exp=DFWORD(df, 0)&0x7e000000; if (DFISINF(df)) { memset(bcdzero, 0, DECPMAX); return decFloatFromBCD(df, exp, bcdzero, sig); } } else exp=GETEXPUN(df); return decFloatFromBCD(df, exp, bcdar, sig); } /* decFloatSetCoefficient */ /* ------------------------------------------------------------------ */ /* decFloatSetExponent -- set exponent or special value */ /* */ /* df is the target decFloat (and source of coefficient/payload) */ /* set is the context for reporting status */ /* exp is the unbiased exponent, q, or a special value in the form */ /* returned by decFloatGetExponent */ /* returns df, which will be canonical */ /* */ /* No error is possible, but Overflow or Underflow might occur. */ /* ------------------------------------------------------------------ */ decFloat * decFloatSetExponent(decFloat *df, decContext *set, Int exp) { uByte bcdcopy[DECPMAX]; /* for coefficient */ bcdnum num; /* work */ num.exponent=exp; num.sign=decFloatGetCoefficient(df, bcdcopy); /* extract coefficient */ if (DFISSPECIAL(df)) { /* MSD or more needs correcting */ if (DFISINF(df)) memset(bcdcopy, 0, DECPMAX); bcdcopy[0]=0; } num.msd=bcdcopy; num.lsd=bcdcopy+DECPMAX-1; return decFinalize(df, &num, set); } /* decFloatSetExponent */ /* ------------------------------------------------------------------ */ /* decFloatRadix -- returns the base (10) */ /* */ /* df is any decFloat of this format */ /* ------------------------------------------------------------------ */ uInt decFloatRadix(const decFloat *df) { if (df) return 10; /* to placate compiler */ return 10; } /* decFloatRadix */ #if (DECCHECK || DECTRACE) /* ------------------------------------------------------------------ */ /* decFloatShow -- printf a decFloat in hexadecimal and decimal */ /* df is the decFloat to show */ /* tag is a tag string displayed with the number */ /* */ /* This is a debug aid; the precise format of the string may change. */ /* ------------------------------------------------------------------ */ void decFloatShow(const decFloat *df, const char *tag) { char hexbuf[DECBYTES*2+DECBYTES/4+1]; /* NB blank after every fourth */ char buff[DECSTRING]; /* for value in decimal */ Int i, j=0; for (i=0; i<DECBYTES; i++) { #if DECLITEND sprintf(&hexbuf[j], "%02x", df->bytes[DECBYTES-1-i]); #else sprintf(&hexbuf[j], "%02x", df->bytes[i]); #endif j+=2; /* the next line adds blank (and terminator) after final pair, too */ if ((i+1)%4==0) {strcpy(&hexbuf[j], " "); j++;} } decFloatToString(df, buff); printf(">%s> %s [big-endian] %s\n", tag, hexbuf, buff); return; } /* decFloatShow */ #endif /* ------------------------------------------------------------------ */ /* decFloatToBCD -- get sign, exponent, and BCD8 from a decFloat */ /* */ /* df is the source decFloat */ /* exp will be set to the unbiased exponent, q, or to a special */ /* value in the form returned by decFloatGetExponent */ /* bcdar is where DECPMAX bytes will be written, one BCD digit in */ /* each byte (BCD8 encoding); if df is a NaN the first byte will */ /* be zero, and if it is infinite they will all be zero */ /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ /* 0 otherwise) */ /* */ /* No error is possible, and no status will be set. */ /* ------------------------------------------------------------------ */ Int decFloatToBCD(const decFloat *df, Int *exp, uByte *bcdar) { if (DFISINF(df)) { memset(bcdar, 0, DECPMAX); *exp=DFWORD(df, 0)&0x7e000000; } else { GETCOEFF(df, bcdar); /* use macro */ if (DFISNAN(df)) { bcdar[0]=0; /* MSD needs correcting */ *exp=DFWORD(df, 0)&0x7e000000; } else { /* finite */ *exp=GETEXPUN(df); } } return DFISSIGNED(df); } /* decFloatToBCD */ /* ------------------------------------------------------------------ */ /* decFloatToEngString -- conversion to numeric string, engineering */ /* */ /* df is the decFloat format number to convert */ /* string is the string where the result will be laid out */ /* */ /* string must be at least DECPMAX+9 characters (the worst case is */ /* "-0.00000nnn...nnn\0", which is as long as the exponent form when */ /* DECEMAXD<=4); this condition is asserted above */ /* */ /* No error is possible, and no status will be set */ /* ------------------------------------------------------------------ */ char * decFloatToEngString(const decFloat *df, char *string){ uInt msd; /* coefficient MSD */ Int exp; /* exponent top two bits or full */ uInt comb; /* combination field */ char *cstart; /* coefficient start */ char *c; /* output pointer in string */ char *s, *t; /* .. (source, target) */ Int pre, e; /* work */ const uByte *u; /* .. */ uInt uiwork; /* for macros [one compiler needs */ /* volatile here to avoid bug, but */ /* that doubles execution time] */ /* Source words; macro handles endianness */ uInt sourhi=DFWORD(df, 0); /* word with sign */ #if DECPMAX==16 uInt sourlo=DFWORD(df, 1); #elif DECPMAX==34 uInt sourmh=DFWORD(df, 1); uInt sourml=DFWORD(df, 2); uInt sourlo=DFWORD(df, 3); #endif c=string; /* where result will go */ if (((Int)sourhi)<0) *c++='-'; /* handle sign */ comb=sourhi>>26; /* sign+combination field */ msd=DECCOMBMSD[comb]; /* decode the combination field */ exp=DECCOMBEXP[comb]; /* .. */ if (EXPISSPECIAL(exp)) { /* special */ if (exp==DECFLOAT_Inf) { /* infinity */ strcpy(c, "Inf"); strcpy(c+3, "inity"); return string; /* easy */ } if (sourhi&0x02000000) *c++='s'; /* sNaN */ strcpy(c, "NaN"); /* complete word */ c+=3; /* step past */ /* quick exit if the payload is zero */ #if DECPMAX==7 if ((sourhi&0x000fffff)==0) return string; #elif DECPMAX==16 if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; #elif DECPMAX==34 if (sourlo==0 && sourml==0 && sourmh==0 && (sourhi&0x00003fff)==0) return string; #endif /* otherwise drop through to add integer; set correct exp etc. */ exp=0; msd=0; /* setup for following code */ } else { /* complete exponent; top two bits are in place */ exp+=GETECON(df)-DECBIAS; /* .. + continuation and unbias */ } /* convert the digits of the significand to characters */ cstart=c; /* save start of coefficient */ if (msd) *c++=(char)('0'+(char)msd); /* non-zero most significant digit */ /* Decode the declets. After extracting each declet, it is */ /* decoded to a 4-uByte sequence by table lookup; the four uBytes */ /* are the three encoded BCD8 digits followed by a 1-byte length */ /* (significant digits, except that 000 has length 0). This allows */ /* us to left-align the first declet with non-zero content, then */ /* the remaining ones are full 3-char length. Fixed-length copies */ /* are used because variable-length memcpy causes a subroutine call */ /* in at least two compilers. (The copies are length 4 for speed */ /* and are safe because the last item in the array is of length */ /* three and has the length byte following.) */ #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4]; \ if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \ else if (*(u+3)) { \ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);} #if DECPMAX==7 dpd2char(sourhi>>10); /* declet 1 */ dpd2char(sourhi); /* declet 2 */ #elif DECPMAX==16 dpd2char(sourhi>>8); /* declet 1 */ dpd2char((sourhi<<2) | (sourlo>>30)); /* declet 2 */ dpd2char(sourlo>>20); /* declet 3 */ dpd2char(sourlo>>10); /* declet 4 */ dpd2char(sourlo); /* declet 5 */ #elif DECPMAX==34 dpd2char(sourhi>>4); /* declet 1 */ dpd2char((sourhi<<6) | (sourmh>>26)); /* declet 2 */ dpd2char(sourmh>>16); /* declet 3 */ dpd2char(sourmh>>6); /* declet 4 */ dpd2char((sourmh<<4) | (sourml>>28)); /* declet 5 */ dpd2char(sourml>>18); /* declet 6 */ dpd2char(sourml>>8); /* declet 7 */ dpd2char((sourml<<2) | (sourlo>>30)); /* declet 8 */ dpd2char(sourlo>>20); /* declet 9 */ dpd2char(sourlo>>10); /* declet 10 */ dpd2char(sourlo); /* declet 11 */ #endif if (c==cstart) *c++='0'; /* all zeros, empty -- make "0" */ if (exp==0) { /* integer or NaN case -- easy */ *c='\0'; /* terminate */ return string; } /* non-0 exponent */ e=0; /* assume no E */ pre=(Int)(c-cstart)+exp; /* length+exp [c->LSD+1] */ /* [here, pre-exp is the digits count (==1 for zero)] */ if (exp>0 || pre<-5) { /* need exponential form */ e=pre-1; /* calculate E value */ pre=1; /* assume one digit before '.' */ if (e!=0) { /* engineering: may need to adjust */ Int adj; /* adjustment */ /* The C remainder operator is undefined for negative numbers, so */ /* a positive remainder calculation must be used here */ if (e<0) { adj=(-e)%3; if (adj!=0) adj=3-adj; } else { /* e>0 */ adj=e%3; } e=e-adj; /* if dealing with zero still produce an exponent which is a */ /* multiple of three, as expected, but there will only be the */ /* one zero before the E, still. Otherwise note the padding. */ if (!DFISZERO(df)) pre+=adj; else { /* is zero */ if (adj!=0) { /* 0.00Esnn needed */ e=e+3; pre=-(2-adj); } } /* zero */ } /* engineering adjustment */ } /* exponential form */ /* printf("e=%ld pre=%ld exp=%ld\n", (LI)e, (LI)pre, (LI)exp); */ /* modify the coefficient, adding 0s, '.', and E+nn as needed */ if (pre>0) { /* ddd.ddd (plain), perhaps with E */ /* or dd00 padding for engineering */ char *dotat=cstart+pre; if (dotat<c) { /* if embedded dot needed... */ /* move by fours; there must be space for junk at the end */ /* because there is still space for exponent */ s=dotat+ROUNDDOWN4(c-dotat); /* source */ t=s+1; /* target */ /* open the gap [cannot use memcpy] */ for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); *dotat='.'; c++; /* length increased by one */ } /* need dot? */ else for (; c<dotat; c++) *c='0'; /* pad for engineering */ } /* pre>0 */ else { /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (may have E, but only for 0.00E+3 kind of case -- with plenty of spare space in this case */ pre=-pre+2; /* gap width, including "0." */ t=cstart+ROUNDDOWN4(c-cstart)+pre; /* preferred first target point */ /* backoff if too far to the right */ if (t>string+DECSTRING-5) t=string+DECSTRING-5; /* adjust to fit */ /* now shift the entire coefficient to the right, being careful not */ /* to access to the left of string [cannot use memcpy] */ for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); /* for Quads and Singles there may be a character or two left... */ s+=3; /* where next would come from */ for(; s>=cstart; s--, t--) *(t+3)=*(s); /* now have fill 0. through 0.00000; use overlaps to avoid tests */ if (pre>=4) { memcpy(cstart+pre-4, "0000", 4); memcpy(cstart, "0.00", 4); } else { /* 2 or 3 */ *(cstart+pre-1)='0'; memcpy(cstart, "0.", 2); } c+=pre; /* to end */ } /* finally add the E-part, if needed; it will never be 0, and has */ /* a maximum length of 3 or 4 digits (asserted above) */ if (e!=0) { memcpy(c, "E+", 2); /* starts with E, assume + */ c++; if (e<0) { *c='-'; /* oops, need '-' */ e=-e; /* uInt, please */ } c++; /* Three-character exponents are easy; 4-character a little trickier */ #if DECEMAXD<=3 u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ /* copy fixed 4 characters [is safe], starting at non-zero */ /* and with character mask to convert BCD to char */ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3); /* bump pointer appropriately */ #elif DECEMAXD==4 if (e<1000) { /* 3 (or fewer) digits case */ u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ c+=*(u+3); /* bump pointer appropriately */ } else { /* 4-digits */ Int thou=((e>>3)*1049)>>17; /* e/1000 */ Int rem=e-(1000*thou); /* e%1000 */ *c++=(char)('0'+(char)thou); /* the thousands digit */ u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u)|CHARMASK);/* copy fixed 3+1 characters [is safe] */ c+=3; /* bump pointer, always 3 digits */ } #endif } *c='\0'; /* terminate */ /*printf("res %s\n", string); */ return string; } /* decFloatToEngString */ /* ------------------------------------------------------------------ */ /* decFloatToPacked -- convert decFloat to Packed decimal + exponent */ /* */ /* df is the source decFloat */ /* exp will be set to the unbiased exponent, q, or to a special */ /* value in the form returned by decFloatGetExponent */ /* packed is where DECPMAX nibbles will be written with the sign as */ /* final nibble (0x0c for +, 0x0d for -); a NaN has a first nibble */ /* of zero, and an infinity is all zeros. decDouble and decQuad */ /* have a additional leading zero nibble, leading to result */ /* lengths of 4, 9, and 18 bytes. */ /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ /* 0 otherwise) */ /* */ /* No error is possible, and no status will be set. */ /* ------------------------------------------------------------------ */ Int decFloatToPacked(const decFloat *df, Int *exp, uByte *packed) { uByte bcdar[DECPMAX+2]; /* work buffer */ uByte *ip=bcdar, *op=packed; /* work pointers */ if (DFISINF(df)) { memset(bcdar, 0, DECPMAX+2); *exp=DECFLOAT_Inf; } else { GETCOEFF(df, bcdar+1); /* use macro */ if (DFISNAN(df)) { bcdar[1]=0; /* MSD needs clearing */ *exp=DFWORD(df, 0)&0x7e000000; } else { /* finite */ *exp=GETEXPUN(df); } } /* now pack; coefficient currently at bcdar+1 */ #if SINGLE ip++; /* ignore first byte */ #else *ip=0; /* need leading zero */ #endif /* set final byte to Packed BCD sign value */ bcdar[DECPMAX+1]=(DFISSIGNED(df) ? DECPMINUS : DECPPLUS); /* pack an even number of bytes... */ for (; op<packed+((DECPMAX+2)/2); op++, ip+=2) { *op=(uByte)((*ip<<4)+*(ip+1)); } return (bcdar[DECPMAX+1]==DECPMINUS ? DECFLOAT_Sign : 0); } /* decFloatToPacked */ /* ------------------------------------------------------------------ */ /* decFloatToString -- conversion to numeric string */ /* */ /* df is the decFloat format number to convert */ /* string is the string where the result will be laid out */ /* */ /* string must be at least DECPMAX+9 characters (the worst case is */ /* "-0.00000nnn...nnn\0", which is as long as the exponent form when */ /* DECEMAXD<=4); this condition is asserted above */ /* */ /* No error is possible, and no status will be set */ /* ------------------------------------------------------------------ */ char * decFloatToString(const decFloat *df, char *string){ uInt msd; /* coefficient MSD */ Int exp; /* exponent top two bits or full */ uInt comb; /* combination field */ char *cstart; /* coefficient start */ char *c; /* output pointer in string */ char *s, *t; /* .. (source, target) */ Int pre, e; /* work */ const uByte *u; /* .. */ uInt uiwork; /* for macros [one compiler needs */ /* volatile here to avoid bug, but */ /* that doubles execution time] */ /* Source words; macro handles endianness */ uInt sourhi=DFWORD(df, 0); /* word with sign */ #if DECPMAX==16 uInt sourlo=DFWORD(df, 1); #elif DECPMAX==34 uInt sourmh=DFWORD(df, 1); uInt sourml=DFWORD(df, 2); uInt sourlo=DFWORD(df, 3); #endif c=string; /* where result will go */ if (((Int)sourhi)<0) *c++='-'; /* handle sign */ comb=sourhi>>26; /* sign+combination field */ msd=DECCOMBMSD[comb]; /* decode the combination field */ exp=DECCOMBEXP[comb]; /* .. */ if (!EXPISSPECIAL(exp)) { /* finite */ /* complete exponent; top two bits are in place */ exp+=GETECON(df)-DECBIAS; /* .. + continuation and unbias */ } else { /* IS special */ if (exp==DECFLOAT_Inf) { /* infinity */ strcpy(c, "Infinity"); return string; /* easy */ } if (sourhi&0x02000000) *c++='s'; /* sNaN */ strcpy(c, "NaN"); /* complete word */ c+=3; /* step past */ /* quick exit if the payload is zero */ #if DECPMAX==7 if ((sourhi&0x000fffff)==0) return string; #elif DECPMAX==16 if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; #elif DECPMAX==34 if (sourlo==0 && sourml==0 && sourmh==0 && (sourhi&0x00003fff)==0) return string; #endif /* otherwise drop through to add integer; set correct exp etc. */ exp=0; msd=0; /* setup for following code */ } /* convert the digits of the significand to characters */ cstart=c; /* save start of coefficient */ if (msd) *c++=(char)('0'+(char)msd); /* non-zero most significant digit */ /* Decode the declets. After extracting each declet, it is */ /* decoded to a 4-uByte sequence by table lookup; the four uBytes */ /* are the three encoded BCD8 digits followed by a 1-byte length */ /* (significant digits, except that 000 has length 0). This allows */ /* us to left-align the first declet with non-zero content, then */ /* the remaining ones are full 3-char length. Fixed-length copies */ /* are used because variable-length memcpy causes a subroutine call */ /* in at least two compilers. (The copies are length 4 for speed */ /* and are safe because the last item in the array is of length */ /* three and has the length byte following.) */ #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4]; \ if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \ else if (*(u+3)) { \ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);} #if DECPMAX==7 dpd2char(sourhi>>10); /* declet 1 */ dpd2char(sourhi); /* declet 2 */ #elif DECPMAX==16 dpd2char(sourhi>>8); /* declet 1 */ dpd2char((sourhi<<2) | (sourlo>>30)); /* declet 2 */ dpd2char(sourlo>>20); /* declet 3 */ dpd2char(sourlo>>10); /* declet 4 */ dpd2char(sourlo); /* declet 5 */ #elif DECPMAX==34 dpd2char(sourhi>>4); /* declet 1 */ dpd2char((sourhi<<6) | (sourmh>>26)); /* declet 2 */ dpd2char(sourmh>>16); /* declet 3 */ dpd2char(sourmh>>6); /* declet 4 */ dpd2char((sourmh<<4) | (sourml>>28)); /* declet 5 */ dpd2char(sourml>>18); /* declet 6 */ dpd2char(sourml>>8); /* declet 7 */ dpd2char((sourml<<2) | (sourlo>>30)); /* declet 8 */ dpd2char(sourlo>>20); /* declet 9 */ dpd2char(sourlo>>10); /* declet 10 */ dpd2char(sourlo); /* declet 11 */ #endif if (c==cstart) *c++='0'; /* all zeros, empty -- make "0" */ /*[This fast path is valid but adds 3-5 cycles to worst case length] */ /*if (exp==0) { // integer or NaN case -- easy */ /* *c='\0'; // terminate */ /* return string; */ /* } */ e=0; /* assume no E */ pre=(Int)(c-cstart)+exp; /* length+exp [c->LSD+1] */ /* [here, pre-exp is the digits count (==1 for zero)] */ if (exp>0 || pre<-5) { /* need exponential form */ e=pre-1; /* calculate E value */ pre=1; /* assume one digit before '.' */ } /* exponential form */ /* modify the coefficient, adding 0s, '.', and E+nn as needed */ if (pre>0) { /* ddd.ddd (plain), perhaps with E */ char *dotat=cstart+pre; if (dotat<c) { /* if embedded dot needed... */ /* [memmove is a disaster, here] */ /* move by fours; there must be space for junk at the end */ /* because exponent is still possible */ s=dotat+ROUNDDOWN4(c-dotat); /* source */ t=s+1; /* target */ /* open the gap [cannot use memcpy] */ for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); *dotat='.'; c++; /* length increased by one */ } /* need dot? */ /* finally add the E-part, if needed; it will never be 0, and has */ /* a maximum length of 3 or 4 digits (asserted above) */ if (e!=0) { memcpy(c, "E+", 2); /* starts with E, assume + */ c++; if (e<0) { *c='-'; /* oops, need '-' */ e=-e; /* uInt, please */ } c++; /* Three-character exponents are easy; 4-character a little trickier */ #if DECEMAXD<=3 u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ /* copy fixed 4 characters [is safe], starting at non-zero */ /* and with character mask to convert BCD to char */ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3); /* bump pointer appropriately */ #elif DECEMAXD==4 if (e<1000) { /* 3 (or fewer) digits case */ u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ c+=*(u+3); /* bump pointer appropriately */ } else { /* 4-digits */ Int thou=((e>>3)*1049)>>17; /* e/1000 */ Int rem=e-(1000*thou); /* e%1000 */ *c++=(char)('0'+(char)thou); /* the thousands digit */ u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u)|CHARMASK); /* copy fixed 3+1 characters [is safe] */ c+=3; /* bump pointer, always 3 digits */ } #endif } *c='\0'; /* add terminator */ /*printf("res %s\n", string); */ return string; } /* pre>0 */ /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */ /* Surprisingly, this is close to being the worst-case path, so the */ /* shift is done by fours; this is a little tricky because the */ /* rightmost character to be written must not be beyond where the */ /* rightmost terminator could be -- so backoff to not touch */ /* terminator position if need be (this can make exact alignments */ /* for full Doubles, but in some cases needs care not to access too */ /* far to the left) */ pre=-pre+2; /* gap width, including "0." */ t=cstart+ROUNDDOWN4(c-cstart)+pre; /* preferred first target point */ /* backoff if too far to the right */ if (t>string+DECSTRING-5) t=string+DECSTRING-5; /* adjust to fit */ /* now shift the entire coefficient to the right, being careful not */ /* to access to the left of string [cannot use memcpy] */ for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); /* for Quads and Singles there may be a character or two left... */ s+=3; /* where next would come from */ for(; s>=cstart; s--, t--) *(t+3)=*(s); /* now have fill 0. through 0.00000; use overlaps to avoid tests */ if (pre>=4) { memcpy(cstart+pre-4, "0000", 4); memcpy(cstart, "0.00", 4); } else { /* 2 or 3 */ *(cstart+pre-1)='0'; memcpy(cstart, "0.", 2); } *(c+pre)='\0'; /* terminate */ return string; } /* decFloatToString */ /* ------------------------------------------------------------------ */ /* decFloatToWider -- conversion to next-wider format */ /* */ /* source is the decFloat format number which gets the result of */ /* the conversion */ /* wider is the decFloatWider format number which will be narrowed */ /* returns wider */ /* */ /* Widening is always exact; no status is set (sNaNs are copied and */ /* do not signal). The result will be canonical if the source is, */ /* and may or may not be if the source is not. */ /* ------------------------------------------------------------------ */ /* widening is not possible for decQuad format numbers; simply omit */ #if !QUAD decFloatWider * decFloatToWider(const decFloat *source, decFloatWider *wider) { uInt msd; /* Construct and copy the sign word */ if (DFISSPECIAL(source)) { /* copy sign, combination, and first bit of exponent (sNaN selector) */ DFWWORD(wider, 0)=DFWORD(source, 0)&0xfe000000; msd=0; } else { /* is finite number */ uInt exp=GETEXPUN(source)+DECWBIAS; /* get unbiased exponent and rebias */ uInt code=(exp>>DECWECONL)<<29; /* set two bits of exp [msd=0] */ code|=(exp<<(32-6-DECWECONL)) & 0x03ffffff; /* add exponent continuation */ code|=DFWORD(source, 0)&0x80000000; /* add sign */ DFWWORD(wider, 0)=code; /* .. and place top word in wider */ msd=GETMSD(source); /* get source coefficient MSD [0-9] */ } /* Copy the coefficient and clear any 'unused' words to left */ #if SINGLE DFWWORD(wider, 1)=(DFWORD(source, 0)&0x000fffff)|(msd<<20); #elif DOUBLE DFWWORD(wider, 2)=(DFWORD(source, 0)&0x0003ffff)|(msd<<18); DFWWORD(wider, 3)=DFWORD(source, 1); DFWWORD(wider, 1)=0; #endif return wider; } /* decFloatToWider */ #endif /* ------------------------------------------------------------------ */ /* decFloatVersion -- return package version string */ /* */ /* returns a constant string describing this package */ /* ------------------------------------------------------------------ */ const char *decFloatVersion(void) { return DECVERSION; } /* decFloatVersion */ /* ------------------------------------------------------------------ */ /* decFloatZero -- set to canonical (integer) zero */ /* */ /* df is the decFloat format number to integer +0 (q=0, c=+0) */ /* returns df */ /* */ /* No error is possible, and no status can be set. */ /* ------------------------------------------------------------------ */ decFloat * decFloatZero(decFloat *df){ DFWORD(df, 0)=ZEROWORD; /* set appropriate top word */ #if DOUBLE || QUAD DFWORD(df, 1)=0; #if QUAD DFWORD(df, 2)=0; DFWORD(df, 3)=0; #endif #endif /* decFloatShow(df, "zero"); */ return df; } /* decFloatZero */ /* ------------------------------------------------------------------ */ /* Private generic function (not format-specific) for development use */ /* ------------------------------------------------------------------ */ /* This is included once only, for all to use */ #if QUAD && (DECCHECK || DECTRACE) /* ---------------------------------------------------------------- */ /* decShowNum -- display bcd8 number in debug form */ /* */ /* num is the bcdnum to display */ /* tag is a string to label the display */ /* ---------------------------------------------------------------- */ void decShowNum(const bcdnum *num, const char *tag) { const char *csign="+"; /* sign character */ uByte *ub; /* work */ uInt uiwork; /* for macros */ if (num->sign==DECFLOAT_Sign) csign="-"; printf(">%s> ", tag); if (num->exponent==DECFLOAT_Inf) printf("%sInfinity", csign); else if (num->exponent==DECFLOAT_qNaN) printf("%sqNaN", csign); else if (num->exponent==DECFLOAT_sNaN) printf("%ssNaN", csign); else { /* finite */ char qbuf[10]; /* for right-aligned q */ char *c; /* work */ const uByte *u; /* .. */ Int e=num->exponent; /* .. exponent */ strcpy(qbuf, "q="); c=&qbuf[2]; /* where exponent will go */ /* lay out the exponent */ if (e<0) { *c++='-'; /* add '-' */ e=-e; /* uInt, please */ } #if DECEMAXD>4 #error Exponent form is too long for ShowNum to lay out #endif if (e==0) *c++='0'; /* 0-length case */ else if (e<1000) { /* 3 (or fewer) digits case */ u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ c+=*(u+3); /* bump pointer appropriately */ } else { /* 4-digits */ Int thou=((e>>3)*1049)>>17; /* e/1000 */ Int rem=e-(1000*thou); /* e%1000 */ *c++=(char)('0'+(char)thou); /* the thousands digit */ u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ UBFROMUI(c, UBTOUI(u)|CHARMASK); /* copy fixed 3+1 characters [is safe] */ c+=3; /* bump pointer, always 3 digits */ } *c='\0'; /* add terminator */ printf("%7s c=%s", qbuf, csign); } if (!EXPISSPECIAL(num->exponent) || num->msd!=num->lsd || *num->lsd!=0) { for (ub=num->msd; ub<=num->lsd; ub++) { /* coefficient... */ printf("%1x", *ub); if ((num->lsd-ub)%3==0 && ub!=num->lsd) printf(" "); /* 4-space */ } } printf("\n"); } /* decShowNum */ #endif
Go to most recent revision | Compare with Previous | Blame | View Log