libdecnumber/decNumber.c

   1 /* Decimal number arithmetic module for the decNumber C Library.
   2    Copyright (C) 2005, 2007 Free Software Foundation, Inc.
   3    Contributed by IBM Corporation.  Author Mike Cowlishaw.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 2, or (at your option) any later
  10    version.
  11
  12    In addition to the permissions in the GNU General Public License,
  13    the Free Software Foundation gives you unlimited permission to link
  14    the compiled version of this file into combinations with other
  15    programs, and to distribute those combinations without any
  16    restriction coming from the use of this file.  (The General Public
  17    License restrictions do apply in other respects; for example, they
  18    cover modification of the file, and distribution when not linked
  19    into a combine executable.)
  20
  21    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  22    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  23    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  24    for more details.
  25
  26    You should have received a copy of the GNU General Public License
  27    along with GCC; see the file COPYING.  If not, write to the Free
  28    Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  29    02110-1301, USA.  */
  30
  31 /* ------------------------------------------------------------------ */
  32 /* Decimal Number arithmetic module                                   */
  33 /* ------------------------------------------------------------------ */
  34 /* This module comprises the routines for General Decimal Arithmetic  */
  35 /* as defined in the specification which may be found on the          */
  36 /* http://www2.hursley.ibm.com/decimal web pages.  It implements both */
  37 /* the full ('extended') arithmetic and the simpler ('subset')        */
  38 /* arithmetic.                                                        */
  39 /*                                                                    */
  40 /* Usage notes:                                                       */
  41 /*                                                                    */
  42 /* 1. This code is ANSI C89 except:                                   */
  43 /*                                                                    */
  44 /*       If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and       */
  45 /*       uint64_t types may be used.  To avoid these, set DECUSE64=0  */
  46 /*       and DECDPUN<=4 (see documentation).                          */
  47 /*                                                                    */
  48 /* 2. The decNumber format which this library uses is optimized for   */
  49 /*    efficient processing of relatively short numbers; in particular */
  50 /*    it allows the use of fixed sized structures and minimizes copy  */
  51 /*    and move operations.  It does, however, support arbitrary       */
  52 /*    precision (up to 999,999,999 digits) and arbitrary exponent     */
  53 /*    range (Emax in the range 0 through 999,999,999 and Emin in the  */
  54 /*    range -999,999,999 through 0).  Mathematical functions (for     */
  55 /*    example decNumberExp) as identified below are restricted more   */
  56 /*    tightly: digits, emax, and -emin in the context must be <=      */
  57 /*    DEC_MAX_MATH (999999), and their operand(s) must be within      */
  58 /*    these bounds.                                                   */
  59 /*                                                                    */
  60 /* 3. Logical functions are further restricted; their operands must   */
  61 /*    be finite, positive, have an exponent of zero, and all digits   */
  62 /*    must be either 0 or 1.  The result will only contain digits     */
  63 /*    which are 0 or 1 (and will have exponent=0 and a sign of 0).    */
  64 /*                                                                    */
  65 /* 4. Operands to operator functions are never modified unless they   */
  66 /*    are also specified to be the result number (which is always     */
  67 /*    permitted).  Other than that case, operands must not overlap.   */
  68 /*                                                                    */
  69 /* 5. Error handling: the type of the error is ORed into the status   */
  70 /*    flags in the current context (decContext structure).  The       */
  71 /*    SIGFPE signal is then raised if the corresponding trap-enabler  */
  72 /*    flag in the decContext is set (is 1).                           */
  73 /*                                                                    */
  74 /*    It is the responsibility of the caller to clear the status      */
  75 /*    flags as required.                                              */
  76 /*                                                                    */
  77 /*    The result of any routine which returns a number will always    */
  78 /*    be a valid number (which may be a special value, such as an     */
  79 /*    Infinity or NaN).                                               */
  80 /*                                                                    */
  81 /* 6. The decNumber format is not an exchangeable concrete            */
  82 /*    representation as it comprises fields which may be machine-     */
  83 /*    dependent (packed or unpacked, or special length, for example). */
  84 /*    Canonical conversions to and from strings are provided; other   */
  85 /*    conversions are available in separate modules.                  */
  86 /*                                                                    */
  87 /* 7. Normally, input operands are assumed to be valid.  Set DECCHECK */
  88 /*    to 1 for extended operand checking (including NULL operands).   */
  89 /*    Results are undefined if a badly-formed structure (or a NULL    */
  90 /*    pointer to a structure) is provided, though with DECCHECK       */
  91 /*    enabled the operator routines are protected against exceptions. */
  92 /*    (Except if the result pointer is NULL, which is unrecoverable.) */
  93 /*                                                                    */
  94 /*    However, the routines will never cause exceptions if they are   */
  95 /*    given well-formed operands, even if the value of the operands   */
  96 /*    is inappropriate for the operation and DECCHECK is not set.     */
  97 /*    (Except for SIGFPE, as and where documented.)                   */
  98 /*                                                                    */
  99 /* 8. Subset arithmetic is available only if DECSUBSET is set to 1.   */
 100 /* ------------------------------------------------------------------ */
 101 /* Implementation notes for maintenance of this module:               */
 102 /*                                                                    */
 103 /* 1. Storage leak protection:  Routines which use malloc are not     */
 104 /*    permitted to use return for fastpath or error exits (i.e.,      */
 105 /*    they follow strict structured programming conventions).         */
 106 /*    Instead they have a do{}while(0); construct surrounding the     */
 107 /*    code which is protected -- break may be used to exit this.      */
 108 /*    Other routines can safely use the return statement inline.      */
 109 /*                                                                    */
 110 /*    Storage leak accounting can be enabled using DECALLOC.          */
 111 /*                                                                    */
 112 /* 2. All loops use the for(;;) construct.  Any do construct does     */
 113 /*    not loop; it is for allocation protection as just described.    */
 114 /*                                                                    */
 115 /* 3. Setting status in the context must always be the very last      */
 116 /*    action in a routine, as non-0 status may raise a trap and hence */
 117 /*    the call to set status may not return (if the handler uses long */
 118 /*    jump).  Therefore all cleanup must be done first.  In general,  */
 119 /*    to achieve this status is accumulated and is only applied just  */
 120 /*    before return by calling decContextSetStatus (via decStatus).   */
 121 /*                                                                    */
 122 /*    Routines which allocate storage cannot, in general, use the     */
 123 /*    'top level' routines which could cause a non-returning          */
 124 /*    transfer of control.  The decXxxxOp routines are safe (do not   */
 125 /*    call decStatus even if traps are set in the context) and should */
 126 /*    be used instead (they are also a little faster).                */
 127 /*                                                                    */
 128 /* 4. Exponent checking is minimized by allowing the exponent to      */
 129 /*    grow outside its limits during calculations, provided that      */
 130 /*    the decFinalize function is called later.  Multiplication and   */
 131 /*    division, and intermediate calculations in exponentiation,      */
 132 /*    require more careful checks because of the risk of 31-bit       */
 133 /*    overflow (the most negative valid exponent is -1999999997, for  */
 134 /*    a 999999999-digit number with adjusted exponent of -999999999). */
 135 /*                                                                    */
 136 /* 5. Rounding is deferred until finalization of results, with any    */
 137 /*    'off to the right' data being represented as a single digit     */
 138 /*    residue (in the range -1 through 9).  This avoids any double-   */
 139 /*    rounding when more than one shortening takes place (for         */
 140 /*    example, when a result is subnormal).                           */
 141 /*                                                                    */
 142 /* 6. The digits count is allowed to rise to a multiple of DECDPUN    */
 143 /*    during many operations, so whole Units are handled and exact    */
 144 /*    accounting of digits is not needed.  The correct digits value   */
 145 /*    is found by decGetDigits, which accounts for leading zeros.     */
 146 /*    This must be called before any rounding if the number of digits */
 147 /*    is not known exactly.                                           */
 148 /*                                                                    */
 149 /* 7. The multiply-by-reciprocal 'trick' is used for partitioning     */
 150 /*    numbers up to four digits, using appropriate constants.  This   */
 151 /*    is not useful for longer numbers because overflow of 32 bits    */
 152 /*    would lead to 4 multiplies, which is almost as expensive as     */
 153 /*    a divide (unless a floating-point or 64-bit multiply is         */
 154 /*    assumed to be available).                                       */
 155 /*                                                                    */
 156 /* 8. Unusual abbreviations that may be used in the commentary:       */
 157 /*      lhs -- left hand side (operand, of an operation)              */
 158 /*      lsd -- least significant digit (of coefficient)               */
 159 /*      lsu -- least significant Unit (of coefficient)                */
 160 /*      msd -- most significant digit (of coefficient)                */
 161 /*      msi -- most significant item (in an array)                    */
 162 /*      msu -- most significant Unit (of coefficient)                 */
 163 /*      rhs -- right hand side (operand, of an operation)             */
 164 /*      +ve -- positive                                               */
 165 /*      -ve -- negative                                               */
 166 /*      **  -- raise to the power                                     */
 167 /* ------------------------------------------------------------------ */
 168
 169 #include <stdlib.h>                /* for malloc, free, etc. */
 170 #include <stdio.h>                 /* for printf [if needed] */
 171 #include <string.h>                /* for strcpy */
 172 #include <ctype.h>                 /* for lower */
 173 #include "libdecnumber/dconfig.h"
 174 #include "libdecnumber/decNumber.h"
 175 #include "libdecnumber/decNumberLocal.h"
 176
 177 /* Constants */
 178 /* Public lookup table used by the D2U macro */
 179 const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
 180
 181 #define DECVERB     1              /* set to 1 for verbose DECCHECK */
 182 #define powers      DECPOWERS      /* old internal name */
 183
 184 /* Local constants */
 185 #define DIVIDE      0x80           /* Divide operators */
 186 #define REMAINDER   0x40           /* .. */
 187 #define DIVIDEINT   0x20           /* .. */
 188 #define REMNEAR     0x10           /* .. */
 189 #define COMPARE     0x01           /* Compare operators */
 190 #define COMPMAX     0x02           /* .. */
 191 #define COMPMIN     0x03           /* .. */
 192 #define COMPTOTAL   0x04           /* .. */
 193 #define COMPNAN     0x05           /* .. [NaN processing] */
 194 #define COMPSIG     0x06           /* .. [signaling COMPARE] */
 195 #define COMPMAXMAG  0x07           /* .. */
 196 #define COMPMINMAG  0x08           /* .. */
 197
 198 #define DEC_sNaN     0x40000000    /* local status: sNaN signal */
 199 #define BADINT  (Int)0x80000000    /* most-negative Int; error indicator */
 200 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
 201 #define BIGEVEN (Int)0x80000002
 202 #define BIGODD  (Int)0x80000003
 203
 204 static Unit uarrone[1]={1};   /* Unit array of 1, used for incrementing */
 205
 206 /* Granularity-dependent code */
 207 #if DECDPUN<=4
 208   #define eInt  Int           /* extended integer */
 209   #define ueInt uInt          /* unsigned extended integer */
 210   /* Constant multipliers for divide-by-power-of five using reciprocal */
 211   /* multiply, after removing powers of 2 by shifting, and final shift */
 212   /* of 17 [we only need up to **4] */
 213   static const uInt multies[]={131073, 26215, 5243, 1049, 210};
 214   /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
 215   #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
 216 #else
 217   /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
 218   #if !DECUSE64
 219     #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
 220   #endif
 221   #define eInt  Long          /* extended integer */
 222   #define ueInt uLong         /* unsigned extended integer */
 223 #endif
 224
 225 /* Local routines */
 226 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
 227                               decContext *, uByte, uInt *);
 228 static Flag        decBiStr(const char *, const char *, const char *);
 229 static uInt        decCheckMath(const decNumber *, decContext *, uInt *);
 230 static void        decApplyRound(decNumber *, decContext *, Int, uInt *);
 231 static Int         decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
 232 static decNumber * decCompareOp(decNumber *, const decNumber *,
 233                               const decNumber *, decContext *,
 234                               Flag, uInt *);
 235 static void        decCopyFit(decNumber *, const decNumber *, decContext *,
 236                               Int *, uInt *);
 237 static decNumber * decDecap(decNumber *, Int);
 238 static decNumber * decDivideOp(decNumber *, const decNumber *,
 239                               const decNumber *, decContext *, Flag, uInt *);
 240 static decNumber * decExpOp(decNumber *, const decNumber *,
 241                               decContext *, uInt *);
 242 static void        decFinalize(decNumber *, decContext *, Int *, uInt *);
 243 static Int         decGetDigits(Unit *, Int);
 244 static Int         decGetInt(const decNumber *);
 245 static decNumber * decLnOp(decNumber *, const decNumber *,
 246                               decContext *, uInt *);
 247 static decNumber * decMultiplyOp(decNumber *, const decNumber *,
 248                               const decNumber *, decContext *,
 249                               uInt *);
 250 static decNumber * decNaNs(decNumber *, const decNumber *,
 251                               const decNumber *, decContext *, uInt *);
 252 static decNumber * decQuantizeOp(decNumber *, const decNumber *,
 253                               const decNumber *, decContext *, Flag,
 254                               uInt *);
 255 static void        decReverse(Unit *, Unit *);
 256 static void        decSetCoeff(decNumber *, decContext *, const Unit *,
 257                               Int, Int *, uInt *);
 258 static void        decSetMaxValue(decNumber *, decContext *);
 259 static void        decSetOverflow(decNumber *, decContext *, uInt *);
 260 static void        decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
 261 static Int         decShiftToLeast(Unit *, Int, Int);
 262 static Int         decShiftToMost(Unit *, Int, Int);
 263 static void        decStatus(decNumber *, uInt, decContext *);
 264 static void        decToString(const decNumber *, char[], Flag);
 265 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *);
 266 static Int         decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
 267                               Unit *, Int);
 268 static Int         decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
 269
 270 #if !DECSUBSET
 271 /* decFinish == decFinalize when no subset arithmetic needed */
 272 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
 273 #else
 274 static void        decFinish(decNumber *, decContext *, Int *, uInt *);
 275 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
 276 #endif
 277
 278 /* Local macros */
 279 /* masked special-values bits */
 280 #define SPECIALARG  (rhs->bits & DECSPECIAL)
 281 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
 282
 283 /* Diagnostic macros, etc. */
 284 #if DECALLOC
 285 /* Handle malloc/free accounting.  If enabled, our accountable routines */
 286 /* are used; otherwise the code just goes straight to the system malloc */
 287 /* and free routines. */
 288 #define malloc(a) decMalloc(a)
 289 #define free(a) decFree(a)
 290 #define DECFENCE 0x5a              /* corruption detector */
 291 /* 'Our' malloc and free: */
 292 static void *decMalloc(size_t);
 293 static void  decFree(void *);
 294 uInt decAllocBytes=0;              /* count of bytes allocated */
 295 /* Note that DECALLOC code only checks for storage buffer overflow. */
 296 /* To check for memory leaks, the decAllocBytes variable must be */
 297 /* checked to be 0 at appropriate times (e.g., after the test */
 298 /* harness completes a set of tests).  This checking may be unreliable */
 299 /* if the testing is done in a multi-thread environment. */
 300 #endif
 301
 302 #if DECCHECK
 303 /* Optional checking routines.  Enabling these means that decNumber */
 304 /* and decContext operands to operator routines are checked for */
 305 /* correctness.  This roughly doubles the execution time of the */
 306 /* fastest routines (and adds 600+ bytes), so should not normally be */
 307 /* used in 'production'. */
 308 /* decCheckInexact is used to check that inexact results have a full */
 309 /* complement of digits (where appropriate -- this is not the case */
 310 /* for Quantize, for example) */
 311 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
 312 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
 313 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
 314 static Flag decCheckOperands(decNumber *, const decNumber *,
 315                              const decNumber *, decContext *);
 316 static Flag decCheckNumber(const decNumber *);
 317 static void decCheckInexact(const decNumber *, decContext *);
 318 #endif
 319
 320 #if DECTRACE || DECCHECK
 321 /* Optional trace/debugging routines (may or may not be used) */
 322 void decNumberShow(const decNumber *);  /* displays the components of a number */
 323 static void decDumpAr(char, const Unit *, Int);
 324 #endif
 325
 326 /* ================================================================== */
 327 /* Conversions                                                        */
 328 /* ================================================================== */
 329
 330 /* ------------------------------------------------------------------ */
 331 /* from-int32 -- conversion from Int or uInt                          */
 332 /*                                                                    */
 333 /*  dn is the decNumber to receive the integer                        */
 334 /*  in or uin is the integer to be converted                          */
 335 /*  returns dn                                                        */
 336 /*                                                                    */
 337 /* No error is possible.                                              */
 338 /* ------------------------------------------------------------------ */
 339 decNumber * decNumberFromInt32(decNumber *dn, Int in) {
 340   uInt unsig;
 341   if (in>=0) unsig=in;
 342    else {                               /* negative (possibly BADINT) */
 343     if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
 344      else unsig=-in;                    /* invert */
 345     }
 346   /* in is now positive */
 347   decNumberFromUInt32(dn, unsig);
 348   if (in<0) dn->bits=DECNEG;            /* sign needed */
 349   return dn;
 350   } /* decNumberFromInt32 */
 351
 352 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
 353   Unit *up;                             /* work pointer */
 354   decNumberZero(dn);                    /* clean */
 355   if (uin==0) return dn;                /* [or decGetDigits bad call] */
 356   for (up=dn->lsu; uin>0; up++) {
 357     *up=(Unit)(uin%(DECDPUNMAX+1));
 358     uin=uin/(DECDPUNMAX+1);
 359     }
 360   dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
 361   return dn;
 362   } /* decNumberFromUInt32 */
 363
 364 /* ------------------------------------------------------------------ */
 365 /* to-int32 -- conversion to Int or uInt                              */
 366 /*                                                                    */
 367 /*  dn is the decNumber to convert                                    */
 368 /*  set is the context for reporting errors                           */
 369 /*  returns the converted decNumber, or 0 if Invalid is set           */
 370 /*                                                                    */
 371 /* Invalid is set if the decNumber does not have exponent==0 or if    */
 372 /* it is a NaN, Infinite, or out-of-range.                            */
 373 /* ------------------------------------------------------------------ */
 374 Int decNumberToInt32(const decNumber *dn, decContext *set) {
 375   #if DECCHECK
 376   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
 377   #endif
 378
 379   /* special or too many digits, or bad exponent */
 380   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
 381    else { /* is a finite integer with 10 or fewer digits */
 382     Int d;                         /* work */
 383     const Unit *up;                /* .. */
 384     uInt hi=0, lo;                 /* .. */
 385     up=dn->lsu;                    /* -> lsu */
 386     lo=*up;                        /* get 1 to 9 digits */
 387     #if DECDPUN>1                  /* split to higher */
 388       hi=lo/10;
 389       lo=lo%10;
 390     #endif
 391     up++;
 392     /* collect remaining Units, if any, into hi */
 393     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
 394     /* now low has the lsd, hi the remainder */
 395     if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
 396       /* most-negative is a reprieve */
 397       if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
 398       /* bad -- drop through */
 399       }
 400      else { /* in-range always */
 401       Int i=X10(hi)+lo;
 402       if (dn->bits&DECNEG) return -i;
 403       return i;
 404       }
 405     } /* integer */
 406   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
 407   return 0;
 408   } /* decNumberToInt32 */
 409
 410 uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
 411   #if DECCHECK
 412   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
 413   #endif
 414   /* special or too many digits, or bad exponent, or negative (<0) */
 415   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
 416     || (dn->bits&DECNEG && !ISZERO(dn)));                   /* bad */
 417    else { /* is a finite integer with 10 or fewer digits */
 418     Int d;                         /* work */
 419     const Unit *up;                /* .. */
 420     uInt hi=0, lo;                 /* .. */
 421     up=dn->lsu;                    /* -> lsu */
 422     lo=*up;                        /* get 1 to 9 digits */
 423     #if DECDPUN>1                  /* split to higher */
 424       hi=lo/10;
 425       lo=lo%10;
 426     #endif
 427     up++;
 428     /* collect remaining Units, if any, into hi */
 429     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
 430
 431     /* now low has the lsd, hi the remainder */
 432     if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
 433      else return X10(hi)+lo;
 434     } /* integer */
 435   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
 436   return 0;
 437   } /* decNumberToUInt32 */
 438
 439 decNumber *decNumberFromInt64(decNumber *dn, int64_t in)
 440 {
 441     uint64_t unsig = in;
 442     if (in < 0) {
 443         unsig = -unsig;
 444     }
 445
 446     decNumberFromUInt64(dn, unsig);
 447     if (in < 0) {
 448         dn->bits = DECNEG;        /* sign needed */
 449     }
 450     return dn;
 451 } /* decNumberFromInt64 */
 452
 453 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin)
 454 {
 455     Unit *up;                             /* work pointer */
 456     decNumberZero(dn);                    /* clean */
 457     if (uin == 0) {
 458         return dn;                /* [or decGetDigits bad call] */
 459     }
 460     for (up = dn->lsu; uin > 0; up++) {
 461         *up = (Unit)(uin % (DECDPUNMAX + 1));
 462         uin = uin / (DECDPUNMAX + 1);
 463     }
 464     dn->digits = decGetDigits(dn->lsu, up-dn->lsu);
 465     return dn;
 466 } /* decNumberFromUInt64 */
 467
 468 /* ------------------------------------------------------------------ */
 469 /* to-int64 -- conversion to int64                                    */
 470 /*                                                                    */
 471 /*  dn is the decNumber to convert.  dn is assumed to have been       */
 472 /*    rounded to a floating point integer value.                      */
 473 /*  set is the context for reporting errors                           */
 474 /*  returns the converted decNumber, or 0 if Invalid is set           */
 475 /*                                                                    */
 476 /* Invalid is set if the decNumber is a NaN, Infinite or is out of    */
 477 /* range for a signed 64 bit integer.                                 */
 478 /* ------------------------------------------------------------------ */
 479
 480 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set)
 481 {
 482     if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
 483        (dn->digits + dn->exponent > 19)) {
 484         goto Invalid;
 485     } else {
 486         int64_t d;        /* work */
 487         const Unit *up;   /* .. */
 488         uint64_t hi = 0;
 489         up = dn->lsu;     /* -> lsu */
 490
 491         for (d = 1; d <= dn->digits; up++, d += DECDPUN) {
 492             uint64_t prev = hi;
 493             hi += *up * powers[d-1];
 494             if ((hi < prev) || (hi > INT64_MAX)) {
 495                 goto Invalid;
 496             }
 497         }
 498
 499         uint64_t prev = hi;
 500         hi *= (uint64_t)powers[dn->exponent];
 501         if ((hi < prev) || (hi > INT64_MAX)) {
 502             goto Invalid;
 503         }
 504         return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi;
 505     }
 506
 507 Invalid:
 508     decContextSetStatus(set, DEC_Invalid_operation);
 509     return 0;
 510 } /* decNumberIntegralToInt64 */
 511
 512
 513 /* ------------------------------------------------------------------ */
 514 /* to-scientific-string -- conversion to numeric string               */
 515 /* to-engineering-string -- conversion to numeric string              */
 516 /*                                                                    */
 517 /*   decNumberToString(dn, string);                                   */
 518 /*   decNumberToEngString(dn, string);                                */
 519 /*                                                                    */
 520 /*  dn is the decNumber to convert                                    */
 521 /*  string is the string where the result will be laid out            */
 522 /*                                                                    */
 523 /*  string must be at least dn->digits+14 characters long             */
 524 /*                                                                    */
 525 /*  No error is possible, and no status can be set.                   */
 526 /* ------------------------------------------------------------------ */
 527 char * decNumberToString(const decNumber *dn, char *string){
 528   decToString(dn, string, 0);
 529   return string;
 530   } /* DecNumberToString */
 531
 532 char * decNumberToEngString(const decNumber *dn, char *string){
 533   decToString(dn, string, 1);
 534   return string;
 535   } /* DecNumberToEngString */
 536
 537 /* ------------------------------------------------------------------ */
 538 /* to-number -- conversion from numeric string                        */
 539 /*                                                                    */
 540 /* decNumberFromString -- convert string to decNumber                 */
 541 /*   dn        -- the number structure to fill                        */
 542 /*   chars[]   -- the string to convert ('\0' terminated)             */
 543 /*   set       -- the context used for processing any error,          */
 544 /*                determining the maximum precision available         */
 545 /*                (set.digits), determining the maximum and minimum   */
 546 /*                exponent (set.emax and set.emin), determining if    */
 547 /*                extended values are allowed, and checking the       */
 548 /*                rounding mode if overflow occurs or rounding is     */
 549 /*                needed.                                             */
 550 /*                                                                    */
 551 /* The length of the coefficient and the size of the exponent are     */
 552 /* checked by this routine, so the correct error (Underflow or        */
 553 /* Overflow) can be reported or rounding applied, as necessary.       */
 554 /*                                                                    */
 555 /* If bad syntax is detected, the result will be a quiet NaN.         */
 556 /* ------------------------------------------------------------------ */
 557 decNumber * decNumberFromString(decNumber *dn, const char chars[],
 558                                 decContext *set) {
 559   Int   exponent=0;                /* working exponent [assume 0] */
 560   uByte bits=0;                    /* working flags [assume +ve] */
 561   Unit  *res;                      /* where result will be built */
 562   Unit  resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
 563                                    /* [+9 allows for ln() constants] */
 564   Unit  *allocres=NULL;            /* -> allocated result, iff allocated */
 565   Int   d=0;                       /* count of digits found in decimal part */
 566   const char *dotchar=NULL;        /* where dot was found */
 567   const char *cfirst=chars;        /* -> first character of decimal part */
 568   const char *last=NULL;           /* -> last digit of decimal part */
 569   const char *c;                   /* work */
 570   Unit  *up;                       /* .. */
 571   #if DECDPUN>1
 572   Int   cut, out;                  /* .. */
 573   #endif
 574   Int   residue;                   /* rounding residue */
 575   uInt  status=0;                  /* error code */
 576
 577   #if DECCHECK
 578   if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
 579     return decNumberZero(dn);
 580   #endif
 581
 582   do {                             /* status & malloc protection */
 583     for (c=chars;; c++) {          /* -> input character */
 584       if (*c>='0' && *c<='9') {    /* test for Arabic digit */
 585         last=c;
 586         d++;                       /* count of real digits */
 587         continue;                  /* still in decimal part */
 588         }
 589       if (*c=='.' && dotchar==NULL) { /* first '.' */
 590         dotchar=c;                 /* record offset into decimal part */
 591         if (c==cfirst) cfirst++;   /* first digit must follow */
 592         continue;}
 593       if (c==chars) {              /* first in string... */
 594         if (*c=='-') {             /* valid - sign */
 595           cfirst++;
 596           bits=DECNEG;
 597           continue;}
 598         if (*c=='+') {             /* valid + sign */
 599           cfirst++;
 600           continue;}
 601         }
 602       /* *c is not a digit, or a valid +, -, or '.' */
 603       break;
 604       } /* c */
 605
 606     if (last==NULL) {              /* no digits yet */
 607       status=DEC_Conversion_syntax;/* assume the worst */
 608       if (*c=='\0') break;         /* and no more to come... */
 609       #if DECSUBSET
 610       /* if subset then infinities and NaNs are not allowed */
 611       if (!set->extended) break;   /* hopeless */
 612       #endif
 613       /* Infinities and NaNs are possible, here */
 614       if (dotchar!=NULL) break;    /* .. unless had a dot */
 615       decNumberZero(dn);           /* be optimistic */
 616       if (decBiStr(c, "infinity", "INFINITY")
 617        || decBiStr(c, "inf", "INF")) {
 618         dn->bits=bits | DECINF;
 619         status=0;                  /* is OK */
 620         break; /* all done */
 621         }
 622       /* a NaN expected */
 623       /* 2003.09.10 NaNs are now permitted to have a sign */
 624       dn->bits=bits | DECNAN;      /* assume simple NaN */
 625       if (*c=='s' || *c=='S') {    /* looks like an sNaN */
 626         c++;
 627         dn->bits=bits | DECSNAN;
 628         }
 629       if (*c!='n' && *c!='N') break;    /* check caseless "NaN" */
 630       c++;
 631       if (*c!='a' && *c!='A') break;    /* .. */
 632       c++;
 633       if (*c!='n' && *c!='N') break;    /* .. */
 634       c++;
 635       /* now either nothing, or nnnn payload, expected */
 636       /* -> start of integer and skip leading 0s [including plain 0] */
 637       for (cfirst=c; *cfirst=='0';) cfirst++;
 638       if (*cfirst=='\0') {         /* "NaN" or "sNaN", maybe with all 0s */
 639         status=0;                  /* it's good */
 640         break;                     /* .. */
 641         }
 642       /* something other than 0s; setup last and d as usual [no dots] */
 643       for (c=cfirst;; c++, d++) {
 644         if (*c<'0' || *c>'9') break; /* test for Arabic digit */
 645         last=c;
 646         }
 647       if (*c!='\0') break;         /* not all digits */
 648       if (d>set->digits-1) {
 649         /* [NB: payload in a decNumber can be full length unless */
 650         /* clamped, in which case can only be digits-1] */
 651         if (set->clamp) break;
 652         if (d>set->digits) break;
 653         } /* too many digits? */
 654       /* good; drop through to convert the integer to coefficient */
 655       status=0;                    /* syntax is OK */
 656       bits=dn->bits;               /* for copy-back */
 657       } /* last==NULL */
 658
 659      else if (*c!='\0') {          /* more to process... */
 660       /* had some digits; exponent is only valid sequence now */
 661       Flag nege;                   /* 1=negative exponent */
 662       const char *firstexp;        /* -> first significant exponent digit */
 663       status=DEC_Conversion_syntax;/* assume the worst */
 664       if (*c!='e' && *c!='E') break;
 665       /* Found 'e' or 'E' -- now process explicit exponent */
 666       /* 1998.07.11: sign no longer required */
 667       nege=0;
 668       c++;                         /* to (possible) sign */
 669       if (*c=='-') {nege=1; c++;}
 670        else if (*c=='+') c++;
 671       if (*c=='\0') break;
 672
 673       for (; *c=='0' && *(c+1)!='\0';) c++;  /* strip insignificant zeros */
 674       firstexp=c;                            /* save exponent digit place */
 675       for (; ;c++) {
 676         if (*c<'0' || *c>'9') break;         /* not a digit */
 677         exponent=X10(exponent)+(Int)*c-(Int)'0';
 678         } /* c */
 679       /* if not now on a '\0', *c must not be a digit */
 680       if (*c!='\0') break;
 681
 682       /* (this next test must be after the syntax checks) */
 683       /* if it was too long the exponent may have wrapped, so check */
 684       /* carefully and set it to a certain overflow if wrap possible */
 685       if (c>=firstexp+9+1) {
 686         if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
 687         /* [up to 1999999999 is OK, for example 1E-1000000998] */
 688         }
 689       if (nege) exponent=-exponent;     /* was negative */
 690       status=0;                         /* is OK */
 691       } /* stuff after digits */
 692
 693     /* Here when whole string has been inspected; syntax is good */
 694     /* cfirst->first digit (never dot), last->last digit (ditto) */
 695
 696     /* strip leading zeros/dot [leave final 0 if all 0's] */
 697     if (*cfirst=='0') {                 /* [cfirst has stepped over .] */
 698       for (c=cfirst; c<last; c++, cfirst++) {
 699         if (*c=='.') continue;          /* ignore dots */
 700         if (*c!='0') break;             /* non-zero found */
 701         d--;                            /* 0 stripped */
 702         } /* c */
 703       #if DECSUBSET
 704       /* make a rapid exit for easy zeros if !extended */
 705       if (*cfirst=='0' && !set->extended) {
 706         decNumberZero(dn);              /* clean result */
 707         break;                          /* [could be return] */
 708         }
 709       #endif
 710       } /* at least one leading 0 */
 711
 712     /* Handle decimal point... */
 713     if (dotchar!=NULL && dotchar<last)  /* non-trailing '.' found? */
 714       exponent-=(last-dotchar);         /* adjust exponent */
 715     /* [we can now ignore the .] */
 716
 717     /* OK, the digits string is good.  Assemble in the decNumber, or in */
 718     /* a temporary units array if rounding is needed */
 719     if (d<=set->digits) res=dn->lsu;    /* fits into supplied decNumber */
 720      else {                             /* rounding needed */
 721       Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
 722       res=resbuff;                      /* assume use local buffer */
 723       if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
 724         allocres=(Unit *)malloc(needbytes);
 725         if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
 726         res=allocres;
 727         }
 728       }
 729     /* res now -> number lsu, buffer, or allocated storage for Unit array */
 730
 731     /* Place the coefficient into the selected Unit array */
 732     /* [this is often 70% of the cost of this function when DECDPUN>1] */
 733     #if DECDPUN>1
 734     out=0;                         /* accumulator */
 735     up=res+D2U(d)-1;               /* -> msu */
 736     cut=d-(up-res)*DECDPUN;        /* digits in top unit */
 737     for (c=cfirst;; c++) {         /* along the digits */
 738       if (*c=='.') continue;       /* ignore '.' [don't decrement cut] */
 739       out=X10(out)+(Int)*c-(Int)'0';
 740       if (c==last) break;          /* done [never get to trailing '.'] */
 741       cut--;
 742       if (cut>0) continue;         /* more for this unit */
 743       *up=(Unit)out;               /* write unit */
 744       up--;                        /* prepare for unit below.. */
 745       cut=DECDPUN;                 /* .. */
 746       out=0;                       /* .. */
 747       } /* c */
 748     *up=(Unit)out;                 /* write lsu */
 749
 750     #else
 751     /* DECDPUN==1 */
 752     up=res;                        /* -> lsu */
 753     for (c=last; c>=cfirst; c--) { /* over each character, from least */
 754       if (*c=='.') continue;       /* ignore . [don't step up] */
 755       *up=(Unit)((Int)*c-(Int)'0');
 756       up++;
 757       } /* c */
 758     #endif
 759
 760     dn->bits=bits;
 761     dn->exponent=exponent;
 762     dn->digits=d;
 763
 764     /* if not in number (too long) shorten into the number */
 765     if (d>set->digits) {
 766       residue=0;
 767       decSetCoeff(dn, set, res, d, &residue, &status);
 768       /* always check for overflow or subnormal and round as needed */
 769       decFinalize(dn, set, &residue, &status);
 770       }
 771      else { /* no rounding, but may still have overflow or subnormal */
 772       /* [these tests are just for performance; finalize repeats them] */
 773       if ((dn->exponent-1<set->emin-dn->digits)
 774        || (dn->exponent-1>set->emax-set->digits)) {
 775         residue=0;
 776         decFinalize(dn, set, &residue, &status);
 777         }
 778       }
 779     /* decNumberShow(dn); */
 780     } while(0);                         /* [for break] */
 781
 782   if (allocres!=NULL) free(allocres);   /* drop any storage used */
 783   if (status!=0) decStatus(dn, status, set);
 784   return dn;
 785   } /* decNumberFromString */
 786
 787 /* ================================================================== */
 788 /* Operators                                                          */
 789 /* ================================================================== */
 790
 791 /* ------------------------------------------------------------------ */
 792 /* decNumberAbs -- absolute value operator                            */
 793 /*                                                                    */
 794 /*   This computes C = abs(A)                                         */
 795 /*                                                                    */
 796 /*   res is C, the result.  C may be A                                */
 797 /*   rhs is A                                                         */
 798 /*   set is the context                                               */
 799 /*                                                                    */
 800 /* See also decNumberCopyAbs for a quiet bitwise version of this.     */
 801 /* C must have space for set->digits digits.                          */
 802 /* ------------------------------------------------------------------ */
 803 /* This has the same effect as decNumberPlus unless A is negative,    */
 804 /* in which case it has the same effect as decNumberMinus.            */
 805 /* ------------------------------------------------------------------ */
 806 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
 807                          decContext *set) {
 808   decNumber dzero;                      /* for 0 */
 809   uInt status=0;                        /* accumulator */
 810
 811   #if DECCHECK
 812   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
 813   #endif
 814
 815   decNumberZero(&dzero);                /* set 0 */
 816   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
 817   decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
 818   if (status!=0) decStatus(res, status, set);
 819   #if DECCHECK
 820   decCheckInexact(res, set);
 821   #endif
 822   return res;
 823   } /* decNumberAbs */
 824
 825 /* ------------------------------------------------------------------ */
 826 /* decNumberAdd -- add two Numbers                                    */
 827 /*                                                                    */
 828 /*   This computes C = A + B                                          */
 829 /*                                                                    */
 830 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
 831 /*   lhs is A                                                         */
 832 /*   rhs is B                                                         */
 833 /*   set is the context                                               */
 834 /*                                                                    */
 835 /* C must have space for set->digits digits.                          */
 836 /* ------------------------------------------------------------------ */
 837 /* This just calls the routine shared with Subtract                   */
 838 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
 839                          const decNumber *rhs, decContext *set) {
 840   uInt status=0;                        /* accumulator */
 841   decAddOp(res, lhs, rhs, set, 0, &status);
 842   if (status!=0) decStatus(res, status, set);
 843   #if DECCHECK
 844   decCheckInexact(res, set);
 845   #endif
 846   return res;
 847   } /* decNumberAdd */
 848
 849 /* ------------------------------------------------------------------ */
 850 /* decNumberAnd -- AND two Numbers, digitwise                         */
 851 /*                                                                    */
 852 /*   This computes C = A & B                                          */
 853 /*                                                                    */
 854 /*   res is C, the result.  C may be A and/or B (e.g., X=X&X)         */
 855 /*   lhs is A                                                         */
 856 /*   rhs is B                                                         */
 857 /*   set is the context (used for result length and error report)     */
 858 /*                                                                    */
 859 /* C must have space for set->digits digits.                          */
 860 /*                                                                    */
 861 /* Logical function restrictions apply (see above); a NaN is          */
 862 /* returned with Invalid_operation if a restriction is violated.      */
 863 /* ------------------------------------------------------------------ */
 864 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
 865                          const decNumber *rhs, decContext *set) {
 866   const Unit *ua, *ub;                  /* -> operands */
 867   const Unit *msua, *msub;              /* -> operand msus */
 868   Unit *uc,  *msuc;                     /* -> result and its msu */
 869   Int   msudigs;                        /* digits in res msu */
 870   #if DECCHECK
 871   if (decCheckOperands(res, lhs, rhs, set)) return res;
 872   #endif
 873
 874   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
 875    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
 876     decStatus(res, DEC_Invalid_operation, set);
 877     return res;
 878     }
 879
 880   /* operands are valid */
 881   ua=lhs->lsu;                          /* bottom-up */
 882   ub=rhs->lsu;                          /* .. */
 883   uc=res->lsu;                          /* .. */
 884   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
 885   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
 886   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
 887   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
 888   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
 889     Unit a, b;                          /* extract units */
 890     if (ua>msua) a=0;
 891      else a=*ua;
 892     if (ub>msub) b=0;
 893      else b=*ub;
 894     *uc=0;                              /* can now write back */
 895     if (a|b) {                          /* maybe 1 bits to examine */
 896       Int i, j;
 897       *uc=0;                            /* can now write back */
 898       /* This loop could be unrolled and/or use BIN2BCD tables */
 899       for (i=0; i<DECDPUN; i++) {
 900         if (a&b&1) *uc=*uc+(Unit)powers[i];  /* effect AND */
 901         j=a%10;
 902         a=a/10;
 903         j|=b%10;
 904         b=b/10;
 905         if (j>1) {
 906           decStatus(res, DEC_Invalid_operation, set);
 907           return res;
 908           }
 909         if (uc==msuc && i==msudigs-1) break; /* just did final digit */
 910         } /* each digit */
 911       } /* both OK */
 912     } /* each unit */
 913   /* [here uc-1 is the msu of the result] */
 914   res->digits=decGetDigits(res->lsu, uc-res->lsu);
 915   res->exponent=0;                      /* integer */
 916   res->bits=0;                          /* sign=0 */
 917   return res;  /* [no status to set] */
 918   } /* decNumberAnd */
 919
 920 /* ------------------------------------------------------------------ */
 921 /* decNumberCompare -- compare two Numbers                            */
 922 /*                                                                    */
 923 /*   This computes C = A ? B                                          */
 924 /*                                                                    */
 925 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 926 /*   lhs is A                                                         */
 927 /*   rhs is B                                                         */
 928 /*   set is the context                                               */
 929 /*                                                                    */
 930 /* C must have space for one digit (or NaN).                          */
 931 /* ------------------------------------------------------------------ */
 932 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
 933                              const decNumber *rhs, decContext *set) {
 934   uInt status=0;                        /* accumulator */
 935   decCompareOp(res, lhs, rhs, set, COMPARE, &status);
 936   if (status!=0) decStatus(res, status, set);
 937   return res;
 938   } /* decNumberCompare */
 939
 940 /* ------------------------------------------------------------------ */
 941 /* decNumberCompareSignal -- compare, signalling on all NaNs          */
 942 /*                                                                    */
 943 /*   This computes C = A ? B                                          */
 944 /*                                                                    */
 945 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 946 /*   lhs is A                                                         */
 947 /*   rhs is B                                                         */
 948 /*   set is the context                                               */
 949 /*                                                                    */
 950 /* C must have space for one digit (or NaN).                          */
 951 /* ------------------------------------------------------------------ */
 952 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
 953                                    const decNumber *rhs, decContext *set) {
 954   uInt status=0;                        /* accumulator */
 955   decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
 956   if (status!=0) decStatus(res, status, set);
 957   return res;
 958   } /* decNumberCompareSignal */
 959
 960 /* ------------------------------------------------------------------ */
 961 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
 962 /*                                                                    */
 963 /*   This computes C = A ? B, under total ordering                    */
 964 /*                                                                    */
 965 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 966 /*   lhs is A                                                         */
 967 /*   rhs is B                                                         */
 968 /*   set is the context                                               */
 969 /*                                                                    */
 970 /* C must have space for one digit; the result will always be one of  */
 971 /* -1, 0, or 1.                                                       */
 972 /* ------------------------------------------------------------------ */
 973 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
 974                                   const decNumber *rhs, decContext *set) {
 975   uInt status=0;                        /* accumulator */
 976   decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
 977   if (status!=0) decStatus(res, status, set);
 978   return res;
 979   } /* decNumberCompareTotal */
 980
 981 /* ------------------------------------------------------------------ */
 982 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes  */
 983 /*                                                                    */
 984 /*   This computes C = |A| ? |B|, under total ordering                */
 985 /*                                                                    */
 986 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
 987 /*   lhs is A                                                         */
 988 /*   rhs is B                                                         */
 989 /*   set is the context                                               */
 990 /*                                                                    */
 991 /* C must have space for one digit; the result will always be one of  */
 992 /* -1, 0, or 1.                                                       */
 993 /* ------------------------------------------------------------------ */
 994 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
 995                                      const decNumber *rhs, decContext *set) {
 996   uInt status=0;                   /* accumulator */
 997   uInt needbytes;                  /* for space calculations */
 998   decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
 999   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
1000   decNumber bufb[D2N(DECBUFFER+1)];
1001   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
1002   decNumber *a, *b;                /* temporary pointers */
1003
1004   #if DECCHECK
1005   if (decCheckOperands(res, lhs, rhs, set)) return res;
1006   #endif
1007
1008   do {                                  /* protect allocated storage */
1009     /* if either is negative, take a copy and absolute */
1010     if (decNumberIsNegative(lhs)) {     /* lhs<0 */
1011       a=bufa;
1012       needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
1013       if (needbytes>sizeof(bufa)) {     /* need malloc space */
1014         allocbufa=(decNumber *)malloc(needbytes);
1015         if (allocbufa==NULL) {          /* hopeless -- abandon */
1016           status|=DEC_Insufficient_storage;
1017           break;}
1018         a=allocbufa;                    /* use the allocated space */
1019         }
1020       decNumberCopy(a, lhs);            /* copy content */
1021       a->bits&=~DECNEG;                 /* .. and clear the sign */
1022       lhs=a;                            /* use copy from here on */
1023       }
1024     if (decNumberIsNegative(rhs)) {     /* rhs<0 */
1025       b=bufb;
1026       needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
1027       if (needbytes>sizeof(bufb)) {     /* need malloc space */
1028         allocbufb=(decNumber *)malloc(needbytes);
1029         if (allocbufb==NULL) {          /* hopeless -- abandon */
1030           status|=DEC_Insufficient_storage;
1031           break;}
1032         b=allocbufb;                    /* use the allocated space */
1033         }
1034       decNumberCopy(b, rhs);            /* copy content */
1035       b->bits&=~DECNEG;                 /* .. and clear the sign */
1036       rhs=b;                            /* use copy from here on */
1037       }
1038     decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
1039     } while(0);                         /* end protected */
1040
1041   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1042   if (allocbufb!=NULL) free(allocbufb); /* .. */
1043   if (status!=0) decStatus(res, status, set);
1044   return res;
1045   } /* decNumberCompareTotalMag */
1046
1047 /* ------------------------------------------------------------------ */
1048 /* decNumberDivide -- divide one number by another                    */
1049 /*                                                                    */
1050 /*   This computes C = A / B                                          */
1051 /*                                                                    */
1052 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
1053 /*   lhs is A                                                         */
1054 /*   rhs is B                                                         */
1055 /*   set is the context                                               */
1056 /*                                                                    */
1057 /* C must have space for set->digits digits.                          */
1058 /* ------------------------------------------------------------------ */
1059 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
1060                             const decNumber *rhs, decContext *set) {
1061   uInt status=0;                        /* accumulator */
1062   decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
1063   if (status!=0) decStatus(res, status, set);
1064   #if DECCHECK
1065   decCheckInexact(res, set);
1066   #endif
1067   return res;
1068   } /* decNumberDivide */
1069
1070 /* ------------------------------------------------------------------ */
1071 /* decNumberDivideInteger -- divide and return integer quotient       */
1072 /*                                                                    */
1073 /*   This computes C = A # B, where # is the integer divide operator  */
1074 /*                                                                    */
1075 /*   res is C, the result.  C may be A and/or B (e.g., X=X#X)         */
1076 /*   lhs is A                                                         */
1077 /*   rhs is B                                                         */
1078 /*   set is the context                                               */
1079 /*                                                                    */
1080 /* C must have space for set->digits digits.                          */
1081 /* ------------------------------------------------------------------ */
1082 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1083                                    const decNumber *rhs, decContext *set) {
1084   uInt status=0;                        /* accumulator */
1085   decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1086   if (status!=0) decStatus(res, status, set);
1087   return res;
1088   } /* decNumberDivideInteger */
1089
1090 /* ------------------------------------------------------------------ */
1091 /* decNumberExp -- exponentiation                                     */
1092 /*                                                                    */
1093 /*   This computes C = exp(A)                                         */
1094 /*                                                                    */
1095 /*   res is C, the result.  C may be A                                */
1096 /*   rhs is A                                                         */
1097 /*   set is the context; note that rounding mode has no effect        */
1098 /*                                                                    */
1099 /* C must have space for set->digits digits.                          */
1100 /*                                                                    */
1101 /* Mathematical function restrictions apply (see above); a NaN is     */
1102 /* returned with Invalid_operation if a restriction is violated.      */
1103 /*                                                                    */
1104 /* Finite results will always be full precision and Inexact, except   */
1105 /* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
1106 /*                                                                    */
1107 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1108 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1109 /* error in rare cases.                                               */
1110 /* ------------------------------------------------------------------ */
1111 /* This is a wrapper for decExpOp which can handle the slightly wider */
1112 /* (double) range needed by Ln (which has to be able to calculate     */
1113 /* exp(-a) where a can be the tiniest number (Ntiny).                 */
1114 /* ------------------------------------------------------------------ */
1115 decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1116                          decContext *set) {
1117   uInt status=0;                        /* accumulator */
1118   #if DECSUBSET
1119   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1120   #endif
1121
1122   #if DECCHECK
1123   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1124   #endif
1125
1126   /* Check restrictions; these restrictions ensure that if h=8 (see */
1127   /* decExpOp) then the result will either overflow or underflow to 0. */
1128   /* Other math functions restrict the input range, too, for inverses. */
1129   /* If not violated then carry out the operation. */
1130   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1131     #if DECSUBSET
1132     if (!set->extended) {
1133       /* reduce operand and set lostDigits status, as needed */
1134       if (rhs->digits>set->digits) {
1135         allocrhs=decRoundOperand(rhs, set, &status);
1136         if (allocrhs==NULL) break;
1137         rhs=allocrhs;
1138         }
1139       }
1140     #endif
1141     decExpOp(res, rhs, set, &status);
1142     } while(0);                         /* end protected */
1143
1144   #if DECSUBSET
1145   if (allocrhs !=NULL) free(allocrhs);  /* drop any storage used */
1146   #endif
1147   /* apply significant status */
1148   if (status!=0) decStatus(res, status, set);
1149   #if DECCHECK
1150   decCheckInexact(res, set);
1151   #endif
1152   return res;
1153   } /* decNumberExp */
1154
1155 /* ------------------------------------------------------------------ */
1156 /* decNumberFMA -- fused multiply add                                 */
1157 /*                                                                    */
1158 /*   This computes D = (A * B) + C with only one rounding             */
1159 /*                                                                    */
1160 /*   res is D, the result.  D may be A or B or C (e.g., X=FMA(X,X,X)) */
1161 /*   lhs is A                                                         */
1162 /*   rhs is B                                                         */
1163 /*   fhs is C [far hand side]                                         */
1164 /*   set is the context                                               */
1165 /*                                                                    */
1166 /* Mathematical function restrictions apply (see above); a NaN is     */
1167 /* returned with Invalid_operation if a restriction is violated.      */
1168 /*                                                                    */
1169 /* C must have space for set->digits digits.                          */
1170 /* ------------------------------------------------------------------ */
1171 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1172                          const decNumber *rhs, const decNumber *fhs,
1173                          decContext *set) {
1174   uInt status=0;                   /* accumulator */
1175   decContext dcmul;                /* context for the multiplication */
1176   uInt needbytes;                  /* for space calculations */
1177   decNumber bufa[D2N(DECBUFFER*2+1)];
1178   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
1179   decNumber *acc;                  /* accumulator pointer */
1180   decNumber dzero;                 /* work */
1181
1182   #if DECCHECK
1183   if (decCheckOperands(res, lhs, rhs, set)) return res;
1184   if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1185   #endif
1186
1187   do {                                  /* protect allocated storage */
1188     #if DECSUBSET
1189     if (!set->extended) {               /* [undefined if subset] */
1190       status|=DEC_Invalid_operation;
1191       break;}
1192     #endif
1193     /* Check math restrictions [these ensure no overflow or underflow] */
1194     if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1195      || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1196      || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1197     /* set up context for multiply */
1198     dcmul=*set;
1199     dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1200     /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1201     dcmul.emax=DEC_MAX_EMAX;            /* effectively unbounded .. */
1202     dcmul.emin=DEC_MIN_EMIN;            /* [thanks to Math restrictions] */
1203     /* set up decNumber space to receive the result of the multiply */
1204     acc=bufa;                           /* may fit */
1205     needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1206     if (needbytes>sizeof(bufa)) {       /* need malloc space */
1207       allocbufa=(decNumber *)malloc(needbytes);
1208       if (allocbufa==NULL) {            /* hopeless -- abandon */
1209         status|=DEC_Insufficient_storage;
1210         break;}
1211       acc=allocbufa;                    /* use the allocated space */
1212       }
1213     /* multiply with extended range and necessary precision */
1214     /*printf("emin=%ld\n", dcmul.emin); */
1215     decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1216     /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1217     /* status; if either is seen than ignore fhs (in case it is */
1218     /* another sNaN) and set acc to NaN unless we had an sNaN */
1219     /* [decMultiplyOp leaves that to caller] */
1220     /* Note sNaN has to go through addOp to shorten payload if */
1221     /* necessary */
1222     if ((status&DEC_Invalid_operation)!=0) {
1223       if (!(status&DEC_sNaN)) {         /* but be true invalid */
1224         decNumberZero(res);             /* acc not yet set */
1225         res->bits=DECNAN;
1226         break;
1227         }
1228       decNumberZero(&dzero);            /* make 0 (any non-NaN would do) */
1229       fhs=&dzero;                       /* use that */
1230       }
1231     #if DECCHECK
1232      else { /* multiply was OK */
1233       if (status!=0) printf("Status=%08lx after FMA multiply\n", status);
1234       }
1235     #endif
1236     /* add the third operand and result -> res, and all is done */
1237     decAddOp(res, acc, fhs, set, 0, &status);
1238     } while(0);                         /* end protected */
1239
1240   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1241   if (status!=0) decStatus(res, status, set);
1242   #if DECCHECK
1243   decCheckInexact(res, set);
1244   #endif
1245   return res;
1246   } /* decNumberFMA */
1247
1248 /* ------------------------------------------------------------------ */
1249 /* decNumberInvert -- invert a Number, digitwise                      */
1250 /*                                                                    */
1251 /*   This computes C = ~A                                             */
1252 /*                                                                    */
1253 /*   res is C, the result.  C may be A (e.g., X=~X)                   */
1254 /*   rhs is A                                                         */
1255 /*   set is the context (used for result length and error report)     */
1256 /*                                                                    */
1257 /* C must have space for set->digits digits.                          */
1258 /*                                                                    */
1259 /* Logical function restrictions apply (see above); a NaN is          */
1260 /* returned with Invalid_operation if a restriction is violated.      */
1261 /* ------------------------------------------------------------------ */
1262 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1263                             decContext *set) {
1264   const Unit *ua, *msua;                /* -> operand and its msu */
1265   Unit  *uc, *msuc;                     /* -> result and its msu */
1266   Int   msudigs;                        /* digits in res msu */
1267   #if DECCHECK
1268   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1269   #endif
1270
1271   if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1272     decStatus(res, DEC_Invalid_operation, set);
1273     return res;
1274     }
1275   /* operand is valid */
1276   ua=rhs->lsu;                          /* bottom-up */
1277   uc=res->lsu;                          /* .. */
1278   msua=ua+D2U(rhs->digits)-1;           /* -> msu of rhs */
1279   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
1280   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
1281   for (; uc<=msuc; ua++, uc++) {        /* Unit loop */
1282     Unit a;                             /* extract unit */
1283     Int  i, j;                          /* work */
1284     if (ua>msua) a=0;
1285      else a=*ua;
1286     *uc=0;                              /* can now write back */
1287     /* always need to examine all bits in rhs */
1288     /* This loop could be unrolled and/or use BIN2BCD tables */
1289     for (i=0; i<DECDPUN; i++) {
1290       if ((~a)&1) *uc=*uc+(Unit)powers[i];   /* effect INVERT */
1291       j=a%10;
1292       a=a/10;
1293       if (j>1) {
1294         decStatus(res, DEC_Invalid_operation, set);
1295         return res;
1296         }
1297       if (uc==msuc && i==msudigs-1) break;   /* just did final digit */
1298       } /* each digit */
1299     } /* each unit */
1300   /* [here uc-1 is the msu of the result] */
1301   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1302   res->exponent=0;                      /* integer */
1303   res->bits=0;                          /* sign=0 */
1304   return res;  /* [no status to set] */
1305   } /* decNumberInvert */
1306
1307 /* ------------------------------------------------------------------ */
1308 /* decNumberLn -- natural logarithm                                   */
1309 /*                                                                    */
1310 /*   This computes C = ln(A)                                          */
1311 /*                                                                    */
1312 /*   res is C, the result.  C may be A                                */
1313 /*   rhs is A                                                         */
1314 /*   set is the context; note that rounding mode has no effect        */
1315 /*                                                                    */
1316 /* C must have space for set->digits digits.                          */
1317 /*                                                                    */
1318 /* Notable cases:                                                     */
1319 /*   A<0 -> Invalid                                                   */
1320 /*   A=0 -> -Infinity (Exact)                                         */
1321 /*   A=+Infinity -> +Infinity (Exact)                                 */
1322 /*   A=1 exactly -> 0 (Exact)                                         */
1323 /*                                                                    */
1324 /* Mathematical function restrictions apply (see above); a NaN is     */
1325 /* returned with Invalid_operation if a restriction is violated.      */
1326 /*                                                                    */
1327 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1328 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1329 /* error in rare cases.                                               */
1330 /* ------------------------------------------------------------------ */
1331 /* This is a wrapper for decLnOp which can handle the slightly wider  */
1332 /* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
1333 /* to calculate at p+e+2).                                            */
1334 /* ------------------------------------------------------------------ */
1335 decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1336                         decContext *set) {
1337   uInt status=0;                   /* accumulator */
1338   #if DECSUBSET
1339   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1340   #endif
1341
1342   #if DECCHECK
1343   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1344   #endif
1345
1346   /* Check restrictions; this is a math function; if not violated */
1347   /* then carry out the operation. */
1348   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1349     #if DECSUBSET
1350     if (!set->extended) {
1351       /* reduce operand and set lostDigits status, as needed */
1352       if (rhs->digits>set->digits) {
1353         allocrhs=decRoundOperand(rhs, set, &status);
1354         if (allocrhs==NULL) break;
1355         rhs=allocrhs;
1356         }
1357       /* special check in subset for rhs=0 */
1358       if (ISZERO(rhs)) {                /* +/- zeros -> error */
1359         status|=DEC_Invalid_operation;
1360         break;}
1361       } /* extended=0 */
1362     #endif
1363     decLnOp(res, rhs, set, &status);
1364     } while(0);                         /* end protected */
1365
1366   #if DECSUBSET
1367   if (allocrhs !=NULL) free(allocrhs);  /* drop any storage used */
1368   #endif
1369   /* apply significant status */
1370   if (status!=0) decStatus(res, status, set);
1371   #if DECCHECK
1372   decCheckInexact(res, set);
1373   #endif
1374   return res;
1375   } /* decNumberLn */
1376
1377 /* ------------------------------------------------------------------ */
1378 /* decNumberLogB - get adjusted exponent, by 754r rules               */
1379 /*                                                                    */
1380 /*   This computes C = adjustedexponent(A)                            */
1381 /*                                                                    */
1382 /*   res is C, the result.  C may be A                                */
1383 /*   rhs is A                                                         */
1384 /*   set is the context, used only for digits and status              */
1385 /*                                                                    */
1386 /* C must have space for 10 digits (A might have 10**9 digits and     */
1387 /* an exponent of +999999999, or one digit and an exponent of         */
1388 /* -1999999999).                                                      */
1389 /*                                                                    */
1390 /* This returns the adjusted exponent of A after (in theory) padding  */
1391 /* with zeros on the right to set->digits digits while keeping the    */
1392 /* same value.  The exponent is not limited by emin/emax.             */
1393 /*                                                                    */
1394 /* Notable cases:                                                     */
1395 /*   A<0 -> Use |A|                                                   */
1396 /*   A=0 -> -Infinity (Division by zero)                              */
1397 /*   A=Infinite -> +Infinity (Exact)                                  */
1398 /*   A=1 exactly -> 0 (Exact)                                         */
1399 /*   NaNs are propagated as usual                                     */
1400 /* ------------------------------------------------------------------ */
1401 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1402                           decContext *set) {
1403   uInt status=0;                   /* accumulator */
1404
1405   #if DECCHECK
1406   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1407   #endif
1408
1409   /* NaNs as usual; Infinities return +Infinity; 0->oops */
1410   if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1411    else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1412    else if (decNumberIsZero(rhs)) {
1413     decNumberZero(res);                 /* prepare for Infinity */
1414     res->bits=DECNEG|DECINF;            /* -Infinity */
1415     status|=DEC_Division_by_zero;       /* as per 754r */
1416     }
1417    else { /* finite non-zero */
1418     Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1419     decNumberFromInt32(res, ae);        /* lay it out */
1420     }
1421
1422   if (status!=0) decStatus(res, status, set);
1423   return res;
1424   } /* decNumberLogB */
1425
1426 /* ------------------------------------------------------------------ */
1427 /* decNumberLog10 -- logarithm in base 10                             */
1428 /*                                                                    */
1429 /*   This computes C = log10(A)                                       */
1430 /*                                                                    */
1431 /*   res is C, the result.  C may be A                                */
1432 /*   rhs is A                                                         */
1433 /*   set is the context; note that rounding mode has no effect        */
1434 /*                                                                    */
1435 /* C must have space for set->digits digits.                          */
1436 /*                                                                    */
1437 /* Notable cases:                                                     */
1438 /*   A<0 -> Invalid                                                   */
1439 /*   A=0 -> -Infinity (Exact)                                         */
1440 /*   A=+Infinity -> +Infinity (Exact)                                 */
1441 /*   A=10**n (if n is an integer) -> n (Exact)                        */
1442 /*                                                                    */
1443 /* Mathematical function restrictions apply (see above); a NaN is     */
1444 /* returned with Invalid_operation if a restriction is violated.      */
1445 /*                                                                    */
1446 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1447 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1448 /* error in rare cases.                                               */
1449 /* ------------------------------------------------------------------ */
1450 /* This calculates ln(A)/ln(10) using appropriate precision.  For     */
1451 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
1452 /* requested digits and t is the number of digits in the exponent     */
1453 /* (maximum 6).  For ln(10) it is p + 3; this is often handled by the */
1454 /* fastpath in decLnOp.  The final division is done to the requested  */
1455 /* precision.                                                         */
1456 /* ------------------------------------------------------------------ */
1457 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1458                           decContext *set) {
1459   uInt status=0, ignore=0;         /* status accumulators */
1460   uInt needbytes;                  /* for space calculations */
1461   Int p;                           /* working precision */
1462   Int t;                           /* digits in exponent of A */
1463
1464   /* buffers for a and b working decimals */
1465   /* (adjustment calculator, same size) */
1466   decNumber bufa[D2N(DECBUFFER+2)];
1467   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
1468   decNumber *a=bufa;               /* temporary a */
1469   decNumber bufb[D2N(DECBUFFER+2)];
1470   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
1471   decNumber *b=bufb;               /* temporary b */
1472   decNumber bufw[D2N(10)];         /* working 2-10 digit number */
1473   decNumber *w=bufw;               /* .. */
1474   #if DECSUBSET
1475   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
1476   #endif
1477
1478   decContext aset;                 /* working context */
1479
1480   #if DECCHECK
1481   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1482   #endif
1483
1484   /* Check restrictions; this is a math function; if not violated */
1485   /* then carry out the operation. */
1486   if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1487     #if DECSUBSET
1488     if (!set->extended) {
1489       /* reduce operand and set lostDigits status, as needed */
1490       if (rhs->digits>set->digits) {
1491         allocrhs=decRoundOperand(rhs, set, &status);
1492         if (allocrhs==NULL) break;
1493         rhs=allocrhs;
1494         }
1495       /* special check in subset for rhs=0 */
1496       if (ISZERO(rhs)) {                /* +/- zeros -> error */
1497         status|=DEC_Invalid_operation;
1498         break;}
1499       } /* extended=0 */
1500     #endif
1501
1502     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1503
1504     /* handle exact powers of 10; only check if +ve finite */
1505     if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1506       Int residue=0;               /* (no residue) */
1507       uInt copystat=0;             /* clean status */
1508
1509       /* round to a single digit... */
1510       aset.digits=1;
1511       decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1512       /* if exact and the digit is 1, rhs is a power of 10 */
1513       if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1514         /* the exponent, conveniently, is the power of 10; making */
1515         /* this the result needs a little care as it might not fit, */
1516         /* so first convert it into the working number, and then move */
1517         /* to res */
1518         decNumberFromInt32(w, w->exponent);
1519         residue=0;
1520         decCopyFit(res, w, set, &residue, &status); /* copy & round */
1521         decFinish(res, set, &residue, &status);     /* cleanup/set flags */
1522         break;
1523         } /* not a power of 10 */
1524       } /* not a candidate for exact */
1525
1526     /* simplify the information-content calculation to use 'total */
1527     /* number of digits in a, including exponent' as compared to the */
1528     /* requested digits, as increasing this will only rarely cost an */
1529     /* iteration in ln(a) anyway */
1530     t=6;                                /* it can never be >6 */
1531
1532     /* allocate space when needed... */
1533     p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1534     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1535     if (needbytes>sizeof(bufa)) {       /* need malloc space */
1536       allocbufa=(decNumber *)malloc(needbytes);
1537       if (allocbufa==NULL) {            /* hopeless -- abandon */
1538         status|=DEC_Insufficient_storage;
1539         break;}
1540       a=allocbufa;                      /* use the allocated space */
1541       }
1542     aset.digits=p;                      /* as calculated */
1543     aset.emax=DEC_MAX_MATH;             /* usual bounds */
1544     aset.emin=-DEC_MAX_MATH;            /* .. */
1545     aset.clamp=0;                       /* and no concrete format */
1546     decLnOp(a, rhs, &aset, &status);    /* a=ln(rhs) */
1547
1548     /* skip the division if the result so far is infinite, NaN, or */
1549     /* zero, or there was an error; note NaN from sNaN needs copy */
1550     if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1551     if (a->bits&DECSPECIAL || ISZERO(a)) {
1552       decNumberCopy(res, a);            /* [will fit] */
1553       break;}
1554
1555     /* for ln(10) an extra 3 digits of precision are needed */
1556     p=set->digits+3;
1557     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1558     if (needbytes>sizeof(bufb)) {       /* need malloc space */
1559       allocbufb=(decNumber *)malloc(needbytes);
1560       if (allocbufb==NULL) {            /* hopeless -- abandon */
1561         status|=DEC_Insufficient_storage;
1562         break;}
1563       b=allocbufb;                      /* use the allocated space */
1564       }
1565     decNumberZero(w);                   /* set up 10... */
1566     #if DECDPUN==1
1567     w->lsu[1]=1; w->lsu[0]=0;           /* .. */
1568     #else
1569     w->lsu[0]=10;                       /* .. */
1570     #endif
1571     w->digits=2;                        /* .. */
1572
1573     aset.digits=p;
1574     decLnOp(b, w, &aset, &ignore);      /* b=ln(10) */
1575
1576     aset.digits=set->digits;            /* for final divide */
1577     decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1578     } while(0);                         /* [for break] */
1579
1580   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1581   if (allocbufb!=NULL) free(allocbufb); /* .. */
1582   #if DECSUBSET
1583   if (allocrhs !=NULL) free(allocrhs);  /* .. */
1584   #endif
1585   /* apply significant status */
1586   if (status!=0) decStatus(res, status, set);
1587   #if DECCHECK
1588   decCheckInexact(res, set);
1589   #endif
1590   return res;
1591   } /* decNumberLog10 */
1592
1593 /* ------------------------------------------------------------------ */
1594 /* decNumberMax -- compare two Numbers and return the maximum         */
1595 /*                                                                    */
1596 /*   This computes C = A ? B, returning the maximum by 754R rules     */
1597 /*                                                                    */
1598 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1599 /*   lhs is A                                                         */
1600 /*   rhs is B                                                         */
1601 /*   set is the context                                               */
1602 /*                                                                    */
1603 /* C must have space for set->digits digits.                          */
1604 /* ------------------------------------------------------------------ */
1605 decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1606                          const decNumber *rhs, decContext *set) {
1607   uInt status=0;                        /* accumulator */
1608   decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1609   if (status!=0) decStatus(res, status, set);
1610   #if DECCHECK
1611   decCheckInexact(res, set);
1612   #endif
1613   return res;
1614   } /* decNumberMax */
1615
1616 /* ------------------------------------------------------------------ */
1617 /* decNumberMaxMag -- compare and return the maximum by magnitude     */
1618 /*                                                                    */
1619 /*   This computes C = A ? B, returning the maximum by 754R rules     */
1620 /*                                                                    */
1621 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1622 /*   lhs is A                                                         */
1623 /*   rhs is B                                                         */
1624 /*   set is the context                                               */
1625 /*                                                                    */
1626 /* C must have space for set->digits digits.                          */
1627 /* ------------------------------------------------------------------ */
1628 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1629                          const decNumber *rhs, decContext *set) {
1630   uInt status=0;                        /* accumulator */
1631   decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1632   if (status!=0) decStatus(res, status, set);
1633   #if DECCHECK
1634   decCheckInexact(res, set);
1635   #endif
1636   return res;
1637   } /* decNumberMaxMag */
1638
1639 /* ------------------------------------------------------------------ */
1640 /* decNumberMin -- compare two Numbers and return the minimum         */
1641 /*                                                                    */
1642 /*   This computes C = A ? B, returning the minimum by 754R rules     */
1643 /*                                                                    */
1644 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1645 /*   lhs is A                                                         */
1646 /*   rhs is B                                                         */
1647 /*   set is the context                                               */
1648 /*                                                                    */
1649 /* C must have space for set->digits digits.                          */
1650 /* ------------------------------------------------------------------ */
1651 decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1652                          const decNumber *rhs, decContext *set) {
1653   uInt status=0;                        /* accumulator */
1654   decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1655   if (status!=0) decStatus(res, status, set);
1656   #if DECCHECK
1657   decCheckInexact(res, set);
1658   #endif
1659   return res;
1660   } /* decNumberMin */
1661
1662 /* ------------------------------------------------------------------ */
1663 /* decNumberMinMag -- compare and return the minimum by magnitude     */
1664 /*                                                                    */
1665 /*   This computes C = A ? B, returning the minimum by 754R rules     */
1666 /*                                                                    */
1667 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
1668 /*   lhs is A                                                         */
1669 /*   rhs is B                                                         */
1670 /*   set is the context                                               */
1671 /*                                                                    */
1672 /* C must have space for set->digits digits.                          */
1673 /* ------------------------------------------------------------------ */
1674 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1675                          const decNumber *rhs, decContext *set) {
1676   uInt status=0;                        /* accumulator */
1677   decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1678   if (status!=0) decStatus(res, status, set);
1679   #if DECCHECK
1680   decCheckInexact(res, set);
1681   #endif
1682   return res;
1683   } /* decNumberMinMag */
1684
1685 /* ------------------------------------------------------------------ */
1686 /* decNumberMinus -- prefix minus operator                            */
1687 /*                                                                    */
1688 /*   This computes C = 0 - A                                          */
1689 /*                                                                    */
1690 /*   res is C, the result.  C may be A                                */
1691 /*   rhs is A                                                         */
1692 /*   set is the context                                               */
1693 /*                                                                    */
1694 /* See also decNumberCopyNegate for a quiet bitwise version of this.  */
1695 /* C must have space for set->digits digits.                          */
1696 /* ------------------------------------------------------------------ */
1697 /* Simply use AddOp for the subtract, which will do the necessary.    */
1698 /* ------------------------------------------------------------------ */
1699 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1700                            decContext *set) {
1701   decNumber dzero;
1702   uInt status=0;                        /* accumulator */
1703
1704   #if DECCHECK
1705   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1706   #endif
1707
1708   decNumberZero(&dzero);                /* make 0 */
1709   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
1710   decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1711   if (status!=0) decStatus(res, status, set);
1712   #if DECCHECK
1713   decCheckInexact(res, set);
1714   #endif
1715   return res;
1716   } /* decNumberMinus */
1717
1718 /* ------------------------------------------------------------------ */
1719 /* decNumberNextMinus -- next towards -Infinity                       */
1720 /*                                                                    */
1721 /*   This computes C = A - infinitesimal, rounded towards -Infinity   */
1722 /*                                                                    */
1723 /*   res is C, the result.  C may be A                                */
1724 /*   rhs is A                                                         */
1725 /*   set is the context                                               */
1726 /*                                                                    */
1727 /* This is a generalization of 754r NextDown.                         */
1728 /* ------------------------------------------------------------------ */
1729 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1730                                decContext *set) {
1731   decNumber dtiny;                           /* constant */
1732   decContext workset=*set;                   /* work */
1733   uInt status=0;                             /* accumulator */
1734   #if DECCHECK
1735   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1736   #endif
1737
1738   /* +Infinity is the special case */
1739   if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1740     decSetMaxValue(res, set);                /* is +ve */
1741     /* there is no status to set */
1742     return res;
1743     }
1744   decNumberZero(&dtiny);                     /* start with 0 */
1745   dtiny.lsu[0]=1;                            /* make number that is .. */
1746   dtiny.exponent=DEC_MIN_EMIN-1;             /* .. smaller than tiniest */
1747   workset.round=DEC_ROUND_FLOOR;
1748   decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1749   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1750   if (status!=0) decStatus(res, status, set);
1751   return res;
1752   } /* decNumberNextMinus */
1753
1754 /* ------------------------------------------------------------------ */
1755 /* decNumberNextPlus -- next towards +Infinity                        */
1756 /*                                                                    */
1757 /*   This computes C = A + infinitesimal, rounded towards +Infinity   */
1758 /*                                                                    */
1759 /*   res is C, the result.  C may be A                                */
1760 /*   rhs is A                                                         */
1761 /*   set is the context                                               */
1762 /*                                                                    */
1763 /* This is a generalization of 754r NextUp.                           */
1764 /* ------------------------------------------------------------------ */
1765 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1766                               decContext *set) {
1767   decNumber dtiny;                           /* constant */
1768   decContext workset=*set;                   /* work */
1769   uInt status=0;                             /* accumulator */
1770   #if DECCHECK
1771   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1772   #endif
1773
1774   /* -Infinity is the special case */
1775   if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1776     decSetMaxValue(res, set);
1777     res->bits=DECNEG;                        /* negative */
1778     /* there is no status to set */
1779     return res;
1780     }
1781   decNumberZero(&dtiny);                     /* start with 0 */
1782   dtiny.lsu[0]=1;                            /* make number that is .. */
1783   dtiny.exponent=DEC_MIN_EMIN-1;             /* .. smaller than tiniest */
1784   workset.round=DEC_ROUND_CEILING;
1785   decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1786   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1787   if (status!=0) decStatus(res, status, set);
1788   return res;
1789   } /* decNumberNextPlus */
1790
1791 /* ------------------------------------------------------------------ */
1792 /* decNumberNextToward -- next towards rhs                            */
1793 /*                                                                    */
1794 /*   This computes C = A +/- infinitesimal, rounded towards           */
1795 /*   +/-Infinity in the direction of B, as per 754r nextafter rules   */
1796 /*                                                                    */
1797 /*   res is C, the result.  C may be A or B.                          */
1798 /*   lhs is A                                                         */
1799 /*   rhs is B                                                         */
1800 /*   set is the context                                               */
1801 /*                                                                    */
1802 /* This is a generalization of 754r NextAfter.                        */
1803 /* ------------------------------------------------------------------ */
1804 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1805                                 const decNumber *rhs, decContext *set) {
1806   decNumber dtiny;                           /* constant */
1807   decContext workset=*set;                   /* work */
1808   Int result;                                /* .. */
1809   uInt status=0;                             /* accumulator */
1810   #if DECCHECK
1811   if (decCheckOperands(res, lhs, rhs, set)) return res;
1812   #endif
1813
1814   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1815     decNaNs(res, lhs, rhs, set, &status);
1816     }
1817    else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1818     result=decCompare(lhs, rhs, 0);     /* sign matters */
1819     if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1820      else { /* valid compare */
1821       if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1822        else { /* differ: need NextPlus or NextMinus */
1823         uByte sub;                      /* add or subtract */
1824         if (result<0) {                 /* lhs<rhs, do nextplus */
1825           /* -Infinity is the special case */
1826           if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1827             decSetMaxValue(res, set);
1828             res->bits=DECNEG;           /* negative */
1829             return res;                 /* there is no status to set */
1830             }
1831           workset.round=DEC_ROUND_CEILING;
1832           sub=0;                        /* add, please */
1833           } /* plus */
1834          else {                         /* lhs>rhs, do nextminus */
1835           /* +Infinity is the special case */
1836           if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1837             decSetMaxValue(res, set);
1838             return res;                 /* there is no status to set */
1839             }
1840           workset.round=DEC_ROUND_FLOOR;
1841           sub=DECNEG;                   /* subtract, please */
1842           } /* minus */
1843         decNumberZero(&dtiny);          /* start with 0 */
1844         dtiny.lsu[0]=1;                 /* make number that is .. */
1845         dtiny.exponent=DEC_MIN_EMIN-1;  /* .. smaller than tiniest */
1846         decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1847         /* turn off exceptions if the result is a normal number */
1848         /* (including Nmin), otherwise let all status through */
1849         if (decNumberIsNormal(res, set)) status=0;
1850         } /* unequal */
1851       } /* compare OK */
1852     } /* numeric */
1853   if (status!=0) decStatus(res, status, set);
1854   return res;
1855   } /* decNumberNextToward */
1856
1857 /* ------------------------------------------------------------------ */
1858 /* decNumberOr -- OR two Numbers, digitwise                           */
1859 /*                                                                    */
1860 /*   This computes C = A | B                                          */
1861 /*                                                                    */
1862 /*   res is C, the result.  C may be A and/or B (e.g., X=X|X)         */
1863 /*   lhs is A                                                         */
1864 /*   rhs is B                                                         */
1865 /*   set is the context (used for result length and error report)     */
1866 /*                                                                    */
1867 /* C must have space for set->digits digits.                          */
1868 /*                                                                    */
1869 /* Logical function restrictions apply (see above); a NaN is          */
1870 /* returned with Invalid_operation if a restriction is violated.      */
1871 /* ------------------------------------------------------------------ */
1872 decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1873                         const decNumber *rhs, decContext *set) {
1874   const Unit *ua, *ub;                  /* -> operands */
1875   const Unit *msua, *msub;              /* -> operand msus */
1876   Unit  *uc, *msuc;                     /* -> result and its msu */
1877   Int   msudigs;                        /* digits in res msu */
1878   #if DECCHECK
1879   if (decCheckOperands(res, lhs, rhs, set)) return res;
1880   #endif
1881
1882   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1883    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1884     decStatus(res, DEC_Invalid_operation, set);
1885     return res;
1886     }
1887   /* operands are valid */
1888   ua=lhs->lsu;                          /* bottom-up */
1889   ub=rhs->lsu;                          /* .. */
1890   uc=res->lsu;                          /* .. */
1891   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
1892   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
1893   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
1894   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
1895   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
1896     Unit a, b;                          /* extract units */
1897     if (ua>msua) a=0;
1898      else a=*ua;
1899     if (ub>msub) b=0;
1900      else b=*ub;
1901     *uc=0;                              /* can now write back */
1902     if (a|b) {                          /* maybe 1 bits to examine */
1903       Int i, j;
1904       /* This loop could be unrolled and/or use BIN2BCD tables */
1905       for (i=0; i<DECDPUN; i++) {
1906         if ((a|b)&1) *uc=*uc+(Unit)powers[i];     /* effect OR */
1907         j=a%10;
1908         a=a/10;
1909         j|=b%10;
1910         b=b/10;
1911         if (j>1) {
1912           decStatus(res, DEC_Invalid_operation, set);
1913           return res;
1914           }
1915         if (uc==msuc && i==msudigs-1) break;      /* just did final digit */
1916         } /* each digit */
1917       } /* non-zero */
1918     } /* each unit */
1919   /* [here uc-1 is the msu of the result] */
1920   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1921   res->exponent=0;                      /* integer */
1922   res->bits=0;                          /* sign=0 */
1923   return res;  /* [no status to set] */
1924   } /* decNumberOr */
1925
1926 /* ------------------------------------------------------------------ */
1927 /* decNumberPlus -- prefix plus operator                              */
1928 /*                                                                    */
1929 /*   This computes C = 0 + A                                          */
1930 /*                                                                    */
1931 /*   res is C, the result.  C may be A                                */
1932 /*   rhs is A                                                         */
1933 /*   set is the context                                               */
1934 /*                                                                    */
1935 /* See also decNumberCopy for a quiet bitwise version of this.        */
1936 /* C must have space for set->digits digits.                          */
1937 /* ------------------------------------------------------------------ */
1938 /* This simply uses AddOp; Add will take fast path after preparing A. */
1939 /* Performance is a concern here, as this routine is often used to    */
1940 /* check operands and apply rounding and overflow/underflow testing.  */
1941 /* ------------------------------------------------------------------ */
1942 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
1943                           decContext *set) {
1944   decNumber dzero;
1945   uInt status=0;                        /* accumulator */
1946   #if DECCHECK
1947   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1948   #endif
1949
1950   decNumberZero(&dzero);                /* make 0 */
1951   dzero.exponent=rhs->exponent;         /* [no coefficient expansion] */
1952   decAddOp(res, &dzero, rhs, set, 0, &status);
1953   if (status!=0) decStatus(res, status, set);
1954   #if DECCHECK
1955   decCheckInexact(res, set);
1956   #endif
1957   return res;
1958   } /* decNumberPlus */
1959
1960 /* ------------------------------------------------------------------ */
1961 /* decNumberMultiply -- multiply two Numbers                          */
1962 /*                                                                    */
1963 /*   This computes C = A x B                                          */
1964 /*                                                                    */
1965 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
1966 /*   lhs is A                                                         */
1967 /*   rhs is B                                                         */
1968 /*   set is the context                                               */
1969 /*                                                                    */
1970 /* C must have space for set->digits digits.                          */
1971 /* ------------------------------------------------------------------ */
1972 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
1973                               const decNumber *rhs, decContext *set) {
1974   uInt status=0;                   /* accumulator */
1975   decMultiplyOp(res, lhs, rhs, set, &status);
1976   if (status!=0) decStatus(res, status, set);
1977   #if DECCHECK
1978   decCheckInexact(res, set);
1979   #endif
1980   return res;
1981   } /* decNumberMultiply */
1982
1983 /* ------------------------------------------------------------------ */
1984 /* decNumberPower -- raise a number to a power                        */
1985 /*                                                                    */
1986 /*   This computes C = A ** B                                         */
1987 /*                                                                    */
1988 /*   res is C, the result.  C may be A and/or B (e.g., X=X**X)        */
1989 /*   lhs is A                                                         */
1990 /*   rhs is B                                                         */
1991 /*   set is the context                                               */
1992 /*                                                                    */
1993 /* C must have space for set->digits digits.                          */
1994 /*                                                                    */
1995 /* Mathematical function restrictions apply (see above); a NaN is     */
1996 /* returned with Invalid_operation if a restriction is violated.      */
1997 /*                                                                    */
1998 /* However, if 1999999997<=B<=999999999 and B is an integer then the  */
1999 /* restrictions on A and the context are relaxed to the usual bounds, */
2000 /* for compatibility with the earlier (integer power only) version    */
2001 /* of this function.                                                  */
2002 /*                                                                    */
2003 /* When B is an integer, the result may be exact, even if rounded.    */
2004 /*                                                                    */
2005 /* The final result is rounded according to the context; it will      */
2006 /* almost always be correctly rounded, but may be up to 1 ulp in      */
2007 /* error in rare cases.                                               */
2008 /* ------------------------------------------------------------------ */
2009 decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
2010                            const decNumber *rhs, decContext *set) {
2011   #if DECSUBSET
2012   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
2013   decNumber *allocrhs=NULL;        /* .., rhs */
2014   #endif
2015   decNumber *allocdac=NULL;        /* -> allocated acc buffer, iff used */
2016   decNumber *allocinv=NULL;        /* -> allocated 1/x buffer, iff used */
2017   Int   reqdigits=set->digits;     /* requested DIGITS */
2018   Int   n;                         /* rhs in binary */
2019   Flag  rhsint=0;                  /* 1 if rhs is an integer */
2020   Flag  useint=0;                  /* 1 if can use integer calculation */
2021   Flag  isoddint=0;                /* 1 if rhs is an integer and odd */
2022   Int   i;                         /* work */
2023   #if DECSUBSET
2024   Int   dropped;                   /* .. */
2025   #endif
2026   uInt  needbytes;                 /* buffer size needed */
2027   Flag  seenbit;                   /* seen a bit while powering */
2028   Int   residue=0;                 /* rounding residue */
2029   uInt  status=0;                  /* accumulators */
2030   uByte bits=0;                    /* result sign if errors */
2031   decContext aset;                 /* working context */
2032   decNumber dnOne;                 /* work value 1... */
2033   /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
2034   decNumber dacbuff[D2N(DECBUFFER+9)];
2035   decNumber *dac=dacbuff;          /* -> result accumulator */
2036   /* same again for possible 1/lhs calculation */
2037   decNumber invbuff[D2N(DECBUFFER+9)];
2038
2039   #if DECCHECK
2040   if (decCheckOperands(res, lhs, rhs, set)) return res;
2041   #endif
2042
2043   do {                             /* protect allocated storage */
2044     #if DECSUBSET
2045     if (!set->extended) { /* reduce operands and set status, as needed */
2046       if (lhs->digits>reqdigits) {
2047         alloclhs=decRoundOperand(lhs, set, &status);
2048         if (alloclhs==NULL) break;
2049         lhs=alloclhs;
2050         }
2051       if (rhs->digits>reqdigits) {
2052         allocrhs=decRoundOperand(rhs, set, &status);
2053         if (allocrhs==NULL) break;
2054         rhs=allocrhs;
2055         }
2056       }
2057     #endif
2058     /* [following code does not require input rounding] */
2059
2060     /* handle NaNs and rhs Infinity (lhs infinity is harder) */
2061     if (SPECIALARGS) {
2062       if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
2063         decNaNs(res, lhs, rhs, set, &status);
2064         break;}
2065       if (decNumberIsInfinite(rhs)) {   /* rhs Infinity */
2066         Flag rhsneg=rhs->bits&DECNEG;   /* save rhs sign */
2067         if (decNumberIsNegative(lhs)    /* lhs<0 */
2068          && !decNumberIsZero(lhs))      /* .. */
2069           status|=DEC_Invalid_operation;
2070          else {                         /* lhs >=0 */
2071           decNumberZero(&dnOne);        /* set up 1 */
2072           dnOne.lsu[0]=1;
2073           decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
2074           decNumberZero(res);           /* prepare for 0/1/Infinity */
2075           if (decNumberIsNegative(dac)) {    /* lhs<1 */
2076             if (rhsneg) res->bits|=DECINF;   /* +Infinity [else is +0] */
2077             }
2078            else if (dac->lsu[0]==0) {        /* lhs=1 */
2079             /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2080             Int shift=set->digits-1;
2081             *res->lsu=1;                     /* was 0, make int 1 */
2082             res->digits=decShiftToMost(res->lsu, 1, shift);
2083             res->exponent=-shift;            /* make 1.0000... */
2084             status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2085             }
2086            else {                            /* lhs>1 */
2087             if (!rhsneg) res->bits|=DECINF;  /* +Infinity [else is +0] */
2088             }
2089           } /* lhs>=0 */
2090         break;}
2091       /* [lhs infinity drops through] */
2092       } /* specials */
2093
2094     /* Original rhs may be an integer that fits and is in range */
2095     n=decGetInt(rhs);
2096     if (n!=BADINT) {                    /* it is an integer */
2097       rhsint=1;                         /* record the fact for 1**n */
2098       isoddint=(Flag)n&1;               /* [works even if big] */
2099       if (n!=BIGEVEN && n!=BIGODD)      /* can use integer path? */
2100         useint=1;                       /* looks good */
2101       }
2102
2103     if (decNumberIsNegative(lhs)        /* -x .. */
2104       && isoddint) bits=DECNEG;         /* .. to an odd power */
2105
2106     /* handle LHS infinity */
2107     if (decNumberIsInfinite(lhs)) {     /* [NaNs already handled] */
2108       uByte rbits=rhs->bits;            /* save */
2109       decNumberZero(res);               /* prepare */
2110       if (n==0) *res->lsu=1;            /* [-]Inf**0 => 1 */
2111        else {
2112         /* -Inf**nonint -> error */
2113         if (!rhsint && decNumberIsNegative(lhs)) {
2114           status|=DEC_Invalid_operation;     /* -Inf**nonint is error */
2115           break;}
2116         if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2117         /* [otherwise will be 0 or -0] */
2118         res->bits=bits;
2119         }
2120       break;}
2121
2122     /* similarly handle LHS zero */
2123     if (decNumberIsZero(lhs)) {
2124       if (n==0) {                            /* 0**0 => Error */
2125         #if DECSUBSET
2126         if (!set->extended) {                /* [unless subset] */
2127           decNumberZero(res);
2128           *res->lsu=1;                       /* return 1 */
2129           break;}
2130         #endif
2131         status|=DEC_Invalid_operation;
2132         }
2133        else {                                /* 0**x */
2134         uByte rbits=rhs->bits;               /* save */
2135         if (rbits & DECNEG) {                /* was a 0**(-n) */
2136           #if DECSUBSET
2137           if (!set->extended) {              /* [bad if subset] */
2138             status|=DEC_Invalid_operation;
2139             break;}
2140           #endif
2141           bits|=DECINF;
2142           }
2143         decNumberZero(res);                  /* prepare */
2144         /* [otherwise will be 0 or -0] */
2145         res->bits=bits;
2146         }
2147       break;}
2148
2149     /* here both lhs and rhs are finite; rhs==0 is handled in the */
2150     /* integer path.  Next handle the non-integer cases */
2151     if (!useint) {                      /* non-integral rhs */
2152       /* any -ve lhs is bad, as is either operand or context out of */
2153       /* bounds */
2154       if (decNumberIsNegative(lhs)) {
2155         status|=DEC_Invalid_operation;
2156         break;}
2157       if (decCheckMath(lhs, set, &status)
2158        || decCheckMath(rhs, set, &status)) break; /* variable status */
2159
2160       decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2161       aset.emax=DEC_MAX_MATH;           /* usual bounds */
2162       aset.emin=-DEC_MAX_MATH;          /* .. */
2163       aset.clamp=0;                     /* and no concrete format */
2164
2165       /* calculate the result using exp(ln(lhs)*rhs), which can */
2166       /* all be done into the accumulator, dac.  The precision needed */
2167       /* is enough to contain the full information in the lhs (which */
2168       /* is the total digits, including exponent), or the requested */
2169       /* precision, if larger, + 4; 6 is used for the exponent */
2170       /* maximum length, and this is also used when it is shorter */
2171       /* than the requested digits as it greatly reduces the >0.5 ulp */
2172       /* cases at little cost (because Ln doubles digits each */
2173       /* iteration so a few extra digits rarely causes an extra */
2174       /* iteration) */
2175       aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2176       } /* non-integer rhs */
2177
2178      else { /* rhs is in-range integer */
2179       if (n==0) {                       /* x**0 = 1 */
2180         /* (0**0 was handled above) */
2181         decNumberZero(res);             /* result=1 */
2182         *res->lsu=1;                    /* .. */
2183         break;}
2184       /* rhs is a non-zero integer */
2185       if (n<0) n=-n;                    /* use abs(n) */
2186
2187       aset=*set;                        /* clone the context */
2188       aset.round=DEC_ROUND_HALF_EVEN;   /* internally use balanced */
2189       /* calculate the working DIGITS */
2190       aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2191       #if DECSUBSET
2192       if (!set->extended) aset.digits--;     /* use classic precision */
2193       #endif
2194       /* it's an error if this is more than can be handled */
2195       if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2196       } /* integer path */
2197
2198     /* aset.digits is the count of digits for the accumulator needed */
2199     /* if accumulator is too long for local storage, then allocate */
2200     needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2201     /* [needbytes also used below if 1/lhs needed] */
2202     if (needbytes>sizeof(dacbuff)) {
2203       allocdac=(decNumber *)malloc(needbytes);
2204       if (allocdac==NULL) {   /* hopeless -- abandon */
2205         status|=DEC_Insufficient_storage;
2206         break;}
2207       dac=allocdac;           /* use the allocated space */
2208       }
2209     /* here, aset is set up and accumulator is ready for use */
2210
2211     if (!useint) {                           /* non-integral rhs */
2212       /* x ** y; special-case x=1 here as it will otherwise always */
2213       /* reduce to integer 1; decLnOp has a fastpath which detects */
2214       /* the case of x=1 */
2215       decLnOp(dac, lhs, &aset, &status);     /* dac=ln(lhs) */
2216       /* [no error possible, as lhs 0 already handled] */
2217       if (ISZERO(dac)) {                     /* x==1, 1.0, etc. */
2218         /* need to return fully-padded 1.0000 etc., but rhsint->1 */
2219         *dac->lsu=1;                         /* was 0, make int 1 */
2220         if (!rhsint) {                       /* add padding */
2221           Int shift=set->digits-1;
2222           dac->digits=decShiftToMost(dac->lsu, 1, shift);
2223           dac->exponent=-shift;              /* make 1.0000... */
2224           status|=DEC_Inexact|DEC_Rounded;   /* deemed inexact */
2225           }
2226         }
2227        else {
2228         decMultiplyOp(dac, dac, rhs, &aset, &status);  /* dac=dac*rhs */
2229         decExpOp(dac, dac, &aset, &status);            /* dac=exp(dac) */
2230         }
2231       /* and drop through for final rounding */
2232       } /* non-integer rhs */
2233
2234      else {                             /* carry on with integer */
2235       decNumberZero(dac);               /* acc=1 */
2236       *dac->lsu=1;                      /* .. */
2237
2238       /* if a negative power the constant 1 is needed, and if not subset */
2239       /* invert the lhs now rather than inverting the result later */
2240       if (decNumberIsNegative(rhs)) {   /* was a **-n [hence digits>0] */
2241         decNumber *inv=invbuff;         /* assume use fixed buffer */
2242         decNumberCopy(&dnOne, dac);     /* dnOne=1;  [needed now or later] */
2243         #if DECSUBSET
2244         if (set->extended) {            /* need to calculate 1/lhs */
2245         #endif
2246           /* divide lhs into 1, putting result in dac [dac=1/dac] */
2247           decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2248           /* now locate or allocate space for the inverted lhs */
2249           if (needbytes>sizeof(invbuff)) {
2250             allocinv=(decNumber *)malloc(needbytes);
2251             if (allocinv==NULL) {       /* hopeless -- abandon */
2252               status|=DEC_Insufficient_storage;
2253               break;}
2254             inv=allocinv;               /* use the allocated space */
2255             }
2256           /* [inv now points to big-enough buffer or allocated storage] */
2257           decNumberCopy(inv, dac);      /* copy the 1/lhs */
2258           decNumberCopy(dac, &dnOne);   /* restore acc=1 */
2259           lhs=inv;                      /* .. and go forward with new lhs */
2260         #if DECSUBSET
2261           }
2262         #endif
2263         }
2264
2265       /* Raise-to-the-power loop... */
2266       seenbit=0;                   /* set once a 1-bit is encountered */
2267       for (i=1;;i++){              /* for each bit [top bit ignored] */
2268         /* abandon if had overflow or terminal underflow */
2269         if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2270           if (status&DEC_Overflow || ISZERO(dac)) break;
2271           }
2272         /* [the following two lines revealed an optimizer bug in a C++ */
2273         /* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2274         n=n<<1;                    /* move next bit to testable position */
2275         if (n<0) {                 /* top bit is set */
2276           seenbit=1;               /* OK, significant bit seen */
2277           decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2278           }
2279         if (i==31) break;          /* that was the last bit */
2280         if (!seenbit) continue;    /* no need to square 1 */
2281         decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2282         } /*i*/ /* 32 bits */
2283
2284       /* complete internal overflow or underflow processing */
2285       if (status & (DEC_Overflow|DEC_Underflow)) {
2286         #if DECSUBSET
2287         /* If subset, and power was negative, reverse the kind of -erflow */
2288         /* [1/x not yet done] */
2289         if (!set->extended && decNumberIsNegative(rhs)) {
2290           if (status & DEC_Overflow)
2291             status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2292            else { /* trickier -- Underflow may or may not be set */
2293             status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2294             status|=DEC_Overflow;
2295             }
2296           }
2297         #endif
2298         dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2299         /* round subnormals [to set.digits rather than aset.digits] */
2300         /* or set overflow result similarly as required */
2301         decFinalize(dac, set, &residue, &status);
2302         decNumberCopy(res, dac);   /* copy to result (is now OK length) */
2303         break;
2304         }
2305
2306       #if DECSUBSET
2307       if (!set->extended &&                  /* subset math */
2308           decNumberIsNegative(rhs)) {        /* was a **-n [hence digits>0] */
2309         /* so divide result into 1 [dac=1/dac] */
2310         decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2311         }
2312       #endif
2313       } /* rhs integer path */
2314
2315     /* reduce result to the requested length and copy to result */
2316     decCopyFit(res, dac, set, &residue, &status);
2317     decFinish(res, set, &residue, &status);  /* final cleanup */
2318     #if DECSUBSET
2319     if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */
2320     #endif
2321     } while(0);                         /* end protected */
2322
2323   if (allocdac!=NULL) free(allocdac);   /* drop any storage used */
2324   if (allocinv!=NULL) free(allocinv);   /* .. */
2325   #if DECSUBSET
2326   if (alloclhs!=NULL) free(alloclhs);   /* .. */
2327   if (allocrhs!=NULL) free(allocrhs);   /* .. */
2328   #endif
2329   if (status!=0) decStatus(res, status, set);
2330   #if DECCHECK
2331   decCheckInexact(res, set);
2332   #endif
2333   return res;
2334   } /* decNumberPower */
2335
2336 /* ------------------------------------------------------------------ */
2337 /* decNumberQuantize -- force exponent to requested value             */
2338 /*                                                                    */
2339 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2340 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2341 /*   of C has exponent of B.  The numerical value of C will equal A,  */
2342 /*   except for the effects of any rounding that occurred.            */
2343 /*                                                                    */
2344 /*   res is C, the result.  C may be A or B                           */
2345 /*   lhs is A, the number to adjust                                   */
2346 /*   rhs is B, the number with exponent to match                      */
2347 /*   set is the context                                               */
2348 /*                                                                    */
2349 /* C must have space for set->digits digits.                          */
2350 /*                                                                    */
2351 /* Unless there is an error or the result is infinite, the exponent   */
2352 /* after the operation is guaranteed to be equal to that of B.        */
2353 /* ------------------------------------------------------------------ */
2354 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2355                               const decNumber *rhs, decContext *set) {
2356   uInt status=0;                        /* accumulator */
2357   decQuantizeOp(res, lhs, rhs, set, 1, &status);
2358   if (status!=0) decStatus(res, status, set);
2359   return res;
2360   } /* decNumberQuantize */
2361
2362 /* ------------------------------------------------------------------ */
2363 /* decNumberReduce -- remove trailing zeros                           */
2364 /*                                                                    */
2365 /*   This computes C = 0 + A, and normalizes the result               */
2366 /*                                                                    */
2367 /*   res is C, the result.  C may be A                                */
2368 /*   rhs is A                                                         */
2369 /*   set is the context                                               */
2370 /*                                                                    */
2371 /* C must have space for set->digits digits.                          */
2372 /* ------------------------------------------------------------------ */
2373 /* Previously known as Normalize */
2374 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2375                                decContext *set) {
2376   return decNumberReduce(res, rhs, set);
2377   } /* decNumberNormalize */
2378
2379 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2380                             decContext *set) {
2381   #if DECSUBSET
2382   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
2383   #endif
2384   uInt status=0;                   /* as usual */
2385   Int  residue=0;                  /* as usual */
2386   Int  dropped;                    /* work */
2387
2388   #if DECCHECK
2389   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2390   #endif
2391
2392   do {                             /* protect allocated storage */
2393     #if DECSUBSET
2394     if (!set->extended) {
2395       /* reduce operand and set lostDigits status, as needed */
2396       if (rhs->digits>set->digits) {
2397         allocrhs=decRoundOperand(rhs, set, &status);
2398         if (allocrhs==NULL) break;
2399         rhs=allocrhs;
2400         }
2401       }
2402     #endif
2403     /* [following code does not require input rounding] */
2404
2405     /* Infinities copy through; NaNs need usual treatment */
2406     if (decNumberIsNaN(rhs)) {
2407       decNaNs(res, rhs, NULL, set, &status);
2408       break;
2409       }
2410
2411     /* reduce result to the requested length and copy to result */
2412     decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2413     decFinish(res, set, &residue, &status);       /* cleanup/set flags */
2414     decTrim(res, set, 1, &dropped);               /* normalize in place */
2415     } while(0);                              /* end protected */
2416
2417   #if DECSUBSET
2418   if (allocrhs !=NULL) free(allocrhs);       /* .. */
2419   #endif
2420   if (status!=0) decStatus(res, status, set);/* then report status */
2421   return res;
2422   } /* decNumberReduce */
2423
2424 /* ------------------------------------------------------------------ */
2425 /* decNumberRescale -- force exponent to requested value              */
2426 /*                                                                    */
2427 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2428 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2429 /*   of C has the value B.  The numerical value of C will equal A,    */
2430 /*   except for the effects of any rounding that occurred.            */
2431 /*                                                                    */
2432 /*   res is C, the result.  C may be A or B                           */
2433 /*   lhs is A, the number to adjust                                   */
2434 /*   rhs is B, the requested exponent                                 */
2435 /*   set is the context                                               */
2436 /*                                                                    */
2437 /* C must have space for set->digits digits.                          */
2438 /*                                                                    */
2439 /* Unless there is an error or the result is infinite, the exponent   */
2440 /* after the operation is guaranteed to be equal to B.                */
2441 /* ------------------------------------------------------------------ */
2442 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2443                              const decNumber *rhs, decContext *set) {
2444   uInt status=0;                        /* accumulator */
2445   decQuantizeOp(res, lhs, rhs, set, 0, &status);
2446   if (status!=0) decStatus(res, status, set);
2447   return res;
2448   } /* decNumberRescale */
2449
2450 /* ------------------------------------------------------------------ */
2451 /* decNumberRemainder -- divide and return remainder                  */
2452 /*                                                                    */
2453 /*   This computes C = A % B                                          */
2454 /*                                                                    */
2455 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
2456 /*   lhs is A                                                         */
2457 /*   rhs is B                                                         */
2458 /*   set is the context                                               */
2459 /*                                                                    */
2460 /* C must have space for set->digits digits.                          */
2461 /* ------------------------------------------------------------------ */
2462 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2463                                const decNumber *rhs, decContext *set) {
2464   uInt status=0;                        /* accumulator */
2465   decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2466   if (status!=0) decStatus(res, status, set);
2467   #if DECCHECK
2468   decCheckInexact(res, set);
2469   #endif
2470   return res;
2471   } /* decNumberRemainder */
2472
2473 /* ------------------------------------------------------------------ */
2474 /* decNumberRemainderNear -- divide and return remainder from nearest */
2475 /*                                                                    */
2476 /*   This computes C = A % B, where % is the IEEE remainder operator  */
2477 /*                                                                    */
2478 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
2479 /*   lhs is A                                                         */
2480 /*   rhs is B                                                         */
2481 /*   set is the context                                               */
2482 /*                                                                    */
2483 /* C must have space for set->digits digits.                          */
2484 /* ------------------------------------------------------------------ */
2485 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2486                                    const decNumber *rhs, decContext *set) {
2487   uInt status=0;                        /* accumulator */
2488   decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2489   if (status!=0) decStatus(res, status, set);
2490   #if DECCHECK
2491   decCheckInexact(res, set);
2492   #endif
2493   return res;
2494   } /* decNumberRemainderNear */
2495
2496 /* ------------------------------------------------------------------ */
2497 /* decNumberRotate -- rotate the coefficient of a Number left/right   */
2498 /*                                                                    */
2499 /*   This computes C = A rot B  (in base ten and rotating set->digits */
2500 /*   digits).                                                         */
2501 /*                                                                    */
2502 /*   res is C, the result.  C may be A and/or B (e.g., X=XrotX)       */
2503 /*   lhs is A                                                         */
2504 /*   rhs is B, the number of digits to rotate (-ve to right)          */
2505 /*   set is the context                                               */
2506 /*                                                                    */
2507 /* The digits of the coefficient of A are rotated to the left (if B   */
2508 /* is positive) or to the right (if B is negative) without adjusting  */
2509 /* the exponent or the sign of A.  If lhs->digits is less than        */
2510 /* set->digits the coefficient is padded with zeros on the left       */
2511 /* before the rotate.  Any leading zeros in the result are removed    */
2512 /* as usual.                                                          */
2513 /*                                                                    */
2514 /* B must be an integer (q=0) and in the range -set->digits through   */
2515 /* +set->digits.                                                      */
2516 /* C must have space for set->digits digits.                          */
2517 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2518 /* B must be valid).  No status is set unless B is invalid or an      */
2519 /* operand is an sNaN.                                                */
2520 /* ------------------------------------------------------------------ */
2521 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2522                            const decNumber *rhs, decContext *set) {
2523   uInt status=0;              /* accumulator */
2524   Int  rotate;                /* rhs as an Int */
2525
2526   #if DECCHECK
2527   if (decCheckOperands(res, lhs, rhs, set)) return res;
2528   #endif
2529
2530   /* NaNs propagate as normal */
2531   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2532     decNaNs(res, lhs, rhs, set, &status);
2533    /* rhs must be an integer */
2534    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2535     status=DEC_Invalid_operation;
2536    else { /* both numeric, rhs is an integer */
2537     rotate=decGetInt(rhs);                   /* [cannot fail] */
2538     if (rotate==BADINT                       /* something bad .. */
2539      || rotate==BIGODD || rotate==BIGEVEN    /* .. very big .. */
2540      || abs(rotate)>set->digits)             /* .. or out of range */
2541       status=DEC_Invalid_operation;
2542      else {                                  /* rhs is OK */
2543       decNumberCopy(res, lhs);
2544       /* convert -ve rotate to equivalent positive rotation */
2545       if (rotate<0) rotate=set->digits+rotate;
2546       if (rotate!=0 && rotate!=set->digits   /* zero or full rotation */
2547        && !decNumberIsInfinite(res)) {       /* lhs was infinite */
2548         /* left-rotate to do; 0 < rotate < set->digits */
2549         uInt units, shift;                   /* work */
2550         uInt msudigits;                      /* digits in result msu */
2551         Unit *msu=res->lsu+D2U(res->digits)-1;    /* current msu */
2552         Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2553         for (msu++; msu<=msumax; msu++) *msu=0;   /* ensure high units=0 */
2554         res->digits=set->digits;                  /* now full-length */
2555         msudigits=MSUDIGITS(res->digits);         /* actual digits in msu */
2556
2557         /* rotation here is done in-place, in three steps */
2558         /* 1. shift all to least up to one unit to unit-align final */
2559         /*    lsd [any digits shifted out are rotated to the left, */
2560         /*    abutted to the original msd (which may require split)] */
2561         /* */
2562         /*    [if there are no whole units left to rotate, the */
2563         /*    rotation is now complete] */
2564         /* */
2565         /* 2. shift to least, from below the split point only, so that */
2566         /*    the final msd is in the right place in its Unit [any */
2567         /*    digits shifted out will fit exactly in the current msu, */
2568         /*    left aligned, no split required] */
2569         /* */
2570         /* 3. rotate all the units by reversing left part, right */
2571         /*    part, and then whole */
2572         /* */
2573         /* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2574         /* */
2575         /*   start: 00a bcd efg hij klm npq */
2576         /* */
2577         /*      1a  000 0ab cde fgh|ijk lmn [pq saved] */
2578         /*      1b  00p qab cde fgh|ijk lmn */
2579         /* */
2580         /*      2a  00p qab cde fgh|00i jkl [mn saved] */
2581         /*      2b  mnp qab cde fgh|00i jkl */
2582         /* */
2583         /*      3a  fgh cde qab mnp|00i jkl */
2584         /*      3b  fgh cde qab mnp|jkl 00i */
2585         /*      3c  00i jkl mnp qab cde fgh */
2586
2587         /* Step 1: amount to shift is the partial right-rotate count */
2588         rotate=set->digits-rotate;      /* make it right-rotate */
2589         units=rotate/DECDPUN;           /* whole units to rotate */
2590         shift=rotate%DECDPUN;           /* left-over digits count */
2591         if (shift>0) {                  /* not an exact number of units */
2592           uInt save=res->lsu[0]%powers[shift];    /* save low digit(s) */
2593           decShiftToLeast(res->lsu, D2U(res->digits), shift);
2594           if (shift>msudigits) {        /* msumax-1 needs >0 digits */
2595             uInt rem=save%powers[shift-msudigits];/* split save */
2596             *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2597             *(msumax-1)=*(msumax-1)
2598                        +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2599             }
2600            else { /* all fits in msumax */
2601             *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2602             }
2603           } /* digits shift needed */
2604
2605         /* If whole units to rotate... */
2606         if (units>0) {                  /* some to do */
2607           /* Step 2: the units to touch are the whole ones in rotate, */
2608           /*   if any, and the shift is DECDPUN-msudigits (which may be */
2609           /*   0, again) */
2610           shift=DECDPUN-msudigits;
2611           if (shift>0) {                /* not an exact number of units */
2612             uInt save=res->lsu[0]%powers[shift];  /* save low digit(s) */
2613             decShiftToLeast(res->lsu, units, shift);
2614             *msumax=*msumax+(Unit)(save*powers[msudigits]);
2615             } /* partial shift needed */
2616
2617           /* Step 3: rotate the units array using triple reverse */
2618           /* (reversing is easy and fast) */
2619           decReverse(res->lsu+units, msumax);     /* left part */
2620           decReverse(res->lsu, res->lsu+units-1); /* right part */
2621           decReverse(res->lsu, msumax);           /* whole */
2622           } /* whole units to rotate */
2623         /* the rotation may have left an undetermined number of zeros */
2624         /* on the left, so true length needs to be calculated */
2625         res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2626         } /* rotate needed */
2627       } /* rhs OK */
2628     } /* numerics */
2629   if (status!=0) decStatus(res, status, set);
2630   return res;
2631   } /* decNumberRotate */
2632
2633 /* ------------------------------------------------------------------ */
2634 /* decNumberSameQuantum -- test for equal exponents                   */
2635 /*                                                                    */
2636 /*   res is the result number, which will contain either 0 or 1       */
2637 /*   lhs is a number to test                                          */
2638 /*   rhs is the second (usually a pattern)                            */
2639 /*                                                                    */
2640 /* No errors are possible and no context is needed.                   */
2641 /* ------------------------------------------------------------------ */
2642 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2643                                  const decNumber *rhs) {
2644   Unit ret=0;                      /* return value */
2645
2646   #if DECCHECK
2647   if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2648   #endif
2649
2650   if (SPECIALARGS) {
2651     if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2652      else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2653      /* [anything else with a special gives 0] */
2654     }
2655    else if (lhs->exponent==rhs->exponent) ret=1;
2656
2657   decNumberZero(res);              /* OK to overwrite an operand now */
2658   *res->lsu=ret;
2659   return res;
2660   } /* decNumberSameQuantum */
2661
2662 /* ------------------------------------------------------------------ */
2663 /* decNumberScaleB -- multiply by a power of 10                       */
2664 /*                                                                    */
2665 /* This computes C = A x 10**B where B is an integer (q=0) with       */
2666 /* maximum magnitude 2*(emax+digits)                                  */
2667 /*                                                                    */
2668 /*   res is C, the result.  C may be A or B                           */
2669 /*   lhs is A, the number to adjust                                   */
2670 /*   rhs is B, the requested power of ten to use                      */
2671 /*   set is the context                                               */
2672 /*                                                                    */
2673 /* C must have space for set->digits digits.                          */
2674 /*                                                                    */
2675 /* The result may underflow or overflow.                              */
2676 /* ------------------------------------------------------------------ */
2677 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2678                             const decNumber *rhs, decContext *set) {
2679   Int  reqexp;                /* requested exponent change [B] */
2680   uInt status=0;              /* accumulator */
2681   Int  residue;               /* work */
2682
2683   #if DECCHECK
2684   if (decCheckOperands(res, lhs, rhs, set)) return res;
2685   #endif
2686
2687   /* Handle special values except lhs infinite */
2688   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2689     decNaNs(res, lhs, rhs, set, &status);
2690     /* rhs must be an integer */
2691    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2692     status=DEC_Invalid_operation;
2693    else {
2694     /* lhs is a number; rhs is a finite with q==0 */
2695     reqexp=decGetInt(rhs);                   /* [cannot fail] */
2696     if (reqexp==BADINT                       /* something bad .. */
2697      || reqexp==BIGODD || reqexp==BIGEVEN    /* .. very big .. */
2698      || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2699       status=DEC_Invalid_operation;
2700      else {                                  /* rhs is OK */
2701       decNumberCopy(res, lhs);               /* all done if infinite lhs */
2702       if (!decNumberIsInfinite(res)) {       /* prepare to scale */
2703         res->exponent+=reqexp;               /* adjust the exponent */
2704         residue=0;
2705         decFinalize(res, set, &residue, &status); /* .. and check */
2706         } /* finite LHS */
2707       } /* rhs OK */
2708     } /* rhs finite */
2709   if (status!=0) decStatus(res, status, set);
2710   return res;
2711   } /* decNumberScaleB */
2712
2713 /* ------------------------------------------------------------------ */
2714 /* decNumberShift -- shift the coefficient of a Number left or right  */
2715 /*                                                                    */
2716 /*   This computes C = A << B or C = A >> -B  (in base ten).          */
2717 /*                                                                    */
2718 /*   res is C, the result.  C may be A and/or B (e.g., X=X<<X)        */
2719 /*   lhs is A                                                         */
2720 /*   rhs is B, the number of digits to shift (-ve to right)           */
2721 /*   set is the context                                               */
2722 /*                                                                    */
2723 /* The digits of the coefficient of A are shifted to the left (if B   */
2724 /* is positive) or to the right (if B is negative) without adjusting  */
2725 /* the exponent or the sign of A.                                     */
2726 /*                                                                    */
2727 /* B must be an integer (q=0) and in the range -set->digits through   */
2728 /* +set->digits.                                                      */
2729 /* C must have space for set->digits digits.                          */
2730 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2731 /* B must be valid).  No status is set unless B is invalid or an      */
2732 /* operand is an sNaN.                                                */
2733 /* ------------------------------------------------------------------ */
2734 decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2735                            const decNumber *rhs, decContext *set) {
2736   uInt status=0;              /* accumulator */
2737   Int  shift;                 /* rhs as an Int */
2738
2739   #if DECCHECK
2740   if (decCheckOperands(res, lhs, rhs, set)) return res;
2741   #endif
2742
2743   /* NaNs propagate as normal */
2744   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2745     decNaNs(res, lhs, rhs, set, &status);
2746    /* rhs must be an integer */
2747    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2748     status=DEC_Invalid_operation;
2749    else { /* both numeric, rhs is an integer */
2750     shift=decGetInt(rhs);                    /* [cannot fail] */
2751     if (shift==BADINT                        /* something bad .. */
2752      || shift==BIGODD || shift==BIGEVEN      /* .. very big .. */
2753      || abs(shift)>set->digits)              /* .. or out of range */
2754       status=DEC_Invalid_operation;
2755      else {                                  /* rhs is OK */
2756       decNumberCopy(res, lhs);
2757       if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2758         if (shift>0) {                       /* to left */
2759           if (shift==set->digits) {          /* removing all */
2760             *res->lsu=0;                     /* so place 0 */
2761             res->digits=1;                   /* .. */
2762             }
2763            else {                            /* */
2764             /* first remove leading digits if necessary */
2765             if (res->digits+shift>set->digits) {
2766               decDecap(res, res->digits+shift-set->digits);
2767               /* that updated res->digits; may have gone to 1 (for a */
2768               /* single digit or for zero */
2769               }
2770             if (res->digits>1 || *res->lsu)  /* if non-zero.. */
2771               res->digits=decShiftToMost(res->lsu, res->digits, shift);
2772             } /* partial left */
2773           } /* left */
2774          else { /* to right */
2775           if (-shift>=res->digits) {         /* discarding all */
2776             *res->lsu=0;                     /* so place 0 */
2777             res->digits=1;                   /* .. */
2778             }
2779            else {
2780             decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2781             res->digits-=(-shift);
2782             }
2783           } /* to right */
2784         } /* non-0 non-Inf shift */
2785       } /* rhs OK */
2786     } /* numerics */
2787   if (status!=0) decStatus(res, status, set);
2788   return res;
2789   } /* decNumberShift */
2790
2791 /* ------------------------------------------------------------------ */
2792 /* decNumberSquareRoot -- square root operator                        */
2793 /*                                                                    */
2794 /*   This computes C = squareroot(A)                                  */
2795 /*                                                                    */
2796 /*   res is C, the result.  C may be A                                */
2797 /*   rhs is A                                                         */
2798 /*   set is the context; note that rounding mode has no effect        */
2799 /*                                                                    */
2800 /* C must have space for set->digits digits.                          */
2801 /* ------------------------------------------------------------------ */
2802 /* This uses the following varying-precision algorithm in:            */
2803 /*                                                                    */
2804 /*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
2805 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2806 /*   pp229-237, ACM, September 1985.                                  */
2807 /*                                                                    */
2808 /* The square-root is calculated using Newton's method, after which   */
2809 /* a check is made to ensure the result is correctly rounded.         */
2810 /*                                                                    */
2811 /* % [Reformatted original Numerical Turing source code follows.]     */
2812 /* function sqrt(x : real) : real                                     */
2813 /* % sqrt(x) returns the properly rounded approximation to the square */
2814 /* % root of x, in the precision of the calling environment, or it    */
2815 /* % fails if x < 0.                                                  */
2816 /* % t e hull and a abrham, august, 1984                              */
2817 /* if x <= 0 then                                                     */
2818 /*   if x < 0 then                                                    */
2819 /*     assert false                                                   */
2820 /*   else                                                             */
2821 /*     result 0                                                       */
2822 /*   end if                                                           */
2823 /* end if                                                             */
2824 /* var f := setexp(x, 0)  % fraction part of x   [0.1 <= x < 1]       */
2825 /* var e := getexp(x)     % exponent part of x                        */
2826 /* var approx : real                                                  */
2827 /* if e mod 2 = 0  then                                               */
2828 /*   approx := .259 + .819 * f   % approx to root of f                */
2829 /* else                                                               */
2830 /*   f := f/l0                   % adjustments                        */
2831 /*   e := e + 1                  %   for odd                          */
2832 /*   approx := .0819 + 2.59 * f  %   exponent                         */
2833 /* end if                                                             */
2834 /*                                                                    */
2835 /* var p:= 3                                                          */
2836 /* const maxp := currentprecision + 2                                 */
2837 /* loop                                                               */
2838 /*   p := min(2*p - 2, maxp)     % p = 4,6,10, . . . , maxp           */
2839 /*   precision p                                                      */
2840 /*   approx := .5 * (approx + f/approx)                               */
2841 /*   exit when p = maxp                                               */
2842 /* end loop                                                           */
2843 /*                                                                    */
2844 /* % approx is now within 1 ulp of the properly rounded square root   */
2845 /* % of f; to ensure proper rounding, compare squares of (approx -    */
2846 /* % l/2 ulp) and (approx + l/2 ulp) with f.                          */
2847 /* p := currentprecision                                              */
2848 /* begin                                                              */
2849 /*   precision p + 2                                                  */
2850 /*   const approxsubhalf := approx - setexp(.5, -p)                   */
2851 /*   if mulru(approxsubhalf, approxsubhalf) > f then                  */
2852 /*     approx := approx - setexp(.l, -p + 1)                          */
2853 /*   else                                                             */
2854 /*     const approxaddhalf := approx + setexp(.5, -p)                 */
2855 /*     if mulrd(approxaddhalf, approxaddhalf) < f then                */
2856 /*       approx := approx + setexp(.l, -p + 1)                        */
2857 /*     end if                                                         */
2858 /*   end if                                                           */
2859 /* end                                                                */
2860 /* result setexp(approx, e div 2)  % fix exponent                     */
2861 /* end sqrt                                                           */
2862 /* ------------------------------------------------------------------ */
2863 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2864                                 decContext *set) {
2865   decContext workset, approxset;   /* work contexts */
2866   decNumber dzero;                 /* used for constant zero */
2867   Int  maxp;                       /* largest working precision */
2868   Int  workp;                      /* working precision */
2869   Int  residue=0;                  /* rounding residue */
2870   uInt status=0, ignore=0;         /* status accumulators */
2871   uInt rstatus;                    /* .. */
2872   Int  exp;                        /* working exponent */
2873   Int  ideal;                      /* ideal (preferred) exponent */
2874   Int  needbytes;                  /* work */
2875   Int  dropped;                    /* .. */
2876
2877   #if DECSUBSET
2878   decNumber *allocrhs=NULL;        /* non-NULL if rounded rhs allocated */
2879   #endif
2880   /* buffer for f [needs +1 in case DECBUFFER 0] */
2881   decNumber buff[D2N(DECBUFFER+1)];
2882   /* buffer for a [needs +2 to match likely maxp] */
2883   decNumber bufa[D2N(DECBUFFER+2)];
2884   /* buffer for temporary, b [must be same size as a] */
2885   decNumber bufb[D2N(DECBUFFER+2)];
2886   decNumber *allocbuff=NULL;       /* -> allocated buff, iff allocated */
2887   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
2888   decNumber *allocbufb=NULL;       /* -> allocated bufb, iff allocated */
2889   decNumber *f=buff;               /* reduced fraction */
2890   decNumber *a=bufa;               /* approximation to result */
2891   decNumber *b=bufb;               /* intermediate result */
2892   /* buffer for temporary variable, up to 3 digits */
2893   decNumber buft[D2N(3)];
2894   decNumber *t=buft;               /* up-to-3-digit constant or work */
2895
2896   #if DECCHECK
2897   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2898   #endif
2899
2900   do {                             /* protect allocated storage */
2901     #if DECSUBSET
2902     if (!set->extended) {
2903       /* reduce operand and set lostDigits status, as needed */
2904       if (rhs->digits>set->digits) {
2905         allocrhs=decRoundOperand(rhs, set, &status);
2906         if (allocrhs==NULL) break;
2907         /* [Note: 'f' allocation below could reuse this buffer if */
2908         /* used, but as this is rare they are kept separate for clarity.] */
2909         rhs=allocrhs;
2910         }
2911       }
2912     #endif
2913     /* [following code does not require input rounding] */
2914
2915     /* handle infinities and NaNs */
2916     if (SPECIALARG) {
2917       if (decNumberIsInfinite(rhs)) {         /* an infinity */
2918         if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
2919          else decNumberCopy(res, rhs);        /* +Infinity */
2920         }
2921        else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
2922       break;
2923       }
2924
2925     /* calculate the ideal (preferred) exponent [floor(exp/2)] */
2926     /* [We would like to write: ideal=rhs->exponent>>1, but this */
2927     /* generates a compiler warning.  Generated code is the same.] */
2928     ideal=(rhs->exponent&~1)/2;         /* target */
2929
2930     /* handle zeros */
2931     if (ISZERO(rhs)) {
2932       decNumberCopy(res, rhs);          /* could be 0 or -0 */
2933       res->exponent=ideal;              /* use the ideal [safe] */
2934       /* use decFinish to clamp any out-of-range exponent, etc. */
2935       decFinish(res, set, &residue, &status);
2936       break;
2937       }
2938
2939     /* any other -x is an oops */
2940     if (decNumberIsNegative(rhs)) {
2941       status|=DEC_Invalid_operation;
2942       break;
2943       }
2944
2945     /* space is needed for three working variables */
2946     /*   f -- the same precision as the RHS, reduced to 0.01->0.99... */
2947     /*   a -- Hull's approximation -- precision, when assigned, is */
2948     /*        currentprecision+1 or the input argument precision, */
2949     /*        whichever is larger (+2 for use as temporary) */
2950     /*   b -- intermediate temporary result (same size as a) */
2951     /* if any is too long for local storage, then allocate */
2952     workp=MAXI(set->digits+1, rhs->digits);  /* actual rounding precision */
2953     maxp=workp+2;                            /* largest working precision */
2954
2955     needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
2956     if (needbytes>(Int)sizeof(buff)) {
2957       allocbuff=(decNumber *)malloc(needbytes);
2958       if (allocbuff==NULL) {  /* hopeless -- abandon */
2959         status|=DEC_Insufficient_storage;
2960         break;}
2961       f=allocbuff;            /* use the allocated space */
2962       }
2963     /* a and b both need to be able to hold a maxp-length number */
2964     needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
2965     if (needbytes>(Int)sizeof(bufa)) {            /* [same applies to b] */
2966       allocbufa=(decNumber *)malloc(needbytes);
2967       allocbufb=(decNumber *)malloc(needbytes);
2968       if (allocbufa==NULL || allocbufb==NULL) {   /* hopeless */
2969         status|=DEC_Insufficient_storage;
2970         break;}
2971       a=allocbufa;            /* use the allocated spaces */
2972       b=allocbufb;            /* .. */
2973       }
2974
2975     /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2976     decNumberCopy(f, rhs);
2977     exp=f->exponent+f->digits;               /* adjusted to Hull rules */
2978     f->exponent=-(f->digits);                /* to range */
2979
2980     /* set up working context */
2981     decContextDefault(&workset, DEC_INIT_DECIMAL64);
2982
2983     /* [Until further notice, no error is possible and status bits */
2984     /* (Rounded, etc.) should be ignored, not accumulated.] */
2985
2986     /* Calculate initial approximation, and allow for odd exponent */
2987     workset.digits=workp;                    /* p for initial calculation */
2988     t->bits=0; t->digits=3;
2989     a->bits=0; a->digits=3;
2990     if ((exp & 1)==0) {                      /* even exponent */
2991       /* Set t=0.259, a=0.819 */
2992       t->exponent=-3;
2993       a->exponent=-3;
2994       #if DECDPUN>=3
2995         t->lsu[0]=259;
2996         a->lsu[0]=819;
2997       #elif DECDPUN==2
2998         t->lsu[0]=59; t->lsu[1]=2;
2999         a->lsu[0]=19; a->lsu[1]=8;
3000       #else
3001         t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
3002         a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
3003       #endif
3004       }
3005      else {                                  /* odd exponent */
3006       /* Set t=0.0819, a=2.59 */
3007       f->exponent--;                         /* f=f/10 */
3008       exp++;                                 /* e=e+1 */
3009       t->exponent=-4;
3010       a->exponent=-2;
3011       #if DECDPUN>=3
3012         t->lsu[0]=819;
3013         a->lsu[0]=259;
3014       #elif DECDPUN==2
3015         t->lsu[0]=19; t->lsu[1]=8;
3016         a->lsu[0]=59; a->lsu[1]=2;
3017       #else
3018         t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
3019         a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
3020       #endif
3021       }
3022     decMultiplyOp(a, a, f, &workset, &ignore);    /* a=a*f */
3023     decAddOp(a, a, t, &workset, 0, &ignore);      /* ..+t */
3024     /* [a is now the initial approximation for sqrt(f), calculated with */
3025     /* currentprecision, which is also a's precision.] */
3026
3027     /* the main calculation loop */
3028     decNumberZero(&dzero);                   /* make 0 */
3029     decNumberZero(t);                        /* set t = 0.5 */
3030     t->lsu[0]=5;                             /* .. */
3031     t->exponent=-1;                          /* .. */
3032     workset.digits=3;                        /* initial p */
3033     for (;;) {
3034       /* set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp] */
3035       workset.digits=workset.digits*2-2;
3036       if (workset.digits>maxp) workset.digits=maxp;
3037       /* a = 0.5 * (a + f/a) */
3038       /* [calculated at p then rounded to currentprecision] */
3039       decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
3040       decAddOp(b, b, a, &workset, 0, &ignore);    /* b=b+a */
3041       decMultiplyOp(a, b, t, &workset, &ignore);  /* a=b*0.5 */
3042       if (a->digits==maxp) break;            /* have required digits */
3043       } /* loop */
3044
3045     /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
3046     /* now reduce to length, etc.; this needs to be done with a */
3047     /* having the correct exponent so as to handle subnormals */
3048     /* correctly */
3049     approxset=*set;                          /* get emin, emax, etc. */
3050     approxset.round=DEC_ROUND_HALF_EVEN;
3051     a->exponent+=exp/2;                      /* set correct exponent */
3052
3053     rstatus=0;                               /* clear status */
3054     residue=0;                               /* .. and accumulator */
3055     decCopyFit(a, a, &approxset, &residue, &rstatus);  /* reduce (if needed) */
3056     decFinish(a, &approxset, &residue, &rstatus);      /* clean and finalize */
3057
3058     /* Overflow was possible if the input exponent was out-of-range, */
3059     /* in which case quit */
3060     if (rstatus&DEC_Overflow) {
3061       status=rstatus;                        /* use the status as-is */
3062       decNumberCopy(res, a);                 /* copy to result */
3063       break;
3064       }
3065
3066     /* Preserve status except Inexact/Rounded */
3067     status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3068
3069     /* Carry out the Hull correction */
3070     a->exponent-=exp/2;                      /* back to 0.1->1 */
3071
3072     /* a is now at final precision and within 1 ulp of the properly */
3073     /* rounded square root of f; to ensure proper rounding, compare */
3074     /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3075     /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3076     /* the ulp */
3077     workset.digits--;                             /* maxp-1 is OK now */
3078     t->exponent=-a->digits-1;                     /* make 0.5 ulp */
3079     decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3080     workset.round=DEC_ROUND_UP;
3081     decMultiplyOp(b, b, b, &workset, &ignore);    /* b = mulru(b, b) */
3082     decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3083     if (decNumberIsNegative(b)) {                 /* f < b [i.e., b > f] */
3084       /* this is the more common adjustment, though both are rare */
3085       t->exponent++;                              /* make 1.0 ulp */
3086       t->lsu[0]=1;                                /* .. */
3087       decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3088       /* assign to approx [round to length] */
3089       approxset.emin-=exp/2;                      /* adjust to match a */
3090       approxset.emax-=exp/2;
3091       decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3092       }
3093      else {
3094       decAddOp(b, a, t, &workset, 0, &ignore);    /* b = a + 0.5 ulp */
3095       workset.round=DEC_ROUND_DOWN;
3096       decMultiplyOp(b, b, b, &workset, &ignore);  /* b = mulrd(b, b) */
3097       decCompareOp(b, b, f, &workset, COMPARE, &ignore);   /* b ? f */
3098       if (decNumberIsNegative(b)) {               /* b < f */
3099         t->exponent++;                            /* make 1.0 ulp */
3100         t->lsu[0]=1;                              /* .. */
3101         decAddOp(a, a, t, &workset, 0, &ignore);  /* a = a + 1 ulp */
3102         /* assign to approx [round to length] */
3103         approxset.emin-=exp/2;                    /* adjust to match a */
3104         approxset.emax-=exp/2;
3105         decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3106         }
3107       }
3108     /* [no errors are possible in the above, and rounding/inexact during */
3109     /* estimation are irrelevant, so status was not accumulated] */
3110
3111     /* Here, 0.1 <= a < 1  (still), so adjust back */
3112     a->exponent+=exp/2;                      /* set correct exponent */
3113
3114     /* count droppable zeros [after any subnormal rounding] by */
3115     /* trimming a copy */
3116     decNumberCopy(b, a);
3117     decTrim(b, set, 1, &dropped);            /* [drops trailing zeros] */
3118
3119     /* Set Inexact and Rounded.  The answer can only be exact if */
3120     /* it is short enough so that squaring it could fit in workp digits, */
3121     /* and it cannot have trailing zeros due to clamping, so these are */
3122     /* the only (relatively rare) conditions a careful check is needed */
3123     if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */
3124       status|=DEC_Inexact|DEC_Rounded;
3125       }
3126      else {                                  /* could be exact/unrounded */
3127       uInt mstatus=0;                        /* local status */
3128       decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3129       if (mstatus&DEC_Overflow) {            /* result just won't fit */
3130         status|=DEC_Inexact|DEC_Rounded;
3131         }
3132        else {                                /* plausible */
3133         decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3134         if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3135          else {                              /* is Exact */
3136           /* here, dropped is the count of trailing zeros in 'a' */
3137           /* use closest exponent to ideal... */
3138           Int todrop=ideal-a->exponent;      /* most that can be dropped */
3139           if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3140            else {                            /* unrounded */
3141             if (dropped<todrop) {            /* clamp to those available */
3142               todrop=dropped;
3143               status|=DEC_Clamped;
3144               }
3145             if (todrop>0) {                  /* have some to drop */
3146               decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3147               a->exponent+=todrop;           /* maintain numerical value */
3148               a->digits-=todrop;             /* new length */
3149               }
3150             }
3151           }
3152         }
3153       }
3154
3155     /* double-check Underflow, as perhaps the result could not have */
3156     /* been subnormal (initial argument too big), or it is now Exact */
3157     if (status&DEC_Underflow) {
3158       Int ae=rhs->exponent+rhs->digits-1;    /* adjusted exponent */
3159       /* check if truly subnormal */
3160       #if DECEXTFLAG                         /* DEC_Subnormal too */
3161         if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3162       #else
3163         if (ae>=set->emin*2) status&=~DEC_Underflow;
3164       #endif
3165       /* check if truly inexact */
3166       if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3167       }
3168
3169     decNumberCopy(res, a);                   /* a is now the result */
3170     } while(0);                              /* end protected */
3171
3172   if (allocbuff!=NULL) free(allocbuff);      /* drop any storage used */
3173   if (allocbufa!=NULL) free(allocbufa);      /* .. */
3174   if (allocbufb!=NULL) free(allocbufb);      /* .. */
3175   #if DECSUBSET
3176   if (allocrhs !=NULL) free(allocrhs);       /* .. */
3177   #endif
3178   if (status!=0) decStatus(res, status, set);/* then report status */
3179   #if DECCHECK
3180   decCheckInexact(res, set);
3181   #endif
3182   return res;
3183   } /* decNumberSquareRoot */
3184
3185 /* ------------------------------------------------------------------ */
3186 /* decNumberSubtract -- subtract two Numbers                          */
3187 /*                                                                    */
3188 /*   This computes C = A - B                                          */
3189 /*                                                                    */
3190 /*   res is C, the result.  C may be A and/or B (e.g., X=X-X)         */
3191 /*   lhs is A                                                         */
3192 /*   rhs is B                                                         */
3193 /*   set is the context                                               */
3194 /*                                                                    */
3195 /* C must have space for set->digits digits.                          */
3196 /* ------------------------------------------------------------------ */
3197 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3198                               const decNumber *rhs, decContext *set) {
3199   uInt status=0;                        /* accumulator */
3200
3201   decAddOp(res, lhs, rhs, set, DECNEG, &status);
3202   if (status!=0) decStatus(res, status, set);
3203   #if DECCHECK
3204   decCheckInexact(res, set);
3205   #endif
3206   return res;
3207   } /* decNumberSubtract */
3208
3209 /* ------------------------------------------------------------------ */
3210 /* decNumberToIntegralExact -- round-to-integral-value with InExact   */
3211 /* decNumberToIntegralValue -- round-to-integral-value                */
3212 /*                                                                    */
3213 /*   res is the result                                                */
3214 /*   rhs is input number                                              */
3215 /*   set is the context                                               */
3216 /*                                                                    */
3217 /* res must have space for any value of rhs.                          */
3218 /*                                                                    */
3219 /* This implements the IEEE special operators and therefore treats    */
3220 /* special values as valid.  For finite numbers it returns            */
3221 /* rescale(rhs, 0) if rhs->exponent is <0.                            */
3222 /* Otherwise the result is rhs (so no error is possible, except for   */
3223 /* sNaN).                                                             */
3224 /*                                                                    */
3225 /* The context is used for rounding mode and status after sNaN, but   */
3226 /* the digits setting is ignored.  The Exact version will signal      */
3227 /* Inexact if the result differs numerically from rhs; the other      */
3228 /* never signals Inexact.                                             */
3229 /* ------------------------------------------------------------------ */
3230 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3231                                      decContext *set) {
3232   decNumber dn;
3233   decContext workset;              /* working context */
3234   uInt status=0;                   /* accumulator */
3235
3236   #if DECCHECK
3237   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3238   #endif
3239
3240   /* handle infinities and NaNs */
3241   if (SPECIALARG) {
3242     if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3243      else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3244     }
3245    else { /* finite */
3246     /* have a finite number; no error possible (res must be big enough) */
3247     if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3248     /* that was easy, but if negative exponent there is work to do... */
3249     workset=*set;                  /* clone rounding, etc. */
3250     workset.digits=rhs->digits;    /* no length rounding */
3251     workset.traps=0;               /* no traps */
3252     decNumberZero(&dn);            /* make a number with exponent 0 */
3253     decNumberQuantize(res, rhs, &dn, &workset);
3254     status|=workset.status;
3255     }
3256   if (status!=0) decStatus(res, status, set);
3257   return res;
3258   } /* decNumberToIntegralExact */
3259
3260 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3261                                      decContext *set) {
3262   decContext workset=*set;         /* working context */
3263   workset.traps=0;                 /* no traps */
3264   decNumberToIntegralExact(res, rhs, &workset);
3265   /* this never affects set, except for sNaNs; NaN will have been set */
3266   /* or propagated already, so no need to call decStatus */
3267   set->status|=workset.status&DEC_Invalid_operation;
3268   return res;
3269   } /* decNumberToIntegralValue */
3270
3271 /* ------------------------------------------------------------------ */
3272 /* decNumberXor -- XOR two Numbers, digitwise                         */
3273 /*                                                                    */
3274 /*   This computes C = A ^ B                                          */
3275 /*                                                                    */
3276 /*   res is C, the result.  C may be A and/or B (e.g., X=X^X)         */
3277 /*   lhs is A                                                         */
3278 /*   rhs is B                                                         */
3279 /*   set is the context (used for result length and error report)     */
3280 /*                                                                    */
3281 /* C must have space for set->digits digits.                          */
3282 /*                                                                    */
3283 /* Logical function restrictions apply (see above); a NaN is          */
3284 /* returned with Invalid_operation if a restriction is violated.      */
3285 /* ------------------------------------------------------------------ */
3286 decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3287                          const decNumber *rhs, decContext *set) {
3288   const Unit *ua, *ub;                  /* -> operands */
3289   const Unit *msua, *msub;              /* -> operand msus */
3290   Unit  *uc, *msuc;                     /* -> result and its msu */
3291   Int   msudigs;                        /* digits in res msu */
3292   #if DECCHECK
3293   if (decCheckOperands(res, lhs, rhs, set)) return res;
3294   #endif
3295
3296   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3297    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3298     decStatus(res, DEC_Invalid_operation, set);
3299     return res;
3300     }
3301   /* operands are valid */
3302   ua=lhs->lsu;                          /* bottom-up */
3303   ub=rhs->lsu;                          /* .. */
3304   uc=res->lsu;                          /* .. */
3305   msua=ua+D2U(lhs->digits)-1;           /* -> msu of lhs */
3306   msub=ub+D2U(rhs->digits)-1;           /* -> msu of rhs */
3307   msuc=uc+D2U(set->digits)-1;           /* -> msu of result */
3308   msudigs=MSUDIGITS(set->digits);       /* [faster than remainder] */
3309   for (; uc<=msuc; ua++, ub++, uc++) {  /* Unit loop */
3310     Unit a, b;                          /* extract units */
3311     if (ua>msua) a=0;
3312      else a=*ua;
3313     if (ub>msub) b=0;
3314      else b=*ub;
3315     *uc=0;                              /* can now write back */
3316     if (a|b) {                          /* maybe 1 bits to examine */
3317       Int i, j;
3318       /* This loop could be unrolled and/or use BIN2BCD tables */
3319       for (i=0; i<DECDPUN; i++) {
3320         if ((a^b)&1) *uc=*uc+(Unit)powers[i];     /* effect XOR */
3321         j=a%10;
3322         a=a/10;
3323         j|=b%10;
3324         b=b/10;
3325         if (j>1) {
3326           decStatus(res, DEC_Invalid_operation, set);
3327           return res;
3328           }
3329         if (uc==msuc && i==msudigs-1) break;      /* just did final digit */
3330         } /* each digit */
3331       } /* non-zero */
3332     } /* each unit */
3333   /* [here uc-1 is the msu of the result] */
3334   res->digits=decGetDigits(res->lsu, uc-res->lsu);
3335   res->exponent=0;                      /* integer */
3336   res->bits=0;                          /* sign=0 */
3337   return res;  /* [no status to set] */
3338   } /* decNumberXor */
3339
3340
3341 /* ================================================================== */
3342 /* Utility routines                                                   */
3343 /* ================================================================== */
3344
3345 /* ------------------------------------------------------------------ */
3346 /* decNumberClass -- return the decClass of a decNumber               */
3347 /*   dn -- the decNumber to test                                      */
3348 /*   set -- the context to use for Emin                               */
3349 /*   returns the decClass enum                                        */
3350 /* ------------------------------------------------------------------ */
3351 enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3352   if (decNumberIsSpecial(dn)) {
3353     if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3354     if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3355     /* must be an infinity */
3356     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3357     return DEC_CLASS_POS_INF;
3358     }
3359   /* is finite */
3360   if (decNumberIsNormal(dn, set)) { /* most common */
3361     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3362     return DEC_CLASS_POS_NORMAL;
3363     }
3364   /* is subnormal or zero */
3365   if (decNumberIsZero(dn)) {    /* most common */
3366     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3367     return DEC_CLASS_POS_ZERO;
3368     }
3369   if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3370   return DEC_CLASS_POS_SUBNORMAL;
3371   } /* decNumberClass */
3372
3373 /* ------------------------------------------------------------------ */
3374 /* decNumberClassToString -- convert decClass to a string             */
3375 /*                                                                    */
3376 /*  eclass is a valid decClass                                        */
3377 /*  returns a constant string describing the class (max 13+1 chars)   */
3378 /* ------------------------------------------------------------------ */
3379 const char *decNumberClassToString(enum decClass eclass) {
3380   if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
3381   if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
3382   if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
3383   if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
3384   if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3385   if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3386   if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
3387   if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
3388   if (eclass==DEC_CLASS_QNAN)          return DEC_ClassString_QN;
3389   if (eclass==DEC_CLASS_SNAN)          return DEC_ClassString_SN;
3390   return DEC_ClassString_UN;           /* Unknown */
3391   } /* decNumberClassToString */
3392
3393 /* ------------------------------------------------------------------ */
3394 /* decNumberCopy -- copy a number                                     */
3395 /*                                                                    */
3396 /*   dest is the target decNumber                                     */
3397 /*   src  is the source decNumber                                     */
3398 /*   returns dest                                                     */
3399 /*                                                                    */
3400 /* (dest==src is allowed and is a no-op)                              */
3401 /* All fields are updated as required.  This is a utility operation,  */
3402 /* so special values are unchanged and no error is possible.          */
3403 /* ------------------------------------------------------------------ */
3404 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3405
3406   #if DECCHECK
3407   if (src==NULL) return decNumberZero(dest);
3408   #endif
3409
3410   if (dest==src) return dest;                /* no copy required */
3411
3412   /* Use explicit assignments here as structure assignment could copy */
3413   /* more than just the lsu (for small DECDPUN).  This would not affect */
3414   /* the value of the results, but could disturb test harness spill */
3415   /* checking. */
3416   dest->bits=src->bits;
3417   dest->exponent=src->exponent;
3418   dest->digits=src->digits;
3419   dest->lsu[0]=src->lsu[0];
3420   if (src->digits>DECDPUN) {                 /* more Units to come */
3421     const Unit *smsup, *s;                   /* work */
3422     Unit  *d;                                /* .. */
3423     /* memcpy for the remaining Units would be safe as they cannot */
3424     /* overlap.  However, this explicit loop is faster in short cases. */
3425     d=dest->lsu+1;                           /* -> first destination */
3426     smsup=src->lsu+D2U(src->digits);         /* -> source msu+1 */
3427     for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3428     }
3429   return dest;
3430   } /* decNumberCopy */
3431
3432 /* ------------------------------------------------------------------ */
3433 /* decNumberCopyAbs -- quiet absolute value operator                  */
3434 /*                                                                    */
3435 /*   This sets C = abs(A)                                             */
3436 /*                                                                    */
3437 /*   res is C, the result.  C may be A                                */
3438 /*   rhs is A                                                         */
3439 /*                                                                    */
3440 /* C must have space for set->digits digits.                          */
3441 /* No exception or error can occur; this is a quiet bitwise operation.*/
3442 /* See also decNumberAbs for a checking version of this.              */
3443 /* ------------------------------------------------------------------ */
3444 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3445   #if DECCHECK
3446   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3447   #endif
3448   decNumberCopy(res, rhs);
3449   res->bits&=~DECNEG;                   /* turn off sign */
3450   return res;
3451   } /* decNumberCopyAbs */
3452
3453 /* ------------------------------------------------------------------ */
3454 /* decNumberCopyNegate -- quiet negate value operator                 */
3455 /*                                                                    */
3456 /*   This sets C = negate(A)                                          */
3457 /*                                                                    */
3458 /*   res is C, the result.  C may be A                                */
3459 /*   rhs is A                                                         */
3460 /*                                                                    */
3461 /* C must have space for set->digits digits.                          */
3462 /* No exception or error can occur; this is a quiet bitwise operation.*/
3463 /* See also decNumberMinus for a checking version of this.            */
3464 /* ------------------------------------------------------------------ */
3465 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3466   #if DECCHECK
3467   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3468   #endif
3469   decNumberCopy(res, rhs);
3470   res->bits^=DECNEG;                    /* invert the sign */
3471   return res;
3472   } /* decNumberCopyNegate */
3473
3474 /* ------------------------------------------------------------------ */
3475 /* decNumberCopySign -- quiet copy and set sign operator              */
3476 /*                                                                    */
3477 /*   This sets C = A with the sign of B                               */
3478 /*                                                                    */
3479 /*   res is C, the result.  C may be A                                */
3480 /*   lhs is A                                                         */
3481 /*   rhs is B                                                         */
3482 /*                                                                    */
3483 /* C must have space for set->digits digits.                          */
3484 /* No exception or error can occur; this is a quiet bitwise operation.*/
3485 /* ------------------------------------------------------------------ */
3486 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3487                               const decNumber *rhs) {
3488   uByte sign;                           /* rhs sign */
3489   #if DECCHECK
3490   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3491   #endif
3492   sign=rhs->bits & DECNEG;              /* save sign bit */
3493   decNumberCopy(res, lhs);
3494   res->bits&=~DECNEG;                   /* clear the sign */
3495   res->bits|=sign;                      /* set from rhs */
3496   return res;
3497   } /* decNumberCopySign */
3498
3499 /* ------------------------------------------------------------------ */
3500 /* decNumberGetBCD -- get the coefficient in BCD8                     */
3501 /*   dn is the source decNumber                                       */
3502 /*   bcd is the uInt array that will receive dn->digits BCD bytes,    */
3503 /*     most-significant at offset 0                                   */
3504 /*   returns bcd                                                      */
3505 /*                                                                    */
3506 /* bcd must have at least dn->digits bytes.  No error is possible; if */
3507 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0.   */
3508 /* ------------------------------------------------------------------ */
3509 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) {
3510   uByte *ub=bcd+dn->digits-1;      /* -> lsd */
3511   const Unit *up=dn->lsu;          /* Unit pointer, -> lsu */
3512
3513   #if DECDPUN==1                   /* trivial simple copy */
3514     for (; ub>=bcd; ub--, up++) *ub=*up;
3515   #else                            /* chopping needed */
3516     uInt u=*up;                    /* work */
3517     uInt cut=DECDPUN;              /* downcounter through unit */
3518     for (; ub>=bcd; ub--) {
3519       *ub=(uByte)(u%10);           /* [*6554 trick inhibits, here] */
3520       u=u/10;
3521       cut--;
3522       if (cut>0) continue;         /* more in this unit */
3523       up++;
3524       u=*up;
3525       cut=DECDPUN;
3526       }
3527   #endif
3528   return bcd;
3529   } /* decNumberGetBCD */
3530
3531 /* ------------------------------------------------------------------ */
3532 /* decNumberSetBCD -- set (replace) the coefficient from BCD8         */
3533 /*   dn is the target decNumber                                       */
3534 /*   bcd is the uInt array that will source n BCD bytes, most-        */
3535 /*     significant at offset 0                                        */
3536 /*   n is the number of digits in the source BCD array (bcd)          */
3537 /*   returns dn                                                       */
3538 /*                                                                    */
3539 /* dn must have space for at least n digits.  No error is possible;   */
3540 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1   */
3541 /* and bcd[0] zero.                                                   */
3542 /* ------------------------------------------------------------------ */
3543 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3544   Unit *up = dn->lsu + D2U(n) - 1;      /* -> msu [target pointer] */
3545   const uByte *ub=bcd;                  /* -> source msd */
3546
3547   #if DECDPUN==1                        /* trivial simple copy */
3548     for (; ub<bcd+n; ub++, up--) *up=*ub;
3549   #else                                 /* some assembly needed */
3550     /* calculate how many digits in msu, and hence first cut */
3551     Int cut=MSUDIGITS(n);               /* [faster than remainder] */
3552     for (;up>=dn->lsu; up--) {          /* each Unit from msu */
3553       *up=0;                            /* will take <=DECDPUN digits */
3554       for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3555       cut=DECDPUN;                      /* next Unit has all digits */
3556       }
3557   #endif
3558   dn->digits=n;                         /* set digit count */
3559   return dn;
3560   } /* decNumberSetBCD */
3561
3562 /* ------------------------------------------------------------------ */
3563 /* decNumberIsNormal -- test normality of a decNumber                 */
3564 /*   dn is the decNumber to test                                      */
3565 /*   set is the context to use for Emin                               */
3566 /*   returns 1 if |dn| is finite and >=Nmin, 0 otherwise              */
3567 /* ------------------------------------------------------------------ */
3568 Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3569   Int ae;                               /* adjusted exponent */
3570   #if DECCHECK
3571   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3572   #endif
3573
3574   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3575   if (decNumberIsZero(dn)) return 0;    /* not non-zero */
3576
3577   ae=dn->exponent+dn->digits-1;         /* adjusted exponent */
3578   if (ae<set->emin) return 0;           /* is subnormal */
3579   return 1;
3580   } /* decNumberIsNormal */
3581
3582 /* ------------------------------------------------------------------ */
3583 /* decNumberIsSubnormal -- test subnormality of a decNumber           */
3584 /*   dn is the decNumber to test                                      */
3585 /*   set is the context to use for Emin                               */
3586 /*   returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise    */
3587 /* ------------------------------------------------------------------ */
3588 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3589   Int ae;                               /* adjusted exponent */
3590   #if DECCHECK
3591   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3592   #endif
3593
3594   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3595   if (decNumberIsZero(dn)) return 0;    /* not non-zero */
3596
3597   ae=dn->exponent+dn->digits-1;         /* adjusted exponent */
3598   if (ae<set->emin) return 1;           /* is subnormal */
3599   return 0;
3600   } /* decNumberIsSubnormal */
3601
3602 /* ------------------------------------------------------------------ */
3603 /* decNumberTrim -- remove insignificant zeros                        */
3604 /*                                                                    */
3605 /*   dn is the number to trim                                         */
3606 /*   returns dn                                                       */
3607 /*                                                                    */
3608 /* All fields are updated as required.  This is a utility operation,  */
3609 /* so special values are unchanged and no error is possible.          */
3610 /* ------------------------------------------------------------------ */
3611 decNumber * decNumberTrim(decNumber *dn) {
3612   Int  dropped;                    /* work */
3613   decContext set;                  /* .. */
3614   #if DECCHECK
3615   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3616   #endif
3617   decContextDefault(&set, DEC_INIT_BASE);    /* clamp=0 */
3618   return decTrim(dn, &set, 0, &dropped);
3619   } /* decNumberTrim */
3620
3621 /* ------------------------------------------------------------------ */
3622 /* decNumberVersion -- return the name and version of this module     */
3623 /*                                                                    */
3624 /* No error is possible.                                              */
3625 /* ------------------------------------------------------------------ */
3626 const char * decNumberVersion(void) {
3627   return DECVERSION;
3628   } /* decNumberVersion */
3629
3630 /* ------------------------------------------------------------------ */
3631 /* decNumberZero -- set a number to 0                                 */
3632 /*                                                                    */
3633 /*   dn is the number to set, with space for one digit                */
3634 /*   returns dn                                                       */
3635 /*                                                                    */
3636 /* No error is possible.                                              */
3637 /* ------------------------------------------------------------------ */
3638 /* Memset is not used as it is much slower in some environments. */
3639 decNumber * decNumberZero(decNumber *dn) {
3640
3641   #if DECCHECK
3642   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3643   #endif
3644
3645   dn->bits=0;
3646   dn->exponent=0;
3647   dn->digits=1;
3648   dn->lsu[0]=0;
3649   return dn;
3650   } /* decNumberZero */
3651
3652 /* ================================================================== */
3653 /* Local routines                                                     */
3654 /* ================================================================== */
3655
3656 /* ------------------------------------------------------------------ */
3657 /* decToString -- lay out a number into a string                      */
3658 /*                                                                    */
3659 /*   dn     is the number to lay out                                  */
3660 /*   string is where to lay out the number                            */
3661 /*   eng    is 1 if Engineering, 0 if Scientific                      */
3662 /*                                                                    */
3663 /* string must be at least dn->digits+14 characters long              */
3664 /* No error is possible.                                              */
3665 /*                                                                    */
3666 /* Note that this routine can generate a -0 or 0.000.  These are      */
3667 /* never generated in subset to-number or arithmetic, but can occur   */
3668 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).              */
3669 /* ------------------------------------------------------------------ */
3670 /* If DECCHECK is enabled the string "?" is returned if a number is */
3671 /* invalid. */
3672 static void decToString(const decNumber *dn, char *string, Flag eng) {
3673   Int exp=dn->exponent;       /* local copy */
3674   Int e;                      /* E-part value */
3675   Int pre;                    /* digits before the '.' */
3676   Int cut;                    /* for counting digits in a Unit */
3677   char *c=string;             /* work [output pointer] */
3678   const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3679   uInt u, pow;                /* work */
3680
3681   #if DECCHECK
3682   if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3683     strcpy(string, "?");
3684     return;}
3685   #endif
3686
3687   if (decNumberIsNegative(dn)) {   /* Negatives get a minus */
3688     *c='-';
3689     c++;
3690     }
3691   if (dn->bits&DECSPECIAL) {       /* Is a special value */
3692     if (decNumberIsInfinite(dn)) {
3693       strcpy(c,   "Inf");
3694       strcpy(c+3, "inity");
3695       return;}
3696     /* a NaN */
3697     if (dn->bits&DECSNAN) {        /* signalling NaN */
3698       *c='s';
3699       c++;
3700       }
3701     strcpy(c, "NaN");
3702     c+=3;                          /* step past */
3703     /* if not a clean non-zero coefficient, that's all there is in a */
3704     /* NaN string */
3705     if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3706     /* [drop through to add integer] */
3707     }
3708
3709   /* calculate how many digits in msu, and hence first cut */
3710   cut=MSUDIGITS(dn->digits);       /* [faster than remainder] */
3711   cut--;                           /* power of ten for digit */
3712
3713   if (exp==0) {                    /* simple integer [common fastpath] */
3714     for (;up>=dn->lsu; up--) {     /* each Unit from msu */
3715       u=*up;                       /* contains DECDPUN digits to lay out */
3716       for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3717       cut=DECDPUN-1;               /* next Unit has all digits */
3718       }
3719     *c='\0';                       /* terminate the string */
3720     return;}
3721
3722   /* non-0 exponent -- assume plain form */
3723   pre=dn->digits+exp;              /* digits before '.' */
3724   e=0;                             /* no E */
3725   if ((exp>0) || (pre<-5)) {       /* need exponential form */
3726     e=exp+dn->digits-1;            /* calculate E value */
3727     pre=1;                         /* assume one digit before '.' */
3728     if (eng && (e!=0)) {           /* engineering: may need to adjust */
3729       Int adj;                     /* adjustment */
3730       /* The C remainder operator is undefined for negative numbers, so */
3731       /* a positive remainder calculation must be used here */
3732       if (e<0) {
3733         adj=(-e)%3;
3734         if (adj!=0) adj=3-adj;
3735         }
3736        else { /* e>0 */
3737         adj=e%3;
3738         }
3739       e=e-adj;
3740       /* if dealing with zero still produce an exponent which is a */
3741       /* multiple of three, as expected, but there will only be the */
3742       /* one zero before the E, still.  Otherwise note the padding. */
3743       if (!ISZERO(dn)) pre+=adj;
3744        else {  /* is zero */
3745         if (adj!=0) {              /* 0.00Esnn needed */
3746           e=e+3;
3747           pre=-(2-adj);
3748           }
3749         } /* zero */
3750       } /* eng */
3751     } /* need exponent */
3752
3753   /* lay out the digits of the coefficient, adding 0s and . as needed */
3754   u=*up;
3755   if (pre>0) {                     /* xxx.xxx or xx00 (engineering) form */
3756     Int n=pre;
3757     for (; pre>0; pre--, c++, cut--) {
3758       if (cut<0) {                 /* need new Unit */
3759         if (up==dn->lsu) break;    /* out of input digits (pre>digits) */
3760         up--;
3761         cut=DECDPUN-1;
3762         u=*up;
3763         }
3764       TODIGIT(u, cut, c, pow);
3765       }
3766     if (n<dn->digits) {            /* more to come, after '.' */
3767       *c='.'; c++;
3768       for (;; c++, cut--) {
3769         if (cut<0) {               /* need new Unit */
3770           if (up==dn->lsu) break;  /* out of input digits */
3771           up--;
3772           cut=DECDPUN-1;
3773           u=*up;
3774           }
3775         TODIGIT(u, cut, c, pow);
3776         }
3777       }
3778      else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3779     }
3780    else {                          /* 0.xxx or 0.000xxx form */
3781     *c='0'; c++;
3782     *c='.'; c++;
3783     for (; pre<0; pre++, c++) *c='0';   /* add any 0's after '.' */
3784     for (; ; c++, cut--) {
3785       if (cut<0) {                 /* need new Unit */
3786         if (up==dn->lsu) break;    /* out of input digits */
3787         up--;
3788         cut=DECDPUN-1;
3789         u=*up;
3790         }
3791       TODIGIT(u, cut, c, pow);
3792       }
3793     }
3794
3795   /* Finally add the E-part, if needed.  It will never be 0, has a
3796      base maximum and minimum of +999999999 through -999999999, but
3797      could range down to -1999999998 for anormal numbers */
3798   if (e!=0) {
3799     Flag had=0;               /* 1=had non-zero */
3800     *c='E'; c++;
3801     *c='+'; c++;              /* assume positive */
3802     u=e;                      /* .. */
3803     if (e<0) {
3804       *(c-1)='-';             /* oops, need - */
3805       u=-e;                   /* uInt, please */
3806       }
3807     /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3808     for (cut=9; cut>=0; cut--) {
3809       TODIGIT(u, cut, c, pow);
3810       if (*c=='0' && !had) continue;    /* skip leading zeros */
3811       had=1;                            /* had non-0 */
3812       c++;                              /* step for next */
3813       } /* cut */
3814     }
3815   *c='\0';          /* terminate the string (all paths) */
3816   return;
3817   } /* decToString */
3818
3819 /* ------------------------------------------------------------------ */
3820 /* decAddOp -- add/subtract operation                                 */
3821 /*                                                                    */
3822 /*   This computes C = A + B                                          */
3823 /*                                                                    */
3824 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
3825 /*   lhs is A                                                         */
3826 /*   rhs is B                                                         */
3827 /*   set is the context                                               */
3828 /*   negate is DECNEG if rhs should be negated, or 0 otherwise        */
3829 /*   status accumulates status for the caller                         */
3830 /*                                                                    */
3831 /* C must have space for set->digits digits.                          */
3832 /* Inexact in status must be 0 for correct Exact zero sign in result  */
3833 /* ------------------------------------------------------------------ */
3834 /* If possible, the coefficient is calculated directly into C.        */
3835 /* However, if:                                                       */
3836 /*   -- a digits+1 calculation is needed because the numbers are      */
3837 /*      unaligned and span more than set->digits digits               */
3838 /*   -- a carry to digits+1 digits looks possible                     */
3839 /*   -- C is the same as A or B, and the result would destructively   */
3840 /*      overlap the A or B coefficient                                */
3841 /* then the result must be calculated into a temporary buffer.  In    */
3842 /* this case a local (stack) buffer is used if possible, and only if  */
3843 /* too long for that does malloc become the final resort.             */
3844 /*                                                                    */
3845 /* Misalignment is handled as follows:                                */
3846 /*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
3847 /*   BPad: Apply the padding by a combination of shifting (whole      */
3848 /*         units) and multiplication (part units).                    */
3849 /*                                                                    */
3850 /* Addition, especially x=x+1, is speed-critical.                     */
3851 /* The static buffer is larger than might be expected to allow for    */
3852 /* calls from higher-level functions (notably exp).                   */
3853 /* ------------------------------------------------------------------ */
3854 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3855                             const decNumber *rhs, decContext *set,
3856                             uByte negate, uInt *status) {
3857   #if DECSUBSET
3858   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
3859   decNumber *allocrhs=NULL;        /* .., rhs */
3860   #endif
3861   Int   rhsshift;                  /* working shift (in Units) */
3862   Int   maxdigits;                 /* longest logical length */
3863   Int   mult;                      /* multiplier */
3864   Int   residue;                   /* rounding accumulator */
3865   uByte bits;                      /* result bits */
3866   Flag  diffsign;                  /* non-0 if arguments have different sign */
3867   Unit  *acc;                      /* accumulator for result */
3868   Unit  accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3869                                    /* allocations when called from */
3870                                    /* other operations, notable exp] */
3871   Unit  *allocacc=NULL;            /* -> allocated acc buffer, iff allocated */
3872   Int   reqdigits=set->digits;     /* local copy; requested DIGITS */
3873   Int   padding;                   /* work */
3874
3875   #if DECCHECK
3876   if (decCheckOperands(res, lhs, rhs, set)) return res;
3877   #endif
3878
3879   do {                             /* protect allocated storage */
3880     #if DECSUBSET
3881     if (!set->extended) {
3882       /* reduce operands and set lostDigits status, as needed */
3883       if (lhs->digits>reqdigits) {
3884         alloclhs=decRoundOperand(lhs, set, status);
3885         if (alloclhs==NULL) break;
3886         lhs=alloclhs;
3887         }
3888       if (rhs->digits>reqdigits) {
3889         allocrhs=decRoundOperand(rhs, set, status);
3890         if (allocrhs==NULL) break;
3891         rhs=allocrhs;
3892         }
3893       }
3894     #endif
3895     /* [following code does not require input rounding] */
3896
3897     /* note whether signs differ [used all paths] */
3898     diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3899
3900     /* handle infinities and NaNs */
3901     if (SPECIALARGS) {                  /* a special bit set */
3902       if (SPECIALARGS & (DECSNAN | DECNAN))  /* a NaN */
3903         decNaNs(res, lhs, rhs, set, status);
3904        else { /* one or two infinities */
3905         if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
3906           /* two infinities with different signs is invalid */
3907           if (decNumberIsInfinite(rhs) && diffsign) {
3908             *status|=DEC_Invalid_operation;
3909             break;
3910             }
3911           bits=lhs->bits & DECNEG;      /* get sign from LHS */
3912           }
3913          else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3914         bits|=DECINF;
3915         decNumberZero(res);
3916         res->bits=bits;                 /* set +/- infinity */
3917         } /* an infinity */
3918       break;
3919       }
3920
3921     /* Quick exit for add 0s; return the non-0, modified as need be */
3922     if (ISZERO(lhs)) {
3923       Int adjust;                       /* work */
3924       Int lexp=lhs->exponent;           /* save in case LHS==RES */
3925       bits=lhs->bits;                   /* .. */
3926       residue=0;                        /* clear accumulator */
3927       decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3928       res->bits^=negate;                /* flip if rhs was negated */
3929       #if DECSUBSET
3930       if (set->extended) {              /* exponents on zeros count */
3931       #endif
3932         /* exponent will be the lower of the two */
3933         adjust=lexp-res->exponent;      /* adjustment needed [if -ve] */
3934         if (ISZERO(res)) {              /* both 0: special IEEE 854 rules */
3935           if (adjust<0) res->exponent=lexp;  /* set exponent */
3936           /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3937           if (diffsign) {
3938             if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3939              else res->bits=DECNEG;     /* preserve 0 sign */
3940             }
3941           }
3942          else { /* non-0 res */
3943           if (adjust<0) {     /* 0-padding needed */
3944             if ((res->digits-adjust)>set->digits) {
3945               adjust=res->digits-set->digits;     /* to fit exactly */
3946               *status|=DEC_Rounded;               /* [but exact] */
3947               }
3948             res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3949             res->exponent+=adjust;                /* set the exponent. */
3950             }
3951           } /* non-0 res */
3952       #if DECSUBSET
3953         } /* extended */
3954       #endif
3955       decFinish(res, set, &residue, status);      /* clean and finalize */
3956       break;}
3957
3958     if (ISZERO(rhs)) {                  /* [lhs is non-zero] */
3959       Int adjust;                       /* work */
3960       Int rexp=rhs->exponent;           /* save in case RHS==RES */
3961       bits=rhs->bits;                   /* be clean */
3962       residue=0;                        /* clear accumulator */
3963       decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3964       #if DECSUBSET
3965       if (set->extended) {              /* exponents on zeros count */
3966       #endif
3967         /* exponent will be the lower of the two */
3968         /* [0-0 case handled above] */
3969         adjust=rexp-res->exponent;      /* adjustment needed [if -ve] */
3970         if (adjust<0) {     /* 0-padding needed */
3971           if ((res->digits-adjust)>set->digits) {
3972             adjust=res->digits-set->digits;     /* to fit exactly */
3973             *status|=DEC_Rounded;               /* [but exact] */
3974             }
3975           res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3976           res->exponent+=adjust;                /* set the exponent. */
3977           }
3978       #if DECSUBSET
3979         } /* extended */
3980       #endif
3981       decFinish(res, set, &residue, status);      /* clean and finalize */
3982       break;}
3983
3984     /* [NB: both fastpath and mainpath code below assume these cases */
3985     /* (notably 0-0) have already been handled] */
3986
3987     /* calculate the padding needed to align the operands */
3988     padding=rhs->exponent-lhs->exponent;
3989
3990     /* Fastpath cases where the numbers are aligned and normal, the RHS */
3991     /* is all in one unit, no operand rounding is needed, and no carry, */
3992     /* lengthening, or borrow is needed */
3993     if (padding==0
3994         && rhs->digits<=DECDPUN
3995         && rhs->exponent>=set->emin     /* [some normals drop through] */
3996         && rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
3997         && rhs->digits<=reqdigits
3998         && lhs->digits<=reqdigits) {
3999       Int partial=*lhs->lsu;
4000       if (!diffsign) {                  /* adding */
4001         partial+=*rhs->lsu;
4002         if ((partial<=DECDPUNMAX)       /* result fits in unit */
4003          && (lhs->digits>=DECDPUN ||    /* .. and no digits-count change */
4004              partial<(Int)powers[lhs->digits])) { /* .. */
4005           if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4006           *res->lsu=(Unit)partial;      /* [copy could have overwritten RHS] */
4007           break;
4008           }
4009         /* else drop out for careful add */
4010         }
4011        else {                           /* signs differ */
4012         partial-=*rhs->lsu;
4013         if (partial>0) { /* no borrow needed, and non-0 result */
4014           if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4015           *res->lsu=(Unit)partial;
4016           /* this could have reduced digits [but result>0] */
4017           res->digits=decGetDigits(res->lsu, D2U(res->digits));
4018           break;
4019           }
4020         /* else drop out for careful subtract */
4021         }
4022       }
4023
4024     /* Now align (pad) the lhs or rhs so they can be added or */
4025     /* subtracted, as necessary.  If one number is much larger than */
4026     /* the other (that is, if in plain form there is a least one */
4027     /* digit between the lowest digit of one and the highest of the */
4028     /* other) padding with up to DIGITS-1 trailing zeros may be */
4029     /* needed; then apply rounding (as exotic rounding modes may be */
4030     /* affected by the residue). */
4031     rhsshift=0;               /* rhs shift to left (padding) in Units */
4032     bits=lhs->bits;           /* assume sign is that of LHS */
4033     mult=1;                   /* likely multiplier */
4034
4035     /* [if padding==0 the operands are aligned; no padding is needed] */
4036     if (padding!=0) {
4037       /* some padding needed; always pad the RHS, as any required */
4038       /* padding can then be effected by a simple combination of */
4039       /* shifts and a multiply */
4040       Flag swapped=0;
4041       if (padding<0) {                  /* LHS needs the padding */
4042         const decNumber *t;
4043         padding=-padding;               /* will be +ve */
4044         bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
4045         t=lhs; lhs=rhs; rhs=t;
4046         swapped=1;
4047         }
4048
4049       /* If, after pad, rhs would be longer than lhs by digits+1 or */
4050       /* more then lhs cannot affect the answer, except as a residue, */
4051       /* so only need to pad up to a length of DIGITS+1. */
4052       if (rhs->digits+padding > lhs->digits+reqdigits+1) {
4053         /* The RHS is sufficient */
4054         /* for residue use the relative sign indication... */
4055         Int shift=reqdigits-rhs->digits;     /* left shift needed */
4056         residue=1;                           /* residue for rounding */
4057         if (diffsign) residue=-residue;      /* signs differ */
4058         /* copy, shortening if necessary */
4059         decCopyFit(res, rhs, set, &residue, status);
4060         /* if it was already shorter, then need to pad with zeros */
4061         if (shift>0) {
4062           res->digits=decShiftToMost(res->lsu, res->digits, shift);
4063           res->exponent-=shift;              /* adjust the exponent. */
4064           }
4065         /* flip the result sign if unswapped and rhs was negated */
4066         if (!swapped) res->bits^=negate;
4067         decFinish(res, set, &residue, status);    /* done */
4068         break;}
4069
4070       /* LHS digits may affect result */
4071       rhsshift=D2U(padding+1)-1;        /* this much by Unit shift .. */
4072       mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4073       } /* padding needed */
4074
4075     if (diffsign) mult=-mult;           /* signs differ */
4076
4077     /* determine the longer operand */
4078     maxdigits=rhs->digits+padding;      /* virtual length of RHS */
4079     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4080
4081     /* Decide on the result buffer to use; if possible place directly */
4082     /* into result. */
4083     acc=res->lsu;                       /* assume add direct to result */
4084     /* If destructive overlap, or the number is too long, or a carry or */
4085     /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4086     /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4087     if ((maxdigits>=reqdigits)          /* is, or could be, too large */
4088      || (res==rhs && rhsshift>0)) {     /* destructive overlap */
4089       /* buffer needed, choose it; units for maxdigits digits will be */
4090       /* needed, +1 Unit for carry or borrow */
4091       Int need=D2U(maxdigits)+1;
4092       acc=accbuff;                      /* assume use local buffer */
4093       if (need*sizeof(Unit)>sizeof(accbuff)) {
4094         /* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4095         allocacc=(Unit *)malloc(need*sizeof(Unit));
4096         if (allocacc==NULL) {           /* hopeless -- abandon */
4097           *status|=DEC_Insufficient_storage;
4098           break;}
4099         acc=allocacc;
4100         }
4101       }
4102
4103     res->bits=(uByte)(bits&DECNEG);     /* it's now safe to overwrite.. */
4104     res->exponent=lhs->exponent;        /* .. operands (even if aliased) */
4105
4106     #if DECTRACE
4107       decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4108       decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4109       printf("  :h: %ld %ld\n", rhsshift, mult);
4110     #endif
4111
4112     /* add [A+B*m] or subtract [A+B*(-m)] */
4113     res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4114                               rhs->lsu, D2U(rhs->digits),
4115                               rhsshift, acc, mult)
4116                *DECDPUN;           /* [units -> digits] */
4117     if (res->digits<0) {           /* borrowed... */
4118       res->digits=-res->digits;
4119       res->bits^=DECNEG;           /* flip the sign */
4120       }
4121     #if DECTRACE
4122       decDumpAr('+', acc, D2U(res->digits));
4123     #endif
4124
4125     /* If a buffer was used the result must be copied back, possibly */
4126     /* shortening.  (If no buffer was used then the result must have */
4127     /* fit, so can't need rounding and residue must be 0.) */
4128     residue=0;                     /* clear accumulator */
4129     if (acc!=res->lsu) {
4130       #if DECSUBSET
4131       if (set->extended) {         /* round from first significant digit */
4132       #endif
4133         /* remove leading zeros that were added due to rounding up to */
4134         /* integral Units -- before the test for rounding. */
4135         if (res->digits>reqdigits)
4136           res->digits=decGetDigits(acc, D2U(res->digits));
4137         decSetCoeff(res, set, acc, res->digits, &residue, status);
4138       #if DECSUBSET
4139         }
4140        else { /* subset arithmetic rounds from original significant digit */
4141         /* May have an underestimate.  This only occurs when both */
4142         /* numbers fit in DECDPUN digits and are padding with a */
4143         /* negative multiple (-10, -100...) and the top digit(s) become */
4144         /* 0.  (This only matters when using X3.274 rules where the */
4145         /* leading zero could be included in the rounding.) */
4146         if (res->digits<maxdigits) {
4147           *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4148           res->digits=maxdigits;
4149           }
4150          else {
4151           /* remove leading zeros that added due to rounding up to */
4152           /* integral Units (but only those in excess of the original */
4153           /* maxdigits length, unless extended) before test for rounding. */
4154           if (res->digits>reqdigits) {
4155             res->digits=decGetDigits(acc, D2U(res->digits));
4156             if (res->digits<maxdigits) res->digits=maxdigits;
4157             }
4158           }
4159         decSetCoeff(res, set, acc, res->digits, &residue, status);
4160         /* Now apply rounding if needed before removing leading zeros. */
4161         /* This is safe because subnormals are not a possibility */
4162         if (residue!=0) {
4163           decApplyRound(res, set, residue, status);
4164           residue=0;                 /* did what needed to be done */
4165           }
4166         } /* subset */
4167       #endif
4168       } /* used buffer */
4169
4170     /* strip leading zeros [these were left on in case of subset subtract] */
4171     res->digits=decGetDigits(res->lsu, D2U(res->digits));
4172
4173     /* apply checks and rounding */
4174     decFinish(res, set, &residue, status);
4175
4176     /* "When the sum of two operands with opposite signs is exactly */
4177     /* zero, the sign of that sum shall be '+' in all rounding modes */
4178     /* except round toward -Infinity, in which mode that sign shall be */
4179     /* '-'."  [Subset zeros also never have '-', set by decFinish.] */
4180     if (ISZERO(res) && diffsign
4181      #if DECSUBSET
4182      && set->extended
4183      #endif
4184      && (*status&DEC_Inexact)==0) {
4185       if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   /* sign - */
4186                                   else res->bits&=~DECNEG;  /* sign + */
4187       }
4188     } while(0);                              /* end protected */
4189
4190   if (allocacc!=NULL) free(allocacc);        /* drop any storage used */
4191   #if DECSUBSET
4192   if (allocrhs!=NULL) free(allocrhs);        /* .. */
4193   if (alloclhs!=NULL) free(alloclhs);        /* .. */
4194   #endif
4195   return res;
4196   } /* decAddOp */
4197
4198 /* ------------------------------------------------------------------ */
4199 /* decDivideOp -- division operation                                  */
4200 /*                                                                    */
4201 /*  This routine performs the calculations for all four division      */
4202 /*  operators (divide, divideInteger, remainder, remainderNear).      */
4203 /*                                                                    */
4204 /*  C=A op B                                                          */
4205 /*                                                                    */
4206 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
4207 /*   lhs is A                                                         */
4208 /*   rhs is B                                                         */
4209 /*   set is the context                                               */
4210 /*   op  is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
4211 /*   status is the usual accumulator                                  */
4212 /*                                                                    */
4213 /* C must have space for set->digits digits.                          */
4214 /*                                                                    */
4215 /* ------------------------------------------------------------------ */
4216 /*   The underlying algorithm of this routine is the same as in the   */
4217 /*   1981 S/370 implementation, that is, non-restoring long division  */
4218 /*   with bi-unit (rather than bi-digit) estimation for each unit     */
4219 /*   multiplier.  In this pseudocode overview, complications for the  */
4220 /*   Remainder operators and division residues for exact rounding are */
4221 /*   omitted for clarity.                                             */
4222 /*                                                                    */
4223 /*     Prepare operands and handle special values                     */
4224 /*     Test for x/0 and then 0/x                                      */
4225 /*     Exp =Exp1 - Exp2                                               */
4226 /*     Exp =Exp +len(var1) -len(var2)                                 */
4227 /*     Sign=Sign1 * Sign2                                             */
4228 /*     Pad accumulator (Var1) to double-length with 0's (pad1)        */
4229 /*     Pad Var2 to same length as Var1                                */
4230 /*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
4231 /*     have=0                                                         */
4232 /*     Do until (have=digits+1 OR residue=0)                          */
4233 /*       if exp<0 then if integer divide/residue then leave           */
4234 /*       this_unit=0                                                  */
4235 /*       Do forever                                                   */
4236 /*          compare numbers                                           */
4237 /*          if <0 then leave inner_loop                               */
4238 /*          if =0 then (* quick exit without subtract *) do           */
4239 /*             this_unit=this_unit+1; output this_unit                */
4240 /*             leave outer_loop; end                                  */
4241 /*          Compare lengths of numbers (mantissae):                   */
4242 /*          If same then tops2=msu2pair -- {units 1&2 of var2}        */
4243 /*                  else tops2=msu2plus -- {0, unit 1 of var2}        */
4244 /*          tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4245 /*          mult=tops1/tops2  -- Good and safe guess at divisor       */
4246 /*          if mult=0 then mult=1                                     */
4247 /*          this_unit=this_unit+mult                                  */
4248 /*          subtract                                                  */
4249 /*          end inner_loop                                            */
4250 /*        if have\=0 | this_unit\=0 then do                           */
4251 /*          output this_unit                                          */
4252 /*          have=have+1; end                                          */
4253 /*        var2=var2/10                                                */
4254 /*        exp=exp-1                                                   */
4255 /*        end outer_loop                                              */
4256 /*     exp=exp+1   -- set the proper exponent                         */
4257 /*     if have=0 then generate answer=0                               */
4258 /*     Return (Result is defined by Var1)                             */
4259 /*                                                                    */
4260 /* ------------------------------------------------------------------ */
4261 /* Two working buffers are needed during the division; one (digits+   */
4262 /* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
4263 /* long subtractions.  These are acc and var1 respectively.           */
4264 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4265 /* The static buffers may be larger than might be expected to allow   */
4266 /* for calls from higher-level functions (notably exp).               */
4267 /* ------------------------------------------------------------------ */
4268 static decNumber * decDivideOp(decNumber *res,
4269                                const decNumber *lhs, const decNumber *rhs,
4270                                decContext *set, Flag op, uInt *status) {
4271   #if DECSUBSET
4272   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
4273   decNumber *allocrhs=NULL;        /* .., rhs */
4274   #endif
4275   Unit  accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4276   Unit  *acc=accbuff;              /* -> accumulator array for result */
4277   Unit  *allocacc=NULL;            /* -> allocated buffer, iff allocated */
4278   Unit  *accnext;                  /* -> where next digit will go */
4279   Int   acclength;                 /* length of acc needed [Units] */
4280   Int   accunits;                  /* count of units accumulated */
4281   Int   accdigits;                 /* count of digits accumulated */
4282
4283   Unit  varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */
4284   Unit  *var1=varbuff;             /* -> var1 array for long subtraction */
4285   Unit  *varalloc=NULL;            /* -> allocated buffer, iff used */
4286   Unit  *msu1;                     /* -> msu of var1 */
4287
4288   const Unit *var2;                /* -> var2 array */
4289   const Unit *msu2;                /* -> msu of var2 */
4290   Int   msu2plus;                  /* msu2 plus one [does not vary] */
4291   eInt  msu2pair;                  /* msu2 pair plus one [does not vary] */
4292
4293   Int   var1units, var2units;      /* actual lengths */
4294   Int   var2ulen;                  /* logical length (units) */
4295   Int   var1initpad=0;             /* var1 initial padding (digits) */
4296   Int   maxdigits;                 /* longest LHS or required acc length */
4297   Int   mult;                      /* multiplier for subtraction */
4298   Unit  thisunit;                  /* current unit being accumulated */
4299   Int   residue;                   /* for rounding */
4300   Int   reqdigits=set->digits;     /* requested DIGITS */
4301   Int   exponent;                  /* working exponent */
4302   Int   maxexponent=0;             /* DIVIDE maximum exponent if unrounded */
4303   uByte bits;                      /* working sign */
4304   Unit  *target;                   /* work */
4305   const Unit *source;              /* .. */
4306   uLong const *pow;                /* .. */
4307   Int   shift, cut;                /* .. */
4308   #if DECSUBSET
4309   Int   dropped;                   /* work */
4310   #endif
4311
4312   #if DECCHECK
4313   if (decCheckOperands(res, lhs, rhs, set)) return res;
4314   #endif
4315
4316   do {                             /* protect allocated storage */
4317     #if DECSUBSET
4318     if (!set->extended) {
4319       /* reduce operands and set lostDigits status, as needed */
4320       if (lhs->digits>reqdigits) {
4321         alloclhs=decRoundOperand(lhs, set, status);
4322         if (alloclhs==NULL) break;
4323         lhs=alloclhs;
4324         }
4325       if (rhs->digits>reqdigits) {
4326         allocrhs=decRoundOperand(rhs, set, status);
4327         if (allocrhs==NULL) break;
4328         rhs=allocrhs;
4329         }
4330       }
4331     #endif
4332     /* [following code does not require input rounding] */
4333
4334     bits=(lhs->bits^rhs->bits)&DECNEG;  /* assumed sign for divisions */
4335
4336     /* handle infinities and NaNs */
4337     if (SPECIALARGS) {                  /* a special bit set */
4338       if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4339         decNaNs(res, lhs, rhs, set, status);
4340         break;
4341         }
4342       /* one or two infinities */
4343       if (decNumberIsInfinite(lhs)) {   /* LHS (dividend) is infinite */
4344         if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4345             op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4346           *status|=DEC_Invalid_operation;
4347           break;
4348           }
4349         /* [Note that infinity/0 raises no exceptions] */
4350         decNumberZero(res);
4351         res->bits=bits|DECINF;          /* set +/- infinity */
4352         break;
4353         }
4354        else {                           /* RHS (divisor) is infinite */
4355         residue=0;
4356         if (op&(REMAINDER|REMNEAR)) {
4357           /* result is [finished clone of] lhs */
4358           decCopyFit(res, lhs, set, &residue, status);
4359           }
4360          else {  /* a division */
4361           decNumberZero(res);
4362           res->bits=bits;               /* set +/- zero */
4363           /* for DIVIDEINT the exponent is always 0.  For DIVIDE, result */
4364           /* is a 0 with infinitely negative exponent, clamped to minimum */
4365           if (op&DIVIDE) {
4366             res->exponent=set->emin-set->digits+1;
4367             *status|=DEC_Clamped;
4368             }
4369           }
4370         decFinish(res, set, &residue, status);
4371         break;
4372         }
4373       }
4374
4375     /* handle 0 rhs (x/0) */
4376     if (ISZERO(rhs)) {                  /* x/0 is always exceptional */
4377       if (ISZERO(lhs)) {
4378         decNumberZero(res);             /* [after lhs test] */
4379         *status|=DEC_Division_undefined;/* 0/0 will become NaN */
4380         }
4381        else {
4382         decNumberZero(res);
4383         if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4384          else {
4385           *status|=DEC_Division_by_zero; /* x/0 */
4386           res->bits=bits|DECINF;         /* .. is +/- Infinity */
4387           }
4388         }
4389       break;}
4390
4391     /* handle 0 lhs (0/x) */
4392     if (ISZERO(lhs)) {                  /* 0/x [x!=0] */
4393       #if DECSUBSET
4394       if (!set->extended) decNumberZero(res);
4395        else {
4396       #endif
4397         if (op&DIVIDE) {
4398           residue=0;
4399           exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4400           decNumberCopy(res, lhs);      /* [zeros always fit] */
4401           res->bits=bits;               /* sign as computed */
4402           res->exponent=exponent;       /* exponent, too */
4403           decFinalize(res, set, &residue, status);   /* check exponent */
4404           }
4405          else if (op&DIVIDEINT) {
4406           decNumberZero(res);           /* integer 0 */
4407           res->bits=bits;               /* sign as computed */
4408           }
4409          else {                         /* a remainder */
4410           exponent=rhs->exponent;       /* [save in case overwrite] */
4411           decNumberCopy(res, lhs);      /* [zeros always fit] */
4412           if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4413           }
4414       #if DECSUBSET
4415         }
4416       #endif
4417       break;}
4418
4419     /* Precalculate exponent.  This starts off adjusted (and hence fits */
4420     /* in 31 bits) and becomes the usual unadjusted exponent as the */
4421     /* division proceeds.  The order of evaluation is important, here, */
4422     /* to avoid wrap. */
4423     exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4424
4425     /* If the working exponent is -ve, then some quick exits are */
4426     /* possible because the quotient is known to be <1 */
4427     /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4428     if (exponent<0 && !(op==DIVIDE)) {
4429       if (op&DIVIDEINT) {
4430         decNumberZero(res);                  /* integer part is 0 */
4431         #if DECSUBSET
4432         if (set->extended)
4433         #endif
4434           res->bits=bits;                    /* set +/- zero */
4435         break;}
4436       /* fastpath remainders so long as the lhs has the smaller */
4437       /* (or equal) exponent */
4438       if (lhs->exponent<=rhs->exponent) {
4439         if (op&REMAINDER || exponent<-1) {
4440           /* It is REMAINDER or safe REMNEAR; result is [finished */
4441           /* clone of] lhs  (r = x - 0*y) */
4442           residue=0;
4443           decCopyFit(res, lhs, set, &residue, status);
4444           decFinish(res, set, &residue, status);
4445           break;
4446           }
4447         /* [unsafe REMNEAR drops through] */
4448         }
4449       } /* fastpaths */
4450
4451     /* Long (slow) division is needed; roll up the sleeves... */
4452
4453     /* The accumulator will hold the quotient of the division. */
4454     /* If it needs to be too long for stack storage, then allocate. */
4455     acclength=D2U(reqdigits+DECDPUN);   /* in Units */
4456     if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4457       /* printf("malloc dvacc %ld units\n", acclength); */
4458       allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4459       if (allocacc==NULL) {             /* hopeless -- abandon */
4460         *status|=DEC_Insufficient_storage;
4461         break;}
4462       acc=allocacc;                     /* use the allocated space */
4463       }
4464
4465     /* var1 is the padded LHS ready for subtractions. */
4466     /* If it needs to be too long for stack storage, then allocate. */
4467     /* The maximum units needed for var1 (long subtraction) is: */
4468     /* Enough for */
4469     /*     (rhs->digits+reqdigits-1) -- to allow full slide to right */
4470     /* or  (lhs->digits)             -- to allow for long lhs */
4471     /* whichever is larger */
4472     /*   +1                -- for rounding of slide to right */
4473     /*   +1                -- for leading 0s */
4474     /*   +1                -- for pre-adjust if a remainder or DIVIDEINT */
4475     /* [Note: unused units do not participate in decUnitAddSub data] */
4476     maxdigits=rhs->digits+reqdigits-1;
4477     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4478     var1units=D2U(maxdigits)+2;
4479     /* allocate a guard unit above msu1 for REMAINDERNEAR */
4480     if (!(op&DIVIDE)) var1units++;
4481     if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4482       /* printf("malloc dvvar %ld units\n", var1units+1); */
4483       varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4484       if (varalloc==NULL) {             /* hopeless -- abandon */
4485         *status|=DEC_Insufficient_storage;
4486         break;}
4487       var1=varalloc;                    /* use the allocated space */
4488       }
4489
4490     /* Extend the lhs and rhs to full long subtraction length.  The lhs */
4491     /* is truly extended into the var1 buffer, with 0 padding, so a */
4492     /* subtract in place is always possible.  The rhs (var2) has */
4493     /* virtual padding (implemented by decUnitAddSub). */
4494     /* One guard unit was allocated above msu1 for rem=rem+rem in */
4495     /* REMAINDERNEAR. */
4496     msu1=var1+var1units-1;              /* msu of var1 */
4497     source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4498     for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4499     for (; target>=var1; target--) *target=0;
4500
4501     /* rhs (var2) is left-aligned with var1 at the start */
4502     var2ulen=var1units;                 /* rhs logical length (units) */
4503     var2units=D2U(rhs->digits);         /* rhs actual length (units) */
4504     var2=rhs->lsu;                      /* -> rhs array */
4505     msu2=var2+var2units-1;              /* -> msu of var2 [never changes] */
4506     /* now set up the variables which will be used for estimating the */
4507     /* multiplication factor.  If these variables are not exact, add */
4508     /* 1 to make sure that the multiplier is never overestimated. */
4509     msu2plus=*msu2;                     /* it's value .. */
4510     if (var2units>1) msu2plus++;        /* .. +1 if any more */
4511     msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4512     if (var2units>1) {                  /* .. [else treat 2nd as 0] */
4513       msu2pair+=*(msu2-1);              /* .. */
4514       if (var2units>2) msu2pair++;      /* .. +1 if any more */
4515       }
4516
4517     /* The calculation is working in units, which may have leading zeros, */
4518     /* but the exponent was calculated on the assumption that they are */
4519     /* both left-aligned.  Adjust the exponent to compensate: add the */
4520     /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4521     /* [This is actually done by counting the digits and negating, as */
4522     /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4523     for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4524     for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4525
4526     /* Now, if doing an integer divide or remainder, ensure that */
4527     /* the result will be Unit-aligned.  To do this, shift the var1 */
4528     /* accumulator towards least if need be.  (It's much easier to */
4529     /* do this now than to reassemble the residue afterwards, if */
4530     /* doing a remainder.)  Also ensure the exponent is not negative. */
4531     if (!(op&DIVIDE)) {
4532       Unit *u;                          /* work */
4533       /* save the initial 'false' padding of var1, in digits */
4534       var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4535       /* Determine the shift to do. */
4536       if (exponent<0) cut=-exponent;
4537        else cut=DECDPUN-exponent%DECDPUN;
4538       decShiftToLeast(var1, var1units, cut);
4539       exponent+=cut;                    /* maintain numerical value */
4540       var1initpad-=cut;                 /* .. and reduce padding */
4541       /* clean any most-significant units which were just emptied */
4542       for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4543       } /* align */
4544      else { /* is DIVIDE */
4545       maxexponent=lhs->exponent-rhs->exponent;    /* save */
4546       /* optimization: if the first iteration will just produce 0, */
4547       /* preadjust to skip it [valid for DIVIDE only] */
4548       if (*msu1<*msu2) {
4549         var2ulen--;                     /* shift down */
4550         exponent-=DECDPUN;              /* update the exponent */
4551         }
4552       }
4553
4554     /* ---- start the long-division loops ------------------------------ */
4555     accunits=0;                         /* no units accumulated yet */
4556     accdigits=0;                        /* .. or digits */
4557     accnext=acc+acclength-1;            /* -> msu of acc [NB: allows digits+1] */
4558     for (;;) {                          /* outer forever loop */
4559       thisunit=0;                       /* current unit assumed 0 */
4560       /* find the next unit */
4561       for (;;) {                        /* inner forever loop */
4562         /* strip leading zero units [from either pre-adjust or from */
4563         /* subtract last time around].  Leave at least one unit. */
4564         for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4565
4566         if (var1units<var2ulen) break;       /* var1 too low for subtract */
4567         if (var1units==var2ulen) {           /* unit-by-unit compare needed */
4568           /* compare the two numbers, from msu */
4569           const Unit *pv1, *pv2;
4570           Unit v2;                           /* units to compare */
4571           pv2=msu2;                          /* -> msu */
4572           for (pv1=msu1; ; pv1--, pv2--) {
4573             /* v1=*pv1 -- always OK */
4574             v2=0;                            /* assume in padding */
4575             if (pv2>=var2) v2=*pv2;          /* in range */
4576             if (*pv1!=v2) break;             /* no longer the same */
4577             if (pv1==var1) break;            /* done; leave pv1 as is */
4578             }
4579           /* here when all inspected or a difference seen */
4580           if (*pv1<v2) break;                /* var1 too low to subtract */
4581           if (*pv1==v2) {                    /* var1 == var2 */
4582             /* reach here if var1 and var2 are identical; subtraction */
4583             /* would increase digit by one, and the residue will be 0 so */
4584             /* the calculation is done; leave the loop with residue=0. */
4585             thisunit++;                      /* as though subtracted */
4586             *var1=0;                         /* set var1 to 0 */
4587             var1units=1;                     /* .. */
4588             break;  /* from inner */
4589             } /* var1 == var2 */
4590           /* *pv1>v2.  Prepare for real subtraction; the lengths are equal */
4591           /* Estimate the multiplier (there's always a msu1-1)... */
4592           /* Bring in two units of var2 to provide a good estimate. */
4593           mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4594           } /* lengths the same */
4595          else { /* var1units > var2ulen, so subtraction is safe */
4596           /* The var2 msu is one unit towards the lsu of the var1 msu, */
4597           /* so only one unit for var2 can be used. */
4598           mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4599           }
4600         if (mult==0) mult=1;                 /* must always be at least 1 */
4601         /* subtraction needed; var1 is > var2 */
4602         thisunit=(Unit)(thisunit+mult);      /* accumulate */
4603         /* subtract var1-var2, into var1; only the overlap needs */
4604         /* processing, as this is an in-place calculation */
4605         shift=var2ulen-var2units;
4606         #if DECTRACE
4607           decDumpAr('1', &var1[shift], var1units-shift);
4608           decDumpAr('2', var2, var2units);
4609           printf("m=%ld\n", -mult);
4610         #endif
4611         decUnitAddSub(&var1[shift], var1units-shift,
4612                       var2, var2units, 0,
4613                       &var1[shift], -mult);
4614         #if DECTRACE
4615           decDumpAr('#', &var1[shift], var1units-shift);
4616         #endif
4617         /* var1 now probably has leading zeros; these are removed at the */
4618         /* top of the inner loop. */
4619         } /* inner loop */
4620
4621       /* The next unit has been calculated in full; unless it's a */
4622       /* leading zero, add to acc */
4623       if (accunits!=0 || thisunit!=0) {      /* is first or non-zero */
4624         *accnext=thisunit;                   /* store in accumulator */
4625         /* account exactly for the new digits */
4626         if (accunits==0) {
4627           accdigits++;                       /* at least one */
4628           for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4629           }
4630          else accdigits+=DECDPUN;
4631         accunits++;                          /* update count */
4632         accnext--;                           /* ready for next */
4633         if (accdigits>reqdigits) break;      /* have enough digits */
4634         }
4635
4636       /* if the residue is zero, the operation is done (unless divide */
4637       /* or divideInteger and still not enough digits yet) */
4638       if (*var1==0 && var1units==1) {        /* residue is 0 */
4639         if (op&(REMAINDER|REMNEAR)) break;
4640         if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4641         /* [drop through if divideInteger] */
4642         }
4643       /* also done enough if calculating remainder or integer */
4644       /* divide and just did the last ('units') unit */
4645       if (exponent==0 && !(op&DIVIDE)) break;
4646
4647       /* to get here, var1 is less than var2, so divide var2 by the per- */
4648       /* Unit power of ten and go for the next digit */
4649       var2ulen--;                            /* shift down */
4650       exponent-=DECDPUN;                     /* update the exponent */
4651       } /* outer loop */
4652
4653     /* ---- division is complete --------------------------------------- */
4654     /* here: acc      has at least reqdigits+1 of good results (or fewer */
4655     /*                if early stop), starting at accnext+1 (its lsu) */
4656     /*       var1     has any residue at the stopping point */
4657     /*       accunits is the number of digits collected in acc */
4658     if (accunits==0) {             /* acc is 0 */
4659       accunits=1;                  /* show have a unit .. */
4660       accdigits=1;                 /* .. */
4661       *accnext=0;                  /* .. whose value is 0 */
4662       }
4663      else accnext++;               /* back to last placed */
4664     /* accnext now -> lowest unit of result */
4665
4666     residue=0;                     /* assume no residue */
4667     if (op&DIVIDE) {
4668       /* record the presence of any residue, for rounding */
4669       if (*var1!=0 || var1units>1) residue=1;
4670        else { /* no residue */
4671         /* Had an exact division; clean up spurious trailing 0s. */
4672         /* There will be at most DECDPUN-1, from the final multiply, */
4673         /* and then only if the result is non-0 (and even) and the */
4674         /* exponent is 'loose'. */
4675         #if DECDPUN>1
4676         Unit lsu=*accnext;
4677         if (!(lsu&0x01) && (lsu!=0)) {
4678           /* count the trailing zeros */
4679           Int drop=0;
4680           for (;; drop++) {    /* [will terminate because lsu!=0] */
4681             if (exponent>=maxexponent) break;     /* don't chop real 0s */
4682             #if DECDPUN<=4
4683               if ((lsu-QUOT10(lsu, drop+1)
4684                   *powers[drop+1])!=0) break;     /* found non-0 digit */
4685             #else
4686               if (lsu%powers[drop+1]!=0) break;   /* found non-0 digit */
4687             #endif
4688             exponent++;
4689             }
4690           if (drop>0) {
4691             accunits=decShiftToLeast(accnext, accunits, drop);
4692             accdigits=decGetDigits(accnext, accunits);
4693             accunits=D2U(accdigits);
4694             /* [exponent was adjusted in the loop] */
4695             }
4696           } /* neither odd nor 0 */
4697         #endif
4698         } /* exact divide */
4699       } /* divide */
4700      else /* op!=DIVIDE */ {
4701       /* check for coefficient overflow */
4702       if (accdigits+exponent>reqdigits) {
4703         *status|=DEC_Division_impossible;
4704         break;
4705         }
4706       if (op & (REMAINDER|REMNEAR)) {
4707         /* [Here, the exponent will be 0, because var1 was adjusted */
4708         /* appropriately.] */
4709         Int postshift;                       /* work */
4710         Flag wasodd=0;                       /* integer was odd */
4711         Unit *quotlsu;                       /* for save */
4712         Int  quotdigits;                     /* .. */
4713
4714         bits=lhs->bits;                      /* remainder sign is always as lhs */
4715
4716         /* Fastpath when residue is truly 0 is worthwhile [and */
4717         /* simplifies the code below] */
4718         if (*var1==0 && var1units==1) {      /* residue is 0 */
4719           Int exp=lhs->exponent;             /* save min(exponents) */
4720           if (rhs->exponent<exp) exp=rhs->exponent;
4721           decNumberZero(res);                /* 0 coefficient */
4722           #if DECSUBSET
4723           if (set->extended)
4724           #endif
4725           res->exponent=exp;                 /* .. with proper exponent */
4726           res->bits=(uByte)(bits&DECNEG);          /* [cleaned] */
4727           decFinish(res, set, &residue, status);   /* might clamp */
4728           break;
4729           }
4730         /* note if the quotient was odd */
4731         if (*accnext & 0x01) wasodd=1;       /* acc is odd */
4732         quotlsu=accnext;                     /* save in case need to reinspect */
4733         quotdigits=accdigits;                /* .. */
4734
4735         /* treat the residue, in var1, as the value to return, via acc */
4736         /* calculate the unused zero digits.  This is the smaller of: */
4737         /*   var1 initial padding (saved above) */
4738         /*   var2 residual padding, which happens to be given by: */
4739         postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4740         /* [the 'exponent' term accounts for the shifts during divide] */
4741         if (var1initpad<postshift) postshift=var1initpad;
4742
4743         /* shift var1 the requested amount, and adjust its digits */
4744         var1units=decShiftToLeast(var1, var1units, postshift);
4745         accnext=var1;
4746         accdigits=decGetDigits(var1, var1units);
4747         accunits=D2U(accdigits);
4748
4749         exponent=lhs->exponent;         /* exponent is smaller of lhs & rhs */
4750         if (rhs->exponent<exponent) exponent=rhs->exponent;
4751
4752         /* Now correct the result if doing remainderNear; if it */
4753         /* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4754         /* the integer was odd then the result should be rem-rhs. */
4755         if (op&REMNEAR) {
4756           Int compare, tarunits;        /* work */
4757           Unit *up;                     /* .. */
4758           /* calculate remainder*2 into the var1 buffer (which has */
4759           /* 'headroom' of an extra unit and hence enough space) */
4760           /* [a dedicated 'double' loop would be faster, here] */
4761           tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4762                                  0, accnext, 1);
4763           /* decDumpAr('r', accnext, tarunits); */
4764
4765           /* Here, accnext (var1) holds tarunits Units with twice the */
4766           /* remainder's coefficient, which must now be compared to the */
4767           /* RHS.  The remainder's exponent may be smaller than the RHS's. */
4768           compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4769                                  rhs->exponent-exponent);
4770           if (compare==BADINT) {             /* deep trouble */
4771             *status|=DEC_Insufficient_storage;
4772             break;}
4773
4774           /* now restore the remainder by dividing by two; the lsu */
4775           /* is known to be even. */
4776           for (up=accnext; up<accnext+tarunits; up++) {
4777             Int half;              /* half to add to lower unit */
4778             half=*up & 0x01;
4779             *up/=2;                /* [shift] */
4780             if (!half) continue;
4781             *(up-1)+=(DECDPUNMAX+1)/2;
4782             }
4783           /* [accunits still describes the original remainder length] */
4784
4785           if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4786             Int exp, expunits, exprem;       /* work */
4787             /* This is effectively causing round-up of the quotient, */
4788             /* so if it was the rare case where it was full and all */
4789             /* nines, it would overflow and hence division-impossible */
4790             /* should be raised */
4791             Flag allnines=0;                 /* 1 if quotient all nines */
4792             if (quotdigits==reqdigits) {     /* could be borderline */
4793               for (up=quotlsu; ; up++) {
4794                 if (quotdigits>DECDPUN) {
4795                   if (*up!=DECDPUNMAX) break;/* non-nines */
4796                   }
4797                  else {                      /* this is the last Unit */
4798                   if (*up==powers[quotdigits]-1) allnines=1;
4799                   break;
4800                   }
4801                 quotdigits-=DECDPUN;         /* checked those digits */
4802                 } /* up */
4803               } /* borderline check */
4804             if (allnines) {
4805               *status|=DEC_Division_impossible;
4806               break;}
4807
4808             /* rem-rhs is needed; the sign will invert.  Again, var1 */
4809             /* can safely be used for the working Units array. */
4810             exp=rhs->exponent-exponent;      /* RHS padding needed */
4811             /* Calculate units and remainder from exponent. */
4812             expunits=exp/DECDPUN;
4813             exprem=exp%DECDPUN;
4814             /* subtract [A+B*(-m)]; the result will always be negative */
4815             accunits=-decUnitAddSub(accnext, accunits,
4816                                     rhs->lsu, D2U(rhs->digits),
4817                                     expunits, accnext, -(Int)powers[exprem]);
4818             accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4819             accunits=D2U(accdigits);    /* and recalculate the units for copy */
4820             /* [exponent is as for original remainder] */
4821             bits^=DECNEG;               /* flip the sign */
4822             }
4823           } /* REMNEAR */
4824         } /* REMAINDER or REMNEAR */
4825       } /* not DIVIDE */
4826
4827     /* Set exponent and bits */
4828     res->exponent=exponent;
4829     res->bits=(uByte)(bits&DECNEG);          /* [cleaned] */
4830
4831     /* Now the coefficient. */
4832     decSetCoeff(res, set, accnext, accdigits, &residue, status);
4833
4834     decFinish(res, set, &residue, status);   /* final cleanup */
4835
4836     #if DECSUBSET
4837     /* If a divide then strip trailing zeros if subset [after round] */
4838     if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped);
4839     #endif
4840     } while(0);                              /* end protected */
4841
4842   if (varalloc!=NULL) free(varalloc);   /* drop any storage used */
4843   if (allocacc!=NULL) free(allocacc);   /* .. */
4844   #if DECSUBSET
4845   if (allocrhs!=NULL) free(allocrhs);   /* .. */
4846   if (alloclhs!=NULL) free(alloclhs);   /* .. */
4847   #endif
4848   return res;
4849   } /* decDivideOp */
4850
4851 /* ------------------------------------------------------------------ */
4852 /* decMultiplyOp -- multiplication operation                          */
4853 /*                                                                    */
4854 /*  This routine performs the multiplication C=A x B.                 */
4855 /*                                                                    */
4856 /*   res is C, the result.  C may be A and/or B (e.g., X=X*X)         */
4857 /*   lhs is A                                                         */
4858 /*   rhs is B                                                         */
4859 /*   set is the context                                               */
4860 /*   status is the usual accumulator                                  */
4861 /*                                                                    */
4862 /* C must have space for set->digits digits.                          */
4863 /*                                                                    */
4864 /* ------------------------------------------------------------------ */
4865 /* 'Classic' multiplication is used rather than Karatsuba, as the     */
4866 /* latter would give only a minor improvement for the short numbers   */
4867 /* expected to be handled most (and uses much more memory).           */
4868 /*                                                                    */
4869 /* There are two major paths here: the general-purpose ('old code')   */
4870 /* path which handles all DECDPUN values, and a fastpath version      */
4871 /* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
4872 /* than two calls to decUnitAddSub would be made.                     */
4873 /*                                                                    */
4874 /* The fastpath version lumps units together into 8-digit or 9-digit  */
4875 /* chunks, and also uses a lazy carry strategy to minimise expensive  */
4876 /* 64-bit divisions.  The chunks are then broken apart again into     */
4877 /* units for continuing processing.  Despite this overhead, the       */
4878 /* fastpath can speed up some 16-digit operations by 10x (and much    */
4879 /* more for higher-precision calculations).                           */
4880 /*                                                                    */
4881 /* A buffer always has to be used for the accumulator; in the         */
4882 /* fastpath, buffers are also always needed for the chunked copies of */
4883 /* of the operand coefficients.                                       */
4884 /* Static buffers are larger than needed just for multiply, to allow  */
4885 /* for calls from other operations (notably exp).                     */
4886 /* ------------------------------------------------------------------ */
4887 #define FASTMUL (DECUSE64 && DECDPUN<5)
4888 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4889                                  const decNumber *rhs, decContext *set,
4890                                  uInt *status) {
4891   Int    accunits;                 /* Units of accumulator in use */
4892   Int    exponent;                 /* work */
4893   Int    residue=0;                /* rounding residue */
4894   uByte  bits;                     /* result sign */
4895   Unit  *acc;                      /* -> accumulator Unit array */
4896   Int    needbytes;                /* size calculator */
4897   void  *allocacc=NULL;            /* -> allocated accumulator, iff allocated */
4898   Unit  accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4899                                    /* *4 for calls from other operations) */
4900   const Unit *mer, *mermsup;       /* work */
4901   Int   madlength;                 /* Units in multiplicand */
4902   Int   shift;                     /* Units to shift multiplicand by */
4903
4904   #if FASTMUL
4905     /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4906     /* (DECDPUN is 2 or 4) then work in base 10**8 */
4907     #if DECDPUN & 1                /* odd */
4908       #define FASTBASE 1000000000  /* base */
4909       #define FASTDIGS          9  /* digits in base */
4910       #define FASTLAZY         18  /* carry resolution point [1->18] */
4911     #else
4912       #define FASTBASE  100000000
4913       #define FASTDIGS          8
4914       #define FASTLAZY       1844  /* carry resolution point [1->1844] */
4915     #endif
4916     /* three buffers are used, two for chunked copies of the operands */
4917     /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4918     /* lazy carry evaluation */
4919     uInt   zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4920     uInt  *zlhi=zlhibuff;                 /* -> lhs array */
4921     uInt  *alloclhi=NULL;                 /* -> allocated buffer, iff allocated */
4922     uInt   zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4923     uInt  *zrhi=zrhibuff;                 /* -> rhs array */
4924     uInt  *allocrhi=NULL;                 /* -> allocated buffer, iff allocated */
4925     uLong  zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4926     /* [allocacc is shared for both paths, as only one will run] */
4927     uLong *zacc=zaccbuff;          /* -> accumulator array for exact result */
4928     #if DECDPUN==1
4929     Int    zoff;                   /* accumulator offset */
4930     #endif
4931     uInt  *lip, *rip;              /* item pointers */
4932     uInt  *lmsi, *rmsi;            /* most significant items */
4933     Int    ilhs, irhs, iacc;       /* item counts in the arrays */
4934     Int    lazy;                   /* lazy carry counter */
4935     uLong  lcarry;                 /* uLong carry */
4936     uInt   carry;                  /* carry (NB not uLong) */
4937     Int    count;                  /* work */
4938     const  Unit *cup;              /* .. */
4939     Unit  *up;                     /* .. */
4940     uLong *lp;                     /* .. */
4941     Int    p;                      /* .. */
4942   #endif
4943
4944   #if DECSUBSET
4945     decNumber *alloclhs=NULL;      /* -> allocated buffer, iff allocated */
4946     decNumber *allocrhs=NULL;      /* -> allocated buffer, iff allocated */
4947   #endif
4948
4949   #if DECCHECK
4950   if (decCheckOperands(res, lhs, rhs, set)) return res;
4951   #endif
4952
4953   /* precalculate result sign */
4954   bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4955
4956   /* handle infinities and NaNs */
4957   if (SPECIALARGS) {               /* a special bit set */
4958     if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4959       decNaNs(res, lhs, rhs, set, status);
4960       return res;}
4961     /* one or two infinities; Infinity * 0 is invalid */
4962     if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4963       ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4964       *status|=DEC_Invalid_operation;
4965       return res;}
4966     decNumberZero(res);
4967     res->bits=bits|DECINF;         /* infinity */
4968     return res;}
4969
4970   /* For best speed, as in DMSRCN [the original Rexx numerics */
4971   /* module], use the shorter number as the multiplier (rhs) and */
4972   /* the longer as the multiplicand (lhs) to minimise the number of */
4973   /* adds (partial products) */
4974   if (lhs->digits<rhs->digits) {   /* swap... */
4975     const decNumber *hold=lhs;
4976     lhs=rhs;
4977     rhs=hold;
4978     }
4979
4980   do {                             /* protect allocated storage */
4981     #if DECSUBSET
4982     if (!set->extended) {
4983       /* reduce operands and set lostDigits status, as needed */
4984       if (lhs->digits>set->digits) {
4985         alloclhs=decRoundOperand(lhs, set, status);
4986         if (alloclhs==NULL) break;
4987         lhs=alloclhs;
4988         }
4989       if (rhs->digits>set->digits) {
4990         allocrhs=decRoundOperand(rhs, set, status);
4991         if (allocrhs==NULL) break;
4992         rhs=allocrhs;
4993         }
4994       }
4995     #endif
4996     /* [following code does not require input rounding] */
4997
4998     #if FASTMUL                    /* fastpath can be used */
4999     /* use the fast path if there are enough digits in the shorter */
5000     /* operand to make the setup and takedown worthwhile */
5001     #define NEEDTWO (DECDPUN*2)    /* within two decUnitAddSub calls */
5002     if (rhs->digits>NEEDTWO) {     /* use fastpath... */
5003       /* calculate the number of elements in each array */
5004       ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
5005       irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
5006       iacc=ilhs+irhs;
5007
5008       /* allocate buffers if required, as usual */
5009       needbytes=ilhs*sizeof(uInt);
5010       if (needbytes>(Int)sizeof(zlhibuff)) {
5011         alloclhi=(uInt *)malloc(needbytes);
5012         zlhi=alloclhi;}
5013       needbytes=irhs*sizeof(uInt);
5014       if (needbytes>(Int)sizeof(zrhibuff)) {
5015         allocrhi=(uInt *)malloc(needbytes);
5016         zrhi=allocrhi;}
5017
5018       /* Allocating the accumulator space needs a special case when */
5019       /* DECDPUN=1 because when converting the accumulator to Units */
5020       /* after the multiplication each 8-byte item becomes 9 1-byte */
5021       /* units.  Therefore iacc extra bytes are needed at the front */
5022       /* (rounded up to a multiple of 8 bytes), and the uLong */
5023       /* accumulator starts offset the appropriate number of units */
5024       /* to the right to avoid overwrite during the unchunking. */
5025       needbytes=iacc*sizeof(uLong);
5026       #if DECDPUN==1
5027       zoff=(iacc+7)/8;        /* items to offset by */
5028       needbytes+=zoff*8;
5029       #endif
5030       if (needbytes>(Int)sizeof(zaccbuff)) {
5031         allocacc=(uLong *)malloc(needbytes);
5032         zacc=(uLong *)allocacc;}
5033       if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
5034         *status|=DEC_Insufficient_storage;
5035         break;}
5036
5037       acc=(Unit *)zacc;       /* -> target Unit array */
5038       #if DECDPUN==1
5039       zacc+=zoff;             /* start uLong accumulator to right */
5040       #endif
5041
5042       /* assemble the chunked copies of the left and right sides */
5043       for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
5044         for (p=0, *lip=0; p<FASTDIGS && count>0;
5045              p+=DECDPUN, cup++, count-=DECDPUN)
5046           *lip+=*cup*powers[p];
5047       lmsi=lip-1;     /* save -> msi */
5048       for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
5049         for (p=0, *rip=0; p<FASTDIGS && count>0;
5050              p+=DECDPUN, cup++, count-=DECDPUN)
5051           *rip+=*cup*powers[p];
5052       rmsi=rip-1;     /* save -> msi */
5053
5054       /* zero the accumulator */
5055       for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
5056
5057       /* Start the multiplication */
5058       /* Resolving carries can dominate the cost of accumulating the */
5059       /* partial products, so this is only done when necessary. */
5060       /* Each uLong item in the accumulator can hold values up to */
5061       /* 2**64-1, and each partial product can be as large as */
5062       /* (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to */
5063       /* itself 18.4 times in a uLong without overflowing, so during */
5064       /* the main calculation resolution is carried out every 18th */
5065       /* add -- every 162 digits.  Similarly, when FASTDIGS=8, the */
5066       /* partial products can be added to themselves 1844.6 times in */
5067       /* a uLong without overflowing, so intermediate carry */
5068       /* resolution occurs only every 14752 digits.  Hence for common */
5069       /* short numbers usually only the one final carry resolution */
5070       /* occurs. */
5071       /* (The count is set via FASTLAZY to simplify experiments to */
5072       /* measure the value of this approach: a 35% improvement on a */
5073       /* [34x34] multiply.) */
5074       lazy=FASTLAZY;                         /* carry delay count */
5075       for (rip=zrhi; rip<=rmsi; rip++) {     /* over each item in rhs */
5076         lp=zacc+(rip-zrhi);                  /* where to add the lhs */
5077         for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5078           *lp+=(uLong)(*lip)*(*rip);         /* [this should in-line] */
5079           } /* lip loop */
5080         lazy--;
5081         if (lazy>0 && rip!=rmsi) continue;
5082         lazy=FASTLAZY;                       /* reset delay count */
5083         /* spin up the accumulator resolving overflows */
5084         for (lp=zacc; lp<zacc+iacc; lp++) {
5085           if (*lp<FASTBASE) continue;        /* it fits */
5086           lcarry=*lp/FASTBASE;               /* top part [slow divide] */
5087           /* lcarry can exceed 2**32-1, so check again; this check */
5088           /* and occasional extra divide (slow) is well worth it, as */
5089           /* it allows FASTLAZY to be increased to 18 rather than 4 */
5090           /* in the FASTDIGS=9 case */
5091           if (lcarry<FASTBASE) carry=(uInt)lcarry;  /* [usual] */
5092            else { /* two-place carry [fairly rare] */
5093             uInt carry2=(uInt)(lcarry/FASTBASE);    /* top top part */
5094             *(lp+2)+=carry2;                        /* add to item+2 */
5095             *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5096             carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5097             }
5098           *(lp+1)+=carry;                    /* add to item above [inline] */
5099           *lp-=((uLong)FASTBASE*carry);      /* [inline] */
5100           } /* carry resolution */
5101         } /* rip loop */
5102
5103       /* The multiplication is complete; time to convert back into */
5104       /* units.  This can be done in-place in the accumulator and in */
5105       /* 32-bit operations, because carries were resolved after the */
5106       /* final add.  This needs N-1 divides and multiplies for */
5107       /* each item in the accumulator (which will become up to N */
5108       /* units, where 2<=N<=9). */
5109       for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5110         uInt item=(uInt)*lp;                 /* decapitate to uInt */
5111         for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5112           uInt part=item/(DECDPUNMAX+1);
5113           *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5114           item=part;
5115           } /* p */
5116         *up=(Unit)item; up++;                /* [final needs no division] */
5117         } /* lp */
5118       accunits=up-acc;                       /* count of units */
5119       }
5120      else { /* here to use units directly, without chunking ['old code'] */
5121     #endif
5122
5123       /* if accumulator will be too long for local storage, then allocate */
5124       acc=accbuff;                 /* -> assume buffer for accumulator */
5125       needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5126       if (needbytes>(Int)sizeof(accbuff)) {
5127         allocacc=(Unit *)malloc(needbytes);
5128         if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5129         acc=(Unit *)allocacc;                /* use the allocated space */
5130         }
5131
5132       /* Now the main long multiplication loop */
5133       /* Unlike the equivalent in the IBM Java implementation, there */
5134       /* is no advantage in calculating from msu to lsu.  So, do it */
5135       /* by the book, as it were. */
5136       /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5137       accunits=1;                  /* accumulator starts at '0' */
5138       *acc=0;                      /* .. (lsu=0) */
5139       shift=0;                     /* no multiplicand shift at first */
5140       madlength=D2U(lhs->digits);  /* this won't change */
5141       mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5142
5143       for (mer=rhs->lsu; mer<mermsup; mer++) {
5144         /* Here, *mer is the next Unit in the multiplier to use */
5145         /* If non-zero [optimization] add it... */
5146         if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5147                                             lhs->lsu, madlength, 0,
5148                                             &acc[shift], *mer)
5149                                             + shift;
5150          else { /* extend acc with a 0; it will be used shortly */
5151           *(acc+accunits)=0;       /* [this avoids length of <=0 later] */
5152           accunits++;
5153           }
5154         /* multiply multiplicand by 10**DECDPUN for next Unit to left */
5155         shift++;                   /* add this for 'logical length' */
5156         } /* n */
5157     #if FASTMUL
5158       } /* unchunked units */
5159     #endif
5160     /* common end-path */
5161     #if DECTRACE
5162       decDumpAr('*', acc, accunits);         /* Show exact result */
5163     #endif
5164
5165     /* acc now contains the exact result of the multiplication, */
5166     /* possibly with a leading zero unit; build the decNumber from */
5167     /* it, noting if any residue */
5168     res->bits=bits;                          /* set sign */
5169     res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5170
5171     /* There can be a 31-bit wrap in calculating the exponent. */
5172     /* This can only happen if both input exponents are negative and */
5173     /* both their magnitudes are large.  If there was a wrap, set a */
5174     /* safe very negative exponent, from which decFinalize() will */
5175     /* raise a hard underflow shortly. */
5176     exponent=lhs->exponent+rhs->exponent;    /* calculate exponent */
5177     if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5178       exponent=-2*DECNUMMAXE;                /* force underflow */
5179     res->exponent=exponent;                  /* OK to overwrite now */
5180
5181
5182     /* Set the coefficient.  If any rounding, residue records */
5183     decSetCoeff(res, set, acc, res->digits, &residue, status);
5184     decFinish(res, set, &residue, status);   /* final cleanup */
5185     } while(0);                         /* end protected */
5186
5187   if (allocacc!=NULL) free(allocacc);   /* drop any storage used */
5188   #if DECSUBSET
5189   if (allocrhs!=NULL) free(allocrhs);   /* .. */
5190   if (alloclhs!=NULL) free(alloclhs);   /* .. */
5191   #endif
5192   #if FASTMUL
5193   if (allocrhi!=NULL) free(allocrhi);   /* .. */
5194   if (alloclhi!=NULL) free(alloclhi);   /* .. */
5195   #endif
5196   return res;
5197   } /* decMultiplyOp */
5198
5199 /* ------------------------------------------------------------------ */
5200 /* decExpOp -- effect exponentiation                                  */
5201 /*                                                                    */
5202 /*   This computes C = exp(A)                                         */
5203 /*                                                                    */
5204 /*   res is C, the result.  C may be A                                */
5205 /*   rhs is A                                                         */
5206 /*   set is the context; note that rounding mode has no effect        */
5207 /*                                                                    */
5208 /* C must have space for set->digits digits. status is updated but    */
5209 /* not set.                                                           */
5210 /*                                                                    */
5211 /* Restrictions:                                                      */
5212 /*                                                                    */
5213 /*   digits, emax, and -emin in the context must be less than         */
5214 /*   2*DEC_MAX_MATH (1999998), and the rhs must be within these       */
5215 /*   bounds or a zero.  This is an internal routine, so these         */
5216 /*   restrictions are contractual and not enforced.                   */
5217 /*                                                                    */
5218 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5219 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5220 /* error in rare cases.                                               */
5221 /*                                                                    */
5222 /* Finite results will always be full precision and Inexact, except   */
5223 /* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
5224 /* ------------------------------------------------------------------ */
5225 /* This approach used here is similar to the algorithm described in   */
5226 /*                                                                    */
5227 /*   Variable Precision Exponential Function, T. E. Hull and          */
5228 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5229 /*   pp79-91, ACM, June 1986.                                         */
5230 /*                                                                    */
5231 /* with the main difference being that the iterations in the series   */
5232 /* evaluation are terminated dynamically (which does not require the  */
5233 /* extra variable-precision variables which are expensive in this     */
5234 /* context).                                                          */
5235 /*                                                                    */
5236 /* The error analysis in Hull & Abrham's paper applies except for the */
5237 /* round-off error accumulation during the series evaluation.  This   */
5238 /* code does not precalculate the number of iterations and so cannot  */
5239 /* use Horner's scheme.  Instead, the accumulation is done at double- */
5240 /* precision, which ensures that the additions of the terms are exact */
5241 /* and do not accumulate round-off (and any round-off errors in the   */
5242 /* terms themselves move 'to the right' faster than they can          */
5243 /* accumulate).  This code also extends the calculation by allowing,  */
5244 /* in the spirit of other decNumber operators, the input to be more   */
5245 /* precise than the result (the precision used is based on the more   */
5246 /* precise of the input or requested result).                         */
5247 /*                                                                    */
5248 /* Implementation notes:                                              */
5249 /*                                                                    */
5250 /* 1. This is separated out as decExpOp so it can be called from      */
5251 /*    other Mathematical functions (notably Ln) with a wider range    */
5252 /*    than normal.  In particular, it can handle the slightly wider   */
5253 /*    (double) range needed by Ln (which has to be able to calculate  */
5254 /*    exp(-x) where x can be the tiniest number (Ntiny).              */
5255 /*                                                                    */
5256 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
5257 /*    iterations by approximately a third with additional (although    */
5258 /*    diminishing) returns as the range is reduced to even smaller    */
5259 /*    fractions.  However, h (the power of 10 used to correct the     */
5260 /*    result at the end, see below) must be kept <=8 as otherwise     */
5261 /*    the final result cannot be computed.  Hence the leverage is a   */
5262 /*    sliding value (8-h), where potentially the range is reduced     */
5263 /*    more for smaller values.                                        */
5264 /*                                                                    */
5265 /*    The leverage that can be applied in this way is severely        */
5266 /*    limited by the cost of the raise-to-the power at the end,       */
5267 /*    which dominates when the number of iterations is small (less    */
5268 /*    than ten) or when rhs is short.  As an example, the adjustment  */
5269 /*    x**10,000,000 needs 31 multiplications, all but one full-width. */
5270 /*                                                                    */
5271 /* 3. The restrictions (especially precision) could be raised with    */
5272 /*    care, but the full decNumber range seems very hard within the   */
5273 /*    32-bit limits.                                                  */
5274 /*                                                                    */
5275 /* 4. The working precisions for the static buffers are twice the     */
5276 /*    obvious size to allow for calls from decNumberPower.            */
5277 /* ------------------------------------------------------------------ */
5278 static decNumber *decExpOp(decNumber *res, const decNumber *rhs,
5279                            decContext *set, uInt *status) {
5280   uInt ignore=0;                   /* working status */
5281   Int h;                           /* adjusted exponent for 0.xxxx */
5282   Int p;                           /* working precision */
5283   Int residue;                     /* rounding residue */
5284   uInt needbytes;                  /* for space calculations */
5285   const decNumber *x=rhs;          /* (may point to safe copy later) */
5286   decContext aset, tset, dset;     /* working contexts */
5287   Int comp;                        /* work */
5288
5289   /* the argument is often copied to normalize it, so (unusually) it */
5290   /* is treated like other buffers, using DECBUFFER, +1 in case */
5291   /* DECBUFFER is 0 */
5292   decNumber bufr[D2N(DECBUFFER*2+1)];
5293   decNumber *allocrhs=NULL;        /* non-NULL if rhs buffer allocated */
5294
5295   /* the working precision will be no more than set->digits+8+1 */
5296   /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5297   /* is 0 (and twice that for the accumulator) */
5298
5299   /* buffer for t, term (working precision plus) */
5300   decNumber buft[D2N(DECBUFFER*2+9+1)];
5301   decNumber *allocbuft=NULL;       /* -> allocated buft, iff allocated */
5302   decNumber *t=buft;               /* term */
5303   /* buffer for a, accumulator (working precision * 2), at least 9 */
5304   decNumber bufa[D2N(DECBUFFER*4+18+1)];
5305   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
5306   decNumber *a=bufa;               /* accumulator */
5307   /* decNumber for the divisor term; this needs at most 9 digits */
5308   /* and so can be fixed size [16 so can use standard context] */
5309   decNumber bufd[D2N(16)];
5310   decNumber *d=bufd;               /* divisor */
5311   decNumber numone;                /* constant 1 */
5312
5313   #if DECCHECK
5314   Int iterations=0;                /* for later sanity check */
5315   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5316   #endif
5317
5318   do {                                  /* protect allocated storage */
5319     if (SPECIALARG) {                   /* handle infinities and NaNs */
5320       if (decNumberIsInfinite(rhs)) {   /* an infinity */
5321         if (decNumberIsNegative(rhs))   /* -Infinity -> +0 */
5322           decNumberZero(res);
5323          else decNumberCopy(res, rhs);  /* +Infinity -> self */
5324         }
5325        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5326       break;}
5327
5328     if (ISZERO(rhs)) {                  /* zeros -> exact 1 */
5329       decNumberZero(res);               /* make clean 1 */
5330       *res->lsu=1;                      /* .. */
5331       break;}                           /* [no status to set] */
5332
5333     /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5334     /* positive and negative tiny cases which will result in inexact */
5335     /* 1.  This also allows the later add-accumulate to always be */
5336     /* exact (because its length will never be more than twice the */
5337     /* working precision). */
5338     /* The comparator (tiny) needs just one digit, so use the */
5339     /* decNumber d for it (reused as the divisor, etc., below); its */
5340     /* exponent is such that if x is positive it will have */
5341     /* set->digits-1 zeros between the decimal point and the digit, */
5342     /* which is 4, and if x is negative one more zero there as the */
5343     /* more precise result will be of the form 0.9999999 rather than */
5344     /* 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0 */
5345     /* or 0.00000004 if digits=7 and x<0.  If RHS not larger than */
5346     /* this then the result will be 1.000000 */
5347     decNumberZero(d);                   /* clean */
5348     *d->lsu=4;                          /* set 4 .. */
5349     d->exponent=-set->digits;           /* * 10**(-d) */
5350     if (decNumberIsNegative(rhs)) d->exponent--;  /* negative case */
5351     comp=decCompare(d, rhs, 1);         /* signless compare */
5352     if (comp==BADINT) {
5353       *status|=DEC_Insufficient_storage;
5354       break;}
5355     if (comp>=0) {                      /* rhs < d */
5356       Int shift=set->digits-1;
5357       decNumberZero(res);               /* set 1 */
5358       *res->lsu=1;                      /* .. */
5359       res->digits=decShiftToMost(res->lsu, 1, shift);
5360       res->exponent=-shift;                  /* make 1.0000... */
5361       *status|=DEC_Inexact | DEC_Rounded;    /* .. inexactly */
5362       break;} /* tiny */
5363
5364     /* set up the context to be used for calculating a, as this is */
5365     /* used on both paths below */
5366     decContextDefault(&aset, DEC_INIT_DECIMAL64);
5367     /* accumulator bounds are as requested (could underflow) */
5368     aset.emax=set->emax;                /* usual bounds */
5369     aset.emin=set->emin;                /* .. */
5370     aset.clamp=0;                       /* and no concrete format */
5371
5372     /* calculate the adjusted (Hull & Abrham) exponent (where the */
5373     /* decimal point is just to the left of the coefficient msd) */
5374     h=rhs->exponent+rhs->digits;
5375     /* if h>8 then 10**h cannot be calculated safely; however, when */
5376     /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5377     /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5378     /* overflow (or underflow to 0) is guaranteed -- so this case can */
5379     /* be handled by simply forcing the appropriate excess */
5380     if (h>8) {                          /* overflow/underflow */
5381       /* set up here so Power call below will over or underflow to */
5382       /* zero; set accumulator to either 2 or 0.02 */
5383       /* [stack buffer for a is always big enough for this] */
5384       decNumberZero(a);
5385       *a->lsu=2;                        /* not 1 but < exp(1) */
5386       if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5387       h=8;                              /* clamp so 10**h computable */
5388       p=9;                              /* set a working precision */
5389       }
5390      else {                             /* h<=8 */
5391       Int maxlever=(rhs->digits>8?1:0);
5392       /* [could/should increase this for precisions >40 or so, too] */
5393
5394       /* if h is 8, cannot normalize to a lower upper limit because */
5395       /* the final result will not be computable (see notes above), */
5396       /* but leverage can be applied whenever h is less than 8. */
5397       /* Apply as much as possible, up to a MAXLEVER digits, which */
5398       /* sets the tradeoff against the cost of the later a**(10**h). */
5399       /* As h is increased, the working precision below also */
5400       /* increases to compensate for the "constant digits at the */
5401       /* front" effect. */
5402       Int lever=MINI(8-h, maxlever);    /* leverage attainable */
5403       Int use=-rhs->digits-lever;       /* exponent to use for RHS */
5404       h+=lever;                         /* apply leverage selected */
5405       if (h<0) {                        /* clamp */
5406         use+=h;                         /* [may end up subnormal] */
5407         h=0;
5408         }
5409       /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5410       if (rhs->exponent!=use) {
5411         decNumber *newrhs=bufr;         /* assume will fit on stack */
5412         needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5413         if (needbytes>sizeof(bufr)) {   /* need malloc space */
5414           allocrhs=(decNumber *)malloc(needbytes);
5415           if (allocrhs==NULL) {         /* hopeless -- abandon */
5416             *status|=DEC_Insufficient_storage;
5417             break;}
5418           newrhs=allocrhs;              /* use the allocated space */
5419           }
5420         decNumberCopy(newrhs, rhs);     /* copy to safe space */
5421         newrhs->exponent=use;           /* normalize; now <1 */
5422         x=newrhs;                       /* ready for use */
5423         /* decNumberShow(x); */
5424         }
5425
5426       /* Now use the usual power series to evaluate exp(x).  The */
5427       /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5428       /* third term by setting the term variable t=x, the accumulator */
5429       /* a=1, and the divisor d=2. */
5430
5431       /* First determine the working precision.  From Hull & Abrham */
5432       /* this is set->digits+h+2.  However, if x is 'over-precise' we */
5433       /* need to allow for all its digits to potentially participate */
5434       /* (consider an x where all the excess digits are 9s) so in */
5435       /* this case use x->digits+h+2 */
5436       p=MAXI(x->digits, set->digits)+h+2;    /* [h<=8] */
5437
5438       /* a and t are variable precision, and depend on p, so space */
5439       /* must be allocated for them if necessary */
5440
5441       /* the accumulator needs to be able to hold 2p digits so that */
5442       /* the additions on the second and subsequent iterations are */
5443       /* sufficiently exact. */
5444       needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5445       if (needbytes>sizeof(bufa)) {     /* need malloc space */
5446         allocbufa=(decNumber *)malloc(needbytes);
5447         if (allocbufa==NULL) {          /* hopeless -- abandon */
5448           *status|=DEC_Insufficient_storage;
5449           break;}
5450         a=allocbufa;                    /* use the allocated space */
5451         }
5452       /* the term needs to be able to hold p digits (which is */
5453       /* guaranteed to be larger than x->digits, so the initial copy */
5454       /* is safe); it may also be used for the raise-to-power */
5455       /* calculation below, which needs an extra two digits */
5456       needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5457       if (needbytes>sizeof(buft)) {     /* need malloc space */
5458         allocbuft=(decNumber *)malloc(needbytes);
5459         if (allocbuft==NULL) {          /* hopeless -- abandon */
5460           *status|=DEC_Insufficient_storage;
5461           break;}
5462         t=allocbuft;                    /* use the allocated space */
5463         }
5464
5465       decNumberCopy(t, x);              /* term=x */
5466       decNumberZero(a); *a->lsu=1;      /* accumulator=1 */
5467       decNumberZero(d); *d->lsu=2;      /* divisor=2 */
5468       decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5469
5470       /* set up the contexts for calculating a, t, and d */
5471       decContextDefault(&tset, DEC_INIT_DECIMAL64);
5472       dset=tset;
5473       /* accumulator bounds are set above, set precision now */
5474       aset.digits=p*2;                  /* double */
5475       /* term bounds avoid any underflow or overflow */
5476       tset.digits=p;
5477       tset.emin=DEC_MIN_EMIN;           /* [emax is plenty] */
5478       /* [dset.digits=16, etc., are sufficient] */
5479
5480       /* finally ready to roll */
5481       for (;;) {
5482         #if DECCHECK
5483         iterations++;
5484         #endif
5485         /* only the status from the accumulation is interesting */
5486         /* [but it should remain unchanged after first add] */
5487         decAddOp(a, a, t, &aset, 0, status);           /* a=a+t */
5488         decMultiplyOp(t, t, x, &tset, &ignore);        /* t=t*x */
5489         decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  /* t=t/d */
5490         /* the iteration ends when the term cannot affect the result, */
5491         /* if rounded to p digits, which is when its value is smaller */
5492         /* than the accumulator by p+1 digits.  There must also be */
5493         /* full precision in a. */
5494         if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5495             && (a->digits>=p)) break;
5496         decAddOp(d, d, &numone, &dset, 0, &ignore);    /* d=d+1 */
5497         } /* iterate */
5498
5499       #if DECCHECK
5500       /* just a sanity check; comment out test to show always */
5501       if (iterations>p+3)
5502         printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5503                iterations, *status, p, x->digits);
5504       #endif
5505       } /* h<=8 */
5506
5507     /* apply postconditioning: a=a**(10**h) -- this is calculated */
5508     /* at a slightly higher precision than Hull & Abrham suggest */
5509     if (h>0) {
5510       Int seenbit=0;               /* set once a 1-bit is seen */
5511       Int i;                       /* counter */
5512       Int n=powers[h];             /* always positive */
5513       aset.digits=p+2;             /* sufficient precision */
5514       /* avoid the overhead and many extra digits of decNumberPower */
5515       /* as all that is needed is the short 'multipliers' loop; here */
5516       /* accumulate the answer into t */
5517       decNumberZero(t); *t->lsu=1; /* acc=1 */
5518       for (i=1;;i++){              /* for each bit [top bit ignored] */
5519         /* abandon if have had overflow or terminal underflow */
5520         if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5521           if (*status&DEC_Overflow || ISZERO(t)) break;}
5522         n=n<<1;                    /* move next bit to testable position */
5523         if (n<0) {                 /* top bit is set */
5524           seenbit=1;               /* OK, have a significant bit */
5525           decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5526           }
5527         if (i==31) break;          /* that was the last bit */
5528         if (!seenbit) continue;    /* no need to square 1 */
5529         decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5530         } /*i*/ /* 32 bits */
5531       /* decNumberShow(t); */
5532       a=t;                         /* and carry on using t instead of a */
5533       }
5534
5535     /* Copy and round the result to res */
5536     residue=1;                          /* indicate dirt to right .. */
5537     if (ISZERO(a)) residue=0;           /* .. unless underflowed to 0 */
5538     aset.digits=set->digits;            /* [use default rounding] */
5539     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5540     decFinish(res, set, &residue, status);       /* cleanup/set flags */
5541     } while(0);                         /* end protected */
5542
5543   if (allocrhs !=NULL) free(allocrhs);  /* drop any storage used */
5544   if (allocbufa!=NULL) free(allocbufa); /* .. */
5545   if (allocbuft!=NULL) free(allocbuft); /* .. */
5546   /* [status is handled by caller] */
5547   return res;
5548   } /* decExpOp */
5549
5550 /* ------------------------------------------------------------------ */
5551 /* Initial-estimate natural logarithm table                           */
5552 /*                                                                    */
5553 /*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
5554 /*           The result is a 4-digit encode of the coefficient (c=the */
5555 /*           top 14 bits encoding 0-9999) and a 2-digit encode of the */
5556 /*           exponent (e=the bottom 2 bits encoding 0-3)              */
5557 /*                                                                    */
5558 /*           The resulting value is given by:                         */
5559 /*                                                                    */
5560 /*             v = -c * 10**(-e-3)                                    */
5561 /*                                                                    */
5562 /*           where e and c are extracted from entry k = LNnn[x-10]    */
5563 /*           where x is truncated (NB) into the range 10 through 99,  */
5564 /*           and then c = k>>2 and e = k&3.                           */
5565 /* ------------------------------------------------------------------ */
5566 static const uShort LNnn[90] = {
5567   9016,  8652,  8316,  8008,  7724,  7456,  7208,
5568   6972,  6748,  6540,  6340,  6148,  5968,  5792,  5628,  5464,  5312,
5569   5164,  5020,  4884,  4748,  4620,  4496,  4376,  4256,  4144,  4032,
5570  39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5571  29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5572  22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5573  15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5574  10197,  9685,  9177,  8677,  8185,  7697,  7213,  6737,  6269,  5801,
5575   5341,  4889,  4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5576  10130,  6046, 20055};
5577
5578 /* ------------------------------------------------------------------ */
5579 /* decLnOp -- effect natural logarithm                                */
5580 /*                                                                    */
5581 /*   This computes C = ln(A)                                          */
5582 /*                                                                    */
5583 /*   res is C, the result.  C may be A                                */
5584 /*   rhs is A                                                         */
5585 /*   set is the context; note that rounding mode has no effect        */
5586 /*                                                                    */
5587 /* C must have space for set->digits digits.                          */
5588 /*                                                                    */
5589 /* Notable cases:                                                     */
5590 /*   A<0 -> Invalid                                                   */
5591 /*   A=0 -> -Infinity (Exact)                                         */
5592 /*   A=+Infinity -> +Infinity (Exact)                                 */
5593 /*   A=1 exactly -> 0 (Exact)                                         */
5594 /*                                                                    */
5595 /* Restrictions (as for Exp):                                         */
5596 /*                                                                    */
5597 /*   digits, emax, and -emin in the context must be less than         */
5598 /*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
5599 /*   bounds or a zero.  This is an internal routine, so these         */
5600 /*   restrictions are contractual and not enforced.                   */
5601 /*                                                                    */
5602 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5603 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5604 /* error in rare cases.                                               */
5605 /* ------------------------------------------------------------------ */
5606 /* The result is calculated using Newton's method, with each          */
5607 /* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
5608 /* Epperson 1989.                                                     */
5609 /*                                                                    */
5610 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5611 /* This has to be calculated at the sum of the precision of x and the */
5612 /* working precision.                                                 */
5613 /*                                                                    */
5614 /* Implementation notes:                                              */
5615 /*                                                                    */
5616 /* 1. This is separated out as decLnOp so it can be called from       */
5617 /*    other Mathematical functions (e.g., Log 10) with a wider range  */
5618 /*    than normal.  In particular, it can handle the slightly wider   */
5619 /*    (+9+2) range needed by a power function.                        */
5620 /*                                                                    */
5621 /* 2. The speed of this function is about 10x slower than exp, as     */
5622 /*    it typically needs 4-6 iterations for short numbers, and the    */
5623 /*    extra precision needed adds a squaring effect, twice.           */
5624 /*                                                                    */
5625 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
5626 /*    as these are common requests.  ln(10) is used by log10(x).      */
5627 /*                                                                    */
5628 /* 4. An iteration might be saved by widening the LNnn table, and     */
5629 /*    would certainly save at least one if it were made ten times     */
5630 /*    bigger, too (for truncated fractions 0.100 through 0.999).      */
5631 /*    However, for most practical evaluations, at least four or five  */
5632 /*    iterations will be neede -- so this would only speed up by      */
5633 /*    20-25% and that probably does not justify increasing the table  */
5634 /*    size.                                                           */
5635 /*                                                                    */
5636 /* 5. The static buffers are larger than might be expected to allow   */
5637 /*    for calls from decNumberPower.                                  */
5638 /* ------------------------------------------------------------------ */
5639 static decNumber *decLnOp(decNumber *res, const decNumber *rhs,
5640                           decContext *set, uInt *status) {
5641   uInt ignore=0;                   /* working status accumulator */
5642   uInt needbytes;                  /* for space calculations */
5643   Int residue;                     /* rounding residue */
5644   Int r;                           /* rhs=f*10**r [see below] */
5645   Int p;                           /* working precision */
5646   Int pp;                          /* precision for iteration */
5647   Int t;                           /* work */
5648
5649   /* buffers for a (accumulator, typically precision+2) and b */
5650   /* (adjustment calculator, same size) */
5651   decNumber bufa[D2N(DECBUFFER+12)];
5652   decNumber *allocbufa=NULL;       /* -> allocated bufa, iff allocated */
5653   decNumber *a=bufa;               /* accumulator/work */
5654   decNumber bufb[D2N(DECBUFFER*2+2)];
5655   decNumber *allocbufb=NULL;       /* -> allocated bufa, iff allocated */
5656   decNumber *b=bufb;               /* adjustment/work */
5657
5658   decNumber  numone;               /* constant 1 */
5659   decNumber  cmp;                  /* work */
5660   decContext aset, bset;           /* working contexts */
5661
5662   #if DECCHECK
5663   Int iterations=0;                /* for later sanity check */
5664   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5665   #endif
5666
5667   do {                                  /* protect allocated storage */
5668     if (SPECIALARG) {                   /* handle infinities and NaNs */
5669       if (decNumberIsInfinite(rhs)) {   /* an infinity */
5670         if (decNumberIsNegative(rhs))   /* -Infinity -> error */
5671           *status|=DEC_Invalid_operation;
5672          else decNumberCopy(res, rhs);  /* +Infinity -> self */
5673         }
5674        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5675       break;}
5676
5677     if (ISZERO(rhs)) {                  /* +/- zeros -> -Infinity */
5678       decNumberZero(res);               /* make clean */
5679       res->bits=DECINF|DECNEG;          /* set - infinity */
5680       break;}                           /* [no status to set] */
5681
5682     /* Non-zero negatives are bad... */
5683     if (decNumberIsNegative(rhs)) {     /* -x -> error */
5684       *status|=DEC_Invalid_operation;
5685       break;}
5686
5687     /* Here, rhs is positive, finite, and in range */
5688
5689     /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5690     if (rhs->exponent==0 && set->digits<=40) {
5691       #if DECDPUN==1
5692       if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5693       #else
5694       if (rhs->lsu[0]==10 && rhs->digits==2) {                  /* ln(10) */
5695       #endif
5696         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5697         #define LN10 "2.302585092994045684017991454684364207601"
5698         decNumberFromString(res, LN10, &aset);
5699         *status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5700         break;}
5701       if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5702         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5703         #define LN2 "0.6931471805599453094172321214581765680755"
5704         decNumberFromString(res, LN2, &aset);
5705         *status|=(DEC_Inexact | DEC_Rounded);
5706         break;}
5707       } /* integer and short */
5708
5709     /* Determine the working precision.  This is normally the */
5710     /* requested precision + 2, with a minimum of 9.  However, if */
5711     /* the rhs is 'over-precise' then allow for all its digits to */
5712     /* potentially participate (consider an rhs where all the excess */
5713     /* digits are 9s) so in this case use rhs->digits+2. */
5714     p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5715
5716     /* Allocate space for the accumulator and the high-precision */
5717     /* adjustment calculator, if necessary.  The accumulator must */
5718     /* be able to hold p digits, and the adjustment up to */
5719     /* rhs->digits+p digits.  They are also made big enough for 16 */
5720     /* digits so that they can be used for calculating the initial */
5721     /* estimate. */
5722     needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5723     if (needbytes>sizeof(bufa)) {     /* need malloc space */
5724       allocbufa=(decNumber *)malloc(needbytes);
5725       if (allocbufa==NULL) {          /* hopeless -- abandon */
5726         *status|=DEC_Insufficient_storage;
5727         break;}
5728       a=allocbufa;                    /* use the allocated space */
5729       }
5730     pp=p+rhs->digits;
5731     needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5732     if (needbytes>sizeof(bufb)) {     /* need malloc space */
5733       allocbufb=(decNumber *)malloc(needbytes);
5734       if (allocbufb==NULL) {          /* hopeless -- abandon */
5735         *status|=DEC_Insufficient_storage;
5736         break;}
5737       b=allocbufb;                    /* use the allocated space */
5738       }
5739
5740     /* Prepare an initial estimate in acc. Calculate this by */
5741     /* considering the coefficient of x to be a normalized fraction, */
5742     /* f, with the decimal point at far left and multiplied by */
5743     /* 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and */
5744     /*   ln(x) = ln(f) + ln(10)*r */
5745     /* Get the initial estimate for ln(f) from a small lookup */
5746     /* table (see above) indexed by the first two digits of f, */
5747     /* truncated. */
5748
5749     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5750     r=rhs->exponent+rhs->digits;        /* 'normalised' exponent */
5751     decNumberFromInt32(a, r);           /* a=r */
5752     decNumberFromInt32(b, 2302585);     /* b=ln(10) (2.302585) */
5753     b->exponent=-6;                     /*  .. */
5754     decMultiplyOp(a, a, b, &aset, &ignore);  /* a=a*b */
5755     /* now get top two digits of rhs into b by simple truncate and */
5756     /* force to integer */
5757     residue=0;                          /* (no residue) */
5758     aset.digits=2; aset.round=DEC_ROUND_DOWN;
5759     decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5760     b->exponent=0;                      /* make integer */
5761     t=decGetInt(b);                     /* [cannot fail] */
5762     if (t<10) t=X10(t);                 /* adjust single-digit b */
5763     t=LNnn[t-10];                       /* look up ln(b) */
5764     decNumberFromInt32(b, t>>2);        /* b=ln(b) coefficient */
5765     b->exponent=-(t&3)-3;               /* set exponent */
5766     b->bits=DECNEG;                     /* ln(0.10)->ln(0.99) always -ve */
5767     aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5768     decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5769     /* the initial estimate is now in a, with up to 4 digits correct. */
5770     /* When rhs is at or near Nmax the estimate will be low, so we */
5771     /* will approach it from below, avoiding overflow when calling exp. */
5772
5773     decNumberZero(&numone); *numone.lsu=1;   /* constant 1 for adjustment */
5774
5775     /* accumulator bounds are as requested (could underflow, but */
5776     /* cannot overflow) */
5777     aset.emax=set->emax;
5778     aset.emin=set->emin;
5779     aset.clamp=0;                       /* no concrete format */
5780     /* set up a context to be used for the multiply and subtract */
5781     bset=aset;
5782     bset.emax=DEC_MAX_MATH*2;           /* use double bounds for the */
5783     bset.emin=-DEC_MAX_MATH*2;          /* adjustment calculation */
5784                                         /* [see decExpOp call below] */
5785     /* for each iteration double the number of digits to calculate, */
5786     /* up to a maximum of p */
5787     pp=9;                               /* initial precision */
5788     /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5789     /* 34+2, which is ideal for standard-sized numbers] */
5790     aset.digits=pp;                     /* working context */
5791     bset.digits=pp+rhs->digits;         /* wider context */
5792     for (;;) {                          /* iterate */
5793       #if DECCHECK
5794       iterations++;
5795       if (iterations>24) break;         /* consider 9 * 2**24 */
5796       #endif
5797       /* calculate the adjustment (exp(-a)*x-1) into b.  This is a */
5798       /* catastrophic subtraction but it really is the difference */
5799       /* from 1 that is of interest. */
5800       /* Use the internal entry point to Exp as it allows the double */
5801       /* range for calculating exp(-a) when a is the tiniest subnormal. */
5802       a->bits^=DECNEG;                  /* make -a */
5803       decExpOp(b, a, &bset, &ignore);   /* b=exp(-a) */
5804       a->bits^=DECNEG;                  /* restore sign of a */
5805       /* now multiply by rhs and subtract 1, at the wider precision */
5806       decMultiplyOp(b, b, rhs, &bset, &ignore);        /* b=b*rhs */
5807       decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5808
5809       /* the iteration ends when the adjustment cannot affect the */
5810       /* result by >=0.5 ulp (at the requested digits), which */
5811       /* is when its value is smaller than the accumulator by */
5812       /* set->digits+1 digits (or it is zero) -- this is a looser */
5813       /* requirement than for Exp because all that happens to the */
5814       /* accumulator after this is the final rounding (but note that */
5815       /* there must also be full precision in a, or a=0). */
5816
5817       if (decNumberIsZero(b) ||
5818           (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5819         if (a->digits==p) break;
5820         if (decNumberIsZero(a)) {
5821           decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5822           if (cmp.lsu[0]==0) a->exponent=0;            /* yes, exact 0 */
5823            else *status|=(DEC_Inexact | DEC_Rounded);  /* no, inexact */
5824           break;
5825           }
5826         /* force padding if adjustment has gone to 0 before full length */
5827         if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5828         }
5829
5830       /* not done yet ... */
5831       decAddOp(a, a, b, &aset, 0, &ignore);  /* a=a+b for next estimate */
5832       if (pp==p) continue;                   /* precision is at maximum */
5833       /* lengthen the next calculation */
5834       pp=pp*2;                               /* double precision */
5835       if (pp>p) pp=p;                        /* clamp to maximum */
5836       aset.digits=pp;                        /* working context */
5837       bset.digits=pp+rhs->digits;            /* wider context */
5838       } /* Newton's iteration */
5839
5840     #if DECCHECK
5841     /* just a sanity check; remove the test to show always */
5842     if (iterations>24)
5843       printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5844             iterations, *status, p, rhs->digits);
5845     #endif
5846
5847     /* Copy and round the result to res */
5848     residue=1;                          /* indicate dirt to right */
5849     if (ISZERO(a)) residue=0;           /* .. unless underflowed to 0 */
5850     aset.digits=set->digits;            /* [use default rounding] */
5851     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5852     decFinish(res, set, &residue, status);       /* cleanup/set flags */
5853     } while(0);                         /* end protected */
5854
5855   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
5856   if (allocbufb!=NULL) free(allocbufb); /* .. */
5857   /* [status is handled by caller] */
5858   return res;
5859   } /* decLnOp */
5860
5861 /* ------------------------------------------------------------------ */
5862 /* decQuantizeOp  -- force exponent to requested value                */
5863 /*                                                                    */
5864 /*   This computes C = op(A, B), where op adjusts the coefficient     */
5865 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
5866 /*   of C has the value B or matches the exponent of B.               */
5867 /*   The numerical value of C will equal A, except for the effects of */
5868 /*   any rounding that occurred.                                      */
5869 /*                                                                    */
5870 /*   res is C, the result.  C may be A or B                           */
5871 /*   lhs is A, the number to adjust                                   */
5872 /*   rhs is B, the requested exponent                                 */
5873 /*   set is the context                                               */
5874 /*   quant is 1 for quantize or 0 for rescale                         */
5875 /*   status is the status accumulator (this can be called without     */
5876 /*          risk of control loss)                                     */
5877 /*                                                                    */
5878 /* C must have space for set->digits digits.                          */
5879 /*                                                                    */
5880 /* Unless there is an error or the result is infinite, the exponent   */
5881 /* after the operation is guaranteed to be that requested.            */
5882 /* ------------------------------------------------------------------ */
5883 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5884                                  const decNumber *rhs, decContext *set,
5885                                  Flag quant, uInt *status) {
5886   #if DECSUBSET
5887   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
5888   decNumber *allocrhs=NULL;        /* .., rhs */
5889   #endif
5890   const decNumber *inrhs=rhs;      /* save original rhs */
5891   Int   reqdigits=set->digits;     /* requested DIGITS */
5892   Int   reqexp;                    /* requested exponent [-scale] */
5893   Int   residue=0;                 /* rounding residue */
5894   Int   etiny=set->emin-(reqdigits-1);
5895
5896   #if DECCHECK
5897   if (decCheckOperands(res, lhs, rhs, set)) return res;
5898   #endif
5899
5900   do {                             /* protect allocated storage */
5901     #if DECSUBSET
5902     if (!set->extended) {
5903       /* reduce operands and set lostDigits status, as needed */
5904       if (lhs->digits>reqdigits) {
5905         alloclhs=decRoundOperand(lhs, set, status);
5906         if (alloclhs==NULL) break;
5907         lhs=alloclhs;
5908         }
5909       if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5910         allocrhs=decRoundOperand(rhs, set, status);
5911         if (allocrhs==NULL) break;
5912         rhs=allocrhs;
5913         }
5914       }
5915     #endif
5916     /* [following code does not require input rounding] */
5917
5918     /* Handle special values */
5919     if (SPECIALARGS) {
5920       /* NaNs get usual processing */
5921       if (SPECIALARGS & (DECSNAN | DECNAN))
5922         decNaNs(res, lhs, rhs, set, status);
5923       /* one infinity but not both is bad */
5924       else if ((lhs->bits ^ rhs->bits) & DECINF)
5925         *status|=DEC_Invalid_operation;
5926       /* both infinity: return lhs */
5927       else decNumberCopy(res, lhs);          /* [nop if in place] */
5928       break;
5929       }
5930
5931     /* set requested exponent */
5932     if (quant) reqexp=inrhs->exponent;  /* quantize -- match exponents */
5933      else {                             /* rescale -- use value of rhs */
5934       /* Original rhs must be an integer that fits and is in range, */
5935       /* which could be from -1999999997 to +999999999, thanks to */
5936       /* subnormals */
5937       reqexp=decGetInt(inrhs);               /* [cannot fail] */
5938       }
5939
5940     #if DECSUBSET
5941     if (!set->extended) etiny=set->emin;     /* no subnormals */
5942     #endif
5943
5944     if (reqexp==BADINT                       /* bad (rescale only) or .. */
5945      || reqexp==BIGODD || reqexp==BIGEVEN    /* very big (ditto) or .. */
5946      || (reqexp<etiny)                       /* < lowest */
5947      || (reqexp>set->emax)) {                /* > emax */
5948       *status|=DEC_Invalid_operation;
5949       break;}
5950
5951     /* the RHS has been processed, so it can be overwritten now if necessary */
5952     if (ISZERO(lhs)) {                       /* zero coefficient unchanged */
5953       decNumberCopy(res, lhs);               /* [nop if in place] */
5954       res->exponent=reqexp;                  /* .. just set exponent */
5955       #if DECSUBSET
5956       if (!set->extended) res->bits=0;       /* subset specification; no -0 */
5957       #endif
5958       }
5959      else {                                  /* non-zero lhs */
5960       Int adjust=reqexp-lhs->exponent;       /* digit adjustment needed */
5961       /* if adjusted coefficient will definitely not fit, give up now */
5962       if ((lhs->digits-adjust)>reqdigits) {
5963         *status|=DEC_Invalid_operation;
5964         break;
5965         }
5966
5967       if (adjust>0) {                        /* increasing exponent */
5968         /* this will decrease the length of the coefficient by adjust */
5969         /* digits, and must round as it does so */
5970         decContext workset;                  /* work */
5971         workset=*set;                        /* clone rounding, etc. */
5972         workset.digits=lhs->digits-adjust;   /* set requested length */
5973         /* [note that the latter can be <1, here] */
5974         decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5975         decApplyRound(res, &workset, residue, status);    /* .. and round */
5976         residue=0;                                        /* [used] */
5977         /* If just rounded a 999s case, exponent will be off by one; */
5978         /* adjust back (after checking space), if so. */
5979         if (res->exponent>reqexp) {
5980           /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5981           /* set->digits==3 */
5982           if (res->digits==reqdigits) {      /* cannot shift by 1 */
5983             *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
5984             *status|=DEC_Invalid_operation;
5985             break;
5986             }
5987           res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5988           res->exponent--;                   /* (re)adjust the exponent. */
5989           }
5990         #if DECSUBSET
5991         if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
5992         #endif
5993         } /* increase */
5994        else /* adjust<=0 */ {                /* decreasing or = exponent */
5995         /* this will increase the length of the coefficient by -adjust */
5996         /* digits, by adding zero or more trailing zeros; this is */
5997         /* already checked for fit, above */
5998         decNumberCopy(res, lhs);             /* [it will fit] */
5999         /* if padding needed (adjust<0), add it now... */
6000         if (adjust<0) {
6001           res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
6002           res->exponent+=adjust;             /* adjust the exponent */
6003           }
6004         } /* decrease */
6005       } /* non-zero */
6006
6007     /* Check for overflow [do not use Finalize in this case, as an */
6008     /* overflow here is a "don't fit" situation] */
6009     if (res->exponent>set->emax-res->digits+1) {  /* too big */
6010       *status|=DEC_Invalid_operation;
6011       break;
6012       }
6013      else {
6014       decFinalize(res, set, &residue, status);    /* set subnormal flags */
6015       *status&=~DEC_Underflow;          /* suppress Underflow [754r] */
6016       }
6017     } while(0);                         /* end protected */
6018
6019   #if DECSUBSET
6020   if (allocrhs!=NULL) free(allocrhs);   /* drop any storage used */
6021   if (alloclhs!=NULL) free(alloclhs);   /* .. */
6022   #endif
6023   return res;
6024   } /* decQuantizeOp */
6025
6026 /* ------------------------------------------------------------------ */
6027 /* decCompareOp -- compare, min, or max two Numbers                   */
6028 /*                                                                    */
6029 /*   This computes C = A ? B and carries out one of four operations:  */
6030 /*     COMPARE    -- returns the signum (as a number) giving the      */
6031 /*                   result of a comparison unless one or both        */
6032 /*                   operands is a NaN (in which case a NaN results)  */
6033 /*     COMPSIG    -- as COMPARE except that a quiet NaN raises        */
6034 /*                   Invalid operation.                               */
6035 /*     COMPMAX    -- returns the larger of the operands, using the    */
6036 /*                   754r maxnum operation                            */
6037 /*     COMPMAXMAG -- ditto, comparing absolute values                 */
6038 /*     COMPMIN    -- the 754r minnum operation                        */
6039 /*     COMPMINMAG -- ditto, comparing absolute values                 */
6040 /*     COMTOTAL   -- returns the signum (as a number) giving the      */
6041 /*                   result of a comparison using 754r total ordering */
6042 /*                                                                    */
6043 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
6044 /*   lhs is A                                                         */
6045 /*   rhs is B                                                         */
6046 /*   set is the context                                               */
6047 /*   op  is the operation flag                                        */
6048 /*   status is the usual accumulator                                  */
6049 /*                                                                    */
6050 /* C must have space for one digit for COMPARE or set->digits for     */
6051 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG.                       */
6052 /* ------------------------------------------------------------------ */
6053 /* The emphasis here is on speed for common cases, and avoiding       */
6054 /* coefficient comparison if possible.                                */
6055 /* ------------------------------------------------------------------ */
6056 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs,
6057                                const decNumber *rhs, decContext *set,
6058                                Flag op, uInt *status) {
6059   #if DECSUBSET
6060   decNumber *alloclhs=NULL;        /* non-NULL if rounded lhs allocated */
6061   decNumber *allocrhs=NULL;        /* .., rhs */
6062   #endif
6063   Int   result=0;                  /* default result value */
6064   uByte merged;                    /* work */
6065
6066   #if DECCHECK
6067   if (decCheckOperands(res, lhs, rhs, set)) return res;
6068   #endif
6069
6070   do {                             /* protect allocated storage */
6071     #if DECSUBSET
6072     if (!set->extended) {
6073       /* reduce operands and set lostDigits status, as needed */
6074       if (lhs->digits>set->digits) {
6075         alloclhs=decRoundOperand(lhs, set, status);
6076         if (alloclhs==NULL) {result=BADINT; break;}
6077         lhs=alloclhs;
6078         }
6079       if (rhs->digits>set->digits) {
6080         allocrhs=decRoundOperand(rhs, set, status);
6081         if (allocrhs==NULL) {result=BADINT; break;}
6082         rhs=allocrhs;
6083         }
6084       }
6085     #endif
6086     /* [following code does not require input rounding] */
6087
6088     /* If total ordering then handle differing signs 'up front' */
6089     if (op==COMPTOTAL) {                /* total ordering */
6090       if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6091         result=-1;
6092         break;
6093         }
6094       if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6095         result=+1;
6096         break;
6097         }
6098       }
6099
6100     /* handle NaNs specially; let infinities drop through */
6101     /* This assumes sNaN (even just one) leads to NaN. */
6102     merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6103     if (merged) {                       /* a NaN bit set */
6104       if (op==COMPARE);                 /* result will be NaN */
6105        else if (op==COMPSIG)            /* treat qNaN as sNaN */
6106         *status|=DEC_Invalid_operation | DEC_sNaN;
6107        else if (op==COMPTOTAL) {        /* total ordering, always finite */
6108         /* signs are known to be the same; compute the ordering here */
6109         /* as if the signs are both positive, then invert for negatives */
6110         if (!decNumberIsNaN(lhs)) result=-1;
6111          else if (!decNumberIsNaN(rhs)) result=+1;
6112          /* here if both NaNs */
6113          else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6114          else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6115          else { /* both NaN or both sNaN */
6116           /* now it just depends on the payload */
6117           result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6118                                 rhs->lsu, D2U(rhs->digits), 0);
6119           /* [Error not possible, as these are 'aligned'] */
6120           } /* both same NaNs */
6121         if (decNumberIsNegative(lhs)) result=-result;
6122         break;
6123         } /* total order */
6124
6125        else if (merged & DECSNAN);           /* sNaN -> qNaN */
6126        else { /* here if MIN or MAX and one or two quiet NaNs */
6127         /* min or max -- 754r rules ignore single NaN */
6128         if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6129           /* just one NaN; force choice to be the non-NaN operand */
6130           op=COMPMAX;
6131           if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6132                              else result=+1; /* pick lhs */
6133           break;
6134           }
6135         } /* max or min */
6136       op=COMPNAN;                            /* use special path */
6137       decNaNs(res, lhs, rhs, set, status);   /* propagate NaN */
6138       break;
6139       }
6140     /* have numbers */
6141     if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6142      else result=decCompare(lhs, rhs, 0);    /* sign matters */
6143     } while(0);                              /* end protected */
6144
6145   if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6146    else {
6147     if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6148       if (op==COMPTOTAL && result==0) {
6149         /* operands are numerically equal or same NaN (and same sign, */
6150         /* tested first); if identical, leave result 0 */
6151         if (lhs->exponent!=rhs->exponent) {
6152           if (lhs->exponent<rhs->exponent) result=-1;
6153            else result=+1;
6154           if (decNumberIsNegative(lhs)) result=-result;
6155           } /* lexp!=rexp */
6156         } /* total-order by exponent */
6157       decNumberZero(res);               /* [always a valid result] */
6158       if (result!=0) {                  /* must be -1 or +1 */
6159         *res->lsu=1;
6160         if (result<0) res->bits=DECNEG;
6161         }
6162       }
6163      else if (op==COMPNAN);             /* special, drop through */
6164      else {                             /* MAX or MIN, non-NaN result */
6165       Int residue=0;                    /* rounding accumulator */
6166       /* choose the operand for the result */
6167       const decNumber *choice;
6168       if (result==0) { /* operands are numerically equal */
6169         /* choose according to sign then exponent (see 754r) */
6170         uByte slhs=(lhs->bits & DECNEG);
6171         uByte srhs=(rhs->bits & DECNEG);
6172         #if DECSUBSET
6173         if (!set->extended) {           /* subset: force left-hand */
6174           op=COMPMAX;
6175           result=+1;
6176           }
6177         else
6178         #endif
6179         if (slhs!=srhs) {          /* signs differ */
6180           if (slhs) result=-1;     /* rhs is max */
6181                else result=+1;     /* lhs is max */
6182           }
6183          else if (slhs && srhs) {  /* both negative */
6184           if (lhs->exponent<rhs->exponent) result=+1;
6185                                       else result=-1;
6186           /* [if equal, use lhs, technically identical] */
6187           }
6188          else {                    /* both positive */
6189           if (lhs->exponent>rhs->exponent) result=+1;
6190                                       else result=-1;
6191           /* [ditto] */
6192           }
6193         } /* numerically equal */
6194       /* here result will be non-0; reverse if looking for MIN */
6195       if (op==COMPMIN || op==COMPMINMAG) result=-result;
6196       choice=(result>0 ? lhs : rhs);    /* choose */
6197       /* copy chosen to result, rounding if need be */
6198       decCopyFit(res, choice, set, &residue, status);
6199       decFinish(res, set, &residue, status);
6200       }
6201     }
6202   #if DECSUBSET
6203   if (allocrhs!=NULL) free(allocrhs);   /* free any storage used */
6204   if (alloclhs!=NULL) free(alloclhs);   /* .. */
6205   #endif
6206   return res;
6207   } /* decCompareOp */
6208
6209 /* ------------------------------------------------------------------ */
6210 /* decCompare -- compare two decNumbers by numerical value            */
6211 /*                                                                    */
6212 /*  This routine compares A ? B without altering them.                */
6213 /*                                                                    */
6214 /*  Arg1 is A, a decNumber which is not a NaN                         */
6215 /*  Arg2 is B, a decNumber which is not a NaN                         */
6216 /*  Arg3 is 1 for a sign-independent compare, 0 otherwise             */
6217 /*                                                                    */
6218 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6219 /*  (the only possible failure is an allocation error)                */
6220 /* ------------------------------------------------------------------ */
6221 static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6222                       Flag abs) {
6223   Int   result;                    /* result value */
6224   Int   sigr;                      /* rhs signum */
6225   Int   compare;                   /* work */
6226
6227   result=1;                                  /* assume signum(lhs) */
6228   if (ISZERO(lhs)) result=0;
6229   if (abs) {
6230     if (ISZERO(rhs)) return result;          /* LHS wins or both 0 */
6231     /* RHS is non-zero */
6232     if (result==0) return -1;                /* LHS is 0; RHS wins */
6233     /* [here, both non-zero, result=1] */
6234     }
6235    else {                                    /* signs matter */
6236     if (result && decNumberIsNegative(lhs)) result=-1;
6237     sigr=1;                                  /* compute signum(rhs) */
6238     if (ISZERO(rhs)) sigr=0;
6239      else if (decNumberIsNegative(rhs)) sigr=-1;
6240     if (result > sigr) return +1;            /* L > R, return 1 */
6241     if (result < sigr) return -1;            /* L < R, return -1 */
6242     if (result==0) return 0;                   /* both 0 */
6243     }
6244
6245   /* signums are the same; both are non-zero */
6246   if ((lhs->bits | rhs->bits) & DECINF) {    /* one or more infinities */
6247     if (decNumberIsInfinite(rhs)) {
6248       if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6249        else result=-result;                  /* only rhs infinite */
6250       }
6251     return result;
6252     }
6253   /* must compare the coefficients, allowing for exponents */
6254   if (lhs->exponent>rhs->exponent) {         /* LHS exponent larger */
6255     /* swap sides, and sign */
6256     const decNumber *temp=lhs;
6257     lhs=rhs;
6258     rhs=temp;
6259     result=-result;
6260     }
6261   compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6262                          rhs->lsu, D2U(rhs->digits),
6263                          rhs->exponent-lhs->exponent);
6264   if (compare!=BADINT) compare*=result;      /* comparison succeeded */
6265   return compare;
6266   } /* decCompare */
6267
6268 /* ------------------------------------------------------------------ */
6269 /* decUnitCompare -- compare two >=0 integers in Unit arrays          */
6270 /*                                                                    */
6271 /*  This routine compares A ? B*10**E where A and B are unit arrays   */
6272 /*  A is a plain integer                                              */
6273 /*  B has an exponent of E (which must be non-negative)               */
6274 /*                                                                    */
6275 /*  Arg1 is A first Unit (lsu)                                        */
6276 /*  Arg2 is A length in Units                                         */
6277 /*  Arg3 is B first Unit (lsu)                                        */
6278 /*  Arg4 is B length in Units                                         */
6279 /*  Arg5 is E (0 if the units are aligned)                            */
6280 /*                                                                    */
6281 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6282 /*  (the only possible failure is an allocation error, which can      */
6283 /*  only occur if E!=0)                                               */
6284 /* ------------------------------------------------------------------ */
6285 static Int decUnitCompare(const Unit *a, Int alength,
6286                           const Unit *b, Int blength, Int exp) {
6287   Unit  *acc;                      /* accumulator for result */
6288   Unit  accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6289   Unit  *allocacc=NULL;            /* -> allocated acc buffer, iff allocated */
6290   Int   accunits, need;            /* units in use or needed for acc */
6291   const Unit *l, *r, *u;           /* work */
6292   Int   expunits, exprem, result;  /* .. */
6293
6294   if (exp==0) {                    /* aligned; fastpath */
6295     if (alength>blength) return 1;
6296     if (alength<blength) return -1;
6297     /* same number of units in both -- need unit-by-unit compare */
6298     l=a+alength-1;
6299     r=b+alength-1;
6300     for (;l>=a; l--, r--) {
6301       if (*l>*r) return 1;
6302       if (*l<*r) return -1;
6303       }
6304     return 0;                      /* all units match */
6305     } /* aligned */
6306
6307   /* Unaligned.  If one is >1 unit longer than the other, padded */
6308   /* approximately, then can return easily */
6309   if (alength>blength+(Int)D2U(exp)) return 1;
6310   if (alength+1<blength+(Int)D2U(exp)) return -1;
6311
6312   /* Need to do a real subtract.  For this, a result buffer is needed */
6313   /* even though only the sign is of interest.  Its length needs */
6314   /* to be the larger of alength and padded blength, +2 */
6315   need=blength+D2U(exp);                /* maximum real length of B */
6316   if (need<alength) need=alength;
6317   need+=2;
6318   acc=accbuff;                          /* assume use local buffer */
6319   if (need*sizeof(Unit)>sizeof(accbuff)) {
6320     allocacc=(Unit *)malloc(need*sizeof(Unit));
6321     if (allocacc==NULL) return BADINT;  /* hopeless -- abandon */
6322     acc=allocacc;
6323     }
6324   /* Calculate units and remainder from exponent. */
6325   expunits=exp/DECDPUN;
6326   exprem=exp%DECDPUN;
6327   /* subtract [A+B*(-m)] */
6328   accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6329                          -(Int)powers[exprem]);
6330   /* [UnitAddSub result may have leading zeros, even on zero] */
6331   if (accunits<0) result=-1;            /* negative result */
6332    else {                               /* non-negative result */
6333     /* check units of the result before freeing any storage */
6334     for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6335     result=(*u==0 ? 0 : +1);
6336     }
6337   /* clean up and return the result */
6338   if (allocacc!=NULL) free(allocacc);   /* drop any storage used */
6339   return result;
6340   } /* decUnitCompare */
6341
6342 /* ------------------------------------------------------------------ */
6343 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
6344 /*                                                                    */
6345 /*  This routine performs the calculation:                            */
6346 /*                                                                    */
6347 /*  C=A+(B*M)                                                         */
6348 /*                                                                    */
6349 /*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.          */
6350 /*                                                                    */
6351 /*  A may be shorter or longer than B.                                */
6352 /*                                                                    */
6353 /*  Leading zeros are not removed after a calculation.  The result is */
6354 /*  either the same length as the longer of A and B (adding any       */
6355 /*  shift), or one Unit longer than that (if a Unit carry occurred).  */
6356 /*                                                                    */
6357 /*  A and B content are not altered unless C is also A or B.          */
6358 /*  C may be the same array as A or B, but only if no zero padding is */
6359 /*  requested (that is, C may be B only if bshift==0).                */
6360 /*  C is filled from the lsu; only those units necessary to complete  */
6361 /*  the calculation are referenced.                                   */
6362 /*                                                                    */
6363 /*  Arg1 is A first Unit (lsu)                                        */
6364 /*  Arg2 is A length in Units                                         */
6365 /*  Arg3 is B first Unit (lsu)                                        */
6366 /*  Arg4 is B length in Units                                         */
6367 /*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
6368 /*  Arg6 is C first Unit (lsu)                                        */
6369 /*  Arg7 is M, the multiplier                                         */
6370 /*                                                                    */
6371 /*  returns the count of Units written to C, which will be non-zero   */
6372 /*  and negated if the result is negative.  That is, the sign of the  */
6373 /*  returned Int is the sign of the result (positive for zero) and    */
6374 /*  the absolute value of the Int is the count of Units.              */
6375 /*                                                                    */
6376 /*  It is the caller's responsibility to make sure that C size is     */
6377 /*  safe, allowing space if necessary for a one-Unit carry.           */
6378 /*                                                                    */
6379 /*  This routine is severely performance-critical; *any* change here  */
6380 /*  must be measured (timed) to assure no performance degradation.    */
6381 /*  In particular, trickery here tends to be counter-productive, as   */
6382 /*  increased complexity of code hurts register optimizations on      */
6383 /*  register-poor architectures.  Avoiding divisions is nearly        */
6384 /*  always a Good Idea, however.                                      */
6385 /*                                                                    */
6386 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
6387 /* (IBM Warwick, UK) for some of the ideas used in this routine.      */
6388 /* ------------------------------------------------------------------ */
6389 static Int decUnitAddSub(const Unit *a, Int alength,
6390                          const Unit *b, Int blength, Int bshift,
6391                          Unit *c, Int m) {
6392   const Unit *alsu=a;              /* A lsu [need to remember it] */
6393   Unit *clsu=c;                    /* C ditto */
6394   Unit *minC;                      /* low water mark for C */
6395   Unit *maxC;                      /* high water mark for C */
6396   eInt carry=0;                    /* carry integer (could be Long) */
6397   Int  add;                        /* work */
6398   #if DECDPUN<=4                   /* myriadal, millenary, etc. */
6399   Int  est;                        /* estimated quotient */
6400   #endif
6401
6402   #if DECTRACE
6403   if (alength<1 || blength<1)
6404     printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6405   #endif
6406
6407   maxC=c+alength;                  /* A is usually the longer */
6408   minC=c+blength;                  /* .. and B the shorter */
6409   if (bshift!=0) {                 /* B is shifted; low As copy across */
6410     minC+=bshift;
6411     /* if in place [common], skip copy unless there's a gap [rare] */
6412     if (a==c && bshift<=alength) {
6413       c+=bshift;
6414       a+=bshift;
6415       }
6416      else for (; c<clsu+bshift; a++, c++) {  /* copy needed */
6417       if (a<alsu+alength) *c=*a;
6418        else *c=0;
6419       }
6420     }
6421   if (minC>maxC) { /* swap */
6422     Unit *hold=minC;
6423     minC=maxC;
6424     maxC=hold;
6425     }
6426
6427   /* For speed, do the addition as two loops; the first where both A */
6428   /* and B contribute, and the second (if necessary) where only one or */
6429   /* other of the numbers contribute. */
6430   /* Carry handling is the same (i.e., duplicated) in each case. */
6431   for (; c<minC; c++) {
6432     carry+=*a;
6433     a++;
6434     carry+=((eInt)*b)*m;                /* [special-casing m=1/-1 */
6435     b++;                                /* here is not a win] */
6436     /* here carry is new Unit of digits; it could be +ve or -ve */
6437     if ((ueInt)carry<=DECDPUNMAX) {     /* fastpath 0-DECDPUNMAX */
6438       *c=(Unit)carry;
6439       carry=0;
6440       continue;
6441       }
6442     #if DECDPUN==4                           /* use divide-by-multiply */
6443       if (carry>=0) {
6444         est=(((ueInt)carry>>11)*53687)>>18;
6445         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6446         carry=est;                           /* likely quotient [89%] */
6447         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6448         carry++;
6449         *c-=DECDPUNMAX+1;
6450         continue;
6451         }
6452       /* negative case */
6453       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6454       est=(((ueInt)carry>>11)*53687)>>18;
6455       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6456       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6457       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6458       carry++;
6459       *c-=DECDPUNMAX+1;
6460     #elif DECDPUN==3
6461       if (carry>=0) {
6462         est=(((ueInt)carry>>3)*16777)>>21;
6463         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6464         carry=est;                           /* likely quotient [99%] */
6465         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6466         carry++;
6467         *c-=DECDPUNMAX+1;
6468         continue;
6469         }
6470       /* negative case */
6471       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6472       est=(((ueInt)carry>>3)*16777)>>21;
6473       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6474       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6475       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6476       carry++;
6477       *c-=DECDPUNMAX+1;
6478     #elif DECDPUN<=2
6479       /* Can use QUOT10 as carry <= 4 digits */
6480       if (carry>=0) {
6481         est=QUOT10(carry, DECDPUN);
6482         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6483         carry=est;                           /* quotient */
6484         continue;
6485         }
6486       /* negative case */
6487       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6488       est=QUOT10(carry, DECDPUN);
6489       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6490       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6491     #else
6492       /* remainder operator is undefined if negative, so must test */
6493       if ((ueInt)carry<(DECDPUNMAX+1)*2) {   /* fastpath carry +1 */
6494         *c=(Unit)(carry-(DECDPUNMAX+1));     /* [helps additions] */
6495         carry=1;
6496         continue;
6497         }
6498       if (carry>=0) {
6499         *c=(Unit)(carry%(DECDPUNMAX+1));
6500         carry=carry/(DECDPUNMAX+1);
6501         continue;
6502         }
6503       /* negative case */
6504       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6505       *c=(Unit)(carry%(DECDPUNMAX+1));
6506       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6507     #endif
6508     } /* c */
6509
6510   /* now may have one or other to complete */
6511   /* [pretest to avoid loop setup/shutdown] */
6512   if (c<maxC) for (; c<maxC; c++) {
6513     if (a<alsu+alength) {               /* still in A */
6514       carry+=*a;
6515       a++;
6516       }
6517      else {                             /* inside B */
6518       carry+=((eInt)*b)*m;
6519       b++;
6520       }
6521     /* here carry is new Unit of digits; it could be +ve or -ve and */
6522     /* magnitude up to DECDPUNMAX squared */
6523     if ((ueInt)carry<=DECDPUNMAX) {     /* fastpath 0-DECDPUNMAX */
6524       *c=(Unit)carry;
6525       carry=0;
6526       continue;
6527       }
6528     /* result for this unit is negative or >DECDPUNMAX */
6529     #if DECDPUN==4                           /* use divide-by-multiply */
6530       if (carry>=0) {
6531         est=(((ueInt)carry>>11)*53687)>>18;
6532         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6533         carry=est;                           /* likely quotient [79.7%] */
6534         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6535         carry++;
6536         *c-=DECDPUNMAX+1;
6537         continue;
6538         }
6539       /* negative case */
6540       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6541       est=(((ueInt)carry>>11)*53687)>>18;
6542       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6543       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6544       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6545       carry++;
6546       *c-=DECDPUNMAX+1;
6547     #elif DECDPUN==3
6548       if (carry>=0) {
6549         est=(((ueInt)carry>>3)*16777)>>21;
6550         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6551         carry=est;                           /* likely quotient [99%] */
6552         if (*c<DECDPUNMAX+1) continue;       /* estimate was correct */
6553         carry++;
6554         *c-=DECDPUNMAX+1;
6555         continue;
6556         }
6557       /* negative case */
6558       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6559       est=(((ueInt)carry>>3)*16777)>>21;
6560       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6561       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6562       if (*c<DECDPUNMAX+1) continue;         /* was OK */
6563       carry++;
6564       *c-=DECDPUNMAX+1;
6565     #elif DECDPUN<=2
6566       if (carry>=0) {
6567         est=QUOT10(carry, DECDPUN);
6568         *c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6569         carry=est;                           /* quotient */
6570         continue;
6571         }
6572       /* negative case */
6573       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6574       est=QUOT10(carry, DECDPUN);
6575       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6576       carry=est-(DECDPUNMAX+1);              /* correctly negative */
6577     #else
6578       if ((ueInt)carry<(DECDPUNMAX+1)*2){    /* fastpath carry 1 */
6579         *c=(Unit)(carry-(DECDPUNMAX+1));
6580         carry=1;
6581         continue;
6582         }
6583       /* remainder operator is undefined if negative, so must test */
6584       if (carry>=0) {
6585         *c=(Unit)(carry%(DECDPUNMAX+1));
6586         carry=carry/(DECDPUNMAX+1);
6587         continue;
6588         }
6589       /* negative case */
6590       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6591       *c=(Unit)(carry%(DECDPUNMAX+1));
6592       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6593     #endif
6594     } /* c */
6595
6596   /* OK, all A and B processed; might still have carry or borrow */
6597   /* return number of Units in the result, negated if a borrow */
6598   if (carry==0) return c-clsu;     /* no carry, so no more to do */
6599   if (carry>0) {                   /* positive carry */
6600     *c=(Unit)carry;                /* place as new unit */
6601     c++;                           /* .. */
6602     return c-clsu;
6603     }
6604   /* -ve carry: it's a borrow; complement needed */
6605   add=1;                           /* temporary carry... */
6606   for (c=clsu; c<maxC; c++) {
6607     add=DECDPUNMAX+add-*c;
6608     if (add<=DECDPUNMAX) {
6609       *c=(Unit)add;
6610       add=0;
6611       }
6612      else {
6613       *c=0;
6614       add=1;
6615       }
6616     }
6617   /* add an extra unit iff it would be non-zero */
6618   #if DECTRACE
6619     printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6620   #endif
6621   if ((add-carry-1)!=0) {
6622     *c=(Unit)(add-carry-1);
6623     c++;                      /* interesting, include it */
6624     }
6625   return clsu-c;              /* -ve result indicates borrowed */
6626   } /* decUnitAddSub */
6627
6628 /* ------------------------------------------------------------------ */
6629 /* decTrim -- trim trailing zeros or normalize                        */
6630 /*                                                                    */
6631 /*   dn is the number to trim or normalize                            */
6632 /*   set is the context to use to check for clamp                     */
6633 /*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
6634 /*   dropped returns the number of discarded trailing zeros           */
6635 /*   returns dn                                                       */
6636 /*                                                                    */
6637 /* If clamp is set in the context then the number of zeros trimmed    */
6638 /* may be limited if the exponent is high.                            */
6639 /* All fields are updated as required.  This is a utility operation,  */
6640 /* so special values are unchanged and no error is possible.          */
6641 /* ------------------------------------------------------------------ */
6642 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6643                            Int *dropped) {
6644   Int   d, exp;                    /* work */
6645   uInt  cut;                       /* .. */
6646   Unit  *up;                       /* -> current Unit */
6647
6648   #if DECCHECK
6649   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6650   #endif
6651
6652   *dropped=0;                           /* assume no zeros dropped */
6653   if ((dn->bits & DECSPECIAL)           /* fast exit if special .. */
6654     || (*dn->lsu & 0x01)) return dn;    /* .. or odd */
6655   if (ISZERO(dn)) {                     /* .. or 0 */
6656     dn->exponent=0;                     /* (sign is preserved) */
6657     return dn;
6658     }
6659
6660   /* have a finite number which is even */
6661   exp=dn->exponent;
6662   cut=1;                           /* digit (1-DECDPUN) in Unit */
6663   up=dn->lsu;                      /* -> current Unit */
6664   for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6665     /* slice by powers */
6666     #if DECDPUN<=4
6667       uInt quot=QUOT10(*up, cut);
6668       if ((*up-quot*powers[cut])!=0) break;  /* found non-0 digit */
6669     #else
6670       if (*up%powers[cut]!=0) break;         /* found non-0 digit */
6671     #endif
6672     /* have a trailing 0 */
6673     if (!all) {                    /* trimming */
6674       /* [if exp>0 then all trailing 0s are significant for trim] */
6675       if (exp<=0) {                /* if digit might be significant */
6676         if (exp==0) break;         /* then quit */
6677         exp++;                     /* next digit might be significant */
6678         }
6679       }
6680     cut++;                         /* next power */
6681     if (cut>DECDPUN) {             /* need new Unit */
6682       up++;
6683       cut=1;
6684       }
6685     } /* d */
6686   if (d==0) return dn;             /* none to drop */
6687
6688   /* may need to limit drop if clamping */
6689   if (set->clamp) {
6690     Int maxd=set->emax-set->digits+1-dn->exponent;
6691     if (maxd<=0) return dn;        /* nothing possible */
6692     if (d>maxd) d=maxd;
6693     }
6694
6695   /* effect the drop */
6696   decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6697   dn->exponent+=d;                 /* maintain numerical value */
6698   dn->digits-=d;                   /* new length */
6699   *dropped=d;                      /* report the count */
6700   return dn;
6701   } /* decTrim */
6702
6703 /* ------------------------------------------------------------------ */
6704 /* decReverse -- reverse a Unit array in place                        */
6705 /*                                                                    */
6706 /*   ulo    is the start of the array                                 */
6707 /*   uhi    is the end of the array (highest Unit to include)         */
6708 /*                                                                    */
6709 /* The units ulo through uhi are reversed in place (if the number     */
6710 /* of units is odd, the middle one is untouched).  Note that the      */
6711 /* digit(s) in each unit are unaffected.                              */
6712 /* ------------------------------------------------------------------ */
6713 static void decReverse(Unit *ulo, Unit *uhi) {
6714   Unit temp;
6715   for (; ulo<uhi; ulo++, uhi--) {
6716     temp=*ulo;
6717     *ulo=*uhi;
6718     *uhi=temp;
6719     }
6720   return;
6721   } /* decReverse */
6722
6723 /* ------------------------------------------------------------------ */
6724 /* decShiftToMost -- shift digits in array towards most significant   */
6725 /*                                                                    */
6726 /*   uar    is the array                                              */
6727 /*   digits is the count of digits in use in the array                */
6728 /*   shift  is the number of zeros to pad with (least significant);   */
6729 /*     it must be zero or positive                                    */
6730 /*                                                                    */
6731 /*   returns the new length of the integer in the array, in digits    */
6732 /*                                                                    */
6733 /* No overflow is permitted (that is, the uar array must be known to  */
6734 /* be large enough to hold the result, after shifting).               */
6735 /* ------------------------------------------------------------------ */
6736 static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6737   Unit  *target, *source, *first;  /* work */
6738   Int   cut;                       /* odd 0's to add */
6739   uInt  next;                      /* work */
6740
6741   if (shift==0) return digits;     /* [fastpath] nothing to do */
6742   if ((digits+shift)<=DECDPUN) {   /* [fastpath] single-unit case */
6743     *uar=(Unit)(*uar*powers[shift]);
6744     return digits+shift;
6745     }
6746
6747   next=0;                          /* all paths */
6748   source=uar+D2U(digits)-1;        /* where msu comes from */
6749   target=source+D2U(shift);        /* where upper part of first cut goes */
6750   cut=DECDPUN-MSUDIGITS(shift);    /* where to slice */
6751   if (cut==0) {                    /* unit-boundary case */
6752     for (; source>=uar; source--, target--) *target=*source;
6753     }
6754    else {
6755     first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6756     for (; source>=uar; source--, target--) {
6757       /* split the source Unit and accumulate remainder for next */
6758       #if DECDPUN<=4
6759         uInt quot=QUOT10(*source, cut);
6760         uInt rem=*source-quot*powers[cut];
6761         next+=quot;
6762       #else
6763         uInt rem=*source%powers[cut];
6764         next+=*source/powers[cut];
6765       #endif
6766       if (target<=first) *target=(Unit)next;   /* write to target iff valid */
6767       next=rem*powers[DECDPUN-cut];            /* save remainder for next Unit */
6768       }
6769     } /* shift-move */
6770
6771   /* propagate any partial unit to one below and clear the rest */
6772   for (; target>=uar; target--) {
6773     *target=(Unit)next;
6774     next=0;
6775     }
6776   return digits+shift;
6777   } /* decShiftToMost */
6778
6779 /* ------------------------------------------------------------------ */
6780 /* decShiftToLeast -- shift digits in array towards least significant */
6781 /*                                                                    */
6782 /*   uar   is the array                                               */
6783 /*   units is length of the array, in units                           */
6784 /*   shift is the number of digits to remove from the lsu end; it     */
6785 /*     must be zero or positive and <= than units*DECDPUN.            */
6786 /*                                                                    */
6787 /*   returns the new length of the integer in the array, in units     */
6788 /*                                                                    */
6789 /* Removed digits are discarded (lost).  Units not required to hold   */
6790 /* the final result are unchanged.                                    */
6791 /* ------------------------------------------------------------------ */
6792 static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6793   Unit  *target, *up;              /* work */
6794   Int   cut, count;                /* work */
6795   Int   quot, rem;                 /* for division */
6796
6797   if (shift==0) return units;      /* [fastpath] nothing to do */
6798   if (shift==units*DECDPUN) {      /* [fastpath] little to do */
6799     *uar=0;                        /* all digits cleared gives zero */
6800     return 1;                      /* leaves just the one */
6801     }
6802
6803   target=uar;                      /* both paths */
6804   cut=MSUDIGITS(shift);
6805   if (cut==DECDPUN) {              /* unit-boundary case; easy */
6806     up=uar+D2U(shift);
6807     for (; up<uar+units; target++, up++) *target=*up;
6808     return target-uar;
6809     }
6810
6811   /* messier */
6812   up=uar+D2U(shift-cut);           /* source; correct to whole Units */
6813   count=units*DECDPUN-shift;       /* the maximum new length */
6814   #if DECDPUN<=4
6815     quot=QUOT10(*up, cut);
6816   #else
6817     quot=*up/powers[cut];
6818   #endif
6819   for (; ; target++) {
6820     *target=(Unit)quot;
6821     count-=(DECDPUN-cut);
6822     if (count<=0) break;
6823     up++;
6824     quot=*up;
6825     #if DECDPUN<=4
6826       quot=QUOT10(quot, cut);
6827       rem=*up-quot*powers[cut];
6828     #else
6829       rem=quot%powers[cut];
6830       quot=quot/powers[cut];
6831     #endif
6832     *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6833     count-=cut;
6834     if (count<=0) break;
6835     }
6836   return target-uar+1;
6837   } /* decShiftToLeast */
6838
6839 #if DECSUBSET
6840 /* ------------------------------------------------------------------ */
6841 /* decRoundOperand -- round an operand  [used for subset only]        */
6842 /*                                                                    */
6843 /*   dn is the number to round (dn->digits is > set->digits)          */
6844 /*   set is the relevant context                                      */
6845 /*   status is the status accumulator                                 */
6846 /*                                                                    */
6847 /*   returns an allocated decNumber with the rounded result.          */
6848 /*                                                                    */
6849 /* lostDigits and other status may be set by this.                    */
6850 /*                                                                    */
6851 /* Since the input is an operand, it must not be modified.            */
6852 /* Instead, return an allocated decNumber, rounded as required.       */
6853 /* It is the caller's responsibility to free the allocated storage.   */
6854 /*                                                                    */
6855 /* If no storage is available then the result cannot be used, so NULL */
6856 /* is returned.                                                       */
6857 /* ------------------------------------------------------------------ */
6858 static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6859                                   uInt *status) {
6860   decNumber *res;                       /* result structure */
6861   uInt newstatus=0;                     /* status from round */
6862   Int  residue=0;                       /* rounding accumulator */
6863
6864   /* Allocate storage for the returned decNumber, big enough for the */
6865   /* length specified by the context */
6866   res=(decNumber *)malloc(sizeof(decNumber)
6867                           +(D2U(set->digits)-1)*sizeof(Unit));
6868   if (res==NULL) {
6869     *status|=DEC_Insufficient_storage;
6870     return NULL;
6871     }
6872   decCopyFit(res, dn, set, &residue, &newstatus);
6873   decApplyRound(res, set, residue, &newstatus);
6874
6875   /* If that set Inexact then "lost digits" is raised... */
6876   if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6877   *status|=newstatus;
6878   return res;
6879   } /* decRoundOperand */
6880 #endif
6881
6882 /* ------------------------------------------------------------------ */
6883 /* decCopyFit -- copy a number, truncating the coefficient if needed  */
6884 /*                                                                    */
6885 /*   dest is the target decNumber                                     */
6886 /*   src  is the source decNumber                                     */
6887 /*   set is the context [used for length (digits) and rounding mode]  */
6888 /*   residue is the residue accumulator                               */
6889 /*   status contains the current status to be updated                 */
6890 /*                                                                    */
6891 /* (dest==src is allowed and will be a no-op if fits)                 */
6892 /* All fields are updated as required.                                */
6893 /* ------------------------------------------------------------------ */
6894 static void decCopyFit(decNumber *dest, const decNumber *src,
6895                        decContext *set, Int *residue, uInt *status) {
6896   dest->bits=src->bits;
6897   dest->exponent=src->exponent;
6898   decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6899   } /* decCopyFit */
6900
6901 /* ------------------------------------------------------------------ */
6902 /* decSetCoeff -- set the coefficient of a number                     */
6903 /*                                                                    */
6904 /*   dn    is the number whose coefficient array is to be set.        */
6905 /*         It must have space for set->digits digits                  */
6906 /*   set   is the context [for size]                                  */
6907 /*   lsu   -> lsu of the source coefficient [may be dn->lsu]          */
6908 /*   len   is digits in the source coefficient [may be dn->digits]    */
6909 /*   residue is the residue accumulator.  This has values as in       */
6910 /*         decApplyRound, and will be unchanged unless the            */
6911 /*         target size is less than len.  In this case, the           */
6912 /*         coefficient is truncated and the residue is updated to     */
6913 /*         reflect the previous residue and the dropped digits.       */
6914 /*   status is the status accumulator, as usual                       */
6915 /*                                                                    */
6916 /* The coefficient may already be in the number, or it can be an      */
6917 /* external intermediate array.  If it is in the number, lsu must ==  */
6918 /* dn->lsu and len must == dn->digits.                                */
6919 /*                                                                    */
6920 /* Note that the coefficient length (len) may be < set->digits, and   */
6921 /* in this case this merely copies the coefficient (or is a no-op     */
6922 /* if dn->lsu==lsu).                                                  */
6923 /*                                                                    */
6924 /* Note also that (only internally, from decQuantizeOp and            */
6925 /* decSetSubnormal) the value of set->digits may be less than one,    */
6926 /* indicating a round to left.  This routine handles that case        */
6927 /* correctly; caller ensures space.                                   */
6928 /*                                                                    */
6929 /* dn->digits, dn->lsu (and as required), and dn->exponent are        */
6930 /* updated as necessary.   dn->bits (sign) is unchanged.              */
6931 /*                                                                    */
6932 /* DEC_Rounded status is set if any digits are discarded.             */
6933 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
6934 /*                       incoming residue was non-0 (implies rounded) */
6935 /* ------------------------------------------------------------------ */
6936 /* mapping array: maps 0-9 to canonical residues, so that a residue */
6937 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
6938 /*                             0  1  2  3  4  5  6  7  8  9 */
6939 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6940 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
6941                         Int len, Int *residue, uInt *status) {
6942   Int   discard;              /* number of digits to discard */
6943   uInt  cut;                  /* cut point in Unit */
6944   const Unit *up;             /* work */
6945   Unit  *target;              /* .. */
6946   Int   count;                /* .. */
6947   #if DECDPUN<=4
6948   uInt  temp;                 /* .. */
6949   #endif
6950
6951   discard=len-set->digits;    /* digits to discard */
6952   if (discard<=0) {           /* no digits are being discarded */
6953     if (dn->lsu!=lsu) {       /* copy needed */
6954       /* copy the coefficient array to the result number; no shift needed */
6955       count=len;              /* avoids D2U */
6956       up=lsu;
6957       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6958         *target=*up;
6959       dn->digits=len;         /* set the new length */
6960       }
6961     /* dn->exponent and residue are unchanged, record any inexactitude */
6962     if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6963     return;
6964     }
6965
6966   /* some digits must be discarded ... */
6967   dn->exponent+=discard;      /* maintain numerical value */
6968   *status|=DEC_Rounded;       /* accumulate Rounded status */
6969   if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6970
6971   if (discard>len) {          /* everything, +1, is being discarded */
6972     /* guard digit is 0 */
6973     /* residue is all the number [NB could be all 0s] */
6974     if (*residue<=0) {        /* not already positive */
6975       count=len;              /* avoids D2U */
6976       for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
6977         *residue=1;
6978         break;                /* no need to check any others */
6979         }
6980       }
6981     if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6982     *dn->lsu=0;               /* coefficient will now be 0 */
6983     dn->digits=1;             /* .. */
6984     return;
6985     } /* total discard */
6986
6987   /* partial discard [most common case] */
6988   /* here, at least the first (most significant) discarded digit exists */
6989
6990   /* spin up the number, noting residue during the spin, until get to */
6991   /* the Unit with the first discarded digit.  When reach it, extract */
6992   /* it and remember its position */
6993   count=0;
6994   for (up=lsu;; up++) {
6995     count+=DECDPUN;
6996     if (count>=discard) break; /* full ones all checked */
6997     if (*up!=0) *residue=1;
6998     } /* up */
6999
7000   /* here up -> Unit with first discarded digit */
7001   cut=discard-(count-DECDPUN)-1;
7002   if (cut==DECDPUN-1) {       /* unit-boundary case (fast) */
7003     Unit half=(Unit)powers[DECDPUN]>>1;
7004     /* set residue directly */
7005     if (*up>=half) {
7006       if (*up>half) *residue=7;
7007       else *residue+=5;       /* add sticky bit */
7008       }
7009      else { /* <half */
7010       if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
7011       }
7012     if (set->digits<=0) {     /* special for Quantize/Subnormal :-( */
7013       *dn->lsu=0;             /* .. result is 0 */
7014       dn->digits=1;           /* .. */
7015       }
7016      else {                   /* shift to least */
7017       count=set->digits;      /* now digits to end up with */
7018       dn->digits=count;       /* set the new length */
7019       up++;                   /* move to next */
7020       /* on unit boundary, so shift-down copy loop is simple */
7021       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7022         *target=*up;
7023       }
7024     } /* unit-boundary case */
7025
7026    else { /* discard digit is in low digit(s), and not top digit */
7027     uInt  discard1;                /* first discarded digit */
7028     uInt  quot, rem;               /* for divisions */
7029     if (cut==0) quot=*up;          /* is at bottom of unit */
7030      else /* cut>0 */ {            /* it's not at bottom of unit */
7031       #if DECDPUN<=4
7032         quot=QUOT10(*up, cut);
7033         rem=*up-quot*powers[cut];
7034       #else
7035         rem=*up%powers[cut];
7036         quot=*up/powers[cut];
7037       #endif
7038       if (rem!=0) *residue=1;
7039       }
7040     /* discard digit is now at bottom of quot */
7041     #if DECDPUN<=4
7042       temp=(quot*6554)>>16;        /* fast /10 */
7043       /* Vowels algorithm here not a win (9 instructions) */
7044       discard1=quot-X10(temp);
7045       quot=temp;
7046     #else
7047       discard1=quot%10;
7048       quot=quot/10;
7049     #endif
7050     /* here, discard1 is the guard digit, and residue is everything */
7051     /* else [use mapping array to accumulate residue safely] */
7052     *residue+=resmap[discard1];
7053     cut++;                         /* update cut */
7054     /* here: up -> Unit of the array with bottom digit */
7055     /*       cut is the division point for each Unit */
7056     /*       quot holds the uncut high-order digits for the current unit */
7057     if (set->digits<=0) {          /* special for Quantize/Subnormal :-( */
7058       *dn->lsu=0;                  /* .. result is 0 */
7059       dn->digits=1;                /* .. */
7060       }
7061      else {                        /* shift to least needed */
7062       count=set->digits;           /* now digits to end up with */
7063       dn->digits=count;            /* set the new length */
7064       /* shift-copy the coefficient array to the result number */
7065       for (target=dn->lsu; ; target++) {
7066         *target=(Unit)quot;
7067         count-=(DECDPUN-cut);
7068         if (count<=0) break;
7069         up++;
7070         quot=*up;
7071         #if DECDPUN<=4
7072           quot=QUOT10(quot, cut);
7073           rem=*up-quot*powers[cut];
7074         #else
7075           rem=quot%powers[cut];
7076           quot=quot/powers[cut];
7077         #endif
7078         *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7079         count-=cut;
7080         if (count<=0) break;
7081         } /* shift-copy loop */
7082       } /* shift to least */
7083     } /* not unit boundary */
7084
7085   if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7086   return;
7087   } /* decSetCoeff */
7088
7089 /* ------------------------------------------------------------------ */
7090 /* decApplyRound -- apply pending rounding to a number                */
7091 /*                                                                    */
7092 /*   dn    is the number, with space for set->digits digits           */
7093 /*   set   is the context [for size and rounding mode]                */
7094 /*   residue indicates pending rounding, being any accumulated        */
7095 /*         guard and sticky information.  It may be:                  */
7096 /*         6-9: rounding digit is >5                                  */
7097 /*         5:   rounding digit is exactly half-way                    */
7098 /*         1-4: rounding digit is <5 and >0                           */
7099 /*         0:   the coefficient is exact                              */
7100 /*        -1:   as 1, but the hidden digits are subtractive, that     */
7101 /*              is, of the opposite sign to dn.  In this case the     */
7102 /*              coefficient must be non-0.  This case occurs when     */
7103 /*              subtracting a small number (which can be reduced to   */
7104 /*              a sticky bit); see decAddOp.                          */
7105 /*   status is the status accumulator, as usual                       */
7106 /*                                                                    */
7107 /* This routine applies rounding while keeping the length of the      */
7108 /* coefficient constant.  The exponent and status are unchanged       */
7109 /* except if:                                                         */
7110 /*                                                                    */
7111 /*   -- the coefficient was increased and is all nines (in which      */
7112 /*      case Overflow could occur, and is handled directly here so    */
7113 /*      the caller does not need to re-test for overflow)             */
7114 /*                                                                    */
7115 /*   -- the coefficient was decreased and becomes all nines (in which */
7116 /*      case Underflow could occur, and is also handled directly).    */
7117 /*                                                                    */
7118 /* All fields in dn are updated as required.                          */
7119 /*                                                                    */
7120 /* ------------------------------------------------------------------ */
7121 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7122                           uInt *status) {
7123   Int  bump;                  /* 1 if coefficient needs to be incremented */
7124                               /* -1 if coefficient needs to be decremented */
7125
7126   if (residue==0) return;     /* nothing to apply */
7127
7128   bump=0;                     /* assume a smooth ride */
7129
7130   /* now decide whether, and how, to round, depending on mode */
7131   switch (set->round) {
7132     case DEC_ROUND_05UP: {    /* round zero or five up (for reround) */
7133       /* This is the same as DEC_ROUND_DOWN unless there is a */
7134       /* positive residue and the lsd of dn is 0 or 5, in which case */
7135       /* it is bumped; when residue is <0, the number is therefore */
7136       /* bumped down unless the final digit was 1 or 6 (in which */
7137       /* case it is bumped down and then up -- a no-op) */
7138       Int lsd5=*dn->lsu%5;     /* get lsd and quintate */
7139       if (residue<0 && lsd5!=1) bump=-1;
7140        else if (residue>0 && lsd5==0) bump=1;
7141       /* [bump==1 could be applied directly; use common path for clarity] */
7142       break;} /* r-05 */
7143
7144     case DEC_ROUND_DOWN: {
7145       /* no change, except if negative residue */
7146       if (residue<0) bump=-1;
7147       break;} /* r-d */
7148
7149     case DEC_ROUND_HALF_DOWN: {
7150       if (residue>5) bump=1;
7151       break;} /* r-h-d */
7152
7153     case DEC_ROUND_HALF_EVEN: {
7154       if (residue>5) bump=1;            /* >0.5 goes up */
7155        else if (residue==5) {           /* exactly 0.5000... */
7156         /* 0.5 goes up iff [new] lsd is odd */
7157         if (*dn->lsu & 0x01) bump=1;
7158         }
7159       break;} /* r-h-e */
7160
7161     case DEC_ROUND_HALF_UP: {
7162       if (residue>=5) bump=1;
7163       break;} /* r-h-u */
7164
7165     case DEC_ROUND_UP: {
7166       if (residue>0) bump=1;
7167       break;} /* r-u */
7168
7169     case DEC_ROUND_CEILING: {
7170       /* same as _UP for positive numbers, and as _DOWN for negatives */
7171       /* [negative residue cannot occur on 0] */
7172       if (decNumberIsNegative(dn)) {
7173         if (residue<0) bump=-1;
7174         }
7175        else {
7176         if (residue>0) bump=1;
7177         }
7178       break;} /* r-c */
7179
7180     case DEC_ROUND_FLOOR: {
7181       /* same as _UP for negative numbers, and as _DOWN for positive */
7182       /* [negative residue cannot occur on 0] */
7183       if (!decNumberIsNegative(dn)) {
7184         if (residue<0) bump=-1;
7185         }
7186        else {
7187         if (residue>0) bump=1;
7188         }
7189       break;} /* r-f */
7190
7191     default: {      /* e.g., DEC_ROUND_MAX */
7192       *status|=DEC_Invalid_context;
7193       #if DECTRACE || (DECCHECK && DECVERB)
7194       printf("Unknown rounding mode: %d\n", set->round);
7195       #endif
7196       break;}
7197     } /* switch */
7198
7199   /* now bump the number, up or down, if need be */
7200   if (bump==0) return;                       /* no action required */
7201
7202   /* Simply use decUnitAddSub unless bumping up and the number is */
7203   /* all nines.  In this special case set to 100... explicitly */
7204   /* and adjust the exponent by one (as otherwise could overflow */
7205   /* the array) */
7206   /* Similarly handle all-nines result if bumping down. */
7207   if (bump>0) {
7208     Unit *up;                                /* work */
7209     uInt count=dn->digits;                   /* digits to be checked */
7210     for (up=dn->lsu; ; up++) {
7211       if (count<=DECDPUN) {
7212         /* this is the last Unit (the msu) */
7213         if (*up!=powers[count]-1) break;     /* not still 9s */
7214         /* here if it, too, is all nines */
7215         *up=(Unit)powers[count-1];           /* here 999 -> 100 etc. */
7216         for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7217         dn->exponent++;                      /* and bump exponent */
7218         /* [which, very rarely, could cause Overflow...] */
7219         if ((dn->exponent+dn->digits)>set->emax+1) {
7220           decSetOverflow(dn, set, status);
7221           }
7222         return;                              /* done */
7223         }
7224       /* a full unit to check, with more to come */
7225       if (*up!=DECDPUNMAX) break;            /* not still 9s */
7226       count-=DECDPUN;
7227       } /* up */
7228     } /* bump>0 */
7229    else {                                    /* -1 */
7230     /* here checking for a pre-bump of 1000... (leading 1, all */
7231     /* other digits zero) */
7232     Unit *up, *sup;                          /* work */
7233     uInt count=dn->digits;                   /* digits to be checked */
7234     for (up=dn->lsu; ; up++) {
7235       if (count<=DECDPUN) {
7236         /* this is the last Unit (the msu) */
7237         if (*up!=powers[count-1]) break;     /* not 100.. */
7238         /* here if have the 1000... case */
7239         sup=up;                              /* save msu pointer */
7240         *up=(Unit)powers[count]-1;           /* here 100 in msu -> 999 */
7241         /* others all to all-nines, too */
7242         for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7243         dn->exponent--;                      /* and bump exponent */
7244
7245         /* iff the number was at the subnormal boundary (exponent=etiny) */
7246         /* then the exponent is now out of range, so it will in fact get */
7247         /* clamped to etiny and the final 9 dropped. */
7248         /* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7249         /*        dn->exponent, set->digits); */
7250         if (dn->exponent+1==set->emin-set->digits+1) {
7251           if (count==1 && dn->digits==1) *sup=0;  /* here 9 -> 0[.9] */
7252            else {
7253             *sup=(Unit)powers[count-1]-1;    /* here 999.. in msu -> 99.. */
7254             dn->digits--;
7255             }
7256           dn->exponent++;
7257           *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7258           }
7259         return;                              /* done */
7260         }
7261
7262       /* a full unit to check, with more to come */
7263       if (*up!=0) break;                     /* not still 0s */
7264       count-=DECDPUN;
7265       } /* up */
7266
7267     } /* bump<0 */
7268
7269   /* Actual bump needed.  Do it. */
7270   decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7271   } /* decApplyRound */
7272
7273 #if DECSUBSET
7274 /* ------------------------------------------------------------------ */
7275 /* decFinish -- finish processing a number                            */
7276 /*                                                                    */
7277 /*   dn is the number                                                 */
7278 /*   set is the context                                               */
7279 /*   residue is the rounding accumulator (as in decApplyRound)        */
7280 /*   status is the accumulator                                        */
7281 /*                                                                    */
7282 /* This finishes off the current number by:                           */
7283 /*    1. If not extended:                                             */
7284 /*       a. Converting a zero result to clean '0'                     */
7285 /*       b. Reducing positive exponents to 0, if would fit in digits  */
7286 /*    2. Checking for overflow and subnormals (always)                */
7287 /* Note this is just Finalize when no subset arithmetic.              */
7288 /* All fields are updated as required.                                */
7289 /* ------------------------------------------------------------------ */
7290 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7291                       uInt *status) {
7292   if (!set->extended) {
7293     if ISZERO(dn) {                /* value is zero */
7294       dn->exponent=0;              /* clean exponent .. */
7295       dn->bits=0;                  /* .. and sign */
7296       return;                      /* no error possible */
7297       }
7298     if (dn->exponent>=0) {         /* non-negative exponent */
7299       /* >0; reduce to integer if possible */
7300       if (set->digits >= (dn->exponent+dn->digits)) {
7301         dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7302         dn->exponent=0;
7303         }
7304       }
7305     } /* !extended */
7306
7307   decFinalize(dn, set, residue, status);
7308   } /* decFinish */
7309 #endif
7310
7311 /* ------------------------------------------------------------------ */
7312 /* decFinalize -- final check, clamp, and round of a number           */
7313 /*                                                                    */
7314 /*   dn is the number                                                 */
7315 /*   set is the context                                               */
7316 /*   residue is the rounding accumulator (as in decApplyRound)        */
7317 /*   status is the status accumulator                                 */
7318 /*                                                                    */
7319 /* This finishes off the current number by checking for subnormal     */
7320 /* results, applying any pending rounding, checking for overflow,     */
7321 /* and applying any clamping.                                         */
7322 /* Underflow and overflow conditions are raised as appropriate.       */
7323 /* All fields are updated as required.                                */
7324 /* ------------------------------------------------------------------ */
7325 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7326                         uInt *status) {
7327   Int shift;                            /* shift needed if clamping */
7328   Int tinyexp=set->emin-dn->digits+1;   /* precalculate subnormal boundary */
7329
7330   /* Must be careful, here, when checking the exponent as the */
7331   /* adjusted exponent could overflow 31 bits [because it may already */
7332   /* be up to twice the expected]. */
7333
7334   /* First test for subnormal.  This must be done before any final */
7335   /* round as the result could be rounded to Nmin or 0. */
7336   if (dn->exponent<=tinyexp) {          /* prefilter */
7337     Int comp;
7338     decNumber nmin;
7339     /* A very nasty case here is dn == Nmin and residue<0 */
7340     if (dn->exponent<tinyexp) {
7341       /* Go handle subnormals; this will apply round if needed. */
7342       decSetSubnormal(dn, set, residue, status);
7343       return;
7344       }
7345     /* Equals case: only subnormal if dn=Nmin and negative residue */
7346     decNumberZero(&nmin);
7347     nmin.lsu[0]=1;
7348     nmin.exponent=set->emin;
7349     comp=decCompare(dn, &nmin, 1);                /* (signless compare) */
7350     if (comp==BADINT) {                           /* oops */
7351       *status|=DEC_Insufficient_storage;          /* abandon... */
7352       return;
7353       }
7354     if (*residue<0 && comp==0) {                  /* neg residue and dn==Nmin */
7355       decApplyRound(dn, set, *residue, status);   /* might force down */
7356       decSetSubnormal(dn, set, residue, status);
7357       return;
7358       }
7359     }
7360
7361   /* now apply any pending round (this could raise overflow). */
7362   if (*residue!=0) decApplyRound(dn, set, *residue, status);
7363
7364   /* Check for overflow [redundant in the 'rare' case] or clamp */
7365   if (dn->exponent<=set->emax-set->digits+1) return;   /* neither needed */
7366
7367
7368   /* here when might have an overflow or clamp to do */
7369   if (dn->exponent>set->emax-dn->digits+1) {           /* too big */
7370     decSetOverflow(dn, set, status);
7371     return;
7372     }
7373   /* here when the result is normal but in clamp range */
7374   if (!set->clamp) return;
7375
7376   /* here when need to apply the IEEE exponent clamp (fold-down) */
7377   shift=dn->exponent-(set->emax-set->digits+1);
7378
7379   /* shift coefficient (if non-zero) */
7380   if (!ISZERO(dn)) {
7381     dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7382     }
7383   dn->exponent-=shift;   /* adjust the exponent to match */
7384   *status|=DEC_Clamped;  /* and record the dirty deed */
7385   return;
7386   } /* decFinalize */
7387
7388 /* ------------------------------------------------------------------ */
7389 /* decSetOverflow -- set number to proper overflow value              */
7390 /*                                                                    */
7391 /*   dn is the number (used for sign [only] and result)               */
7392 /*   set is the context [used for the rounding mode, etc.]            */
7393 /*   status contains the current status to be updated                 */
7394 /*                                                                    */
7395 /* This sets the sign of a number and sets its value to either        */
7396 /* Infinity or the maximum finite value, depending on the sign of     */
7397 /* dn and the rounding mode, following IEEE 854 rules.                */
7398 /* ------------------------------------------------------------------ */
7399 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7400   Flag needmax=0;                  /* result is maximum finite value */
7401   uByte sign=dn->bits&DECNEG;      /* clean and save sign bit */
7402
7403   if (ISZERO(dn)) {                /* zero does not overflow magnitude */
7404     Int emax=set->emax;                      /* limit value */
7405     if (set->clamp) emax-=set->digits-1;     /* lower if clamping */
7406     if (dn->exponent>emax) {                 /* clamp required */
7407       dn->exponent=emax;
7408       *status|=DEC_Clamped;
7409       }
7410     return;
7411     }
7412
7413   decNumberZero(dn);
7414   switch (set->round) {
7415     case DEC_ROUND_DOWN: {
7416       needmax=1;                   /* never Infinity */
7417       break;} /* r-d */
7418     case DEC_ROUND_05UP: {
7419       needmax=1;                   /* never Infinity */
7420       break;} /* r-05 */
7421     case DEC_ROUND_CEILING: {
7422       if (sign) needmax=1;         /* Infinity if non-negative */
7423       break;} /* r-c */
7424     case DEC_ROUND_FLOOR: {
7425       if (!sign) needmax=1;        /* Infinity if negative */
7426       break;} /* r-f */
7427     default: break;                /* Infinity in all other cases */
7428     }
7429   if (needmax) {
7430     decSetMaxValue(dn, set);
7431     dn->bits=sign;                 /* set sign */
7432     }
7433    else dn->bits=sign|DECINF;      /* Value is +/-Infinity */
7434   *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7435   } /* decSetOverflow */
7436
7437 /* ------------------------------------------------------------------ */
7438 /* decSetMaxValue -- set number to +Nmax (maximum normal value)       */
7439 /*                                                                    */
7440 /*   dn is the number to set                                          */
7441 /*   set is the context [used for digits and emax]                    */
7442 /*                                                                    */
7443 /* This sets the number to the maximum positive value.                */
7444 /* ------------------------------------------------------------------ */
7445 static void decSetMaxValue(decNumber *dn, decContext *set) {
7446   Unit *up;                        /* work */
7447   Int count=set->digits;           /* nines to add */
7448   dn->digits=count;
7449   /* fill in all nines to set maximum value */
7450   for (up=dn->lsu; ; up++) {
7451     if (count>DECDPUN) *up=DECDPUNMAX;  /* unit full o'nines */
7452      else {                             /* this is the msu */
7453       *up=(Unit)(powers[count]-1);
7454       break;
7455       }
7456     count-=DECDPUN;                /* filled those digits */
7457     } /* up */
7458   dn->bits=0;                      /* + sign */
7459   dn->exponent=set->emax-set->digits+1;
7460   } /* decSetMaxValue */
7461
7462 /* ------------------------------------------------------------------ */
7463 /* decSetSubnormal -- process value whose exponent is <Emin           */
7464 /*                                                                    */
7465 /*   dn is the number (used as input as well as output; it may have   */
7466 /*         an allowed subnormal value, which may need to be rounded)  */
7467 /*   set is the context [used for the rounding mode]                  */
7468 /*   residue is any pending residue                                   */
7469 /*   status contains the current status to be updated                 */
7470 /*                                                                    */
7471 /* If subset mode, set result to zero and set Underflow flags.        */
7472 /*                                                                    */
7473 /* Value may be zero with a low exponent; this does not set Subnormal */
7474 /* but the exponent will be clamped to Etiny.                         */
7475 /*                                                                    */
7476 /* Otherwise ensure exponent is not out of range, and round as        */
7477 /* necessary.  Underflow is set if the result is Inexact.             */
7478 /* ------------------------------------------------------------------ */
7479 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7480                             uInt *status) {
7481   decContext workset;         /* work */
7482   Int        etiny, adjust;   /* .. */
7483
7484   #if DECSUBSET
7485   /* simple set to zero and 'hard underflow' for subset */
7486   if (!set->extended) {
7487     decNumberZero(dn);
7488     /* always full overflow */
7489     *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7490     return;
7491     }
7492   #endif
7493
7494   /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7495   /* (Etiny) if needed */
7496   etiny=set->emin-(set->digits-1);      /* smallest allowed exponent */
7497
7498   if ISZERO(dn) {                       /* value is zero */
7499     /* residue can never be non-zero here */
7500     #if DECCHECK
7501       if (*residue!=0) {
7502         printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7503         *status|=DEC_Invalid_operation;
7504         }
7505     #endif
7506     if (dn->exponent<etiny) {           /* clamp required */
7507       dn->exponent=etiny;
7508       *status|=DEC_Clamped;
7509       }
7510     return;
7511     }
7512
7513   *status|=DEC_Subnormal;               /* have a non-zero subnormal */
7514   adjust=etiny-dn->exponent;            /* calculate digits to remove */
7515   if (adjust<=0) {                      /* not out of range; unrounded */
7516     /* residue can never be non-zero here, except in the Nmin-residue */
7517     /* case (which is a subnormal result), so can take fast-path here */
7518     /* it may already be inexact (from setting the coefficient) */
7519     if (*status&DEC_Inexact) *status|=DEC_Underflow;
7520     return;
7521     }
7522
7523   /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7524   /* [this code is similar to that in rescale] */
7525   workset=*set;                         /* clone rounding, etc. */
7526   workset.digits=dn->digits-adjust;     /* set requested length */
7527   workset.emin-=adjust;                 /* and adjust emin to match */
7528   /* [note that the latter can be <1, here, similar to Rescale case] */
7529   decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7530   decApplyRound(dn, &workset, *residue, status);
7531
7532   /* Use 754R/854 default rule: Underflow is set iff Inexact */
7533   /* [independent of whether trapped] */
7534   if (*status&DEC_Inexact) *status|=DEC_Underflow;
7535
7536   /* if rounded up a 999s case, exponent will be off by one; adjust */
7537   /* back if so [it will fit, because it was shortened earlier] */
7538   if (dn->exponent>etiny) {
7539     dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7540     dn->exponent--;                     /* (re)adjust the exponent. */
7541     }
7542
7543   /* if rounded to zero, it is by definition clamped... */
7544   if (ISZERO(dn)) *status|=DEC_Clamped;
7545   } /* decSetSubnormal */
7546
7547 /* ------------------------------------------------------------------ */
7548 /* decCheckMath - check entry conditions for a math function          */
7549 /*                                                                    */
7550 /*   This checks the context and the operand                          */
7551 /*                                                                    */
7552 /*   rhs is the operand to check                                      */
7553 /*   set is the context to check                                      */
7554 /*   status is unchanged if both are good                             */
7555 /*                                                                    */
7556 /* returns non-zero if status is changed, 0 otherwise                 */
7557 /*                                                                    */
7558 /* Restrictions enforced:                                             */
7559 /*                                                                    */
7560 /*   digits, emax, and -emin in the context must be less than         */
7561 /*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
7562 /*   non-zero.  Invalid_operation is set in the status if a           */
7563 /*   restriction is violated.                                         */
7564 /* ------------------------------------------------------------------ */
7565 static uInt decCheckMath(const decNumber *rhs, decContext *set,
7566                          uInt *status) {
7567   uInt save=*status;                         /* record */
7568   if (set->digits>DEC_MAX_MATH
7569    || set->emax>DEC_MAX_MATH
7570    || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7571    else if ((rhs->digits>DEC_MAX_MATH
7572      || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7573      || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7574      && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7575   return (*status!=save);
7576   } /* decCheckMath */
7577
7578 /* ------------------------------------------------------------------ */
7579 /* decGetInt -- get integer from a number                             */
7580 /*                                                                    */
7581 /*   dn is the number [which will not be altered]                     */
7582 /*                                                                    */
7583 /*   returns one of:                                                  */
7584 /*     BADINT if there is a non-zero fraction                         */
7585 /*     the converted integer                                          */
7586 /*     BIGEVEN if the integer is even and magnitude > 2*10**9         */
7587 /*     BIGODD  if the integer is odd  and magnitude > 2*10**9         */
7588 /*                                                                    */
7589 /* This checks and gets a whole number from the input decNumber.      */
7590 /* The sign can be determined from dn by the caller when BIGEVEN or   */
7591 /* BIGODD is returned.                                                */
7592 /* ------------------------------------------------------------------ */
7593 static Int decGetInt(const decNumber *dn) {
7594   Int  theInt;                          /* result accumulator */
7595   const Unit *up;                       /* work */
7596   Int  got;                             /* digits (real or not) processed */
7597   Int  ilength=dn->digits+dn->exponent; /* integral length */
7598   Flag neg=decNumberIsNegative(dn);     /* 1 if -ve */
7599
7600   /* The number must be an integer that fits in 10 digits */
7601   /* Assert, here, that 10 is enough for any rescale Etiny */
7602   #if DEC_MAX_EMAX > 999999999
7603     #error GetInt may need updating [for Emax]
7604   #endif
7605   #if DEC_MIN_EMIN < -999999999
7606     #error GetInt may need updating [for Emin]
7607   #endif
7608   if (ISZERO(dn)) return 0;             /* zeros are OK, with any exponent */
7609
7610   up=dn->lsu;                           /* ready for lsu */
7611   theInt=0;                             /* ready to accumulate */
7612   if (dn->exponent>=0) {                /* relatively easy */
7613     /* no fractional part [usual]; allow for positive exponent */
7614     got=dn->exponent;
7615     }
7616    else { /* -ve exponent; some fractional part to check and discard */
7617     Int count=-dn->exponent;            /* digits to discard */
7618     /* spin up whole units until reach the Unit with the unit digit */
7619     for (; count>=DECDPUN; up++) {
7620       if (*up!=0) return BADINT;        /* non-zero Unit to discard */
7621       count-=DECDPUN;
7622       }
7623     if (count==0) got=0;                /* [a multiple of DECDPUN] */
7624      else {                             /* [not multiple of DECDPUN] */
7625       Int rem;                          /* work */
7626       /* slice off fraction digits and check for non-zero */
7627       #if DECDPUN<=4
7628         theInt=QUOT10(*up, count);
7629         rem=*up-theInt*powers[count];
7630       #else
7631         rem=*up%powers[count];          /* slice off discards */
7632         theInt=*up/powers[count];
7633       #endif
7634       if (rem!=0) return BADINT;        /* non-zero fraction */
7635       /* it looks good */
7636       got=DECDPUN-count;                /* number of digits so far */
7637       up++;                             /* ready for next */
7638       }
7639     }
7640   /* now it's known there's no fractional part */
7641
7642   /* tricky code now, to accumulate up to 9.3 digits */
7643   if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7644
7645   if (ilength<11) {
7646     Int save=theInt;
7647     /* collect any remaining unit(s) */
7648     for (; got<ilength; up++) {
7649       theInt+=*up*powers[got];
7650       got+=DECDPUN;
7651       }
7652     if (ilength==10) {                  /* need to check for wrap */
7653       if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7654          /* [that test also disallows the BADINT result case] */
7655        else if (neg && theInt>1999999997) ilength=11;
7656        else if (!neg && theInt>999999999) ilength=11;
7657       if (ilength==11) theInt=save;     /* restore correct low bit */
7658       }
7659     }
7660
7661   if (ilength>10) {                     /* too big */
7662     if (theInt&1) return BIGODD;        /* bottom bit 1 */
7663     return BIGEVEN;                     /* bottom bit 0 */
7664     }
7665
7666   if (neg) theInt=-theInt;              /* apply sign */
7667   return theInt;
7668   } /* decGetInt */
7669
7670 /* ------------------------------------------------------------------ */
7671 /* decDecap -- decapitate the coefficient of a number                 */
7672 /*                                                                    */
7673 /*   dn   is the number to be decapitated                             */
7674 /*   drop is the number of digits to be removed from the left of dn;  */
7675 /*     this must be <= dn->digits (if equal, the coefficient is       */
7676 /*     set to 0)                                                      */
7677 /*                                                                    */
7678 /* Returns dn; dn->digits will be <= the initial digits less drop     */
7679 /* (after removing drop digits there may be leading zero digits       */
7680 /* which will also be removed).  Only dn->lsu and dn->digits change.  */
7681 /* ------------------------------------------------------------------ */
7682 static decNumber *decDecap(decNumber *dn, Int drop) {
7683   Unit *msu;                            /* -> target cut point */
7684   Int cut;                              /* work */
7685   if (drop>=dn->digits) {               /* losing the whole thing */
7686     #if DECCHECK
7687     if (drop>dn->digits)
7688       printf("decDecap called with drop>digits [%ld>%ld]\n",
7689              (LI)drop, (LI)dn->digits);
7690     #endif
7691     dn->lsu[0]=0;
7692     dn->digits=1;
7693     return dn;
7694     }
7695   msu=dn->lsu+D2U(dn->digits-drop)-1;   /* -> likely msu */
7696   cut=MSUDIGITS(dn->digits-drop);       /* digits to be in use in msu */
7697   if (cut!=DECDPUN) *msu%=powers[cut];  /* clear left digits */
7698   /* that may have left leading zero digits, so do a proper count... */
7699   dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7700   return dn;
7701   } /* decDecap */
7702
7703 /* ------------------------------------------------------------------ */
7704 /* decBiStr -- compare string with pairwise options                   */
7705 /*                                                                    */
7706 /*   targ is the string to compare                                    */
7707 /*   str1 is one of the strings to compare against (length may be 0)  */
7708 /*   str2 is the other; it must be the same length as str1            */
7709 /*                                                                    */
7710 /*   returns 1 if strings compare equal, (that is, it is the same     */
7711 /*   length as str1 and str2, and each character of targ is in either */
7712 /*   str1 or str2 in the corresponding position), or 0 otherwise      */
7713 /*                                                                    */
7714 /* This is used for generic caseless compare, including the awkward   */
7715 /* case of the Turkish dotted and dotless Is.  Use as (for example):  */
7716 /*   if (decBiStr(test, "mike", "MIKE")) ...                          */
7717 /* ------------------------------------------------------------------ */
7718 static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7719   for (;;targ++, str1++, str2++) {
7720     if (*targ!=*str1 && *targ!=*str2) return 0;
7721     /* *targ has a match in one (or both, if terminator) */
7722     if (*targ=='\0') break;
7723     } /* forever */
7724   return 1;
7725   } /* decBiStr */
7726
7727 /* ------------------------------------------------------------------ */
7728 /* decNaNs -- handle NaN operand or operands                          */
7729 /*                                                                    */
7730 /*   res     is the result number                                     */
7731 /*   lhs     is the first operand                                     */
7732 /*   rhs     is the second operand, or NULL if none                   */
7733 /*   context is used to limit payload length                          */
7734 /*   status  contains the current status                              */
7735 /*   returns res in case convenient                                   */
7736 /*                                                                    */
7737 /* Called when one or both operands is a NaN, and propagates the      */
7738 /* appropriate result to res.  When an sNaN is found, it is changed   */
7739 /* to a qNaN and Invalid operation is set.                            */
7740 /* ------------------------------------------------------------------ */
7741 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7742                            const decNumber *rhs, decContext *set,
7743                            uInt *status) {
7744   /* This decision tree ends up with LHS being the source pointer, */
7745   /* and status updated if need be */
7746   if (lhs->bits & DECSNAN)
7747     *status|=DEC_Invalid_operation | DEC_sNaN;
7748    else if (rhs==NULL);
7749    else if (rhs->bits & DECSNAN) {
7750     lhs=rhs;
7751     *status|=DEC_Invalid_operation | DEC_sNaN;
7752     }
7753    else if (lhs->bits & DECNAN);
7754    else lhs=rhs;
7755
7756   /* propagate the payload */
7757   if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7758    else { /* too long */
7759     const Unit *ul;
7760     Unit *ur, *uresp1;
7761     /* copy safe number of units, then decapitate */
7762     res->bits=lhs->bits;                /* need sign etc. */
7763     uresp1=res->lsu+D2U(set->digits);
7764     for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7765     res->digits=D2U(set->digits)*DECDPUN;
7766     /* maybe still too long */
7767     if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7768     }
7769
7770   res->bits&=~DECSNAN;        /* convert any sNaN to NaN, while */
7771   res->bits|=DECNAN;          /* .. preserving sign */
7772   res->exponent=0;            /* clean exponent */
7773                               /* [coefficient was copied/decapitated] */
7774   return res;
7775   } /* decNaNs */
7776
7777 /* ------------------------------------------------------------------ */
7778 /* decStatus -- apply non-zero status                                 */
7779 /*                                                                    */
7780 /*   dn     is the number to set if error                             */
7781 /*   status contains the current status (not yet in context)          */
7782 /*   set    is the context                                            */
7783 /*                                                                    */
7784 /* If the status is an error status, the number is set to a NaN,      */
7785 /* unless the error was an overflow, divide-by-zero, or underflow,    */
7786 /* in which case the number will have already been set.               */
7787 /*                                                                    */
7788 /* The context status is then updated with the new status.  Note that */
7789 /* this may raise a signal, so control may never return from this     */
7790 /* routine (hence resources must be recovered before it is called).   */
7791 /* ------------------------------------------------------------------ */
7792 static void decStatus(decNumber *dn, uInt status, decContext *set) {
7793   if (status & DEC_NaNs) {              /* error status -> NaN */
7794     /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7795     if (status & DEC_sNaN) status&=~DEC_sNaN;
7796      else {
7797       decNumberZero(dn);                /* other error: clean throughout */
7798       dn->bits=DECNAN;                  /* and make a quiet NaN */
7799       }
7800     }
7801   decContextSetStatus(set, status);     /* [may not return] */
7802   return;
7803   } /* decStatus */
7804
7805 /* ------------------------------------------------------------------ */
7806 /* decGetDigits -- count digits in a Units array                      */
7807 /*                                                                    */
7808 /*   uar is the Unit array holding the number (this is often an       */
7809 /*          accumulator of some sort)                                 */
7810 /*   len is the length of the array in units [>=1]                    */
7811 /*                                                                    */
7812 /*   returns the number of (significant) digits in the array          */
7813 /*                                                                    */
7814 /* All leading zeros are excluded, except the last if the array has   */
7815 /* only zero Units.                                                   */
7816 /* ------------------------------------------------------------------ */
7817 /* This may be called twice during some operations. */
7818 static Int decGetDigits(Unit *uar, Int len) {
7819   Unit *up=uar+(len-1);            /* -> msu */
7820   Int  digits=(len-1)*DECDPUN+1;   /* possible digits excluding msu */
7821   #if DECDPUN>4
7822   uInt const *pow;                 /* work */
7823   #endif
7824                                    /* (at least 1 in final msu) */
7825   #if DECCHECK
7826   if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7827   #endif
7828
7829   for (; up>=uar; up--) {
7830     if (*up==0) {                  /* unit is all 0s */
7831       if (digits==1) break;        /* a zero has one digit */
7832       digits-=DECDPUN;             /* adjust for 0 unit */
7833       continue;}
7834     /* found the first (most significant) non-zero Unit */
7835     #if DECDPUN>1                  /* not done yet */
7836     if (*up<10) break;             /* is 1-9 */
7837     digits++;
7838     #if DECDPUN>2                  /* not done yet */
7839     if (*up<100) break;            /* is 10-99 */
7840     digits++;
7841     #if DECDPUN>3                  /* not done yet */
7842     if (*up<1000) break;           /* is 100-999 */
7843     digits++;
7844     #if DECDPUN>4                  /* count the rest ... */
7845     for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7846     #endif
7847     #endif
7848     #endif
7849     #endif
7850     break;
7851     } /* up */
7852   return digits;
7853   } /* decGetDigits */
7854
7855 #if DECTRACE | DECCHECK
7856 /* ------------------------------------------------------------------ */
7857 /* decNumberShow -- display a number [debug aid]                      */
7858 /*   dn is the number to show                                         */
7859 /*                                                                    */
7860 /* Shows: sign, exponent, coefficient (msu first), digits             */
7861 /*    or: sign, special-value                                         */
7862 /* ------------------------------------------------------------------ */
7863 /* this is public so other modules can use it */
7864 void decNumberShow(const decNumber *dn) {
7865   const Unit *up;                  /* work */
7866   uInt u, d;                       /* .. */
7867   Int cut;                         /* .. */
7868   char isign='+';                  /* main sign */
7869   if (dn==NULL) {
7870     printf("NULL\n");
7871     return;}
7872   if (decNumberIsNegative(dn)) isign='-';
7873   printf(" >> %c ", isign);
7874   if (dn->bits&DECSPECIAL) {       /* Is a special value */
7875     if (decNumberIsInfinite(dn)) printf("Infinity");
7876      else {                                  /* a NaN */
7877       if (dn->bits&DECSNAN) printf("sNaN");  /* signalling NaN */
7878        else printf("NaN");
7879       }
7880     /* if coefficient and exponent are 0, no more to do */
7881     if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7882       printf("\n");
7883       return;}
7884     /* drop through to report other information */
7885     printf(" ");
7886     }
7887
7888   /* now carefully display the coefficient */
7889   up=dn->lsu+D2U(dn->digits)-1;         /* msu */
7890   printf("%ld", (LI)*up);
7891   for (up=up-1; up>=dn->lsu; up--) {
7892     u=*up;
7893     printf(":");
7894     for (cut=DECDPUN-1; cut>=0; cut--) {
7895       d=u/powers[cut];
7896       u-=d*powers[cut];
7897       printf("%ld", (LI)d);
7898       } /* cut */
7899     } /* up */
7900   if (dn->exponent!=0) {
7901     char esign='+';
7902     if (dn->exponent<0) esign='-';
7903     printf(" E%c%ld", esign, (LI)abs(dn->exponent));
7904     }
7905   printf(" [%ld]\n", (LI)dn->digits);
7906   } /* decNumberShow */
7907 #endif
7908
7909 #if DECTRACE || DECCHECK
7910 /* ------------------------------------------------------------------ */
7911 /* decDumpAr -- display a unit array [debug/check aid]                */
7912 /*   name is a single-character tag name                              */
7913 /*   ar   is the array to display                                     */
7914 /*   len  is the length of the array in Units                         */
7915 /* ------------------------------------------------------------------ */
7916 static void decDumpAr(char name, const Unit *ar, Int len) {
7917   Int i;
7918   const char *spec;
7919   #if DECDPUN==9
7920     spec="%09d ";
7921   #elif DECDPUN==8
7922     spec="%08d ";
7923   #elif DECDPUN==7
7924     spec="%07d ";
7925   #elif DECDPUN==6
7926     spec="%06d ";
7927   #elif DECDPUN==5
7928     spec="%05d ";
7929   #elif DECDPUN==4
7930     spec="%04d ";
7931   #elif DECDPUN==3
7932     spec="%03d ";
7933   #elif DECDPUN==2
7934     spec="%02d ";
7935   #else
7936     spec="%d ";
7937   #endif
7938   printf("  :%c: ", name);
7939   for (i=len-1; i>=0; i--) {
7940     if (i==len-1) printf("%ld ", (LI)ar[i]);
7941      else printf(spec, ar[i]);
7942     }
7943   printf("\n");
7944   return;}
7945 #endif
7946
7947 #if DECCHECK
7948 /* ------------------------------------------------------------------ */
7949 /* decCheckOperands -- check operand(s) to a routine                  */
7950 /*   res is the result structure (not checked; it will be set to      */
7951 /*          quiet NaN if error found (and it is not NULL))            */
7952 /*   lhs is the first operand (may be DECUNRESU)                      */
7953 /*   rhs is the second (may be DECUNUSED)                             */
7954 /*   set is the context (may be DECUNCONT)                            */
7955 /*   returns 0 if both operands, and the context are clean, or 1      */
7956 /*     otherwise (in which case the context will show an error,       */
7957 /*     unless NULL).  Note that res is not cleaned; caller should     */
7958 /*     handle this so res=NULL case is safe.                          */
7959 /* The caller is expected to abandon immediately if 1 is returned.    */
7960 /* ------------------------------------------------------------------ */
7961 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
7962                              const decNumber *rhs, decContext *set) {
7963   Flag bad=0;
7964   if (set==NULL) {                 /* oops; hopeless */
7965     #if DECTRACE || DECVERB
7966     printf("Reference to context is NULL.\n");
7967     #endif
7968     bad=1;
7969     return 1;}
7970    else if (set!=DECUNCONT
7971      && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7972     bad=1;
7973     #if DECTRACE || DECVERB
7974     printf("Bad context [digits=%ld round=%ld].\n",
7975            (LI)set->digits, (LI)set->round);
7976     #endif
7977     }
7978    else {
7979     if (res==NULL) {
7980       bad=1;
7981       #if DECTRACE
7982       /* this one not DECVERB as standard tests include NULL */
7983       printf("Reference to result is NULL.\n");
7984       #endif
7985       }
7986     if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
7987     if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
7988     }
7989   if (bad) {
7990     if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
7991     if (res!=DECUNRESU && res!=NULL) {
7992       decNumberZero(res);
7993       res->bits=DECNAN;       /* qNaN */
7994       }
7995     }
7996   return bad;
7997   } /* decCheckOperands */
7998
7999 /* ------------------------------------------------------------------ */
8000 /* decCheckNumber -- check a number                                   */
8001 /*   dn is the number to check                                        */
8002 /*   returns 0 if the number is clean, or 1 otherwise                 */
8003 /*                                                                    */
8004 /* The number is considered valid if it could be a result from some   */
8005 /* operation in some valid context.                                   */
8006 /* ------------------------------------------------------------------ */
8007 static Flag decCheckNumber(const decNumber *dn) {
8008   const Unit *up;             /* work */
8009   uInt maxuint;               /* .. */
8010   Int ae, d, digits;          /* .. */
8011   Int emin, emax;             /* .. */
8012
8013   if (dn==NULL) {             /* hopeless */
8014     #if DECTRACE
8015     /* this one not DECVERB as standard tests include NULL */
8016     printf("Reference to decNumber is NULL.\n");
8017     #endif
8018     return 1;}
8019
8020   /* check special values */
8021   if (dn->bits & DECSPECIAL) {
8022     if (dn->exponent!=0) {
8023       #if DECTRACE || DECVERB
8024       printf("Exponent %ld (not 0) for a special value [%02x].\n",
8025              (LI)dn->exponent, dn->bits);
8026       #endif
8027       return 1;}
8028
8029     /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
8030     if (decNumberIsInfinite(dn)) {
8031       if (dn->digits!=1) {
8032         #if DECTRACE || DECVERB
8033         printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
8034         #endif
8035         return 1;}
8036       if (*dn->lsu!=0) {
8037         #if DECTRACE || DECVERB
8038         printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
8039         #endif
8040         decDumpAr('I', dn->lsu, D2U(dn->digits));
8041         return 1;}
8042       } /* Inf */
8043     /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
8044     /*             concrete formats (decimal64, etc.). */
8045     return 0;
8046     }
8047
8048   /* check the coefficient */
8049   if (dn->digits<1 || dn->digits>DECNUMMAXP) {
8050     #if DECTRACE || DECVERB
8051     printf("Digits %ld in number.\n", (LI)dn->digits);
8052     #endif
8053     return 1;}
8054
8055   d=dn->digits;
8056
8057   for (up=dn->lsu; d>0; up++) {
8058     if (d>DECDPUN) maxuint=DECDPUNMAX;
8059      else {                   /* reached the msu */
8060       maxuint=powers[d]-1;
8061       if (dn->digits>1 && *up<powers[d-1]) {
8062         #if DECTRACE || DECVERB
8063         printf("Leading 0 in number.\n");
8064         decNumberShow(dn);
8065         #endif
8066         return 1;}
8067       }
8068     if (*up>maxuint) {
8069       #if DECTRACE || DECVERB
8070       printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8071               (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8072       #endif
8073       return 1;}
8074     d-=DECDPUN;
8075     }
8076
8077   /* check the exponent.  Note that input operands can have exponents */
8078   /* which are out of the set->emin/set->emax and set->digits range */
8079   /* (just as they can have more digits than set->digits). */
8080   ae=dn->exponent+dn->digits-1;    /* adjusted exponent */
8081   emax=DECNUMMAXE;
8082   emin=DECNUMMINE;
8083   digits=DECNUMMAXP;
8084   if (ae<emin-(digits-1)) {
8085     #if DECTRACE || DECVERB
8086     printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8087     decNumberShow(dn);
8088     #endif
8089     return 1;}
8090   if (ae>+emax) {
8091     #if DECTRACE || DECVERB
8092     printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8093     decNumberShow(dn);
8094     #endif
8095     return 1;}
8096
8097   return 0;              /* it's OK */
8098   } /* decCheckNumber */
8099
8100 /* ------------------------------------------------------------------ */
8101 /* decCheckInexact -- check a normal finite inexact result has digits */
8102 /*   dn is the number to check                                        */
8103 /*   set is the context (for status and precision)                    */
8104 /*   sets Invalid operation, etc., if some digits are missing         */
8105 /* [this check is not made for DECSUBSET compilation or when          */
8106 /* subnormal is not set]                                              */
8107 /* ------------------------------------------------------------------ */
8108 static void decCheckInexact(const decNumber *dn, decContext *set) {
8109   #if !DECSUBSET && DECEXTFLAG
8110     if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8111      && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8112       #if DECTRACE || DECVERB
8113       printf("Insufficient digits [%ld] on normal Inexact result.\n",
8114              (LI)dn->digits);
8115       decNumberShow(dn);
8116       #endif
8117       decContextSetStatus(set, DEC_Invalid_operation);
8118       }
8119   #else
8120     /* next is a noop for quiet compiler */
8121     if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8122   #endif
8123   return;
8124   } /* decCheckInexact */
8125 #endif
8126
8127 #if DECALLOC
8128 #undef malloc
8129 #undef free
8130 /* ------------------------------------------------------------------ */
8131 /* decMalloc -- accountable allocation routine                        */
8132 /*   n is the number of bytes to allocate                             */
8133 /*                                                                    */
8134 /* Semantics is the same as the stdlib malloc routine, but bytes      */
8135 /* allocated are accounted for globally, and corruption fences are    */
8136 /* added before and after the 'actual' storage.                       */
8137 /* ------------------------------------------------------------------ */
8138 /* This routine allocates storage with an extra twelve bytes; 8 are   */
8139 /* at the start and hold:                                             */
8140 /*   0-3 the original length requested                                */
8141 /*   4-7 buffer corruption detection fence (DECFENCE, x4)             */
8142 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8143 /* ------------------------------------------------------------------ */
8144 static void *decMalloc(size_t n) {
8145   uInt  size=n+12;                 /* true size */
8146   void  *alloc;                    /* -> allocated storage */
8147   uInt  *j;                        /* work */
8148   uByte *b, *b0;                   /* .. */
8149
8150   alloc=malloc(size);              /* -> allocated storage */
8151   if (alloc==NULL) return NULL;    /* out of strorage */
8152   b0=(uByte *)alloc;               /* as bytes */
8153   decAllocBytes+=n;                /* account for storage */
8154   j=(uInt *)alloc;                 /* -> first four bytes */
8155   *j=n;                            /* save n */
8156   /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */
8157   for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8158   for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8159   return b0+8;                     /* -> play area */
8160   } /* decMalloc */
8161
8162 /* ------------------------------------------------------------------ */
8163 /* decFree -- accountable free routine                                */
8164 /*   alloc is the storage to free                                     */
8165 /*                                                                    */
8166 /* Semantics is the same as the stdlib malloc routine, except that    */
8167 /* the global storage accounting is updated and the fences are        */
8168 /* checked to ensure that no routine has written 'out of bounds'.     */
8169 /* ------------------------------------------------------------------ */
8170 /* This routine first checks that the fences have not been corrupted. */
8171 /* It then frees the storage using the 'truw' storage address (that   */
8172 /* is, offset by 8).                                                  */
8173 /* ------------------------------------------------------------------ */
8174 static void decFree(void *alloc) {
8175   uInt  *j, n;                     /* pointer, original length */
8176   uByte *b, *b0;                   /* work */
8177
8178   if (alloc==NULL) return;         /* allowed; it's a nop */
8179   b0=(uByte *)alloc;               /* as bytes */
8180   b0-=8;                           /* -> true start of storage */
8181   j=(uInt *)b0;                    /* -> first four bytes */
8182   n=*j;                            /* lift */
8183   for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8184     printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8185            b-b0-8, (Int)b0);
8186   for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8187     printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8188            b-b0-8, (Int)b0, n);
8189   free(b0);                        /* drop the storage */
8190   decAllocBytes-=n;                /* account for storage */
8191   /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8192   } /* decFree */
8193 #define malloc(a) decMalloc(a)
8194 #define free(a) decFree(a)
8195 #endif