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