| 1 | /* Common code for fixed-size types in the decNumber C Library. |
| 2 | Copyright (C) 2007, 2009 Free Software Foundation, Inc. |
| 3 | Contributed by IBM Corporation. Author Mike Cowlishaw. |
| 4 | |
| 5 | This file is part of GCC. |
| 6 | |
| 7 | GCC is free software; you can redistribute it and/or modify it under |
| 8 | the terms of the GNU General Public License as published by the Free |
| 9 | Software Foundation; either version 3, or (at your option) any later |
| 10 | version. |
| 11 | |
| 12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| 13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| 15 | for more details. |
| 16 | |
| 17 | Under Section 7 of GPL version 3, you are granted additional |
| 18 | permissions described in the GCC Runtime Library Exception, version |
| 19 | 3.1, as published by the Free Software Foundation. |
| 20 | |
| 21 | You should have received a copy of the GNU General Public License and |
| 22 | a copy of the GCC Runtime Library Exception along with this program; |
| 23 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| 24 | <http://www.gnu.org/licenses/>. */ |
| 25 | |
| 26 | /* ------------------------------------------------------------------ */ |
| 27 | /* decCommon.c -- common code for all three fixed-size types */ |
| 28 | /* ------------------------------------------------------------------ */ |
| 29 | /* This module comprises code that is shared between all the formats */ |
| 30 | /* (decSingle, decDouble, and decQuad); it includes set and extract */ |
| 31 | /* of format components, widening, narrowing, and string conversions. */ |
| 32 | /* */ |
| 33 | /* Unlike decNumber, parameterization takes place at compile time */ |
| 34 | /* rather than at runtime. The parameters are set in the decDouble.c */ |
| 35 | /* (etc.) files, which then include this one to produce the compiled */ |
| 36 | /* code. The functions here, therefore, are code shared between */ |
| 37 | /* multiple formats. */ |
| 38 | /* ------------------------------------------------------------------ */ |
| 39 | /* Names here refer to decFloat rather than to decDouble, etc., and */ |
| 40 | /* the functions are in strict alphabetical order. */ |
| 41 | /* Constants, tables, and debug function(s) are included only for QUAD */ |
| 42 | /* (which will always be compiled if DOUBLE or SINGLE are used). */ |
| 43 | /* */ |
| 44 | /* Whenever a decContext is used, only the status may be set (using */ |
| 45 | /* OR) or the rounding mode read; all other fields are ignored and */ |
| 46 | /* untouched. */ |
| 47 | |
| 48 | #include "decCommonSymbols.h" |
| 49 | |
| 50 | /* names for simpler testing and default context */ |
| 51 | #if DECPMAX==7 |
| 52 | #define SINGLE 1 |
| 53 | #define DOUBLE 0 |
| 54 | #define QUAD 0 |
| 55 | #define DEFCONTEXT DEC_INIT_DECIMAL32 |
| 56 | #elif DECPMAX==16 |
| 57 | #define SINGLE 0 |
| 58 | #define DOUBLE 1 |
| 59 | #define QUAD 0 |
| 60 | #define DEFCONTEXT DEC_INIT_DECIMAL64 |
| 61 | #elif DECPMAX==34 |
| 62 | #define SINGLE 0 |
| 63 | #define DOUBLE 0 |
| 64 | #define QUAD 1 |
| 65 | #define DEFCONTEXT DEC_INIT_DECIMAL128 |
| 66 | #else |
| 67 | #error Unexpected DECPMAX value |
| 68 | #endif |
| 69 | |
| 70 | /* Assertions */ |
| 71 | |
| 72 | #if DECPMAX!=7 && DECPMAX!=16 && DECPMAX!=34 |
| 73 | #error Unexpected Pmax (DECPMAX) value for this module |
| 74 | #endif |
| 75 | |
| 76 | /* Assert facts about digit characters, etc. */ |
| 77 | #if ('9'&0x0f)!=9 |
| 78 | #error This module assumes characters are of the form 0b....nnnn |
| 79 | /* where .... are don't care 4 bits and nnnn is 0000 through 1001 */ |
| 80 | #endif |
| 81 | #if ('9'&0xf0)==('.'&0xf0) |
| 82 | #error This module assumes '.' has a different mask than a digit |
| 83 | #endif |
| 84 | |
| 85 | /* Assert ToString lay-out conditions */ |
| 86 | #if DECSTRING<DECPMAX+9 |
| 87 | #error ToString needs at least 8 characters for lead-in and dot |
| 88 | #endif |
| 89 | #if DECPMAX+DECEMAXD+5 > DECSTRING |
| 90 | #error Exponent form can be too long for ToString to lay out safely |
| 91 | #endif |
| 92 | #if DECEMAXD > 4 |
| 93 | #error Exponent form is too long for ToString to lay out |
| 94 | /* Note: code for up to 9 digits exists in archives [decOct] */ |
| 95 | #endif |
| 96 | |
| 97 | /* Private functions used here and possibly in decBasic.c, etc. */ |
| 98 | static decFloat * decFinalize(decFloat *, bcdnum *, decContext *); |
| 99 | static Flag decBiStr(const char *, const char *, const char *); |
| 100 | |
| 101 | /* Macros and private tables; those which are not format-dependent */ |
| 102 | /* are only included if decQuad is being built. */ |
| 103 | |
| 104 | /* ------------------------------------------------------------------ */ |
| 105 | /* Combination field lookup tables (uInts to save measurable work) */ |
| 106 | /* */ |
| 107 | /* DECCOMBEXP - 2 most-significant-bits of exponent (00, 01, or */ |
| 108 | /* 10), shifted left for format, or DECFLOAT_Inf/NaN */ |
| 109 | /* DECCOMBWEXP - The same, for the next-wider format (unless QUAD) */ |
| 110 | /* DECCOMBMSD - 4-bit most-significant-digit */ |
| 111 | /* [0 if the index is a special (Infinity or NaN)] */ |
| 112 | /* DECCOMBFROM - 5-bit combination field from EXP top bits and MSD */ |
| 113 | /* (placed in uInt so no shift is needed) */ |
| 114 | /* */ |
| 115 | /* DECCOMBEXP, DECCOMBWEXP, and DECCOMBMSD are indexed by the sign */ |
| 116 | /* and 5-bit combination field (0-63, the second half of the table */ |
| 117 | /* identical to the first half) */ |
| 118 | /* DECCOMBFROM is indexed by expTopTwoBits*16 + msd */ |
| 119 | /* */ |
| 120 | /* DECCOMBMSD and DECCOMBFROM are not format-dependent and so are */ |
| 121 | /* only included once, when QUAD is being built */ |
| 122 | /* ------------------------------------------------------------------ */ |
| 123 | static const uInt DECCOMBEXP[64]={ |
| 124 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 125 | 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, |
| 126 | 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, |
| 127 | 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, |
| 128 | 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, |
| 129 | 0, 0, 1<<DECECONL, 1<<DECECONL, |
| 130 | 2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN, |
| 131 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 132 | 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, |
| 133 | 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL, |
| 134 | 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, |
| 135 | 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL, |
| 136 | 0, 0, 1<<DECECONL, 1<<DECECONL, |
| 137 | 2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN}; |
| 138 | #if !QUAD |
| 139 | static const uInt DECCOMBWEXP[64]={ |
| 140 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 141 | 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, |
| 142 | 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, |
| 143 | 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, |
| 144 | 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, |
| 145 | 0, 0, 1<<DECWECONL, 1<<DECWECONL, |
| 146 | 2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN, |
| 147 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 148 | 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, |
| 149 | 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, |
| 150 | 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, |
| 151 | 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, |
| 152 | 0, 0, 1<<DECWECONL, 1<<DECWECONL, |
| 153 | 2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN}; |
| 154 | #endif |
| 155 | |
| 156 | #if QUAD |
| 157 | const uInt DECCOMBMSD[64]={ |
| 158 | 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, |
| 159 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0, |
| 160 | 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, |
| 161 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0}; |
| 162 | |
| 163 | const uInt DECCOMBFROM[48]={ |
| 164 | 0x00000000, 0x04000000, 0x08000000, 0x0C000000, 0x10000000, 0x14000000, |
| 165 | 0x18000000, 0x1C000000, 0x60000000, 0x64000000, 0x00000000, 0x00000000, |
| 166 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x20000000, 0x24000000, |
| 167 | 0x28000000, 0x2C000000, 0x30000000, 0x34000000, 0x38000000, 0x3C000000, |
| 168 | 0x68000000, 0x6C000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, |
| 169 | 0x00000000, 0x00000000, 0x40000000, 0x44000000, 0x48000000, 0x4C000000, |
| 170 | 0x50000000, 0x54000000, 0x58000000, 0x5C000000, 0x70000000, 0x74000000, |
| 171 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000}; |
| 172 | |
| 173 | /* ------------------------------------------------------------------ */ |
| 174 | /* Request and include the tables to use for conversions */ |
| 175 | /* ------------------------------------------------------------------ */ |
| 176 | #define DEC_BCD2DPD 1 /* 0-0x999 -> DPD */ |
| 177 | #define DEC_BIN2DPD 1 /* 0-999 -> DPD */ |
| 178 | #define DEC_BIN2BCD8 1 /* 0-999 -> ddd, len */ |
| 179 | #define DEC_DPD2BCD8 1 /* DPD -> ddd, len */ |
| 180 | #define DEC_DPD2BIN 1 /* DPD -> 0-999 */ |
| 181 | #define DEC_DPD2BINK 1 /* DPD -> 0-999000 */ |
| 182 | #define DEC_DPD2BINM 1 /* DPD -> 0-999000000 */ |
| 183 | #include "decDPD.h" /* source of the lookup tables */ |
| 184 | |
| 185 | #endif |
| 186 | |
| 187 | /* ----------------------------------------------------------------- */ |
| 188 | /* decBiStr -- compare string with pairwise options */ |
| 189 | /* */ |
| 190 | /* targ is the string to compare */ |
| 191 | /* str1 is one of the strings to compare against (length may be 0) */ |
| 192 | /* str2 is the other; it must be the same length as str1 */ |
| 193 | /* */ |
| 194 | /* returns 1 if strings compare equal, (that is, targ is the same */ |
| 195 | /* length as str1 and str2, and each character of targ is in one */ |
| 196 | /* of str1 or str2 in the corresponding position), or 0 otherwise */ |
| 197 | /* */ |
| 198 | /* This is used for generic caseless compare, including the awkward */ |
| 199 | /* case of the Turkish dotted and dotless Is. Use as (for example): */ |
| 200 | /* if (decBiStr(test, "mike", "MIKE")) ... */ |
| 201 | /* ----------------------------------------------------------------- */ |
| 202 | static Flag decBiStr(const char *targ, const char *str1, const char *str2) { |
| 203 | for (;;targ++, str1++, str2++) { |
| 204 | if (*targ!=*str1 && *targ!=*str2) return 0; |
| 205 | /* *targ has a match in one (or both, if terminator) */ |
| 206 | if (*targ=='\0') break; |
| 207 | } /* forever */ |
| 208 | return 1; |
| 209 | } /* decBiStr */ |
| 210 | |
| 211 | /* ------------------------------------------------------------------ */ |
| 212 | /* decFinalize -- adjust and store a final result */ |
| 213 | /* */ |
| 214 | /* df is the decFloat format number which gets the final result */ |
| 215 | /* num is the descriptor of the number to be checked and encoded */ |
| 216 | /* [its values, including the coefficient, may be modified] */ |
| 217 | /* set is the context to use */ |
| 218 | /* returns df */ |
| 219 | /* */ |
| 220 | /* The num descriptor may point to a bcd8 string of any length; this */ |
| 221 | /* string may have leading insignificant zeros. If it has more than */ |
| 222 | /* DECPMAX digits then the final digit can be a round-for-reround */ |
| 223 | /* digit (i.e., it may include a sticky bit residue). */ |
| 224 | /* */ |
| 225 | /* The exponent (q) may be one of the codes for a special value and */ |
| 226 | /* can be up to 999999999 for conversion from string. */ |
| 227 | /* */ |
| 228 | /* No error is possible, but Inexact, Underflow, and/or Overflow may */ |
| 229 | /* be set. */ |
| 230 | /* ------------------------------------------------------------------ */ |
| 231 | /* Constant whose size varies with format; also the check for surprises */ |
| 232 | static uByte allnines[DECPMAX]= |
| 233 | #if SINGLE |
| 234 | {9, 9, 9, 9, 9, 9, 9}; |
| 235 | #elif DOUBLE |
| 236 | {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; |
| 237 | #elif QUAD |
| 238 | {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, |
| 239 | 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; |
| 240 | #endif |
| 241 | |
| 242 | static decFloat * decFinalize(decFloat *df, bcdnum *num, |
| 243 | decContext *set) { |
| 244 | uByte *ub; /* work */ |
| 245 | uInt dpd; /* .. */ |
| 246 | uInt uiwork; /* for macros */ |
| 247 | uByte *umsd=num->msd; /* local copy */ |
| 248 | uByte *ulsd=num->lsd; /* .. */ |
| 249 | uInt encode; /* encoding accumulator */ |
| 250 | Int length; /* coefficient length */ |
| 251 | |
| 252 | #if DECCHECK |
| 253 | Int clen=ulsd-umsd+1; |
| 254 | #if QUAD |
| 255 | #define COEXTRA 2 /* extra-long coefficent */ |
| 256 | #else |
| 257 | #define COEXTRA 0 |
| 258 | #endif |
| 259 | if (clen<1 || clen>DECPMAX*3+2+COEXTRA) |
| 260 | printf("decFinalize: suspect coefficient [length=%ld]\n", (LI)clen); |
| 261 | if (num->sign!=0 && num->sign!=DECFLOAT_Sign) |
| 262 | printf("decFinalize: bad sign [%08lx]\n", (LI)num->sign); |
| 263 | if (!EXPISSPECIAL(num->exponent) |
| 264 | && (num->exponent>1999999999 || num->exponent<-1999999999)) |
| 265 | printf("decFinalize: improbable exponent [%ld]\n", (LI)num->exponent); |
| 266 | /* decShowNum(num, "final"); */ |
| 267 | #endif |
| 268 | |
| 269 | /* A special will have an 'exponent' which is very positive and a */ |
| 270 | /* coefficient < DECPMAX */ |
| 271 | length=(uInt)(ulsd-umsd+1); /* coefficient length */ |
| 272 | |
| 273 | if (!NUMISSPECIAL(num)) { |
| 274 | Int drop; /* digits to be dropped */ |
| 275 | /* skip leading insignificant zeros to calculate an exact length */ |
| 276 | /* [this is quite expensive] */ |
| 277 | if (*umsd==0) { |
| 278 | for (; umsd+3<ulsd && UBTOUI(umsd)==0;) umsd+=4; |
| 279 | for (; *umsd==0 && umsd<ulsd;) umsd++; |
| 280 | length=ulsd-umsd+1; /* recalculate */ |
| 281 | } |
| 282 | drop=MAXI(length-DECPMAX, DECQTINY-num->exponent); |
| 283 | /* drop can now be > digits for bottom-clamp (subnormal) cases */ |
| 284 | if (drop>0) { /* rounding needed */ |
| 285 | /* (decFloatQuantize has very similar code to this, so any */ |
| 286 | /* changes may need to be made there, too) */ |
| 287 | uByte *roundat; /* -> re-round digit */ |
| 288 | uByte reround; /* reround value */ |
| 289 | /* printf("Rounding; drop=%ld\n", (LI)drop); */ |
| 290 | |
| 291 | num->exponent+=drop; /* always update exponent */ |
| 292 | |
| 293 | /* Three cases here: */ |
| 294 | /* 1. new LSD is in coefficient (almost always) */ |
| 295 | /* 2. new LSD is digit to left of coefficient (so MSD is */ |
| 296 | /* round-for-reround digit) */ |
| 297 | /* 3. new LSD is to left of case 2 (whole coefficient is sticky) */ |
| 298 | /* [duplicate check-stickies code to save a test] */ |
| 299 | /* [by-digit check for stickies as runs of zeros are rare] */ |
| 300 | if (drop<length) { /* NB lengths not addresses */ |
| 301 | roundat=umsd+length-drop; |
| 302 | reround=*roundat; |
| 303 | for (ub=roundat+1; ub<=ulsd; ub++) { |
| 304 | if (*ub!=0) { /* non-zero to be discarded */ |
| 305 | reround=DECSTICKYTAB[reround]; /* apply sticky bit */ |
| 306 | break; /* [remainder don't-care] */ |
| 307 | } |
| 308 | } /* check stickies */ |
| 309 | ulsd=roundat-1; /* new LSD */ |
| 310 | } |
| 311 | else { /* edge case */ |
| 312 | if (drop==length) { |
| 313 | roundat=umsd; |
| 314 | reround=*roundat; |
| 315 | } |
| 316 | else { |
| 317 | roundat=umsd-1; |
| 318 | reround=0; |
| 319 | } |
| 320 | for (ub=roundat+1; ub<=ulsd; ub++) { |
| 321 | if (*ub!=0) { /* non-zero to be discarded */ |
| 322 | reround=DECSTICKYTAB[reround]; /* apply sticky bit */ |
| 323 | break; /* [remainder don't-care] */ |
| 324 | } |
| 325 | } /* check stickies */ |
| 326 | *umsd=0; /* coefficient is a 0 */ |
| 327 | ulsd=umsd; /* .. */ |
| 328 | } |
| 329 | |
| 330 | if (reround!=0) { /* discarding non-zero */ |
| 331 | uInt bump=0; |
| 332 | set->status|=DEC_Inexact; |
| 333 | /* if adjusted exponent [exp+digits-1] is < EMIN then num is */ |
| 334 | /* subnormal -- so raise Underflow */ |
| 335 | if (num->exponent<DECEMIN && (num->exponent+(ulsd-umsd+1)-1)<DECEMIN) |
| 336 | set->status|=DEC_Underflow; |
| 337 | |
| 338 | /* next decide whether increment of the coefficient is needed */ |
| 339 | if (set->round==DEC_ROUND_HALF_EVEN) { /* fastpath slowest case */ |
| 340 | if (reround>5) bump=1; /* >0.5 goes up */ |
| 341 | else if (reround==5) /* exactly 0.5000 .. */ |
| 342 | bump=*ulsd & 0x01; /* .. up iff [new] lsd is odd */ |
| 343 | } /* r-h-e */ |
| 344 | else switch (set->round) { |
| 345 | case DEC_ROUND_DOWN: { |
| 346 | /* no change */ |
| 347 | break;} /* r-d */ |
| 348 | case DEC_ROUND_HALF_DOWN: { |
| 349 | if (reround>5) bump=1; |
| 350 | break;} /* r-h-d */ |
| 351 | case DEC_ROUND_HALF_UP: { |
| 352 | if (reround>=5) bump=1; |
| 353 | break;} /* r-h-u */ |
| 354 | case DEC_ROUND_UP: { |
| 355 | if (reround>0) bump=1; |
| 356 | break;} /* r-u */ |
| 357 | case DEC_ROUND_CEILING: { |
| 358 | /* same as _UP for positive numbers, and as _DOWN for negatives */ |
| 359 | if (!num->sign && reround>0) bump=1; |
| 360 | break;} /* r-c */ |
| 361 | case DEC_ROUND_FLOOR: { |
| 362 | /* same as _UP for negative numbers, and as _DOWN for positive */ |
| 363 | /* [negative reround cannot occur on 0] */ |
| 364 | if (num->sign && reround>0) bump=1; |
| 365 | break;} /* r-f */ |
| 366 | case DEC_ROUND_05UP: { |
| 367 | if (reround>0) { /* anything out there is 'sticky' */ |
| 368 | /* bump iff lsd=0 or 5; this cannot carry so it could be */ |
| 369 | /* effected immediately with no bump -- but the code */ |
| 370 | /* is clearer if this is done the same way as the others */ |
| 371 | if (*ulsd==0 || *ulsd==5) bump=1; |
| 372 | } |
| 373 | break;} /* r-r */ |
| 374 | default: { /* e.g., DEC_ROUND_MAX */ |
| 375 | set->status|=DEC_Invalid_context; |
| 376 | #if DECCHECK |
| 377 | printf("Unknown rounding mode: %ld\n", (LI)set->round); |
| 378 | #endif |
| 379 | break;} |
| 380 | } /* switch (not r-h-e) */ |
| 381 | /* printf("ReRound: %ld bump: %ld\n", (LI)reround, (LI)bump); */ |
| 382 | |
| 383 | if (bump!=0) { /* need increment */ |
| 384 | /* increment the coefficient; this might end up with 1000... */ |
| 385 | /* (after the all nines case) */ |
| 386 | ub=ulsd; |
| 387 | for(; ub-3>=umsd && UBTOUI(ub-3)==0x09090909; ub-=4) { |
| 388 | UBFROMUI(ub-3, 0); /* to 00000000 */ |
| 389 | } |
| 390 | /* [note ub could now be to left of msd, and it is not safe */ |
| 391 | /* to write to the the left of the msd] */ |
| 392 | /* now at most 3 digits left to non-9 (usually just the one) */ |
| 393 | for (; ub>=umsd; *ub=0, ub--) { |
| 394 | if (*ub==9) continue; /* carry */ |
| 395 | *ub+=1; |
| 396 | break; |
| 397 | } |
| 398 | if (ub<umsd) { /* had all-nines */ |
| 399 | *umsd=1; /* coefficient to 1000... */ |
| 400 | /* usually the 1000... coefficient can be used as-is */ |
| 401 | if ((ulsd-umsd+1)==DECPMAX) { |
| 402 | num->exponent++; |
| 403 | } |
| 404 | else { |
| 405 | /* if coefficient is shorter than Pmax then num is */ |
| 406 | /* subnormal, so extend it; this is safe as drop>0 */ |
| 407 | /* (or, if the coefficient was supplied above, it could */ |
| 408 | /* not be 9); this may make the result normal. */ |
| 409 | ulsd++; |
| 410 | *ulsd=0; |
| 411 | /* [exponent unchanged] */ |
| 412 | #if DECCHECK |
| 413 | if (num->exponent!=DECQTINY) /* sanity check */ |
| 414 | printf("decFinalize: bad all-nines extend [^%ld, %ld]\n", |
| 415 | (LI)num->exponent, (LI)(ulsd-umsd+1)); |
| 416 | #endif |
| 417 | } /* subnormal extend */ |
| 418 | } /* had all-nines */ |
| 419 | } /* bump needed */ |
| 420 | } /* inexact rounding */ |
| 421 | |
| 422 | length=ulsd-umsd+1; /* recalculate (may be <DECPMAX) */ |
| 423 | } /* need round (drop>0) */ |
| 424 | |
| 425 | /* The coefficient will now fit and has final length unless overflow */ |
| 426 | /* decShowNum(num, "rounded"); */ |
| 427 | |
| 428 | /* if exponent is >=emax may have to clamp, overflow, or fold-down */ |
| 429 | if (num->exponent>DECEMAX-(DECPMAX-1)) { /* is edge case */ |
| 430 | /* printf("overflow checks...\n"); */ |
| 431 | if (*ulsd==0 && ulsd==umsd) { /* have zero */ |
| 432 | num->exponent=DECEMAX-(DECPMAX-1); /* clamp to max */ |
| 433 | } |
| 434 | else if ((num->exponent+length-1)>DECEMAX) { /* > Nmax */ |
| 435 | /* Overflow -- these could go straight to encoding, here, but */ |
| 436 | /* instead num is adjusted to keep the code cleaner */ |
| 437 | Flag needmax=0; /* 1 for finite result */ |
| 438 | set->status|=(DEC_Overflow | DEC_Inexact); |
| 439 | switch (set->round) { |
| 440 | case DEC_ROUND_DOWN: { |
| 441 | needmax=1; /* never Infinity */ |
| 442 | break;} /* r-d */ |
| 443 | case DEC_ROUND_05UP: { |
| 444 | needmax=1; /* never Infinity */ |
| 445 | break;} /* r-05 */ |
| 446 | case DEC_ROUND_CEILING: { |
| 447 | if (num->sign) needmax=1; /* Infinity iff non-negative */ |
| 448 | break;} /* r-c */ |
| 449 | case DEC_ROUND_FLOOR: { |
| 450 | if (!num->sign) needmax=1; /* Infinity iff negative */ |
| 451 | break;} /* r-f */ |
| 452 | default: break; /* Infinity in all other cases */ |
| 453 | } |
| 454 | if (!needmax) { /* easy .. set Infinity */ |
| 455 | num->exponent=DECFLOAT_Inf; |
| 456 | *umsd=0; /* be clean: coefficient to 0 */ |
| 457 | ulsd=umsd; /* .. */ |
| 458 | } |
| 459 | else { /* return Nmax */ |
| 460 | umsd=allnines; /* use constant array */ |
| 461 | ulsd=allnines+DECPMAX-1; |
| 462 | num->exponent=DECEMAX-(DECPMAX-1); |
| 463 | } |
| 464 | } |
| 465 | else { /* no overflow but non-zero and may have to fold-down */ |
| 466 | Int shift=num->exponent-(DECEMAX-(DECPMAX-1)); |
| 467 | if (shift>0) { /* fold-down needed */ |
| 468 | /* fold down needed; must copy to buffer in order to pad */ |
| 469 | /* with zeros safely; fortunately this is not the worst case */ |
| 470 | /* path because cannot have had a round */ |
| 471 | uByte buffer[ROUNDUP(DECPMAX+3, 4)]; /* [+3 allows uInt padding] */ |
| 472 | uByte *s=umsd; /* source */ |
| 473 | uByte *t=buffer; /* safe target */ |
| 474 | uByte *tlsd=buffer+(ulsd-umsd)+shift; /* target LSD */ |
| 475 | /* printf("folddown shift=%ld\n", (LI)shift); */ |
| 476 | for (; s<=ulsd; s+=4, t+=4) UBFROMUI(t, UBTOUI(s)); |
| 477 | for (t=tlsd-shift+1; t<=tlsd; t+=4) UBFROMUI(t, 0); /* pad 0s */ |
| 478 | num->exponent-=shift; |
| 479 | umsd=buffer; |
| 480 | ulsd=tlsd; |
| 481 | } |
| 482 | } /* fold-down? */ |
| 483 | length=ulsd-umsd+1; /* recalculate length */ |
| 484 | } /* high-end edge case */ |
| 485 | } /* finite number */ |
| 486 | |
| 487 | /*------------------------------------------------------------------*/ |
| 488 | /* At this point the result will properly fit the decFloat */ |
| 489 | /* encoding, and it can be encoded with no possibility of error */ |
| 490 | /*------------------------------------------------------------------*/ |
| 491 | /* Following code does not alter coefficient (could be allnines array) */ |
| 492 | |
| 493 | /* fast path possible when DECPMAX digits */ |
| 494 | if (length==DECPMAX) { |
| 495 | return decFloatFromBCD(df, num->exponent, umsd, num->sign); |
| 496 | } /* full-length */ |
| 497 | |
| 498 | /* slower path when not a full-length number; must care about length */ |
| 499 | /* [coefficient length here will be < DECPMAX] */ |
| 500 | if (!NUMISSPECIAL(num)) { /* is still finite */ |
| 501 | /* encode the combination field and exponent continuation */ |
| 502 | uInt uexp=(uInt)(num->exponent+DECBIAS); /* biased exponent */ |
| 503 | uInt code=(uexp>>DECECONL)<<4; /* top two bits of exp */ |
| 504 | /* [msd==0] */ |
| 505 | /* look up the combination field and make high word */ |
| 506 | encode=DECCOMBFROM[code]; /* indexed by (0-2)*16+msd */ |
| 507 | encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; /* exponent continuation */ |
| 508 | } |
| 509 | else encode=num->exponent; /* special [already in word] */ |
| 510 | encode|=num->sign; /* add sign */ |
| 511 | |
| 512 | /* private macro to extract a declet, n (where 0<=n<DECLETS and 0 */ |
| 513 | /* refers to the declet from the least significant three digits) */ |
| 514 | /* and put the corresponding DPD code into dpd. Access to umsd and */ |
| 515 | /* ulsd (pointers to the most and least significant digit of the */ |
| 516 | /* variable-length coefficient) is assumed, along with use of a */ |
| 517 | /* working pointer, uInt *ub. */ |
| 518 | /* As not full-length then chances are there are many leading zeros */ |
| 519 | /* [and there may be a partial triad] */ |
| 520 | #define getDPDt(dpd, n) ub=ulsd-(3*(n))-2; \ |
| 521 | if (ub<umsd-2) dpd=0; \ |
| 522 | else if (ub>=umsd) dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)]; \ |
| 523 | else {dpd=*(ub+2); if (ub+1==umsd) dpd+=*(ub+1)*16; dpd=BCD2DPD[dpd];} |
| 524 | |
| 525 | /* place the declets in the encoding words and copy to result (df), */ |
| 526 | /* according to endianness; in all cases complete the sign word */ |
| 527 | /* first */ |
| 528 | #if DECPMAX==7 |
| 529 | getDPDt(dpd, 1); |
| 530 | encode|=dpd<<10; |
| 531 | getDPDt(dpd, 0); |
| 532 | encode|=dpd; |
| 533 | DFWORD(df, 0)=encode; /* just the one word */ |
| 534 | |
| 535 | #elif DECPMAX==16 |
| 536 | getDPDt(dpd, 4); encode|=dpd<<8; |
| 537 | getDPDt(dpd, 3); encode|=dpd>>2; |
| 538 | DFWORD(df, 0)=encode; |
| 539 | encode=dpd<<30; |
| 540 | getDPDt(dpd, 2); encode|=dpd<<20; |
| 541 | getDPDt(dpd, 1); encode|=dpd<<10; |
| 542 | getDPDt(dpd, 0); encode|=dpd; |
| 543 | DFWORD(df, 1)=encode; |
| 544 | |
| 545 | #elif DECPMAX==34 |
| 546 | getDPDt(dpd,10); encode|=dpd<<4; |
| 547 | getDPDt(dpd, 9); encode|=dpd>>6; |
| 548 | DFWORD(df, 0)=encode; |
| 549 | |
| 550 | encode=dpd<<26; |
| 551 | getDPDt(dpd, 8); encode|=dpd<<16; |
| 552 | getDPDt(dpd, 7); encode|=dpd<<6; |
| 553 | getDPDt(dpd, 6); encode|=dpd>>4; |
| 554 | DFWORD(df, 1)=encode; |
| 555 | |
| 556 | encode=dpd<<28; |
| 557 | getDPDt(dpd, 5); encode|=dpd<<18; |
| 558 | getDPDt(dpd, 4); encode|=dpd<<8; |
| 559 | getDPDt(dpd, 3); encode|=dpd>>2; |
| 560 | DFWORD(df, 2)=encode; |
| 561 | |
| 562 | encode=dpd<<30; |
| 563 | getDPDt(dpd, 2); encode|=dpd<<20; |
| 564 | getDPDt(dpd, 1); encode|=dpd<<10; |
| 565 | getDPDt(dpd, 0); encode|=dpd; |
| 566 | DFWORD(df, 3)=encode; |
| 567 | #endif |
| 568 | |
| 569 | /* printf("Status: %08lx\n", (LI)set->status); */ |
| 570 | /* decFloatShow(df, "final2"); */ |
| 571 | return df; |
| 572 | } /* decFinalize */ |
| 573 | |
| 574 | /* ------------------------------------------------------------------ */ |
| 575 | /* decFloatFromBCD -- set decFloat from exponent, BCD8, and sign */ |
| 576 | /* */ |
| 577 | /* df is the target decFloat */ |
| 578 | /* exp is the in-range unbiased exponent, q, or a special value in */ |
| 579 | /* the form returned by decFloatGetExponent */ |
| 580 | /* bcdar holds DECPMAX digits to set the coefficient from, one */ |
| 581 | /* digit in each byte (BCD8 encoding); the first (MSD) is ignored */ |
| 582 | /* if df is a NaN; all are ignored if df is infinite. */ |
| 583 | /* All bytes must be in 0-9; results are undefined otherwise. */ |
| 584 | /* sig is DECFLOAT_Sign to set the sign bit, 0 otherwise */ |
| 585 | /* returns df, which will be canonical */ |
| 586 | /* */ |
| 587 | /* No error is possible, and no status will be set. */ |
| 588 | /* ------------------------------------------------------------------ */ |
| 589 | decFloat * decFloatFromBCD(decFloat *df, Int exp, const uByte *bcdar, |
| 590 | Int sig) { |
| 591 | uInt encode, dpd; /* work */ |
| 592 | const uByte *ub; /* .. */ |
| 593 | |
| 594 | if (EXPISSPECIAL(exp)) encode=exp|sig;/* specials already encoded */ |
| 595 | else { /* is finite */ |
| 596 | /* encode the combination field and exponent continuation */ |
| 597 | uInt uexp=(uInt)(exp+DECBIAS); /* biased exponent */ |
| 598 | uInt code=(uexp>>DECECONL)<<4; /* top two bits of exp */ |
| 599 | code+=bcdar[0]; /* add msd */ |
| 600 | /* look up the combination field and make high word */ |
| 601 | encode=DECCOMBFROM[code]|sig; /* indexed by (0-2)*16+msd */ |
| 602 | encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; /* exponent continuation */ |
| 603 | } |
| 604 | |
| 605 | /* private macro to extract a declet, n (where 0<=n<DECLETS and 0 */ |
| 606 | /* refers to the declet from the least significant three digits) */ |
| 607 | /* and put the corresponding DPD code into dpd. */ |
| 608 | /* Use of a working pointer, uInt *ub, is assumed. */ |
| 609 | |
| 610 | #define getDPDb(dpd, n) ub=bcdar+DECPMAX-1-(3*(n))-2; \ |
| 611 | dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)]; |
| 612 | |
| 613 | /* place the declets in the encoding words and copy to result (df), */ |
| 614 | /* according to endianness; in all cases complete the sign word */ |
| 615 | /* first */ |
| 616 | #if DECPMAX==7 |
| 617 | getDPDb(dpd, 1); |
| 618 | encode|=dpd<<10; |
| 619 | getDPDb(dpd, 0); |
| 620 | encode|=dpd; |
| 621 | DFWORD(df, 0)=encode; /* just the one word */ |
| 622 | |
| 623 | #elif DECPMAX==16 |
| 624 | getDPDb(dpd, 4); encode|=dpd<<8; |
| 625 | getDPDb(dpd, 3); encode|=dpd>>2; |
| 626 | DFWORD(df, 0)=encode; |
| 627 | encode=dpd<<30; |
| 628 | getDPDb(dpd, 2); encode|=dpd<<20; |
| 629 | getDPDb(dpd, 1); encode|=dpd<<10; |
| 630 | getDPDb(dpd, 0); encode|=dpd; |
| 631 | DFWORD(df, 1)=encode; |
| 632 | |
| 633 | #elif DECPMAX==34 |
| 634 | getDPDb(dpd,10); encode|=dpd<<4; |
| 635 | getDPDb(dpd, 9); encode|=dpd>>6; |
| 636 | DFWORD(df, 0)=encode; |
| 637 | |
| 638 | encode=dpd<<26; |
| 639 | getDPDb(dpd, 8); encode|=dpd<<16; |
| 640 | getDPDb(dpd, 7); encode|=dpd<<6; |
| 641 | getDPDb(dpd, 6); encode|=dpd>>4; |
| 642 | DFWORD(df, 1)=encode; |
| 643 | |
| 644 | encode=dpd<<28; |
| 645 | getDPDb(dpd, 5); encode|=dpd<<18; |
| 646 | getDPDb(dpd, 4); encode|=dpd<<8; |
| 647 | getDPDb(dpd, 3); encode|=dpd>>2; |
| 648 | DFWORD(df, 2)=encode; |
| 649 | |
| 650 | encode=dpd<<30; |
| 651 | getDPDb(dpd, 2); encode|=dpd<<20; |
| 652 | getDPDb(dpd, 1); encode|=dpd<<10; |
| 653 | getDPDb(dpd, 0); encode|=dpd; |
| 654 | DFWORD(df, 3)=encode; |
| 655 | #endif |
| 656 | /* decFloatShow(df, "fromB"); */ |
| 657 | return df; |
| 658 | } /* decFloatFromBCD */ |
| 659 | |
| 660 | /* ------------------------------------------------------------------ */ |
| 661 | /* decFloatFromPacked -- set decFloat from exponent and packed BCD */ |
| 662 | /* */ |
| 663 | /* df is the target decFloat */ |
| 664 | /* exp is the in-range unbiased exponent, q, or a special value in */ |
| 665 | /* the form returned by decFloatGetExponent */ |
| 666 | /* packed holds DECPMAX packed decimal digits plus a sign nibble */ |
| 667 | /* (all 6 codes are OK); the first (MSD) is ignored if df is a NaN */ |
| 668 | /* and all except sign are ignored if df is infinite. For DOUBLE */ |
| 669 | /* and QUAD the first (pad) nibble is also ignored in all cases. */ |
| 670 | /* All coefficient nibbles must be in 0-9 and sign in A-F; results */ |
| 671 | /* are undefined otherwise. */ |
| 672 | /* returns df, which will be canonical */ |
| 673 | /* */ |
| 674 | /* No error is possible, and no status will be set. */ |
| 675 | /* ------------------------------------------------------------------ */ |
| 676 | decFloat * decFloatFromPacked(decFloat *df, Int exp, const uByte *packed) { |
| 677 | uByte bcdar[DECPMAX+2]; /* work [+1 for pad, +1 for sign] */ |
| 678 | const uByte *ip; /* .. */ |
| 679 | uByte *op; /* .. */ |
| 680 | Int sig=0; /* sign */ |
| 681 | |
| 682 | /* expand coefficient and sign to BCDAR */ |
| 683 | #if SINGLE |
| 684 | op=bcdar+1; /* no pad digit */ |
| 685 | #else |
| 686 | op=bcdar; /* first (pad) digit ignored */ |
| 687 | #endif |
| 688 | for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) { |
| 689 | *op++=*ip>>4; |
| 690 | *op++=(uByte)(*ip&0x0f); /* [final nibble is sign] */ |
| 691 | } |
| 692 | op--; /* -> sign byte */ |
| 693 | if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign; |
| 694 | |
| 695 | if (EXPISSPECIAL(exp)) { /* Infinity or NaN */ |
| 696 | if (!EXPISINF(exp)) bcdar[1]=0; /* a NaN: ignore MSD */ |
| 697 | else memset(bcdar+1, 0, DECPMAX); /* Infinite: coefficient to 0 */ |
| 698 | } |
| 699 | return decFloatFromBCD(df, exp, bcdar+1, sig); |
| 700 | } /* decFloatFromPacked */ |
| 701 | |
| 702 | /* ------------------------------------------------------------------ */ |
| 703 | /* decFloatFromPackedChecked -- set from exponent and packed; checked */ |
| 704 | /* */ |
| 705 | /* df is the target decFloat */ |
| 706 | /* exp is the in-range unbiased exponent, q, or a special value in */ |
| 707 | /* the form returned by decFloatGetExponent */ |
| 708 | /* packed holds DECPMAX packed decimal digits plus a sign nibble */ |
| 709 | /* (all 6 codes are OK); the first (MSD) must be 0 if df is a NaN */ |
| 710 | /* and all digits must be 0 if df is infinite. For DOUBLE and */ |
| 711 | /* QUAD the first (pad) nibble must be 0. */ |
| 712 | /* All coefficient nibbles must be in 0-9 and sign in A-F. */ |
| 713 | /* returns df, which will be canonical or NULL if any of the */ |
| 714 | /* requirements are not met (if this case df is unchanged); that */ |
| 715 | /* is, the input data must be as returned by decFloatToPacked, */ |
| 716 | /* except that all six sign codes are acccepted. */ |
| 717 | /* */ |
| 718 | /* No status will be set. */ |
| 719 | /* ------------------------------------------------------------------ */ |
| 720 | decFloat * decFloatFromPackedChecked(decFloat *df, Int exp, |
| 721 | const uByte *packed) { |
| 722 | uByte bcdar[DECPMAX+2]; /* work [+1 for pad, +1 for sign] */ |
| 723 | const uByte *ip; /* .. */ |
| 724 | uByte *op; /* .. */ |
| 725 | Int sig=0; /* sign */ |
| 726 | |
| 727 | /* expand coefficient and sign to BCDAR */ |
| 728 | #if SINGLE |
| 729 | op=bcdar+1; /* no pad digit */ |
| 730 | #else |
| 731 | op=bcdar; /* first (pad) digit here */ |
| 732 | #endif |
| 733 | for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) { |
| 734 | *op=*ip>>4; |
| 735 | if (*op>9) return NULL; |
| 736 | op++; |
| 737 | *op=(uByte)(*ip&0x0f); /* [final nibble is sign] */ |
| 738 | if (*op>9 && ip<packed+((DECPMAX+2)/2)-1) return NULL; |
| 739 | op++; |
| 740 | } |
| 741 | op--; /* -> sign byte */ |
| 742 | if (*op<=9) return NULL; /* bad sign */ |
| 743 | if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign; |
| 744 | |
| 745 | #if !SINGLE |
| 746 | if (bcdar[0]!=0) return NULL; /* bad pad nibble */ |
| 747 | #endif |
| 748 | |
| 749 | if (EXPISNAN(exp)) { /* a NaN */ |
| 750 | if (bcdar[1]!=0) return NULL; /* bad msd */ |
| 751 | } /* NaN */ |
| 752 | else if (EXPISINF(exp)) { /* is infinite */ |
| 753 | Int i; |
| 754 | for (i=0; i<DECPMAX; i++) { |
| 755 | if (bcdar[i+1]!=0) return NULL; /* should be all zeros */ |
| 756 | } |
| 757 | } /* infinity */ |
| 758 | else { /* finite */ |
| 759 | /* check the exponent is in range */ |
| 760 | if (exp>DECEMAX-DECPMAX+1) return NULL; |
| 761 | if (exp<DECEMIN-DECPMAX+1) return NULL; |
| 762 | } |
| 763 | return decFloatFromBCD(df, exp, bcdar+1, sig); |
| 764 | } /* decFloatFromPacked */ |
| 765 | |
| 766 | /* ------------------------------------------------------------------ */ |
| 767 | /* decFloatFromString -- conversion from numeric string */ |
| 768 | /* */ |
| 769 | /* result is the decFloat format number which gets the result of */ |
| 770 | /* the conversion */ |
| 771 | /* *string is the character string which should contain a valid */ |
| 772 | /* number (which may be a special value), \0-terminated */ |
| 773 | /* If there are too many significant digits in the */ |
| 774 | /* coefficient it will be rounded. */ |
| 775 | /* set is the context */ |
| 776 | /* returns result */ |
| 777 | /* */ |
| 778 | /* The length of the coefficient and the size of the exponent are */ |
| 779 | /* checked by this routine, so the correct error (Underflow or */ |
| 780 | /* Overflow) can be reported or rounding applied, as necessary. */ |
| 781 | /* */ |
| 782 | /* There is no limit to the coefficient length for finite inputs; */ |
| 783 | /* NaN payloads must be integers with no more than DECPMAX-1 digits. */ |
| 784 | /* Exponents may have up to nine significant digits. */ |
| 785 | /* */ |
| 786 | /* If bad syntax is detected, the result will be a quiet NaN. */ |
| 787 | /* ------------------------------------------------------------------ */ |
| 788 | decFloat * decFloatFromString(decFloat *result, const char *string, |
| 789 | decContext *set) { |
| 790 | Int digits; /* count of digits in coefficient */ |
| 791 | const char *dotchar=NULL; /* where dot was found [NULL if none] */ |
| 792 | const char *cfirst=string; /* -> first character of decimal part */ |
| 793 | const char *c; /* work */ |
| 794 | uByte *ub; /* .. */ |
| 795 | uInt uiwork; /* for macros */ |
| 796 | bcdnum num; /* collects data for finishing */ |
| 797 | uInt error=DEC_Conversion_syntax; /* assume the worst */ |
| 798 | uByte buffer[ROUNDUP(DECSTRING+11, 8)]; /* room for most coefficents, */ |
| 799 | /* some common rounding, +3, & pad */ |
| 800 | #if DECTRACE |
| 801 | /* printf("FromString %s ...\n", string); */ |
| 802 | #endif |
| 803 | |
| 804 | for(;;) { /* once-only 'loop' */ |
| 805 | num.sign=0; /* assume non-negative */ |
| 806 | num.msd=buffer; /* MSD is here always */ |
| 807 | |
| 808 | /* detect and validate the coefficient, including any leading, */ |
| 809 | /* trailing, or embedded '.' */ |
| 810 | /* [could test four-at-a-time here (saving 10% for decQuads), */ |
| 811 | /* but that risks storage violation because the position of the */ |
| 812 | /* terminator is unknown] */ |
| 813 | for (c=string;; c++) { /* -> input character */ |
| 814 | if (((unsigned)(*c-'0'))<=9) continue; /* '0' through '9' is good */ |
| 815 | if (*c=='\0') break; /* most common non-digit */ |
| 816 | if (*c=='.') { |
| 817 | if (dotchar!=NULL) break; /* not first '.' */ |
| 818 | dotchar=c; /* record offset into decimal part */ |
| 819 | continue;} |
| 820 | if (c==string) { /* first in string... */ |
| 821 | if (*c=='-') { /* valid - sign */ |
| 822 | cfirst++; |
| 823 | num.sign=DECFLOAT_Sign; |
| 824 | continue;} |
| 825 | if (*c=='+') { /* valid + sign */ |
| 826 | cfirst++; |
| 827 | continue;} |
| 828 | } |
| 829 | /* *c is not a digit, terminator, or a valid +, -, or '.' */ |
| 830 | break; |
| 831 | } /* c loop */ |
| 832 | |
| 833 | digits=(uInt)(c-cfirst); /* digits (+1 if a dot) */ |
| 834 | |
| 835 | if (digits>0) { /* had digits and/or dot */ |
| 836 | const char *clast=c-1; /* note last coefficient char position */ |
| 837 | Int exp=0; /* exponent accumulator */ |
| 838 | if (*c!='\0') { /* something follows the coefficient */ |
| 839 | uInt edig; /* unsigned work */ |
| 840 | /* had some digits and more to come; expect E[+|-]nnn now */ |
| 841 | const char *firstexp; /* exponent first non-zero */ |
| 842 | if (*c!='E' && *c!='e') break; |
| 843 | c++; /* to (optional) sign */ |
| 844 | if (*c=='-' || *c=='+') c++; /* step over sign (c=clast+2) */ |
| 845 | if (*c=='\0') break; /* no digits! (e.g., '1.2E') */ |
| 846 | for (; *c=='0';) c++; /* skip leading zeros [even last] */ |
| 847 | firstexp=c; /* remember start [maybe '\0'] */ |
| 848 | /* gather exponent digits */ |
| 849 | edig=(uInt)*c-(uInt)'0'; |
| 850 | if (edig<=9) { /* [check not bad or terminator] */ |
| 851 | exp+=edig; /* avoid initial X10 */ |
| 852 | c++; |
| 853 | for (;; c++) { |
| 854 | edig=(uInt)*c-(uInt)'0'; |
| 855 | if (edig>9) break; |
| 856 | exp=exp*10+edig; |
| 857 | } |
| 858 | } |
| 859 | /* if not now on the '\0', *c must not be a digit */ |
| 860 | if (*c!='\0') break; |
| 861 | |
| 862 | /* (this next test must be after the syntax checks) */ |
| 863 | /* if definitely more than the possible digits for format then */ |
| 864 | /* the exponent may have wrapped, so simply set it to a certain */ |
| 865 | /* over/underflow value */ |
| 866 | if (c>firstexp+DECEMAXD) exp=DECEMAX*2; |
| 867 | if (*(clast+2)=='-') exp=-exp; /* was negative */ |
| 868 | } /* digits>0 */ |
| 869 | |
| 870 | if (dotchar!=NULL) { /* had a '.' */ |
| 871 | digits--; /* remove from digits count */ |
| 872 | if (digits==0) break; /* was dot alone: bad syntax */ |
| 873 | exp-=(Int)(clast-dotchar); /* adjust exponent */ |
| 874 | /* [the '.' can now be ignored] */ |
| 875 | } |
| 876 | num.exponent=exp; /* exponent is good; store it */ |
| 877 | |
| 878 | /* Here when whole string has been inspected and syntax is good */ |
| 879 | /* cfirst->first digit or dot, clast->last digit or dot */ |
| 880 | error=0; /* no error possible now */ |
| 881 | |
| 882 | /* if the number of digits in the coefficient will fit in buffer */ |
| 883 | /* then it can simply be converted to bcd8 and copied -- decFinalize */ |
| 884 | /* will take care of leading zeros and rounding; the buffer is big */ |
| 885 | /* enough for all canonical coefficients, including 0.00000nn... */ |
| 886 | ub=buffer; |
| 887 | if (digits<=(Int)(sizeof(buffer)-3)) { /* [-3 allows by-4s copy] */ |
| 888 | c=cfirst; |
| 889 | if (dotchar!=NULL) { /* a dot to worry about */ |
| 890 | if (*(c+1)=='.') { /* common canonical case */ |
| 891 | *ub++=(uByte)(*c-'0'); /* copy leading digit */ |
| 892 | c+=2; /* prepare to handle rest */ |
| 893 | } |
| 894 | else for (; c<=clast;) { /* '.' could be anywhere */ |
| 895 | /* as usual, go by fours when safe; NB it has been asserted */ |
| 896 | /* that a '.' does not have the same mask as a digit */ |
| 897 | if (c<=clast-3 /* safe for four */ |
| 898 | && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) { /* test four */ |
| 899 | UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); /* to BCD8 */ |
| 900 | ub+=4; |
| 901 | c+=4; |
| 902 | continue; |
| 903 | } |
| 904 | if (*c=='.') { /* found the dot */ |
| 905 | c++; /* step over it .. */ |
| 906 | break; /* .. and handle the rest */ |
| 907 | } |
| 908 | *ub++=(uByte)(*c++-'0'); |
| 909 | } |
| 910 | } /* had dot */ |
| 911 | /* Now no dot; do this by fours (where safe) */ |
| 912 | for (; c<=clast-3; c+=4, ub+=4) UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); |
| 913 | for (; c<=clast; c++, ub++) *ub=(uByte)(*c-'0'); |
| 914 | num.lsd=buffer+digits-1; /* record new LSD */ |
| 915 | } /* fits */ |
| 916 | |
| 917 | else { /* too long for buffer */ |
| 918 | /* [This is a rare and unusual case; arbitrary-length input] */ |
| 919 | /* strip leading zeros [but leave final 0 if all 0's] */ |
| 920 | if (*cfirst=='.') cfirst++; /* step past dot at start */ |
| 921 | if (*cfirst=='0') { /* [cfirst always -> digit] */ |
| 922 | for (; cfirst<clast; cfirst++) { |
| 923 | if (*cfirst!='0') { /* non-zero found */ |
| 924 | if (*cfirst=='.') continue; /* [ignore] */ |
| 925 | break; /* done */ |
| 926 | } |
| 927 | digits--; /* 0 stripped */ |
| 928 | } /* cfirst */ |
| 929 | } /* at least one leading 0 */ |
| 930 | |
| 931 | /* the coefficient is now as short as possible, but may still */ |
| 932 | /* be too long; copy up to Pmax+1 digits to the buffer, then */ |
| 933 | /* just record any non-zeros (set round-for-reround digit) */ |
| 934 | for (c=cfirst; c<=clast && ub<=buffer+DECPMAX; c++) { |
| 935 | /* (see commentary just above) */ |
| 936 | if (c<=clast-3 /* safe for four */ |
| 937 | && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) { /* four digits */ |
| 938 | UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f); /* to BCD8 */ |
| 939 | ub+=4; |
| 940 | c+=3; /* [will become 4] */ |
| 941 | continue; |
| 942 | } |
| 943 | if (*c=='.') continue; /* [ignore] */ |
| 944 | *ub++=(uByte)(*c-'0'); |
| 945 | } |
| 946 | ub--; /* -> LSD */ |
| 947 | for (; c<=clast; c++) { /* inspect remaining chars */ |
| 948 | if (*c!='0') { /* sticky bit needed */ |
| 949 | if (*c=='.') continue; /* [ignore] */ |
| 950 | *ub=DECSTICKYTAB[*ub]; /* update round-for-reround */ |
| 951 | break; /* no need to look at more */ |
| 952 | } |
| 953 | } |
| 954 | num.lsd=ub; /* record LSD */ |
| 955 | /* adjust exponent for dropped digits */ |
| 956 | num.exponent+=digits-(Int)(ub-buffer+1); |
| 957 | } /* too long for buffer */ |
| 958 | } /* digits or dot */ |
| 959 | |
| 960 | else { /* no digits or dot were found */ |
| 961 | if (*c=='\0') break; /* nothing to come is bad */ |
| 962 | /* only Infinities and NaNs are allowed, here */ |
| 963 | buffer[0]=0; /* default a coefficient of 0 */ |
| 964 | num.lsd=buffer; /* .. */ |
| 965 | if (decBiStr(c, "infinity", "INFINITY") |
| 966 | || decBiStr(c, "inf", "INF")) num.exponent=DECFLOAT_Inf; |
| 967 | else { /* should be a NaN */ |
| 968 | num.exponent=DECFLOAT_qNaN; /* assume quiet NaN */ |
| 969 | if (*c=='s' || *c=='S') { /* probably an sNaN */ |
| 970 | c++; |
| 971 | num.exponent=DECFLOAT_sNaN; /* assume is in fact sNaN */ |
| 972 | } |
| 973 | if (*c!='N' && *c!='n') break; /* check caseless "NaN" */ |
| 974 | c++; |
| 975 | if (*c!='a' && *c!='A') break; /* .. */ |
| 976 | c++; |
| 977 | if (*c!='N' && *c!='n') break; /* .. */ |
| 978 | c++; |
| 979 | /* now either nothing, or nnnn payload (no dots), expected */ |
| 980 | /* -> start of integer, and skip leading 0s [including plain 0] */ |
| 981 | for (cfirst=c; *cfirst=='0';) cfirst++; |
| 982 | if (*cfirst!='\0') { /* not empty or all-0, payload */ |
| 983 | /* payload found; check all valid digits and copy to buffer as bcd8 */ |
| 984 | ub=buffer; |
| 985 | for (c=cfirst;; c++, ub++) { |
| 986 | if ((unsigned)(*c-'0')>9) break; /* quit if not 0-9 */ |
| 987 | if (c-cfirst==DECPMAX-1) break; /* too many digits */ |
| 988 | *ub=(uByte)(*c-'0'); /* good bcd8 */ |
| 989 | } |
| 990 | if (*c!='\0') break; /* not all digits, or too many */ |
| 991 | num.lsd=ub-1; /* record new LSD */ |
| 992 | } |
| 993 | } /* NaN or sNaN */ |
| 994 | error=0; /* syntax is OK */ |
| 995 | break; /* done with specials */ |
| 996 | } /* digits=0 (special expected) */ |
| 997 | break; |
| 998 | } /* [for(;;) break] */ |
| 999 | |
| 1000 | /* decShowNum(&num, "fromStr"); */ |
| 1001 | |
| 1002 | if (error!=0) { |
| 1003 | set->status|=error; |
| 1004 | num.exponent=DECFLOAT_qNaN; /* set up quiet NaN */ |
| 1005 | num.sign=0; /* .. with 0 sign */ |
| 1006 | buffer[0]=0; /* .. and coefficient */ |
| 1007 | num.lsd=buffer; /* .. */ |
| 1008 | /* decShowNum(&num, "oops"); */ |
| 1009 | } |
| 1010 | |
| 1011 | /* decShowNum(&num, "dffs"); */ |
| 1012 | decFinalize(result, &num, set); /* round, check, and lay out */ |
| 1013 | /* decFloatShow(result, "fromString"); */ |
| 1014 | return result; |
| 1015 | } /* decFloatFromString */ |
| 1016 | |
| 1017 | /* ------------------------------------------------------------------ */ |
| 1018 | /* decFloatFromWider -- conversion from next-wider format */ |
| 1019 | /* */ |
| 1020 | /* result is the decFloat format number which gets the result of */ |
| 1021 | /* the conversion */ |
| 1022 | /* wider is the decFloatWider format number which will be narrowed */ |
| 1023 | /* set is the context */ |
| 1024 | /* returns result */ |
| 1025 | /* */ |
| 1026 | /* Narrowing can cause rounding, overflow, etc., but not Invalid */ |
| 1027 | /* operation (sNaNs are copied and do not signal). */ |
| 1028 | /* ------------------------------------------------------------------ */ |
| 1029 | /* narrow-to is not possible for decQuad format numbers; simply omit */ |
| 1030 | #if !QUAD |
| 1031 | decFloat * decFloatFromWider(decFloat *result, const decFloatWider *wider, |
| 1032 | decContext *set) { |
| 1033 | bcdnum num; /* collects data for finishing */ |
| 1034 | uByte bcdar[DECWPMAX]; /* room for wider coefficient */ |
| 1035 | uInt widerhi=DFWWORD(wider, 0); /* top word */ |
| 1036 | Int exp; |
| 1037 | |
| 1038 | GETWCOEFF(wider, bcdar); |
| 1039 | |
| 1040 | num.msd=bcdar; /* MSD is here always */ |
| 1041 | num.lsd=bcdar+DECWPMAX-1; /* LSD is here always */ |
| 1042 | num.sign=widerhi&0x80000000; /* extract sign [DECFLOAT_Sign=Neg] */ |
| 1043 | |
| 1044 | /* decode the wider combination field to exponent */ |
| 1045 | exp=DECCOMBWEXP[widerhi>>26]; /* decode from wider combination field */ |
| 1046 | /* if it is a special there's nothing to do unless sNaN; if it's */ |
| 1047 | /* finite then add the (wider) exponent continuation and unbias */ |
| 1048 | if (EXPISSPECIAL(exp)) exp=widerhi&0x7e000000; /* include sNaN selector */ |
| 1049 | else exp+=GETWECON(wider)-DECWBIAS; |
| 1050 | num.exponent=exp; |
| 1051 | |
| 1052 | /* decShowNum(&num, "dffw"); */ |
| 1053 | return decFinalize(result, &num, set);/* round, check, and lay out */ |
| 1054 | } /* decFloatFromWider */ |
| 1055 | #endif |
| 1056 | |
| 1057 | /* ------------------------------------------------------------------ */ |
| 1058 | /* decFloatGetCoefficient -- get coefficient as BCD8 */ |
| 1059 | /* */ |
| 1060 | /* df is the decFloat from which to extract the coefficient */ |
| 1061 | /* bcdar is where DECPMAX bytes will be written, one BCD digit in */ |
| 1062 | /* each byte (BCD8 encoding); if df is a NaN the first byte will */ |
| 1063 | /* be zero, and if it is infinite they will all be zero */ |
| 1064 | /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ |
| 1065 | /* 0 otherwise) */ |
| 1066 | /* */ |
| 1067 | /* No error is possible, and no status will be set. If df is a */ |
| 1068 | /* special value the array is set to zeros (for Infinity) or to the */ |
| 1069 | /* payload of a qNaN or sNaN. */ |
| 1070 | /* ------------------------------------------------------------------ */ |
| 1071 | Int decFloatGetCoefficient(const decFloat *df, uByte *bcdar) { |
| 1072 | if (DFISINF(df)) memset(bcdar, 0, DECPMAX); |
| 1073 | else { |
| 1074 | GETCOEFF(df, bcdar); /* use macro */ |
| 1075 | if (DFISNAN(df)) bcdar[0]=0; /* MSD needs correcting */ |
| 1076 | } |
| 1077 | return DFISSIGNED(df); |
| 1078 | } /* decFloatGetCoefficient */ |
| 1079 | |
| 1080 | /* ------------------------------------------------------------------ */ |
| 1081 | /* decFloatGetExponent -- get unbiased exponent */ |
| 1082 | /* */ |
| 1083 | /* df is the decFloat from which to extract the exponent */ |
| 1084 | /* returns the exponent, q. */ |
| 1085 | /* */ |
| 1086 | /* No error is possible, and no status will be set. If df is a */ |
| 1087 | /* special value the first seven bits of the decFloat are returned, */ |
| 1088 | /* left adjusted and with the first (sign) bit set to 0 (followed by */ |
| 1089 | /* 25 0 bits). e.g., -sNaN would return 0x7e000000 (DECFLOAT_sNaN). */ |
| 1090 | /* ------------------------------------------------------------------ */ |
| 1091 | Int decFloatGetExponent(const decFloat *df) { |
| 1092 | if (DFISSPECIAL(df)) return DFWORD(df, 0)&0x7e000000; |
| 1093 | return GETEXPUN(df); |
| 1094 | } /* decFloatGetExponent */ |
| 1095 | |
| 1096 | /* ------------------------------------------------------------------ */ |
| 1097 | /* decFloatSetCoefficient -- set coefficient from BCD8 */ |
| 1098 | /* */ |
| 1099 | /* df is the target decFloat (and source of exponent/special value) */ |
| 1100 | /* bcdar holds DECPMAX digits to set the coefficient from, one */ |
| 1101 | /* digit in each byte (BCD8 encoding); the first (MSD) is ignored */ |
| 1102 | /* if df is a NaN; all are ignored if df is infinite. */ |
| 1103 | /* sig is DECFLOAT_Sign to set the sign bit, 0 otherwise */ |
| 1104 | /* returns df, which will be canonical */ |
| 1105 | /* */ |
| 1106 | /* No error is possible, and no status will be set. */ |
| 1107 | /* ------------------------------------------------------------------ */ |
| 1108 | decFloat * decFloatSetCoefficient(decFloat *df, const uByte *bcdar, |
| 1109 | Int sig) { |
| 1110 | uInt exp; /* for exponent */ |
| 1111 | uByte bcdzero[DECPMAX]; /* for infinities */ |
| 1112 | |
| 1113 | /* Exponent/special code is extracted from df */ |
| 1114 | if (DFISSPECIAL(df)) { |
| 1115 | exp=DFWORD(df, 0)&0x7e000000; |
| 1116 | if (DFISINF(df)) { |
| 1117 | memset(bcdzero, 0, DECPMAX); |
| 1118 | return decFloatFromBCD(df, exp, bcdzero, sig); |
| 1119 | } |
| 1120 | } |
| 1121 | else exp=GETEXPUN(df); |
| 1122 | return decFloatFromBCD(df, exp, bcdar, sig); |
| 1123 | } /* decFloatSetCoefficient */ |
| 1124 | |
| 1125 | /* ------------------------------------------------------------------ */ |
| 1126 | /* decFloatSetExponent -- set exponent or special value */ |
| 1127 | /* */ |
| 1128 | /* df is the target decFloat (and source of coefficient/payload) */ |
| 1129 | /* set is the context for reporting status */ |
| 1130 | /* exp is the unbiased exponent, q, or a special value in the form */ |
| 1131 | /* returned by decFloatGetExponent */ |
| 1132 | /* returns df, which will be canonical */ |
| 1133 | /* */ |
| 1134 | /* No error is possible, but Overflow or Underflow might occur. */ |
| 1135 | /* ------------------------------------------------------------------ */ |
| 1136 | decFloat * decFloatSetExponent(decFloat *df, decContext *set, Int exp) { |
| 1137 | uByte bcdcopy[DECPMAX]; /* for coefficient */ |
| 1138 | bcdnum num; /* work */ |
| 1139 | num.exponent=exp; |
| 1140 | num.sign=decFloatGetCoefficient(df, bcdcopy); /* extract coefficient */ |
| 1141 | if (DFISSPECIAL(df)) { /* MSD or more needs correcting */ |
| 1142 | if (DFISINF(df)) memset(bcdcopy, 0, DECPMAX); |
| 1143 | bcdcopy[0]=0; |
| 1144 | } |
| 1145 | num.msd=bcdcopy; |
| 1146 | num.lsd=bcdcopy+DECPMAX-1; |
| 1147 | return decFinalize(df, &num, set); |
| 1148 | } /* decFloatSetExponent */ |
| 1149 | |
| 1150 | /* ------------------------------------------------------------------ */ |
| 1151 | /* decFloatRadix -- returns the base (10) */ |
| 1152 | /* */ |
| 1153 | /* df is any decFloat of this format */ |
| 1154 | /* ------------------------------------------------------------------ */ |
| 1155 | uInt decFloatRadix(const decFloat *df) { |
| 1156 | if (df) return 10; /* to placate compiler */ |
| 1157 | return 10; |
| 1158 | } /* decFloatRadix */ |
| 1159 | |
| 1160 | #if (DECCHECK || DECTRACE) |
| 1161 | /* ------------------------------------------------------------------ */ |
| 1162 | /* decFloatShow -- printf a decFloat in hexadecimal and decimal */ |
| 1163 | /* df is the decFloat to show */ |
| 1164 | /* tag is a tag string displayed with the number */ |
| 1165 | /* */ |
| 1166 | /* This is a debug aid; the precise format of the string may change. */ |
| 1167 | /* ------------------------------------------------------------------ */ |
| 1168 | void decFloatShow(const decFloat *df, const char *tag) { |
| 1169 | char hexbuf[DECBYTES*2+DECBYTES/4+1]; /* NB blank after every fourth */ |
| 1170 | char buff[DECSTRING]; /* for value in decimal */ |
| 1171 | Int i, j=0; |
| 1172 | |
| 1173 | for (i=0; i<DECBYTES; i++) { |
| 1174 | #if DECLITEND |
| 1175 | sprintf(&hexbuf[j], "%02x", df->bytes[DECBYTES-1-i]); |
| 1176 | #else |
| 1177 | sprintf(&hexbuf[j], "%02x", df->bytes[i]); |
| 1178 | #endif |
| 1179 | j+=2; |
| 1180 | /* the next line adds blank (and terminator) after final pair, too */ |
| 1181 | if ((i+1)%4==0) {strcpy(&hexbuf[j], " "); j++;} |
| 1182 | } |
| 1183 | decFloatToString(df, buff); |
| 1184 | printf(">%s> %s [big-endian] %s\n", tag, hexbuf, buff); |
| 1185 | return; |
| 1186 | } /* decFloatShow */ |
| 1187 | #endif |
| 1188 | |
| 1189 | /* ------------------------------------------------------------------ */ |
| 1190 | /* decFloatToBCD -- get sign, exponent, and BCD8 from a decFloat */ |
| 1191 | /* */ |
| 1192 | /* df is the source decFloat */ |
| 1193 | /* exp will be set to the unbiased exponent, q, or to a special */ |
| 1194 | /* value in the form returned by decFloatGetExponent */ |
| 1195 | /* bcdar is where DECPMAX bytes will be written, one BCD digit in */ |
| 1196 | /* each byte (BCD8 encoding); if df is a NaN the first byte will */ |
| 1197 | /* be zero, and if it is infinite they will all be zero */ |
| 1198 | /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ |
| 1199 | /* 0 otherwise) */ |
| 1200 | /* */ |
| 1201 | /* No error is possible, and no status will be set. */ |
| 1202 | /* ------------------------------------------------------------------ */ |
| 1203 | Int decFloatToBCD(const decFloat *df, Int *exp, uByte *bcdar) { |
| 1204 | if (DFISINF(df)) { |
| 1205 | memset(bcdar, 0, DECPMAX); |
| 1206 | *exp=DFWORD(df, 0)&0x7e000000; |
| 1207 | } |
| 1208 | else { |
| 1209 | GETCOEFF(df, bcdar); /* use macro */ |
| 1210 | if (DFISNAN(df)) { |
| 1211 | bcdar[0]=0; /* MSD needs correcting */ |
| 1212 | *exp=DFWORD(df, 0)&0x7e000000; |
| 1213 | } |
| 1214 | else { /* finite */ |
| 1215 | *exp=GETEXPUN(df); |
| 1216 | } |
| 1217 | } |
| 1218 | return DFISSIGNED(df); |
| 1219 | } /* decFloatToBCD */ |
| 1220 | |
| 1221 | /* ------------------------------------------------------------------ */ |
| 1222 | /* decFloatToEngString -- conversion to numeric string, engineering */ |
| 1223 | /* */ |
| 1224 | /* df is the decFloat format number to convert */ |
| 1225 | /* string is the string where the result will be laid out */ |
| 1226 | /* */ |
| 1227 | /* string must be at least DECPMAX+9 characters (the worst case is */ |
| 1228 | /* "-0.00000nnn...nnn\0", which is as long as the exponent form when */ |
| 1229 | /* DECEMAXD<=4); this condition is asserted above */ |
| 1230 | /* */ |
| 1231 | /* No error is possible, and no status will be set */ |
| 1232 | /* ------------------------------------------------------------------ */ |
| 1233 | char * decFloatToEngString(const decFloat *df, char *string){ |
| 1234 | uInt msd; /* coefficient MSD */ |
| 1235 | Int exp; /* exponent top two bits or full */ |
| 1236 | uInt comb; /* combination field */ |
| 1237 | char *cstart; /* coefficient start */ |
| 1238 | char *c; /* output pointer in string */ |
| 1239 | char *s, *t; /* .. (source, target) */ |
| 1240 | Int pre, e; /* work */ |
| 1241 | const uByte *u; /* .. */ |
| 1242 | uInt uiwork; /* for macros [one compiler needs */ |
| 1243 | /* volatile here to avoid bug, but */ |
| 1244 | /* that doubles execution time] */ |
| 1245 | |
| 1246 | /* Source words; macro handles endianness */ |
| 1247 | uInt sourhi=DFWORD(df, 0); /* word with sign */ |
| 1248 | #if DECPMAX==16 |
| 1249 | uInt sourlo=DFWORD(df, 1); |
| 1250 | #elif DECPMAX==34 |
| 1251 | uInt sourmh=DFWORD(df, 1); |
| 1252 | uInt sourml=DFWORD(df, 2); |
| 1253 | uInt sourlo=DFWORD(df, 3); |
| 1254 | #endif |
| 1255 | |
| 1256 | c=string; /* where result will go */ |
| 1257 | if (((Int)sourhi)<0) *c++='-'; /* handle sign */ |
| 1258 | comb=sourhi>>26; /* sign+combination field */ |
| 1259 | msd=DECCOMBMSD[comb]; /* decode the combination field */ |
| 1260 | exp=DECCOMBEXP[comb]; /* .. */ |
| 1261 | |
| 1262 | if (EXPISSPECIAL(exp)) { /* special */ |
| 1263 | if (exp==DECFLOAT_Inf) { /* infinity */ |
| 1264 | strcpy(c, "Inf"); |
| 1265 | strcpy(c+3, "inity"); |
| 1266 | return string; /* easy */ |
| 1267 | } |
| 1268 | if (sourhi&0x02000000) *c++='s'; /* sNaN */ |
| 1269 | strcpy(c, "NaN"); /* complete word */ |
| 1270 | c+=3; /* step past */ |
| 1271 | /* quick exit if the payload is zero */ |
| 1272 | #if DECPMAX==7 |
| 1273 | if ((sourhi&0x000fffff)==0) return string; |
| 1274 | #elif DECPMAX==16 |
| 1275 | if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; |
| 1276 | #elif DECPMAX==34 |
| 1277 | if (sourlo==0 && sourml==0 && sourmh==0 |
| 1278 | && (sourhi&0x00003fff)==0) return string; |
| 1279 | #endif |
| 1280 | /* otherwise drop through to add integer; set correct exp etc. */ |
| 1281 | exp=0; msd=0; /* setup for following code */ |
| 1282 | } |
| 1283 | else { /* complete exponent; top two bits are in place */ |
| 1284 | exp+=GETECON(df)-DECBIAS; /* .. + continuation and unbias */ |
| 1285 | } |
| 1286 | |
| 1287 | /* convert the digits of the significand to characters */ |
| 1288 | cstart=c; /* save start of coefficient */ |
| 1289 | if (msd) *c++=(char)('0'+(char)msd); /* non-zero most significant digit */ |
| 1290 | |
| 1291 | /* Decode the declets. After extracting each declet, it is */ |
| 1292 | /* decoded to a 4-uByte sequence by table lookup; the four uBytes */ |
| 1293 | /* are the three encoded BCD8 digits followed by a 1-byte length */ |
| 1294 | /* (significant digits, except that 000 has length 0). This allows */ |
| 1295 | /* us to left-align the first declet with non-zero content, then */ |
| 1296 | /* the remaining ones are full 3-char length. Fixed-length copies */ |
| 1297 | /* are used because variable-length memcpy causes a subroutine call */ |
| 1298 | /* in at least two compilers. (The copies are length 4 for speed */ |
| 1299 | /* and are safe because the last item in the array is of length */ |
| 1300 | /* three and has the length byte following.) */ |
| 1301 | #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4]; \ |
| 1302 | if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \ |
| 1303 | else if (*(u+3)) { \ |
| 1304 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);} |
| 1305 | |
| 1306 | #if DECPMAX==7 |
| 1307 | dpd2char(sourhi>>10); /* declet 1 */ |
| 1308 | dpd2char(sourhi); /* declet 2 */ |
| 1309 | |
| 1310 | #elif DECPMAX==16 |
| 1311 | dpd2char(sourhi>>8); /* declet 1 */ |
| 1312 | dpd2char((sourhi<<2) | (sourlo>>30)); /* declet 2 */ |
| 1313 | dpd2char(sourlo>>20); /* declet 3 */ |
| 1314 | dpd2char(sourlo>>10); /* declet 4 */ |
| 1315 | dpd2char(sourlo); /* declet 5 */ |
| 1316 | |
| 1317 | #elif DECPMAX==34 |
| 1318 | dpd2char(sourhi>>4); /* declet 1 */ |
| 1319 | dpd2char((sourhi<<6) | (sourmh>>26)); /* declet 2 */ |
| 1320 | dpd2char(sourmh>>16); /* declet 3 */ |
| 1321 | dpd2char(sourmh>>6); /* declet 4 */ |
| 1322 | dpd2char((sourmh<<4) | (sourml>>28)); /* declet 5 */ |
| 1323 | dpd2char(sourml>>18); /* declet 6 */ |
| 1324 | dpd2char(sourml>>8); /* declet 7 */ |
| 1325 | dpd2char((sourml<<2) | (sourlo>>30)); /* declet 8 */ |
| 1326 | dpd2char(sourlo>>20); /* declet 9 */ |
| 1327 | dpd2char(sourlo>>10); /* declet 10 */ |
| 1328 | dpd2char(sourlo); /* declet 11 */ |
| 1329 | #endif |
| 1330 | |
| 1331 | if (c==cstart) *c++='0'; /* all zeros, empty -- make "0" */ |
| 1332 | |
| 1333 | if (exp==0) { /* integer or NaN case -- easy */ |
| 1334 | *c='\0'; /* terminate */ |
| 1335 | return string; |
| 1336 | } |
| 1337 | /* non-0 exponent */ |
| 1338 | |
| 1339 | e=0; /* assume no E */ |
| 1340 | pre=(Int)(c-cstart)+exp; /* length+exp [c->LSD+1] */ |
| 1341 | /* [here, pre-exp is the digits count (==1 for zero)] */ |
| 1342 | |
| 1343 | if (exp>0 || pre<-5) { /* need exponential form */ |
| 1344 | e=pre-1; /* calculate E value */ |
| 1345 | pre=1; /* assume one digit before '.' */ |
| 1346 | if (e!=0) { /* engineering: may need to adjust */ |
| 1347 | Int adj; /* adjustment */ |
| 1348 | /* The C remainder operator is undefined for negative numbers, so */ |
| 1349 | /* a positive remainder calculation must be used here */ |
| 1350 | if (e<0) { |
| 1351 | adj=(-e)%3; |
| 1352 | if (adj!=0) adj=3-adj; |
| 1353 | } |
| 1354 | else { /* e>0 */ |
| 1355 | adj=e%3; |
| 1356 | } |
| 1357 | e=e-adj; |
| 1358 | /* if dealing with zero still produce an exponent which is a */ |
| 1359 | /* multiple of three, as expected, but there will only be the */ |
| 1360 | /* one zero before the E, still. Otherwise note the padding. */ |
| 1361 | if (!DFISZERO(df)) pre+=adj; |
| 1362 | else { /* is zero */ |
| 1363 | if (adj!=0) { /* 0.00Esnn needed */ |
| 1364 | e=e+3; |
| 1365 | pre=-(2-adj); |
| 1366 | } |
| 1367 | } /* zero */ |
| 1368 | } /* engineering adjustment */ |
| 1369 | } /* exponential form */ |
| 1370 | /* printf("e=%ld pre=%ld exp=%ld\n", (LI)e, (LI)pre, (LI)exp); */ |
| 1371 | |
| 1372 | /* modify the coefficient, adding 0s, '.', and E+nn as needed */ |
| 1373 | if (pre>0) { /* ddd.ddd (plain), perhaps with E */ |
| 1374 | /* or dd00 padding for engineering */ |
| 1375 | char *dotat=cstart+pre; |
| 1376 | if (dotat<c) { /* if embedded dot needed... */ |
| 1377 | /* move by fours; there must be space for junk at the end */ |
| 1378 | /* because there is still space for exponent */ |
| 1379 | s=dotat+ROUNDDOWN4(c-dotat); /* source */ |
| 1380 | t=s+1; /* target */ |
| 1381 | /* open the gap [cannot use memcpy] */ |
| 1382 | for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); |
| 1383 | *dotat='.'; |
| 1384 | c++; /* length increased by one */ |
| 1385 | } /* need dot? */ |
| 1386 | else for (; c<dotat; c++) *c='0'; /* pad for engineering */ |
| 1387 | } /* pre>0 */ |
| 1388 | else { |
| 1389 | /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (may have |
| 1390 | E, but only for 0.00E+3 kind of case -- with plenty of spare |
| 1391 | space in this case */ |
| 1392 | pre=-pre+2; /* gap width, including "0." */ |
| 1393 | t=cstart+ROUNDDOWN4(c-cstart)+pre; /* preferred first target point */ |
| 1394 | /* backoff if too far to the right */ |
| 1395 | if (t>string+DECSTRING-5) t=string+DECSTRING-5; /* adjust to fit */ |
| 1396 | /* now shift the entire coefficient to the right, being careful not */ |
| 1397 | /* to access to the left of string [cannot use memcpy] */ |
| 1398 | for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); |
| 1399 | /* for Quads and Singles there may be a character or two left... */ |
| 1400 | s+=3; /* where next would come from */ |
| 1401 | for(; s>=cstart; s--, t--) *(t+3)=*(s); |
| 1402 | /* now have fill 0. through 0.00000; use overlaps to avoid tests */ |
| 1403 | if (pre>=4) { |
| 1404 | memcpy(cstart+pre-4, "0000", 4); |
| 1405 | memcpy(cstart, "0.00", 4); |
| 1406 | } |
| 1407 | else { /* 2 or 3 */ |
| 1408 | *(cstart+pre-1)='0'; |
| 1409 | memcpy(cstart, "0.", 2); |
| 1410 | } |
| 1411 | c+=pre; /* to end */ |
| 1412 | } |
| 1413 | |
| 1414 | /* finally add the E-part, if needed; it will never be 0, and has */ |
| 1415 | /* a maximum length of 3 or 4 digits (asserted above) */ |
| 1416 | if (e!=0) { |
| 1417 | memcpy(c, "E+", 2); /* starts with E, assume + */ |
| 1418 | c++; |
| 1419 | if (e<0) { |
| 1420 | *c='-'; /* oops, need '-' */ |
| 1421 | e=-e; /* uInt, please */ |
| 1422 | } |
| 1423 | c++; |
| 1424 | /* Three-character exponents are easy; 4-character a little trickier */ |
| 1425 | #if DECEMAXD<=3 |
| 1426 | u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ |
| 1427 | /* copy fixed 4 characters [is safe], starting at non-zero */ |
| 1428 | /* and with character mask to convert BCD to char */ |
| 1429 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); |
| 1430 | c+=*(u+3); /* bump pointer appropriately */ |
| 1431 | #elif DECEMAXD==4 |
| 1432 | if (e<1000) { /* 3 (or fewer) digits case */ |
| 1433 | u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ |
| 1434 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ |
| 1435 | c+=*(u+3); /* bump pointer appropriately */ |
| 1436 | } |
| 1437 | else { /* 4-digits */ |
| 1438 | Int thou=((e>>3)*1049)>>17; /* e/1000 */ |
| 1439 | Int rem=e-(1000*thou); /* e%1000 */ |
| 1440 | *c++=(char)('0'+(char)thou); /* the thousands digit */ |
| 1441 | u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ |
| 1442 | UBFROMUI(c, UBTOUI(u)|CHARMASK);/* copy fixed 3+1 characters [is safe] */ |
| 1443 | c+=3; /* bump pointer, always 3 digits */ |
| 1444 | } |
| 1445 | #endif |
| 1446 | } |
| 1447 | *c='\0'; /* terminate */ |
| 1448 | /*printf("res %s\n", string); */ |
| 1449 | return string; |
| 1450 | } /* decFloatToEngString */ |
| 1451 | |
| 1452 | /* ------------------------------------------------------------------ */ |
| 1453 | /* decFloatToPacked -- convert decFloat to Packed decimal + exponent */ |
| 1454 | /* */ |
| 1455 | /* df is the source decFloat */ |
| 1456 | /* exp will be set to the unbiased exponent, q, or to a special */ |
| 1457 | /* value in the form returned by decFloatGetExponent */ |
| 1458 | /* packed is where DECPMAX nibbles will be written with the sign as */ |
| 1459 | /* final nibble (0x0c for +, 0x0d for -); a NaN has a first nibble */ |
| 1460 | /* of zero, and an infinity is all zeros. decDouble and decQuad */ |
| 1461 | /* have a additional leading zero nibble, leading to result */ |
| 1462 | /* lengths of 4, 9, and 18 bytes. */ |
| 1463 | /* returns the sign of the coefficient (DECFLOAT_Sign if negative, */ |
| 1464 | /* 0 otherwise) */ |
| 1465 | /* */ |
| 1466 | /* No error is possible, and no status will be set. */ |
| 1467 | /* ------------------------------------------------------------------ */ |
| 1468 | Int decFloatToPacked(const decFloat *df, Int *exp, uByte *packed) { |
| 1469 | uByte bcdar[DECPMAX+2]; /* work buffer */ |
| 1470 | uByte *ip=bcdar, *op=packed; /* work pointers */ |
| 1471 | if (DFISINF(df)) { |
| 1472 | memset(bcdar, 0, DECPMAX+2); |
| 1473 | *exp=DECFLOAT_Inf; |
| 1474 | } |
| 1475 | else { |
| 1476 | GETCOEFF(df, bcdar+1); /* use macro */ |
| 1477 | if (DFISNAN(df)) { |
| 1478 | bcdar[1]=0; /* MSD needs clearing */ |
| 1479 | *exp=DFWORD(df, 0)&0x7e000000; |
| 1480 | } |
| 1481 | else { /* finite */ |
| 1482 | *exp=GETEXPUN(df); |
| 1483 | } |
| 1484 | } |
| 1485 | /* now pack; coefficient currently at bcdar+1 */ |
| 1486 | #if SINGLE |
| 1487 | ip++; /* ignore first byte */ |
| 1488 | #else |
| 1489 | *ip=0; /* need leading zero */ |
| 1490 | #endif |
| 1491 | /* set final byte to Packed BCD sign value */ |
| 1492 | bcdar[DECPMAX+1]=(DFISSIGNED(df) ? DECPMINUS : DECPPLUS); |
| 1493 | /* pack an even number of bytes... */ |
| 1494 | for (; op<packed+((DECPMAX+2)/2); op++, ip+=2) { |
| 1495 | *op=(uByte)((*ip<<4)+*(ip+1)); |
| 1496 | } |
| 1497 | return (bcdar[DECPMAX+1]==DECPMINUS ? DECFLOAT_Sign : 0); |
| 1498 | } /* decFloatToPacked */ |
| 1499 | |
| 1500 | /* ------------------------------------------------------------------ */ |
| 1501 | /* decFloatToString -- conversion to numeric string */ |
| 1502 | /* */ |
| 1503 | /* df is the decFloat format number to convert */ |
| 1504 | /* string is the string where the result will be laid out */ |
| 1505 | /* */ |
| 1506 | /* string must be at least DECPMAX+9 characters (the worst case is */ |
| 1507 | /* "-0.00000nnn...nnn\0", which is as long as the exponent form when */ |
| 1508 | /* DECEMAXD<=4); this condition is asserted above */ |
| 1509 | /* */ |
| 1510 | /* No error is possible, and no status will be set */ |
| 1511 | /* ------------------------------------------------------------------ */ |
| 1512 | char * decFloatToString(const decFloat *df, char *string){ |
| 1513 | uInt msd; /* coefficient MSD */ |
| 1514 | Int exp; /* exponent top two bits or full */ |
| 1515 | uInt comb; /* combination field */ |
| 1516 | char *cstart; /* coefficient start */ |
| 1517 | char *c; /* output pointer in string */ |
| 1518 | char *s, *t; /* .. (source, target) */ |
| 1519 | Int pre, e; /* work */ |
| 1520 | const uByte *u; /* .. */ |
| 1521 | uInt uiwork; /* for macros [one compiler needs */ |
| 1522 | /* volatile here to avoid bug, but */ |
| 1523 | /* that doubles execution time] */ |
| 1524 | |
| 1525 | /* Source words; macro handles endianness */ |
| 1526 | uInt sourhi=DFWORD(df, 0); /* word with sign */ |
| 1527 | #if DECPMAX==16 |
| 1528 | uInt sourlo=DFWORD(df, 1); |
| 1529 | #elif DECPMAX==34 |
| 1530 | uInt sourmh=DFWORD(df, 1); |
| 1531 | uInt sourml=DFWORD(df, 2); |
| 1532 | uInt sourlo=DFWORD(df, 3); |
| 1533 | #endif |
| 1534 | |
| 1535 | c=string; /* where result will go */ |
| 1536 | if (((Int)sourhi)<0) *c++='-'; /* handle sign */ |
| 1537 | comb=sourhi>>26; /* sign+combination field */ |
| 1538 | msd=DECCOMBMSD[comb]; /* decode the combination field */ |
| 1539 | exp=DECCOMBEXP[comb]; /* .. */ |
| 1540 | |
| 1541 | if (!EXPISSPECIAL(exp)) { /* finite */ |
| 1542 | /* complete exponent; top two bits are in place */ |
| 1543 | exp+=GETECON(df)-DECBIAS; /* .. + continuation and unbias */ |
| 1544 | } |
| 1545 | else { /* IS special */ |
| 1546 | if (exp==DECFLOAT_Inf) { /* infinity */ |
| 1547 | strcpy(c, "Infinity"); |
| 1548 | return string; /* easy */ |
| 1549 | } |
| 1550 | if (sourhi&0x02000000) *c++='s'; /* sNaN */ |
| 1551 | strcpy(c, "NaN"); /* complete word */ |
| 1552 | c+=3; /* step past */ |
| 1553 | /* quick exit if the payload is zero */ |
| 1554 | #if DECPMAX==7 |
| 1555 | if ((sourhi&0x000fffff)==0) return string; |
| 1556 | #elif DECPMAX==16 |
| 1557 | if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; |
| 1558 | #elif DECPMAX==34 |
| 1559 | if (sourlo==0 && sourml==0 && sourmh==0 |
| 1560 | && (sourhi&0x00003fff)==0) return string; |
| 1561 | #endif |
| 1562 | /* otherwise drop through to add integer; set correct exp etc. */ |
| 1563 | exp=0; msd=0; /* setup for following code */ |
| 1564 | } |
| 1565 | |
| 1566 | /* convert the digits of the significand to characters */ |
| 1567 | cstart=c; /* save start of coefficient */ |
| 1568 | if (msd) *c++=(char)('0'+(char)msd); /* non-zero most significant digit */ |
| 1569 | |
| 1570 | /* Decode the declets. After extracting each declet, it is */ |
| 1571 | /* decoded to a 4-uByte sequence by table lookup; the four uBytes */ |
| 1572 | /* are the three encoded BCD8 digits followed by a 1-byte length */ |
| 1573 | /* (significant digits, except that 000 has length 0). This allows */ |
| 1574 | /* us to left-align the first declet with non-zero content, then */ |
| 1575 | /* the remaining ones are full 3-char length. Fixed-length copies */ |
| 1576 | /* are used because variable-length memcpy causes a subroutine call */ |
| 1577 | /* in at least two compilers. (The copies are length 4 for speed */ |
| 1578 | /* and are safe because the last item in the array is of length */ |
| 1579 | /* three and has the length byte following.) */ |
| 1580 | #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4]; \ |
| 1581 | if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \ |
| 1582 | else if (*(u+3)) { \ |
| 1583 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);} |
| 1584 | |
| 1585 | #if DECPMAX==7 |
| 1586 | dpd2char(sourhi>>10); /* declet 1 */ |
| 1587 | dpd2char(sourhi); /* declet 2 */ |
| 1588 | |
| 1589 | #elif DECPMAX==16 |
| 1590 | dpd2char(sourhi>>8); /* declet 1 */ |
| 1591 | dpd2char((sourhi<<2) | (sourlo>>30)); /* declet 2 */ |
| 1592 | dpd2char(sourlo>>20); /* declet 3 */ |
| 1593 | dpd2char(sourlo>>10); /* declet 4 */ |
| 1594 | dpd2char(sourlo); /* declet 5 */ |
| 1595 | |
| 1596 | #elif DECPMAX==34 |
| 1597 | dpd2char(sourhi>>4); /* declet 1 */ |
| 1598 | dpd2char((sourhi<<6) | (sourmh>>26)); /* declet 2 */ |
| 1599 | dpd2char(sourmh>>16); /* declet 3 */ |
| 1600 | dpd2char(sourmh>>6); /* declet 4 */ |
| 1601 | dpd2char((sourmh<<4) | (sourml>>28)); /* declet 5 */ |
| 1602 | dpd2char(sourml>>18); /* declet 6 */ |
| 1603 | dpd2char(sourml>>8); /* declet 7 */ |
| 1604 | dpd2char((sourml<<2) | (sourlo>>30)); /* declet 8 */ |
| 1605 | dpd2char(sourlo>>20); /* declet 9 */ |
| 1606 | dpd2char(sourlo>>10); /* declet 10 */ |
| 1607 | dpd2char(sourlo); /* declet 11 */ |
| 1608 | #endif |
| 1609 | |
| 1610 | if (c==cstart) *c++='0'; /* all zeros, empty -- make "0" */ |
| 1611 | |
| 1612 | /*[This fast path is valid but adds 3-5 cycles to worst case length] */ |
| 1613 | /*if (exp==0) { // integer or NaN case -- easy */ |
| 1614 | /* *c='\0'; // terminate */ |
| 1615 | /* return string; */ |
| 1616 | /* } */ |
| 1617 | |
| 1618 | e=0; /* assume no E */ |
| 1619 | pre=(Int)(c-cstart)+exp; /* length+exp [c->LSD+1] */ |
| 1620 | /* [here, pre-exp is the digits count (==1 for zero)] */ |
| 1621 | |
| 1622 | if (exp>0 || pre<-5) { /* need exponential form */ |
| 1623 | e=pre-1; /* calculate E value */ |
| 1624 | pre=1; /* assume one digit before '.' */ |
| 1625 | } /* exponential form */ |
| 1626 | |
| 1627 | /* modify the coefficient, adding 0s, '.', and E+nn as needed */ |
| 1628 | if (pre>0) { /* ddd.ddd (plain), perhaps with E */ |
| 1629 | char *dotat=cstart+pre; |
| 1630 | if (dotat<c) { /* if embedded dot needed... */ |
| 1631 | /* [memmove is a disaster, here] */ |
| 1632 | /* move by fours; there must be space for junk at the end */ |
| 1633 | /* because exponent is still possible */ |
| 1634 | s=dotat+ROUNDDOWN4(c-dotat); /* source */ |
| 1635 | t=s+1; /* target */ |
| 1636 | /* open the gap [cannot use memcpy] */ |
| 1637 | for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); |
| 1638 | *dotat='.'; |
| 1639 | c++; /* length increased by one */ |
| 1640 | } /* need dot? */ |
| 1641 | |
| 1642 | /* finally add the E-part, if needed; it will never be 0, and has */ |
| 1643 | /* a maximum length of 3 or 4 digits (asserted above) */ |
| 1644 | if (e!=0) { |
| 1645 | memcpy(c, "E+", 2); /* starts with E, assume + */ |
| 1646 | c++; |
| 1647 | if (e<0) { |
| 1648 | *c='-'; /* oops, need '-' */ |
| 1649 | e=-e; /* uInt, please */ |
| 1650 | } |
| 1651 | c++; |
| 1652 | /* Three-character exponents are easy; 4-character a little trickier */ |
| 1653 | #if DECEMAXD<=3 |
| 1654 | u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ |
| 1655 | /* copy fixed 4 characters [is safe], starting at non-zero */ |
| 1656 | /* and with character mask to convert BCD to char */ |
| 1657 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); |
| 1658 | c+=*(u+3); /* bump pointer appropriately */ |
| 1659 | #elif DECEMAXD==4 |
| 1660 | if (e<1000) { /* 3 (or fewer) digits case */ |
| 1661 | u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ |
| 1662 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ |
| 1663 | c+=*(u+3); /* bump pointer appropriately */ |
| 1664 | } |
| 1665 | else { /* 4-digits */ |
| 1666 | Int thou=((e>>3)*1049)>>17; /* e/1000 */ |
| 1667 | Int rem=e-(1000*thou); /* e%1000 */ |
| 1668 | *c++=(char)('0'+(char)thou); /* the thousands digit */ |
| 1669 | u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ |
| 1670 | UBFROMUI(c, UBTOUI(u)|CHARMASK); /* copy fixed 3+1 characters [is safe] */ |
| 1671 | c+=3; /* bump pointer, always 3 digits */ |
| 1672 | } |
| 1673 | #endif |
| 1674 | } |
| 1675 | *c='\0'; /* add terminator */ |
| 1676 | /*printf("res %s\n", string); */ |
| 1677 | return string; |
| 1678 | } /* pre>0 */ |
| 1679 | |
| 1680 | /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */ |
| 1681 | /* Surprisingly, this is close to being the worst-case path, so the */ |
| 1682 | /* shift is done by fours; this is a little tricky because the */ |
| 1683 | /* rightmost character to be written must not be beyond where the */ |
| 1684 | /* rightmost terminator could be -- so backoff to not touch */ |
| 1685 | /* terminator position if need be (this can make exact alignments */ |
| 1686 | /* for full Doubles, but in some cases needs care not to access too */ |
| 1687 | /* far to the left) */ |
| 1688 | |
| 1689 | pre=-pre+2; /* gap width, including "0." */ |
| 1690 | t=cstart+ROUNDDOWN4(c-cstart)+pre; /* preferred first target point */ |
| 1691 | /* backoff if too far to the right */ |
| 1692 | if (t>string+DECSTRING-5) t=string+DECSTRING-5; /* adjust to fit */ |
| 1693 | /* now shift the entire coefficient to the right, being careful not */ |
| 1694 | /* to access to the left of string [cannot use memcpy] */ |
| 1695 | for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s)); |
| 1696 | /* for Quads and Singles there may be a character or two left... */ |
| 1697 | s+=3; /* where next would come from */ |
| 1698 | for(; s>=cstart; s--, t--) *(t+3)=*(s); |
| 1699 | /* now have fill 0. through 0.00000; use overlaps to avoid tests */ |
| 1700 | if (pre>=4) { |
| 1701 | memcpy(cstart+pre-4, "0000", 4); |
| 1702 | memcpy(cstart, "0.00", 4); |
| 1703 | } |
| 1704 | else { /* 2 or 3 */ |
| 1705 | *(cstart+pre-1)='0'; |
| 1706 | memcpy(cstart, "0.", 2); |
| 1707 | } |
| 1708 | *(c+pre)='\0'; /* terminate */ |
| 1709 | return string; |
| 1710 | } /* decFloatToString */ |
| 1711 | |
| 1712 | /* ------------------------------------------------------------------ */ |
| 1713 | /* decFloatToWider -- conversion to next-wider format */ |
| 1714 | /* */ |
| 1715 | /* source is the decFloat format number which gets the result of */ |
| 1716 | /* the conversion */ |
| 1717 | /* wider is the decFloatWider format number which will be narrowed */ |
| 1718 | /* returns wider */ |
| 1719 | /* */ |
| 1720 | /* Widening is always exact; no status is set (sNaNs are copied and */ |
| 1721 | /* do not signal). The result will be canonical if the source is, */ |
| 1722 | /* and may or may not be if the source is not. */ |
| 1723 | /* ------------------------------------------------------------------ */ |
| 1724 | /* widening is not possible for decQuad format numbers; simply omit */ |
| 1725 | #if !QUAD |
| 1726 | decFloatWider * decFloatToWider(const decFloat *source, decFloatWider *wider) { |
| 1727 | uInt msd; |
| 1728 | |
| 1729 | /* Construct and copy the sign word */ |
| 1730 | if (DFISSPECIAL(source)) { |
| 1731 | /* copy sign, combination, and first bit of exponent (sNaN selector) */ |
| 1732 | DFWWORD(wider, 0)=DFWORD(source, 0)&0xfe000000; |
| 1733 | msd=0; |
| 1734 | } |
| 1735 | else { /* is finite number */ |
| 1736 | uInt exp=GETEXPUN(source)+DECWBIAS; /* get unbiased exponent and rebias */ |
| 1737 | uInt code=(exp>>DECWECONL)<<29; /* set two bits of exp [msd=0] */ |
| 1738 | code|=(exp<<(32-6-DECWECONL)) & 0x03ffffff; /* add exponent continuation */ |
| 1739 | code|=DFWORD(source, 0)&0x80000000; /* add sign */ |
| 1740 | DFWWORD(wider, 0)=code; /* .. and place top word in wider */ |
| 1741 | msd=GETMSD(source); /* get source coefficient MSD [0-9] */ |
| 1742 | } |
| 1743 | /* Copy the coefficient and clear any 'unused' words to left */ |
| 1744 | #if SINGLE |
| 1745 | DFWWORD(wider, 1)=(DFWORD(source, 0)&0x000fffff)|(msd<<20); |
| 1746 | #elif DOUBLE |
| 1747 | DFWWORD(wider, 2)=(DFWORD(source, 0)&0x0003ffff)|(msd<<18); |
| 1748 | DFWWORD(wider, 3)=DFWORD(source, 1); |
| 1749 | DFWWORD(wider, 1)=0; |
| 1750 | #endif |
| 1751 | return wider; |
| 1752 | } /* decFloatToWider */ |
| 1753 | #endif |
| 1754 | |
| 1755 | /* ------------------------------------------------------------------ */ |
| 1756 | /* decFloatVersion -- return package version string */ |
| 1757 | /* */ |
| 1758 | /* returns a constant string describing this package */ |
| 1759 | /* ------------------------------------------------------------------ */ |
| 1760 | const char *decFloatVersion(void) { |
| 1761 | return DECVERSION; |
| 1762 | } /* decFloatVersion */ |
| 1763 | |
| 1764 | /* ------------------------------------------------------------------ */ |
| 1765 | /* decFloatZero -- set to canonical (integer) zero */ |
| 1766 | /* */ |
| 1767 | /* df is the decFloat format number to integer +0 (q=0, c=+0) */ |
| 1768 | /* returns df */ |
| 1769 | /* */ |
| 1770 | /* No error is possible, and no status can be set. */ |
| 1771 | /* ------------------------------------------------------------------ */ |
| 1772 | decFloat * decFloatZero(decFloat *df){ |
| 1773 | DFWORD(df, 0)=ZEROWORD; /* set appropriate top word */ |
| 1774 | #if DOUBLE || QUAD |
| 1775 | DFWORD(df, 1)=0; |
| 1776 | #if QUAD |
| 1777 | DFWORD(df, 2)=0; |
| 1778 | DFWORD(df, 3)=0; |
| 1779 | #endif |
| 1780 | #endif |
| 1781 | /* decFloatShow(df, "zero"); */ |
| 1782 | return df; |
| 1783 | } /* decFloatZero */ |
| 1784 | |
| 1785 | /* ------------------------------------------------------------------ */ |
| 1786 | /* Private generic function (not format-specific) for development use */ |
| 1787 | /* ------------------------------------------------------------------ */ |
| 1788 | /* This is included once only, for all to use */ |
| 1789 | #if QUAD && (DECCHECK || DECTRACE) |
| 1790 | /* ---------------------------------------------------------------- */ |
| 1791 | /* decShowNum -- display bcd8 number in debug form */ |
| 1792 | /* */ |
| 1793 | /* num is the bcdnum to display */ |
| 1794 | /* tag is a string to label the display */ |
| 1795 | /* ---------------------------------------------------------------- */ |
| 1796 | void decShowNum(const bcdnum *num, const char *tag) { |
| 1797 | const char *csign="+"; /* sign character */ |
| 1798 | uByte *ub; /* work */ |
| 1799 | uInt uiwork; /* for macros */ |
| 1800 | if (num->sign==DECFLOAT_Sign) csign="-"; |
| 1801 | |
| 1802 | printf(">%s> ", tag); |
| 1803 | if (num->exponent==DECFLOAT_Inf) printf("%sInfinity", csign); |
| 1804 | else if (num->exponent==DECFLOAT_qNaN) printf("%sqNaN", csign); |
| 1805 | else if (num->exponent==DECFLOAT_sNaN) printf("%ssNaN", csign); |
| 1806 | else { /* finite */ |
| 1807 | char qbuf[10]; /* for right-aligned q */ |
| 1808 | char *c; /* work */ |
| 1809 | const uByte *u; /* .. */ |
| 1810 | Int e=num->exponent; /* .. exponent */ |
| 1811 | strcpy(qbuf, "q="); |
| 1812 | c=&qbuf[2]; /* where exponent will go */ |
| 1813 | /* lay out the exponent */ |
| 1814 | if (e<0) { |
| 1815 | *c++='-'; /* add '-' */ |
| 1816 | e=-e; /* uInt, please */ |
| 1817 | } |
| 1818 | #if DECEMAXD>4 |
| 1819 | #error Exponent form is too long for ShowNum to lay out |
| 1820 | #endif |
| 1821 | if (e==0) *c++='0'; /* 0-length case */ |
| 1822 | else if (e<1000) { /* 3 (or fewer) digits case */ |
| 1823 | u=&BIN2BCD8[e*4]; /* -> 3 digits + length byte */ |
| 1824 | UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); /* [as above] */ |
| 1825 | c+=*(u+3); /* bump pointer appropriately */ |
| 1826 | } |
| 1827 | else { /* 4-digits */ |
| 1828 | Int thou=((e>>3)*1049)>>17; /* e/1000 */ |
| 1829 | Int rem=e-(1000*thou); /* e%1000 */ |
| 1830 | *c++=(char)('0'+(char)thou); /* the thousands digit */ |
| 1831 | u=&BIN2BCD8[rem*4]; /* -> 3 digits + length byte */ |
| 1832 | UBFROMUI(c, UBTOUI(u)|CHARMASK); /* copy fixed 3+1 characters [is safe] */ |
| 1833 | c+=3; /* bump pointer, always 3 digits */ |
| 1834 | } |
| 1835 | *c='\0'; /* add terminator */ |
| 1836 | printf("%7s c=%s", qbuf, csign); |
| 1837 | } |
| 1838 | |
| 1839 | if (!EXPISSPECIAL(num->exponent) || num->msd!=num->lsd || *num->lsd!=0) { |
| 1840 | for (ub=num->msd; ub<=num->lsd; ub++) { /* coefficient... */ |
| 1841 | printf("%1x", *ub); |
| 1842 | if ((num->lsd-ub)%3==0 && ub!=num->lsd) printf(" "); /* 4-space */ |
| 1843 | } |
| 1844 | } |
| 1845 | printf("\n"); |
| 1846 | } /* decShowNum */ |
| 1847 | #endif |