?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gas/
[binutils-gdb.git] / libdecnumber / decCommon.c
blobfa16e792e668058f37129685c06f72502f3426af
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
The GNU Binutils are a collection of binary tools.