OSDN Git Service

PR other/37897
[pf3gnuchains/gcc-fork.git] / libdecnumber / decCommon.c
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