libdecnumber/decCommon.c

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