xref: /openbmc/qemu/libdecnumber/decNumber.c (revision 18fe5d99)
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 "qemu/osdep.h"
170 #include "qemu/host-utils.h"
171 #include "libdecnumber/dconfig.h"
172 #include "libdecnumber/decNumber.h"
173 #include "libdecnumber/decNumberLocal.h"
174 
175 /* Constants */
176 /* Public lookup table used by the D2U macro */
177 const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
178 
179 #define DECVERB	    1		   /* set to 1 for verbose DECCHECK */
180 #define powers	    DECPOWERS	   /* old internal name */
181 
182 /* Local constants */
183 #define DIVIDE	    0x80	   /* Divide operators */
184 #define REMAINDER   0x40	   /* .. */
185 #define DIVIDEINT   0x20	   /* .. */
186 #define REMNEAR	    0x10	   /* .. */
187 #define COMPARE	    0x01	   /* Compare operators */
188 #define COMPMAX	    0x02	   /* .. */
189 #define COMPMIN	    0x03	   /* .. */
190 #define COMPTOTAL   0x04	   /* .. */
191 #define COMPNAN	    0x05	   /* .. [NaN processing] */
192 #define COMPSIG	    0x06	   /* .. [signaling COMPARE] */
193 #define COMPMAXMAG  0x07	   /* .. */
194 #define COMPMINMAG  0x08	   /* .. */
195 
196 #define DEC_sNaN     0x40000000	   /* local status: sNaN signal */
197 #define BADINT	(Int)0x80000000	   /* most-negative Int; error indicator */
198 /* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
199 #define BIGEVEN (Int)0x80000002
200 #define BIGODD	(Int)0x80000003
201 
202 static Unit uarrone[1]={1};   /* Unit array of 1, used for incrementing */
203 
204 /* Granularity-dependent code */
205 #if DECDPUN<=4
206   #define eInt	Int	      /* extended integer */
207   #define ueInt uInt	      /* unsigned extended integer */
208   /* Constant multipliers for divide-by-power-of five using reciprocal */
209   /* multiply, after removing powers of 2 by shifting, and final shift */
210   /* of 17 [we only need up to **4] */
211   static const uInt multies[]={131073, 26215, 5243, 1049, 210};
212   /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
213   #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
214 #else
215   /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
216   #if !DECUSE64
217     #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
218   #endif
219   #define eInt	Long	      /* extended integer */
220   #define ueInt uLong	      /* unsigned extended integer */
221 #endif
222 
223 /* Local routines */
224 static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
225 			      decContext *, uByte, uInt *);
226 static Flag	   decBiStr(const char *, const char *, const char *);
227 static uInt	   decCheckMath(const decNumber *, decContext *, uInt *);
228 static void	   decApplyRound(decNumber *, decContext *, Int, uInt *);
229 static Int	   decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
230 static decNumber * decCompareOp(decNumber *, const decNumber *,
231 			      const decNumber *, decContext *,
232 			      Flag, uInt *);
233 static void	   decCopyFit(decNumber *, const decNumber *, decContext *,
234 			      Int *, uInt *);
235 static decNumber * decDecap(decNumber *, Int);
236 static decNumber * decDivideOp(decNumber *, const decNumber *,
237 			      const decNumber *, decContext *, Flag, uInt *);
238 static decNumber * decExpOp(decNumber *, const decNumber *,
239 			      decContext *, uInt *);
240 static void	   decFinalize(decNumber *, decContext *, Int *, uInt *);
241 static Int	   decGetDigits(Unit *, Int);
242 static Int	   decGetInt(const decNumber *);
243 static decNumber * decLnOp(decNumber *, const decNumber *,
244 			      decContext *, uInt *);
245 static decNumber * decMultiplyOp(decNumber *, const decNumber *,
246 			      const decNumber *, decContext *,
247 			      uInt *);
248 static decNumber * decNaNs(decNumber *, const decNumber *,
249 			      const decNumber *, decContext *, uInt *);
250 static decNumber * decQuantizeOp(decNumber *, const decNumber *,
251 			      const decNumber *, decContext *, Flag,
252 			      uInt *);
253 static void	   decReverse(Unit *, Unit *);
254 static void	   decSetCoeff(decNumber *, decContext *, const Unit *,
255 			      Int, Int *, uInt *);
256 static void	   decSetMaxValue(decNumber *, decContext *);
257 static void	   decSetOverflow(decNumber *, decContext *, uInt *);
258 static void	   decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
259 static Int	   decShiftToLeast(Unit *, Int, Int);
260 static Int	   decShiftToMost(Unit *, Int, Int);
261 static void	   decStatus(decNumber *, uInt, decContext *);
262 static void	   decToString(const decNumber *, char[], Flag);
263 static decNumber * decTrim(decNumber *, decContext *, Flag, Int *);
264 static Int	   decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
265 			      Unit *, Int);
266 static Int	   decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
267 static bool        mulUInt128ByPowOf10(uLong *, uLong *, uInt);
268 
269 #if !DECSUBSET
270 /* decFinish == decFinalize when no subset arithmetic needed */
271 #define decFinish(a,b,c,d) decFinalize(a,b,c,d)
272 #else
273 static void	   decFinish(decNumber *, decContext *, Int *, uInt *);
274 static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
275 #endif
276 
277 /* Local macros */
278 /* masked special-values bits */
279 #define SPECIALARG  (rhs->bits & DECSPECIAL)
280 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
281 
282 /* Diagnostic macros, etc. */
283 #if DECALLOC
284 /* Handle malloc/free accounting.  If enabled, our accountable routines */
285 /* are used; otherwise the code just goes straight to the system malloc */
286 /* and free routines. */
287 #define malloc(a) decMalloc(a)
288 #define free(a) decFree(a)
289 #define DECFENCE 0x5a		   /* corruption detector */
290 /* 'Our' malloc and free: */
291 static void *decMalloc(size_t);
292 static void  decFree(void *);
293 uInt decAllocBytes=0;		   /* count of bytes allocated */
294 /* Note that DECALLOC code only checks for storage buffer overflow. */
295 /* To check for memory leaks, the decAllocBytes variable must be */
296 /* checked to be 0 at appropriate times (e.g., after the test */
297 /* harness completes a set of tests).  This checking may be unreliable */
298 /* if the testing is done in a multi-thread environment. */
299 #endif
300 
301 #if DECCHECK
302 /* Optional checking routines.	Enabling these means that decNumber */
303 /* and decContext operands to operator routines are checked for */
304 /* correctness.	 This roughly doubles the execution time of the */
305 /* fastest routines (and adds 600+ bytes), so should not normally be */
306 /* used in 'production'. */
307 /* decCheckInexact is used to check that inexact results have a full */
308 /* complement of digits (where appropriate -- this is not the case */
309 /* for Quantize, for example) */
310 #define DECUNRESU ((decNumber *)(void *)0xffffffff)
311 #define DECUNUSED ((const decNumber *)(void *)0xffffffff)
312 #define DECUNCONT ((decContext *)(void *)(0xffffffff))
313 static Flag decCheckOperands(decNumber *, const decNumber *,
314 			     const decNumber *, decContext *);
315 static Flag decCheckNumber(const decNumber *);
316 static void decCheckInexact(const decNumber *, decContext *);
317 #endif
318 
319 #if DECTRACE || DECCHECK
320 /* Optional trace/debugging routines (may or may not be used) */
321 void decNumberShow(const decNumber *);	/* displays the components of a number */
322 static void decDumpAr(char, const Unit *, Int);
323 #endif
324 
325 /* ================================================================== */
326 /* Conversions							      */
327 /* ================================================================== */
328 
329 /* ------------------------------------------------------------------ */
330 /* from-int32 -- conversion from Int or uInt			      */
331 /*								      */
332 /*  dn is the decNumber to receive the integer			      */
333 /*  in or uin is the integer to be converted			      */
334 /*  returns dn							      */
335 /*								      */
336 /* No error is possible.					      */
337 /* ------------------------------------------------------------------ */
338 decNumber * decNumberFromInt32(decNumber *dn, Int in) {
339   uInt unsig;
340   if (in>=0) unsig=in;
341    else {				/* negative (possibly BADINT) */
342     if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
343      else unsig=-in;			/* invert */
344     }
345   /* in is now positive */
346   decNumberFromUInt32(dn, unsig);
347   if (in<0) dn->bits=DECNEG;		/* sign needed */
348   return dn;
349   } /* decNumberFromInt32 */
350 
351 decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
352   Unit *up;				/* work pointer */
353   decNumberZero(dn);			/* clean */
354   if (uin==0) return dn;		/* [or decGetDigits bad call] */
355   for (up=dn->lsu; uin>0; up++) {
356     *up=(Unit)(uin%(DECDPUNMAX+1));
357     uin=uin/(DECDPUNMAX+1);
358     }
359   dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
360   return dn;
361   } /* decNumberFromUInt32 */
362 
363 /* ------------------------------------------------------------------ */
364 /* to-int32 -- conversion to Int or uInt			      */
365 /*								      */
366 /*  dn is the decNumber to convert				      */
367 /*  set is the context for reporting errors			      */
368 /*  returns the converted decNumber, or 0 if Invalid is set	      */
369 /*								      */
370 /* Invalid is set if the decNumber does not have exponent==0 or if    */
371 /* it is a NaN, Infinite, or out-of-range.			      */
372 /* ------------------------------------------------------------------ */
373 Int decNumberToInt32(const decNumber *dn, decContext *set) {
374   #if DECCHECK
375   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
376   #endif
377 
378   /* special or too many digits, or bad exponent */
379   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
380    else { /* is a finite integer with 10 or fewer digits */
381     Int d;			   /* work */
382     const Unit *up;		   /* .. */
383     uInt hi=0, lo;		   /* .. */
384     up=dn->lsu;			   /* -> lsu */
385     lo=*up;			   /* get 1 to 9 digits */
386     #if DECDPUN>1		   /* split to higher */
387       hi=lo/10;
388       lo=lo%10;
389     #endif
390     up++;
391     /* collect remaining Units, if any, into hi */
392     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
393     /* now low has the lsd, hi the remainder */
394     if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
395       /* most-negative is a reprieve */
396       if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
397       /* bad -- drop through */
398       }
399      else { /* in-range always */
400       Int i=X10(hi)+lo;
401       if (dn->bits&DECNEG) return -i;
402       return i;
403       }
404     } /* integer */
405   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
406   return 0;
407   } /* decNumberToInt32 */
408 
409 uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
410   #if DECCHECK
411   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
412   #endif
413   /* special or too many digits, or bad exponent, or negative (<0) */
414   if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
415     || (dn->bits&DECNEG && !ISZERO(dn)));		    /* bad */
416    else { /* is a finite integer with 10 or fewer digits */
417     Int d;			   /* work */
418     const Unit *up;		   /* .. */
419     uInt hi=0, lo;		   /* .. */
420     up=dn->lsu;			   /* -> lsu */
421     lo=*up;			   /* get 1 to 9 digits */
422     #if DECDPUN>1		   /* split to higher */
423       hi=lo/10;
424       lo=lo%10;
425     #endif
426     up++;
427     /* collect remaining Units, if any, into hi */
428     for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
429 
430     /* now low has the lsd, hi the remainder */
431     if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
432      else return X10(hi)+lo;
433     } /* integer */
434   decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
435   return 0;
436   } /* decNumberToUInt32 */
437 
438 decNumber *decNumberFromInt64(decNumber *dn, int64_t in)
439 {
440     uint64_t unsig = in;
441     if (in < 0) {
442         unsig = -unsig;
443     }
444 
445     decNumberFromUInt64(dn, unsig);
446     if (in < 0) {
447         dn->bits = DECNEG;        /* sign needed */
448     }
449     return dn;
450 } /* decNumberFromInt64 */
451 
452 decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin)
453 {
454     Unit *up;                             /* work pointer */
455     decNumberZero(dn);                    /* clean */
456     if (uin == 0) {
457         return dn;                /* [or decGetDigits bad call] */
458     }
459     for (up = dn->lsu; uin > 0; up++) {
460         *up = (Unit)(uin % (DECDPUNMAX + 1));
461         uin = uin / (DECDPUNMAX + 1);
462     }
463     dn->digits = decGetDigits(dn->lsu, up-dn->lsu);
464     return dn;
465 } /* decNumberFromUInt64 */
466 
467 decNumber *decNumberFromInt128(decNumber *dn, uint64_t lo, int64_t hi)
468 {
469     uint64_t unsig_hi = hi;
470     if (hi < 0) {
471         if (lo == 0) {
472             unsig_hi = -unsig_hi;
473         } else {
474             unsig_hi = ~unsig_hi;
475             lo = -lo;
476         }
477     }
478 
479     decNumberFromUInt128(dn, lo, unsig_hi);
480     if (hi < 0) {
481         dn->bits = DECNEG;        /* sign needed */
482     }
483     return dn;
484 } /* decNumberFromInt128 */
485 
486 decNumber *decNumberFromUInt128(decNumber *dn, uint64_t lo, uint64_t hi)
487 {
488     uint64_t rem;
489     Unit *up;                             /* work pointer */
490     decNumberZero(dn);                    /* clean */
491     if (lo == 0 && hi == 0) {
492         return dn;                /* [or decGetDigits bad call] */
493     }
494     for (up = dn->lsu; hi > 0 || lo > 0; up++) {
495         rem = divu128(&lo, &hi, DECDPUNMAX + 1);
496         *up = (Unit)rem;
497     }
498     dn->digits = decGetDigits(dn->lsu, up - dn->lsu);
499     return dn;
500 } /* decNumberFromUInt128 */
501 
502 /* ------------------------------------------------------------------ */
503 /* to-int64 -- conversion to int64                                    */
504 /*                                                                    */
505 /*  dn is the decNumber to convert.  dn is assumed to have been       */
506 /*    rounded to a floating point integer value.                      */
507 /*  set is the context for reporting errors                           */
508 /*  returns the converted decNumber, or 0 if Invalid is set           */
509 /*                                                                    */
510 /* Invalid is set if the decNumber is a NaN, Infinite or is out of    */
511 /* range for a signed 64 bit integer.                                 */
512 /* ------------------------------------------------------------------ */
513 
514 int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set)
515 {
516     if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
517        (dn->digits + dn->exponent > 19)) {
518         goto Invalid;
519     } else {
520         int64_t d;        /* work */
521         const Unit *up;   /* .. */
522         uint64_t hi = 0;
523         up = dn->lsu;     /* -> lsu */
524 
525         for (d = 1; d <= dn->digits; up++, d += DECDPUN) {
526             uint64_t prev = hi;
527             hi += *up * powers[d-1];
528             if ((hi < prev) || (hi > INT64_MAX)) {
529                 goto Invalid;
530             }
531         }
532 
533         uint64_t prev = hi;
534         hi *= (uint64_t)powers[dn->exponent];
535         if ((hi < prev) || (hi > INT64_MAX)) {
536             goto Invalid;
537         }
538         return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi;
539     }
540 
541 Invalid:
542     decContextSetStatus(set, DEC_Invalid_operation);
543     return 0;
544 } /* decNumberIntegralToInt64 */
545 
546 /* ------------------------------------------------------------------ */
547 /* decNumberIntegralToInt128 -- conversion to int128                  */
548 /*                                                                    */
549 /*  dn is the decNumber to convert.  dn is assumed to have been       */
550 /*    rounded to a floating point integer value.                      */
551 /*  set is the context for reporting errors                           */
552 /*  returns the converted decNumber via plow and phigh                */
553 /*                                                                    */
554 /* Invalid is set if the decNumber is a NaN, Infinite or is out of    */
555 /* range for a signed 128 bit integer.                                */
556 /* ------------------------------------------------------------------ */
557 
558 void decNumberIntegralToInt128(const decNumber *dn, decContext *set,
559         uint64_t *plow, uint64_t *phigh)
560 {
561     int d;        /* work */
562     const Unit *up;   /* .. */
563     uint64_t lo = 0, hi = 0;
564 
565     if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
566        (dn->digits + dn->exponent > 39)) {
567         goto Invalid;
568     }
569 
570     up = dn->lsu;     /* -> lsu */
571 
572     for (d = (dn->digits - 1) / DECDPUN; d >= 0; d--) {
573         if (mulu128(&lo, &hi, DECDPUNMAX + 1)) {
574             /* overflow */
575             goto Invalid;
576         }
577         if (uadd64_overflow(lo, up[d], &lo)) {
578             if (uadd64_overflow(hi, 1, &hi)) {
579                 /* overflow */
580                 goto Invalid;
581             }
582         }
583     }
584 
585     if (mulUInt128ByPowOf10(&lo, &hi, dn->exponent)) {
586         /* overflow */
587         goto Invalid;
588     }
589 
590     if (decNumberIsNegative(dn)) {
591         if (lo == 0) {
592             *phigh = -hi;
593             *plow = 0;
594         } else {
595             *phigh = ~hi;
596             *plow = -lo;
597         }
598     } else {
599         *plow = lo;
600         *phigh = hi;
601     }
602 
603     return;
604 
605 Invalid:
606     decContextSetStatus(set, DEC_Invalid_operation);
607 } /* decNumberIntegralToInt128 */
608 
609 /* ------------------------------------------------------------------ */
610 /* to-scientific-string -- conversion to numeric string		      */
611 /* to-engineering-string -- conversion to numeric string	      */
612 /*								      */
613 /*   decNumberToString(dn, string);				      */
614 /*   decNumberToEngString(dn, string);				      */
615 /*								      */
616 /*  dn is the decNumber to convert				      */
617 /*  string is the string where the result will be laid out	      */
618 /*								      */
619 /*  string must be at least dn->digits+14 characters long	      */
620 /*								      */
621 /*  No error is possible, and no status can be set.		      */
622 /* ------------------------------------------------------------------ */
623 char * decNumberToString(const decNumber *dn, char *string){
624   decToString(dn, string, 0);
625   return string;
626   } /* DecNumberToString */
627 
628 char * decNumberToEngString(const decNumber *dn, char *string){
629   decToString(dn, string, 1);
630   return string;
631   } /* DecNumberToEngString */
632 
633 /* ------------------------------------------------------------------ */
634 /* to-number -- conversion from numeric string			      */
635 /*								      */
636 /* decNumberFromString -- convert string to decNumber		      */
637 /*   dn	       -- the number structure to fill			      */
638 /*   chars[]   -- the string to convert ('\0' terminated)	      */
639 /*   set       -- the context used for processing any error,	      */
640 /*		  determining the maximum precision available	      */
641 /*		  (set.digits), determining the maximum and minimum   */
642 /*		  exponent (set.emax and set.emin), determining if    */
643 /*		  extended values are allowed, and checking the	      */
644 /*		  rounding mode if overflow occurs or rounding is     */
645 /*		  needed.					      */
646 /*								      */
647 /* The length of the coefficient and the size of the exponent are     */
648 /* checked by this routine, so the correct error (Underflow or	      */
649 /* Overflow) can be reported or rounding applied, as necessary.	      */
650 /*								      */
651 /* If bad syntax is detected, the result will be a quiet NaN.	      */
652 /* ------------------------------------------------------------------ */
653 decNumber * decNumberFromString(decNumber *dn, const char chars[],
654 				decContext *set) {
655   Int	exponent=0;		   /* working exponent [assume 0] */
656   uByte bits=0;			   /* working flags [assume +ve] */
657   Unit	*res;			   /* where result will be built */
658   Unit	resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
659 				   /* [+9 allows for ln() constants] */
660   Unit	*allocres=NULL;		   /* -> allocated result, iff allocated */
661   Int	d=0;			   /* count of digits found in decimal part */
662   const char *dotchar=NULL;	   /* where dot was found */
663   const char *cfirst=chars;	   /* -> first character of decimal part */
664   const char *last=NULL;	   /* -> last digit of decimal part */
665   const char *c;		   /* work */
666   Unit	*up;			   /* .. */
667   #if DECDPUN>1
668   Int	cut, out;		   /* .. */
669   #endif
670   Int	residue;		   /* rounding residue */
671   uInt	status=0;		   /* error code */
672 
673   #if DECCHECK
674   if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
675     return decNumberZero(dn);
676   #endif
677 
678   do {				   /* status & malloc protection */
679     for (c=chars;; c++) {	   /* -> input character */
680       if (*c>='0' && *c<='9') {	   /* test for Arabic digit */
681 	last=c;
682 	d++;			   /* count of real digits */
683 	continue;		   /* still in decimal part */
684 	}
685       if (*c=='.' && dotchar==NULL) { /* first '.' */
686 	dotchar=c;		   /* record offset into decimal part */
687 	if (c==cfirst) cfirst++;   /* first digit must follow */
688 	continue;}
689       if (c==chars) {		   /* first in string... */
690 	if (*c=='-') {		   /* valid - sign */
691 	  cfirst++;
692 	  bits=DECNEG;
693 	  continue;}
694 	if (*c=='+') {		   /* valid + sign */
695 	  cfirst++;
696 	  continue;}
697 	}
698       /* *c is not a digit, or a valid +, -, or '.' */
699       break;
700       } /* c */
701 
702     if (last==NULL) {		   /* no digits yet */
703       status=DEC_Conversion_syntax;/* assume the worst */
704       if (*c=='\0') break;	   /* and no more to come... */
705       #if DECSUBSET
706       /* if subset then infinities and NaNs are not allowed */
707       if (!set->extended) break;   /* hopeless */
708       #endif
709       /* Infinities and NaNs are possible, here */
710       if (dotchar!=NULL) break;	   /* .. unless had a dot */
711       decNumberZero(dn);	   /* be optimistic */
712       if (decBiStr(c, "infinity", "INFINITY")
713        || decBiStr(c, "inf", "INF")) {
714 	dn->bits=bits | DECINF;
715 	status=0;		   /* is OK */
716 	break; /* all done */
717 	}
718       /* a NaN expected */
719       /* 2003.09.10 NaNs are now permitted to have a sign */
720       dn->bits=bits | DECNAN;	   /* assume simple NaN */
721       if (*c=='s' || *c=='S') {	   /* looks like an sNaN */
722 	c++;
723 	dn->bits=bits | DECSNAN;
724 	}
725       if (*c!='n' && *c!='N') break;	/* check caseless "NaN" */
726       c++;
727       if (*c!='a' && *c!='A') break;	/* .. */
728       c++;
729       if (*c!='n' && *c!='N') break;	/* .. */
730       c++;
731       /* now either nothing, or nnnn payload, expected */
732       /* -> start of integer and skip leading 0s [including plain 0] */
733       for (cfirst=c; *cfirst=='0';) cfirst++;
734       if (*cfirst=='\0') {	   /* "NaN" or "sNaN", maybe with all 0s */
735 	status=0;		   /* it's good */
736 	break;			   /* .. */
737 	}
738       /* something other than 0s; setup last and d as usual [no dots] */
739       for (c=cfirst;; c++, d++) {
740 	if (*c<'0' || *c>'9') break; /* test for Arabic digit */
741 	last=c;
742 	}
743       if (*c!='\0') break;	   /* not all digits */
744       if (d>set->digits-1) {
745 	/* [NB: payload in a decNumber can be full length unless */
746 	/* clamped, in which case can only be digits-1] */
747 	if (set->clamp) break;
748 	if (d>set->digits) break;
749 	} /* too many digits? */
750       /* good; drop through to convert the integer to coefficient */
751       status=0;			   /* syntax is OK */
752       bits=dn->bits;		   /* for copy-back */
753       } /* last==NULL */
754 
755      else if (*c!='\0') {	   /* more to process... */
756       /* had some digits; exponent is only valid sequence now */
757       Flag nege;		   /* 1=negative exponent */
758       const char *firstexp;	   /* -> first significant exponent digit */
759       status=DEC_Conversion_syntax;/* assume the worst */
760       if (*c!='e' && *c!='E') break;
761       /* Found 'e' or 'E' -- now process explicit exponent */
762       /* 1998.07.11: sign no longer required */
763       nege=0;
764       c++;			   /* to (possible) sign */
765       if (*c=='-') {nege=1; c++;}
766        else if (*c=='+') c++;
767       if (*c=='\0') break;
768 
769       for (; *c=='0' && *(c+1)!='\0';) c++;  /* strip insignificant zeros */
770       firstexp=c;			     /* save exponent digit place */
771       for (; ;c++) {
772 	if (*c<'0' || *c>'9') break;	     /* not a digit */
773 	exponent=X10(exponent)+(Int)*c-(Int)'0';
774 	} /* c */
775       /* if not now on a '\0', *c must not be a digit */
776       if (*c!='\0') break;
777 
778       /* (this next test must be after the syntax checks) */
779       /* if it was too long the exponent may have wrapped, so check */
780       /* carefully and set it to a certain overflow if wrap possible */
781       if (c>=firstexp+9+1) {
782 	if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
783 	/* [up to 1999999999 is OK, for example 1E-1000000998] */
784 	}
785       if (nege) exponent=-exponent;	/* was negative */
786       status=0;				/* is OK */
787       } /* stuff after digits */
788 
789     /* Here when whole string has been inspected; syntax is good */
790     /* cfirst->first digit (never dot), last->last digit (ditto) */
791 
792     /* strip leading zeros/dot [leave final 0 if all 0's] */
793     if (*cfirst=='0') {			/* [cfirst has stepped over .] */
794       for (c=cfirst; c<last; c++, cfirst++) {
795 	if (*c=='.') continue;		/* ignore dots */
796 	if (*c!='0') break;		/* non-zero found */
797 	d--;				/* 0 stripped */
798 	} /* c */
799       #if DECSUBSET
800       /* make a rapid exit for easy zeros if !extended */
801       if (*cfirst=='0' && !set->extended) {
802 	decNumberZero(dn);		/* clean result */
803 	break;				/* [could be return] */
804 	}
805       #endif
806       } /* at least one leading 0 */
807 
808     /* Handle decimal point... */
809     if (dotchar!=NULL && dotchar<last)	/* non-trailing '.' found? */
810       exponent-=(last-dotchar);		/* adjust exponent */
811     /* [we can now ignore the .] */
812 
813     /* OK, the digits string is good.  Assemble in the decNumber, or in */
814     /* a temporary units array if rounding is needed */
815     if (d<=set->digits) res=dn->lsu;	/* fits into supplied decNumber */
816      else {				/* rounding needed */
817       Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
818       res=resbuff;			/* assume use local buffer */
819       if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
820 	allocres=(Unit *)malloc(needbytes);
821 	if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
822 	res=allocres;
823 	}
824       }
825     /* res now -> number lsu, buffer, or allocated storage for Unit array */
826 
827     /* Place the coefficient into the selected Unit array */
828     /* [this is often 70% of the cost of this function when DECDPUN>1] */
829     #if DECDPUN>1
830     out=0;			   /* accumulator */
831     up=res+D2U(d)-1;		   /* -> msu */
832     cut=d-(up-res)*DECDPUN;	   /* digits in top unit */
833     for (c=cfirst;; c++) {	   /* along the digits */
834       if (*c=='.') continue;	   /* ignore '.' [don't decrement cut] */
835       out=X10(out)+(Int)*c-(Int)'0';
836       if (c==last) break;	   /* done [never get to trailing '.'] */
837       cut--;
838       if (cut>0) continue;	   /* more for this unit */
839       *up=(Unit)out;		   /* write unit */
840       up--;			   /* prepare for unit below.. */
841       cut=DECDPUN;		   /* .. */
842       out=0;			   /* .. */
843       } /* c */
844     *up=(Unit)out;		   /* write lsu */
845 
846     #else
847     /* DECDPUN==1 */
848     up=res;			   /* -> lsu */
849     for (c=last; c>=cfirst; c--) { /* over each character, from least */
850       if (*c=='.') continue;	   /* ignore . [don't step up] */
851       *up=(Unit)((Int)*c-(Int)'0');
852       up++;
853       } /* c */
854     #endif
855 
856     dn->bits=bits;
857     dn->exponent=exponent;
858     dn->digits=d;
859 
860     /* if not in number (too long) shorten into the number */
861     if (d>set->digits) {
862       residue=0;
863       decSetCoeff(dn, set, res, d, &residue, &status);
864       /* always check for overflow or subnormal and round as needed */
865       decFinalize(dn, set, &residue, &status);
866       }
867      else { /* no rounding, but may still have overflow or subnormal */
868       /* [these tests are just for performance; finalize repeats them] */
869       if ((dn->exponent-1<set->emin-dn->digits)
870        || (dn->exponent-1>set->emax-set->digits)) {
871 	residue=0;
872 	decFinalize(dn, set, &residue, &status);
873 	}
874       }
875     /* decNumberShow(dn); */
876     } while(0);				/* [for break] */
877 
878   if (allocres!=NULL) free(allocres);	/* drop any storage used */
879   if (status!=0) decStatus(dn, status, set);
880   return dn;
881   } /* decNumberFromString */
882 
883 /* ================================================================== */
884 /* Operators							      */
885 /* ================================================================== */
886 
887 /* ------------------------------------------------------------------ */
888 /* decNumberAbs -- absolute value operator			      */
889 /*								      */
890 /*   This computes C = abs(A)					      */
891 /*								      */
892 /*   res is C, the result.  C may be A				      */
893 /*   rhs is A							      */
894 /*   set is the context						      */
895 /*								      */
896 /* See also decNumberCopyAbs for a quiet bitwise version of this.     */
897 /* C must have space for set->digits digits.			      */
898 /* ------------------------------------------------------------------ */
899 /* This has the same effect as decNumberPlus unless A is negative,    */
900 /* in which case it has the same effect as decNumberMinus.	      */
901 /* ------------------------------------------------------------------ */
902 decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
903 			 decContext *set) {
904   decNumber dzero;			/* for 0 */
905   uInt status=0;			/* accumulator */
906 
907   #if DECCHECK
908   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
909   #endif
910 
911   decNumberZero(&dzero);		/* set 0 */
912   dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
913   decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
914   if (status!=0) decStatus(res, status, set);
915   #if DECCHECK
916   decCheckInexact(res, set);
917   #endif
918   return res;
919   } /* decNumberAbs */
920 
921 /* ------------------------------------------------------------------ */
922 /* decNumberAdd -- add two Numbers				      */
923 /*								      */
924 /*   This computes C = A + B					      */
925 /*								      */
926 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
927 /*   lhs is A							      */
928 /*   rhs is B							      */
929 /*   set is the context						      */
930 /*								      */
931 /* C must have space for set->digits digits.			      */
932 /* ------------------------------------------------------------------ */
933 /* This just calls the routine shared with Subtract		      */
934 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
935 			 const decNumber *rhs, decContext *set) {
936   uInt status=0;			/* accumulator */
937   decAddOp(res, lhs, rhs, set, 0, &status);
938   if (status!=0) decStatus(res, status, set);
939   #if DECCHECK
940   decCheckInexact(res, set);
941   #endif
942   return res;
943   } /* decNumberAdd */
944 
945 /* ------------------------------------------------------------------ */
946 /* decNumberAnd -- AND two Numbers, digitwise			      */
947 /*								      */
948 /*   This computes C = A & B					      */
949 /*								      */
950 /*   res is C, the result.  C may be A and/or B (e.g., X=X&X)	      */
951 /*   lhs is A							      */
952 /*   rhs is B							      */
953 /*   set is the context (used for result length and error report)     */
954 /*								      */
955 /* C must have space for set->digits digits.			      */
956 /*								      */
957 /* Logical function restrictions apply (see above); a NaN is	      */
958 /* returned with Invalid_operation if a restriction is violated.      */
959 /* ------------------------------------------------------------------ */
960 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
961 			 const decNumber *rhs, decContext *set) {
962   const Unit *ua, *ub;			/* -> operands */
963   const Unit *msua, *msub;		/* -> operand msus */
964   Unit *uc,  *msuc;			/* -> result and its msu */
965   Int	msudigs;			/* digits in res msu */
966   #if DECCHECK
967   if (decCheckOperands(res, lhs, rhs, set)) return res;
968   #endif
969 
970   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
971    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
972     decStatus(res, DEC_Invalid_operation, set);
973     return res;
974     }
975 
976   /* operands are valid */
977   ua=lhs->lsu;				/* bottom-up */
978   ub=rhs->lsu;				/* .. */
979   uc=res->lsu;				/* .. */
980   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
981   msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
982   msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
983   msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
984   for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
985     Unit a, b;				/* extract units */
986     if (ua>msua) a=0;
987      else a=*ua;
988     if (ub>msub) b=0;
989      else b=*ub;
990     *uc=0;				/* can now write back */
991     if (a|b) {				/* maybe 1 bits to examine */
992       Int i, j;
993       *uc=0;				/* can now write back */
994       /* This loop could be unrolled and/or use BIN2BCD tables */
995       for (i=0; i<DECDPUN; i++) {
996 	if (a&b&1) *uc=*uc+(Unit)powers[i];  /* effect AND */
997 	j=a%10;
998 	a=a/10;
999 	j|=b%10;
1000 	b=b/10;
1001 	if (j>1) {
1002 	  decStatus(res, DEC_Invalid_operation, set);
1003 	  return res;
1004 	  }
1005 	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1006 	} /* each digit */
1007       } /* both OK */
1008     } /* each unit */
1009   /* [here uc-1 is the msu of the result] */
1010   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1011   res->exponent=0;			/* integer */
1012   res->bits=0;				/* sign=0 */
1013   return res;  /* [no status to set] */
1014   } /* decNumberAnd */
1015 
1016 /* ------------------------------------------------------------------ */
1017 /* decNumberCompare -- compare two Numbers			      */
1018 /*								      */
1019 /*   This computes C = A ? B					      */
1020 /*								      */
1021 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1022 /*   lhs is A							      */
1023 /*   rhs is B							      */
1024 /*   set is the context						      */
1025 /*								      */
1026 /* C must have space for one digit (or NaN).			      */
1027 /* ------------------------------------------------------------------ */
1028 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
1029 			     const decNumber *rhs, decContext *set) {
1030   uInt status=0;			/* accumulator */
1031   decCompareOp(res, lhs, rhs, set, COMPARE, &status);
1032   if (status!=0) decStatus(res, status, set);
1033   return res;
1034   } /* decNumberCompare */
1035 
1036 /* ------------------------------------------------------------------ */
1037 /* decNumberCompareSignal -- compare, signalling on all NaNs	      */
1038 /*								      */
1039 /*   This computes C = A ? B					      */
1040 /*								      */
1041 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1042 /*   lhs is A							      */
1043 /*   rhs is B							      */
1044 /*   set is the context						      */
1045 /*								      */
1046 /* C must have space for one digit (or NaN).			      */
1047 /* ------------------------------------------------------------------ */
1048 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
1049 				   const decNumber *rhs, decContext *set) {
1050   uInt status=0;			/* accumulator */
1051   decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
1052   if (status!=0) decStatus(res, status, set);
1053   return res;
1054   } /* decNumberCompareSignal */
1055 
1056 /* ------------------------------------------------------------------ */
1057 /* decNumberCompareTotal -- compare two Numbers, using total ordering */
1058 /*								      */
1059 /*   This computes C = A ? B, under total ordering		      */
1060 /*								      */
1061 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1062 /*   lhs is A							      */
1063 /*   rhs is B							      */
1064 /*   set is the context						      */
1065 /*								      */
1066 /* C must have space for one digit; the result will always be one of  */
1067 /* -1, 0, or 1.							      */
1068 /* ------------------------------------------------------------------ */
1069 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
1070 				  const decNumber *rhs, decContext *set) {
1071   uInt status=0;			/* accumulator */
1072   decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
1073   if (status!=0) decStatus(res, status, set);
1074   return res;
1075   } /* decNumberCompareTotal */
1076 
1077 /* ------------------------------------------------------------------ */
1078 /* decNumberCompareTotalMag -- compare, total ordering of magnitudes  */
1079 /*								      */
1080 /*   This computes C = |A| ? |B|, under total ordering		      */
1081 /*								      */
1082 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1083 /*   lhs is A							      */
1084 /*   rhs is B							      */
1085 /*   set is the context						      */
1086 /*								      */
1087 /* C must have space for one digit; the result will always be one of  */
1088 /* -1, 0, or 1.							      */
1089 /* ------------------------------------------------------------------ */
1090 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
1091 				     const decNumber *rhs, decContext *set) {
1092   uInt status=0;		   /* accumulator */
1093   uInt needbytes;		   /* for space calculations */
1094   decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
1095   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1096   decNumber bufb[D2N(DECBUFFER+1)];
1097   decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
1098   decNumber *a, *b;		   /* temporary pointers */
1099 
1100   #if DECCHECK
1101   if (decCheckOperands(res, lhs, rhs, set)) return res;
1102   #endif
1103 
1104   do {					/* protect allocated storage */
1105     /* if either is negative, take a copy and absolute */
1106     if (decNumberIsNegative(lhs)) {	/* lhs<0 */
1107       a=bufa;
1108       needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
1109       if (needbytes>sizeof(bufa)) {	/* need malloc space */
1110 	allocbufa=(decNumber *)malloc(needbytes);
1111 	if (allocbufa==NULL) {		/* hopeless -- abandon */
1112 	  status|=DEC_Insufficient_storage;
1113 	  break;}
1114 	a=allocbufa;			/* use the allocated space */
1115 	}
1116       decNumberCopy(a, lhs);		/* copy content */
1117       a->bits&=~DECNEG;			/* .. and clear the sign */
1118       lhs=a;				/* use copy from here on */
1119       }
1120     if (decNumberIsNegative(rhs)) {	/* rhs<0 */
1121       b=bufb;
1122       needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
1123       if (needbytes>sizeof(bufb)) {	/* need malloc space */
1124 	allocbufb=(decNumber *)malloc(needbytes);
1125 	if (allocbufb==NULL) {		/* hopeless -- abandon */
1126 	  status|=DEC_Insufficient_storage;
1127 	  break;}
1128 	b=allocbufb;			/* use the allocated space */
1129 	}
1130       decNumberCopy(b, rhs);		/* copy content */
1131       b->bits&=~DECNEG;			/* .. and clear the sign */
1132       rhs=b;				/* use copy from here on */
1133       }
1134     decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
1135     } while(0);				/* end protected */
1136 
1137   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1138   if (allocbufb!=NULL) free(allocbufb); /* .. */
1139   if (status!=0) decStatus(res, status, set);
1140   return res;
1141   } /* decNumberCompareTotalMag */
1142 
1143 /* ------------------------------------------------------------------ */
1144 /* decNumberDivide -- divide one number by another		      */
1145 /*								      */
1146 /*   This computes C = A / B					      */
1147 /*								      */
1148 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)	      */
1149 /*   lhs is A							      */
1150 /*   rhs is B							      */
1151 /*   set is the context						      */
1152 /*								      */
1153 /* C must have space for set->digits digits.			      */
1154 /* ------------------------------------------------------------------ */
1155 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
1156 			    const decNumber *rhs, decContext *set) {
1157   uInt status=0;			/* accumulator */
1158   decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
1159   if (status!=0) decStatus(res, status, set);
1160   #if DECCHECK
1161   decCheckInexact(res, set);
1162   #endif
1163   return res;
1164   } /* decNumberDivide */
1165 
1166 /* ------------------------------------------------------------------ */
1167 /* decNumberDivideInteger -- divide and return integer quotient	      */
1168 /*								      */
1169 /*   This computes C = A # B, where # is the integer divide operator  */
1170 /*								      */
1171 /*   res is C, the result.  C may be A and/or B (e.g., X=X#X)	      */
1172 /*   lhs is A							      */
1173 /*   rhs is B							      */
1174 /*   set is the context						      */
1175 /*								      */
1176 /* C must have space for set->digits digits.			      */
1177 /* ------------------------------------------------------------------ */
1178 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1179 				   const decNumber *rhs, decContext *set) {
1180   uInt status=0;			/* accumulator */
1181   decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1182   if (status!=0) decStatus(res, status, set);
1183   return res;
1184   } /* decNumberDivideInteger */
1185 
1186 /* ------------------------------------------------------------------ */
1187 /* decNumberExp -- exponentiation				      */
1188 /*								      */
1189 /*   This computes C = exp(A)					      */
1190 /*								      */
1191 /*   res is C, the result.  C may be A				      */
1192 /*   rhs is A							      */
1193 /*   set is the context; note that rounding mode has no effect	      */
1194 /*								      */
1195 /* C must have space for set->digits digits.			      */
1196 /*								      */
1197 /* Mathematical function restrictions apply (see above); a NaN is     */
1198 /* returned with Invalid_operation if a restriction is violated.      */
1199 /*								      */
1200 /* Finite results will always be full precision and Inexact, except   */
1201 /* when A is a zero or -Infinity (giving 1 or 0 respectively).	      */
1202 /*								      */
1203 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1204 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1205 /* error in rare cases.						      */
1206 /* ------------------------------------------------------------------ */
1207 /* This is a wrapper for decExpOp which can handle the slightly wider */
1208 /* (double) range needed by Ln (which has to be able to calculate     */
1209 /* exp(-a) where a can be the tiniest number (Ntiny).		      */
1210 /* ------------------------------------------------------------------ */
1211 decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1212 			 decContext *set) {
1213   uInt status=0;			/* accumulator */
1214   #if DECSUBSET
1215   decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1216   #endif
1217 
1218   #if DECCHECK
1219   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1220   #endif
1221 
1222   /* Check restrictions; these restrictions ensure that if h=8 (see */
1223   /* decExpOp) then the result will either overflow or underflow to 0. */
1224   /* Other math functions restrict the input range, too, for inverses. */
1225   /* If not violated then carry out the operation. */
1226   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1227     #if DECSUBSET
1228     if (!set->extended) {
1229       /* reduce operand and set lostDigits status, as needed */
1230       if (rhs->digits>set->digits) {
1231 	allocrhs=decRoundOperand(rhs, set, &status);
1232 	if (allocrhs==NULL) break;
1233 	rhs=allocrhs;
1234 	}
1235       }
1236     #endif
1237     decExpOp(res, rhs, set, &status);
1238     } while(0);				/* end protected */
1239 
1240   #if DECSUBSET
1241   if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
1242   #endif
1243   /* apply significant status */
1244   if (status!=0) decStatus(res, status, set);
1245   #if DECCHECK
1246   decCheckInexact(res, set);
1247   #endif
1248   return res;
1249   } /* decNumberExp */
1250 
1251 /* ------------------------------------------------------------------ */
1252 /* decNumberFMA -- fused multiply add				      */
1253 /*								      */
1254 /*   This computes D = (A * B) + C with only one rounding	      */
1255 /*								      */
1256 /*   res is D, the result.  D may be A or B or C (e.g., X=FMA(X,X,X)) */
1257 /*   lhs is A							      */
1258 /*   rhs is B							      */
1259 /*   fhs is C [far hand side]					      */
1260 /*   set is the context						      */
1261 /*								      */
1262 /* Mathematical function restrictions apply (see above); a NaN is     */
1263 /* returned with Invalid_operation if a restriction is violated.      */
1264 /*								      */
1265 /* C must have space for set->digits digits.			      */
1266 /* ------------------------------------------------------------------ */
1267 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1268 			 const decNumber *rhs, const decNumber *fhs,
1269 			 decContext *set) {
1270   uInt status=0;		   /* accumulator */
1271   decContext dcmul;		   /* context for the multiplication */
1272   uInt needbytes;		   /* for space calculations */
1273   decNumber bufa[D2N(DECBUFFER*2+1)];
1274   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1275   decNumber *acc;		   /* accumulator pointer */
1276   decNumber dzero;		   /* work */
1277 
1278   #if DECCHECK
1279   if (decCheckOperands(res, lhs, rhs, set)) return res;
1280   if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1281   #endif
1282 
1283   do {					/* protect allocated storage */
1284     #if DECSUBSET
1285     if (!set->extended) {		/* [undefined if subset] */
1286       status|=DEC_Invalid_operation;
1287       break;}
1288     #endif
1289     /* Check math restrictions [these ensure no overflow or underflow] */
1290     if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1291      || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1292      || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1293     /* set up context for multiply */
1294     dcmul=*set;
1295     dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1296     /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1297     dcmul.emax=DEC_MAX_EMAX;		/* effectively unbounded .. */
1298     dcmul.emin=DEC_MIN_EMIN;		/* [thanks to Math restrictions] */
1299     /* set up decNumber space to receive the result of the multiply */
1300     acc=bufa;				/* may fit */
1301     needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1302     if (needbytes>sizeof(bufa)) {	/* need malloc space */
1303       allocbufa=(decNumber *)malloc(needbytes);
1304       if (allocbufa==NULL) {		/* hopeless -- abandon */
1305 	status|=DEC_Insufficient_storage;
1306 	break;}
1307       acc=allocbufa;			/* use the allocated space */
1308       }
1309     /* multiply with extended range and necessary precision */
1310     /*printf("emin=%ld\n", dcmul.emin); */
1311     decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1312     /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1313     /* status; if either is seen than ignore fhs (in case it is */
1314     /* another sNaN) and set acc to NaN unless we had an sNaN */
1315     /* [decMultiplyOp leaves that to caller] */
1316     /* Note sNaN has to go through addOp to shorten payload if */
1317     /* necessary */
1318     if ((status&DEC_Invalid_operation)!=0) {
1319       if (!(status&DEC_sNaN)) {		/* but be true invalid */
1320 	decNumberZero(res);		/* acc not yet set */
1321 	res->bits=DECNAN;
1322 	break;
1323 	}
1324       decNumberZero(&dzero);		/* make 0 (any non-NaN would do) */
1325       fhs=&dzero;			/* use that */
1326       }
1327     #if DECCHECK
1328      else { /* multiply was OK */
1329       if (status!=0) printf("Status=%08lx after FMA multiply\n", status);
1330       }
1331     #endif
1332     /* add the third operand and result -> res, and all is done */
1333     decAddOp(res, acc, fhs, set, 0, &status);
1334     } while(0);				/* end protected */
1335 
1336   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1337   if (status!=0) decStatus(res, status, set);
1338   #if DECCHECK
1339   decCheckInexact(res, set);
1340   #endif
1341   return res;
1342   } /* decNumberFMA */
1343 
1344 /* ------------------------------------------------------------------ */
1345 /* decNumberInvert -- invert a Number, digitwise		      */
1346 /*								      */
1347 /*   This computes C = ~A					      */
1348 /*								      */
1349 /*   res is C, the result.  C may be A (e.g., X=~X)		      */
1350 /*   rhs is A							      */
1351 /*   set is the context (used for result length and error report)     */
1352 /*								      */
1353 /* C must have space for set->digits digits.			      */
1354 /*								      */
1355 /* Logical function restrictions apply (see above); a NaN is	      */
1356 /* returned with Invalid_operation if a restriction is violated.      */
1357 /* ------------------------------------------------------------------ */
1358 decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1359 			    decContext *set) {
1360   const Unit *ua, *msua;		/* -> operand and its msu */
1361   Unit	*uc, *msuc;			/* -> result and its msu */
1362   Int	msudigs;			/* digits in res msu */
1363   #if DECCHECK
1364   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1365   #endif
1366 
1367   if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1368     decStatus(res, DEC_Invalid_operation, set);
1369     return res;
1370     }
1371   /* operand is valid */
1372   ua=rhs->lsu;				/* bottom-up */
1373   uc=res->lsu;				/* .. */
1374   msua=ua+D2U(rhs->digits)-1;		/* -> msu of rhs */
1375   msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
1376   msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
1377   for (; uc<=msuc; ua++, uc++) {	/* Unit loop */
1378     Unit a;				/* extract unit */
1379     Int	 i, j;				/* work */
1380     if (ua>msua) a=0;
1381      else a=*ua;
1382     *uc=0;				/* can now write back */
1383     /* always need to examine all bits in rhs */
1384     /* This loop could be unrolled and/or use BIN2BCD tables */
1385     for (i=0; i<DECDPUN; i++) {
1386       if ((~a)&1) *uc=*uc+(Unit)powers[i];   /* effect INVERT */
1387       j=a%10;
1388       a=a/10;
1389       if (j>1) {
1390 	decStatus(res, DEC_Invalid_operation, set);
1391 	return res;
1392 	}
1393       if (uc==msuc && i==msudigs-1) break;   /* just did final digit */
1394       } /* each digit */
1395     } /* each unit */
1396   /* [here uc-1 is the msu of the result] */
1397   res->digits=decGetDigits(res->lsu, uc-res->lsu);
1398   res->exponent=0;			/* integer */
1399   res->bits=0;				/* sign=0 */
1400   return res;  /* [no status to set] */
1401   } /* decNumberInvert */
1402 
1403 /* ------------------------------------------------------------------ */
1404 /* decNumberLn -- natural logarithm				      */
1405 /*								      */
1406 /*   This computes C = ln(A)					      */
1407 /*								      */
1408 /*   res is C, the result.  C may be A				      */
1409 /*   rhs is A							      */
1410 /*   set is the context; note that rounding mode has no effect	      */
1411 /*								      */
1412 /* C must have space for set->digits digits.			      */
1413 /*								      */
1414 /* Notable cases:						      */
1415 /*   A<0 -> Invalid						      */
1416 /*   A=0 -> -Infinity (Exact)					      */
1417 /*   A=+Infinity -> +Infinity (Exact)				      */
1418 /*   A=1 exactly -> 0 (Exact)					      */
1419 /*								      */
1420 /* Mathematical function restrictions apply (see above); a NaN is     */
1421 /* returned with Invalid_operation if a restriction is violated.      */
1422 /*								      */
1423 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1424 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1425 /* error in rare cases.						      */
1426 /* ------------------------------------------------------------------ */
1427 /* This is a wrapper for decLnOp which can handle the slightly wider  */
1428 /* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
1429 /* to calculate at p+e+2).					      */
1430 /* ------------------------------------------------------------------ */
1431 decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1432 			decContext *set) {
1433   uInt status=0;		   /* accumulator */
1434   #if DECSUBSET
1435   decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1436   #endif
1437 
1438   #if DECCHECK
1439   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1440   #endif
1441 
1442   /* Check restrictions; this is a math function; if not violated */
1443   /* then carry out the operation. */
1444   if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1445     #if DECSUBSET
1446     if (!set->extended) {
1447       /* reduce operand and set lostDigits status, as needed */
1448       if (rhs->digits>set->digits) {
1449 	allocrhs=decRoundOperand(rhs, set, &status);
1450 	if (allocrhs==NULL) break;
1451 	rhs=allocrhs;
1452 	}
1453       /* special check in subset for rhs=0 */
1454       if (ISZERO(rhs)) {		/* +/- zeros -> error */
1455 	status|=DEC_Invalid_operation;
1456 	break;}
1457       } /* extended=0 */
1458     #endif
1459     decLnOp(res, rhs, set, &status);
1460     } while(0);				/* end protected */
1461 
1462   #if DECSUBSET
1463   if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
1464   #endif
1465   /* apply significant status */
1466   if (status!=0) decStatus(res, status, set);
1467   #if DECCHECK
1468   decCheckInexact(res, set);
1469   #endif
1470   return res;
1471   } /* decNumberLn */
1472 
1473 /* ------------------------------------------------------------------ */
1474 /* decNumberLogB - get adjusted exponent, by 754r rules		      */
1475 /*								      */
1476 /*   This computes C = adjustedexponent(A)			      */
1477 /*								      */
1478 /*   res is C, the result.  C may be A				      */
1479 /*   rhs is A							      */
1480 /*   set is the context, used only for digits and status	      */
1481 /*								      */
1482 /* C must have space for 10 digits (A might have 10**9 digits and     */
1483 /* an exponent of +999999999, or one digit and an exponent of	      */
1484 /* -1999999999).						      */
1485 /*								      */
1486 /* This returns the adjusted exponent of A after (in theory) padding  */
1487 /* with zeros on the right to set->digits digits while keeping the    */
1488 /* same value.	The exponent is not limited by emin/emax.	      */
1489 /*								      */
1490 /* Notable cases:						      */
1491 /*   A<0 -> Use |A|						      */
1492 /*   A=0 -> -Infinity (Division by zero)			      */
1493 /*   A=Infinite -> +Infinity (Exact)				      */
1494 /*   A=1 exactly -> 0 (Exact)					      */
1495 /*   NaNs are propagated as usual				      */
1496 /* ------------------------------------------------------------------ */
1497 decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1498 			  decContext *set) {
1499   uInt status=0;		   /* accumulator */
1500 
1501   #if DECCHECK
1502   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1503   #endif
1504 
1505   /* NaNs as usual; Infinities return +Infinity; 0->oops */
1506   if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1507    else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1508    else if (decNumberIsZero(rhs)) {
1509     decNumberZero(res);			/* prepare for Infinity */
1510     res->bits=DECNEG|DECINF;		/* -Infinity */
1511     status|=DEC_Division_by_zero;	/* as per 754r */
1512     }
1513    else { /* finite non-zero */
1514     Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1515     decNumberFromInt32(res, ae);	/* lay it out */
1516     }
1517 
1518   if (status!=0) decStatus(res, status, set);
1519   return res;
1520   } /* decNumberLogB */
1521 
1522 /* ------------------------------------------------------------------ */
1523 /* decNumberLog10 -- logarithm in base 10			      */
1524 /*								      */
1525 /*   This computes C = log10(A)					      */
1526 /*								      */
1527 /*   res is C, the result.  C may be A				      */
1528 /*   rhs is A							      */
1529 /*   set is the context; note that rounding mode has no effect	      */
1530 /*								      */
1531 /* C must have space for set->digits digits.			      */
1532 /*								      */
1533 /* Notable cases:						      */
1534 /*   A<0 -> Invalid						      */
1535 /*   A=0 -> -Infinity (Exact)					      */
1536 /*   A=+Infinity -> +Infinity (Exact)				      */
1537 /*   A=10**n (if n is an integer) -> n (Exact)			      */
1538 /*								      */
1539 /* Mathematical function restrictions apply (see above); a NaN is     */
1540 /* returned with Invalid_operation if a restriction is violated.      */
1541 /*								      */
1542 /* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1543 /* almost always be correctly rounded, but may be up to 1 ulp in      */
1544 /* error in rare cases.						      */
1545 /* ------------------------------------------------------------------ */
1546 /* This calculates ln(A)/ln(10) using appropriate precision.  For     */
1547 /* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
1548 /* requested digits and t is the number of digits in the exponent     */
1549 /* (maximum 6).	 For ln(10) it is p + 3; this is often handled by the */
1550 /* fastpath in decLnOp.	 The final division is done to the requested  */
1551 /* precision.							      */
1552 /* ------------------------------------------------------------------ */
1553 decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1554 			  decContext *set) {
1555   uInt status=0, ignore=0;	   /* status accumulators */
1556   uInt needbytes;		   /* for space calculations */
1557   Int p;			   /* working precision */
1558   Int t;			   /* digits in exponent of A */
1559 
1560   /* buffers for a and b working decimals */
1561   /* (adjustment calculator, same size) */
1562   decNumber bufa[D2N(DECBUFFER+2)];
1563   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1564   decNumber *a=bufa;		   /* temporary a */
1565   decNumber bufb[D2N(DECBUFFER+2)];
1566   decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
1567   decNumber *b=bufb;		   /* temporary b */
1568   decNumber bufw[D2N(10)];	   /* working 2-10 digit number */
1569   decNumber *w=bufw;		   /* .. */
1570   #if DECSUBSET
1571   decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1572   #endif
1573 
1574   decContext aset;		   /* working context */
1575 
1576   #if DECCHECK
1577   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1578   #endif
1579 
1580   /* Check restrictions; this is a math function; if not violated */
1581   /* then carry out the operation. */
1582   if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1583     #if DECSUBSET
1584     if (!set->extended) {
1585       /* reduce operand and set lostDigits status, as needed */
1586       if (rhs->digits>set->digits) {
1587 	allocrhs=decRoundOperand(rhs, set, &status);
1588 	if (allocrhs==NULL) break;
1589 	rhs=allocrhs;
1590 	}
1591       /* special check in subset for rhs=0 */
1592       if (ISZERO(rhs)) {		/* +/- zeros -> error */
1593 	status|=DEC_Invalid_operation;
1594 	break;}
1595       } /* extended=0 */
1596     #endif
1597 
1598     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1599 
1600     /* handle exact powers of 10; only check if +ve finite */
1601     if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1602       Int residue=0;		   /* (no residue) */
1603       uInt copystat=0;		   /* clean status */
1604 
1605       /* round to a single digit... */
1606       aset.digits=1;
1607       decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1608       /* if exact and the digit is 1, rhs is a power of 10 */
1609       if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1610 	/* the exponent, conveniently, is the power of 10; making */
1611 	/* this the result needs a little care as it might not fit, */
1612 	/* so first convert it into the working number, and then move */
1613 	/* to res */
1614 	decNumberFromInt32(w, w->exponent);
1615 	residue=0;
1616 	decCopyFit(res, w, set, &residue, &status); /* copy & round */
1617 	decFinish(res, set, &residue, &status);	    /* cleanup/set flags */
1618 	break;
1619 	} /* not a power of 10 */
1620       } /* not a candidate for exact */
1621 
1622     /* simplify the information-content calculation to use 'total */
1623     /* number of digits in a, including exponent' as compared to the */
1624     /* requested digits, as increasing this will only rarely cost an */
1625     /* iteration in ln(a) anyway */
1626     t=6;				/* it can never be >6 */
1627 
1628     /* allocate space when needed... */
1629     p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1630     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1631     if (needbytes>sizeof(bufa)) {	/* need malloc space */
1632       allocbufa=(decNumber *)malloc(needbytes);
1633       if (allocbufa==NULL) {		/* hopeless -- abandon */
1634 	status|=DEC_Insufficient_storage;
1635 	break;}
1636       a=allocbufa;			/* use the allocated space */
1637       }
1638     aset.digits=p;			/* as calculated */
1639     aset.emax=DEC_MAX_MATH;		/* usual bounds */
1640     aset.emin=-DEC_MAX_MATH;		/* .. */
1641     aset.clamp=0;			/* and no concrete format */
1642     decLnOp(a, rhs, &aset, &status);	/* a=ln(rhs) */
1643 
1644     /* skip the division if the result so far is infinite, NaN, or */
1645     /* zero, or there was an error; note NaN from sNaN needs copy */
1646     if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1647     if (a->bits&DECSPECIAL || ISZERO(a)) {
1648       decNumberCopy(res, a);		/* [will fit] */
1649       break;}
1650 
1651     /* for ln(10) an extra 3 digits of precision are needed */
1652     p=set->digits+3;
1653     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1654     if (needbytes>sizeof(bufb)) {	/* need malloc space */
1655       allocbufb=(decNumber *)malloc(needbytes);
1656       if (allocbufb==NULL) {		/* hopeless -- abandon */
1657 	status|=DEC_Insufficient_storage;
1658 	break;}
1659       b=allocbufb;			/* use the allocated space */
1660       }
1661     decNumberZero(w);			/* set up 10... */
1662     #if DECDPUN==1
1663     w->lsu[1]=1; w->lsu[0]=0;		/* .. */
1664     #else
1665     w->lsu[0]=10;			/* .. */
1666     #endif
1667     w->digits=2;			/* .. */
1668 
1669     aset.digits=p;
1670     decLnOp(b, w, &aset, &ignore);	/* b=ln(10) */
1671 
1672     aset.digits=set->digits;		/* for final divide */
1673     decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1674     } while(0);				/* [for break] */
1675 
1676   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1677   if (allocbufb!=NULL) free(allocbufb); /* .. */
1678   #if DECSUBSET
1679   if (allocrhs !=NULL) free(allocrhs);	/* .. */
1680   #endif
1681   /* apply significant status */
1682   if (status!=0) decStatus(res, status, set);
1683   #if DECCHECK
1684   decCheckInexact(res, set);
1685   #endif
1686   return res;
1687   } /* decNumberLog10 */
1688 
1689 /* ------------------------------------------------------------------ */
1690 /* decNumberMax -- compare two Numbers and return the maximum	      */
1691 /*								      */
1692 /*   This computes C = A ? B, returning the maximum by 754R rules     */
1693 /*								      */
1694 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1695 /*   lhs is A							      */
1696 /*   rhs is B							      */
1697 /*   set is the context						      */
1698 /*								      */
1699 /* C must have space for set->digits digits.			      */
1700 /* ------------------------------------------------------------------ */
1701 decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1702 			 const decNumber *rhs, decContext *set) {
1703   uInt status=0;			/* accumulator */
1704   decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1705   if (status!=0) decStatus(res, status, set);
1706   #if DECCHECK
1707   decCheckInexact(res, set);
1708   #endif
1709   return res;
1710   } /* decNumberMax */
1711 
1712 /* ------------------------------------------------------------------ */
1713 /* decNumberMaxMag -- compare and return the maximum by magnitude     */
1714 /*								      */
1715 /*   This computes C = A ? B, returning the maximum by 754R rules     */
1716 /*								      */
1717 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1718 /*   lhs is A							      */
1719 /*   rhs is B							      */
1720 /*   set is the context						      */
1721 /*								      */
1722 /* C must have space for set->digits digits.			      */
1723 /* ------------------------------------------------------------------ */
1724 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1725 			 const decNumber *rhs, decContext *set) {
1726   uInt status=0;			/* accumulator */
1727   decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1728   if (status!=0) decStatus(res, status, set);
1729   #if DECCHECK
1730   decCheckInexact(res, set);
1731   #endif
1732   return res;
1733   } /* decNumberMaxMag */
1734 
1735 /* ------------------------------------------------------------------ */
1736 /* decNumberMin -- compare two Numbers and return the minimum	      */
1737 /*								      */
1738 /*   This computes C = A ? B, returning the minimum by 754R rules     */
1739 /*								      */
1740 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1741 /*   lhs is A							      */
1742 /*   rhs is B							      */
1743 /*   set is the context						      */
1744 /*								      */
1745 /* C must have space for set->digits digits.			      */
1746 /* ------------------------------------------------------------------ */
1747 decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1748 			 const decNumber *rhs, decContext *set) {
1749   uInt status=0;			/* accumulator */
1750   decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1751   if (status!=0) decStatus(res, status, set);
1752   #if DECCHECK
1753   decCheckInexact(res, set);
1754   #endif
1755   return res;
1756   } /* decNumberMin */
1757 
1758 /* ------------------------------------------------------------------ */
1759 /* decNumberMinMag -- compare and return the minimum by magnitude     */
1760 /*								      */
1761 /*   This computes C = A ? B, returning the minimum by 754R rules     */
1762 /*								      */
1763 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1764 /*   lhs is A							      */
1765 /*   rhs is B							      */
1766 /*   set is the context						      */
1767 /*								      */
1768 /* C must have space for set->digits digits.			      */
1769 /* ------------------------------------------------------------------ */
1770 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1771 			 const decNumber *rhs, decContext *set) {
1772   uInt status=0;			/* accumulator */
1773   decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1774   if (status!=0) decStatus(res, status, set);
1775   #if DECCHECK
1776   decCheckInexact(res, set);
1777   #endif
1778   return res;
1779   } /* decNumberMinMag */
1780 
1781 /* ------------------------------------------------------------------ */
1782 /* decNumberMinus -- prefix minus operator			      */
1783 /*								      */
1784 /*   This computes C = 0 - A					      */
1785 /*								      */
1786 /*   res is C, the result.  C may be A				      */
1787 /*   rhs is A							      */
1788 /*   set is the context						      */
1789 /*								      */
1790 /* See also decNumberCopyNegate for a quiet bitwise version of this.  */
1791 /* C must have space for set->digits digits.			      */
1792 /* ------------------------------------------------------------------ */
1793 /* Simply use AddOp for the subtract, which will do the necessary.    */
1794 /* ------------------------------------------------------------------ */
1795 decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1796 			   decContext *set) {
1797   decNumber dzero;
1798   uInt status=0;			/* accumulator */
1799 
1800   #if DECCHECK
1801   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1802   #endif
1803 
1804   decNumberZero(&dzero);		/* make 0 */
1805   dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
1806   decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1807   if (status!=0) decStatus(res, status, set);
1808   #if DECCHECK
1809   decCheckInexact(res, set);
1810   #endif
1811   return res;
1812   } /* decNumberMinus */
1813 
1814 /* ------------------------------------------------------------------ */
1815 /* decNumberNextMinus -- next towards -Infinity			      */
1816 /*								      */
1817 /*   This computes C = A - infinitesimal, rounded towards -Infinity   */
1818 /*								      */
1819 /*   res is C, the result.  C may be A				      */
1820 /*   rhs is A							      */
1821 /*   set is the context						      */
1822 /*								      */
1823 /* This is a generalization of 754r NextDown.			      */
1824 /* ------------------------------------------------------------------ */
1825 decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1826 			       decContext *set) {
1827   decNumber dtiny;			     /* constant */
1828   decContext workset=*set;		     /* work */
1829   uInt status=0;			     /* accumulator */
1830   #if DECCHECK
1831   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1832   #endif
1833 
1834   /* +Infinity is the special case */
1835   if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1836     decSetMaxValue(res, set);		     /* is +ve */
1837     /* there is no status to set */
1838     return res;
1839     }
1840   decNumberZero(&dtiny);		     /* start with 0 */
1841   dtiny.lsu[0]=1;			     /* make number that is .. */
1842   dtiny.exponent=DEC_MIN_EMIN-1;	     /* .. smaller than tiniest */
1843   workset.round=DEC_ROUND_FLOOR;
1844   decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1845   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1846   if (status!=0) decStatus(res, status, set);
1847   return res;
1848   } /* decNumberNextMinus */
1849 
1850 /* ------------------------------------------------------------------ */
1851 /* decNumberNextPlus -- next towards +Infinity			      */
1852 /*								      */
1853 /*   This computes C = A + infinitesimal, rounded towards +Infinity   */
1854 /*								      */
1855 /*   res is C, the result.  C may be A				      */
1856 /*   rhs is A							      */
1857 /*   set is the context						      */
1858 /*								      */
1859 /* This is a generalization of 754r NextUp.			      */
1860 /* ------------------------------------------------------------------ */
1861 decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1862 			      decContext *set) {
1863   decNumber dtiny;			     /* constant */
1864   decContext workset=*set;		     /* work */
1865   uInt status=0;			     /* accumulator */
1866   #if DECCHECK
1867   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1868   #endif
1869 
1870   /* -Infinity is the special case */
1871   if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1872     decSetMaxValue(res, set);
1873     res->bits=DECNEG;			     /* negative */
1874     /* there is no status to set */
1875     return res;
1876     }
1877   decNumberZero(&dtiny);		     /* start with 0 */
1878   dtiny.lsu[0]=1;			     /* make number that is .. */
1879   dtiny.exponent=DEC_MIN_EMIN-1;	     /* .. smaller than tiniest */
1880   workset.round=DEC_ROUND_CEILING;
1881   decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1882   status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1883   if (status!=0) decStatus(res, status, set);
1884   return res;
1885   } /* decNumberNextPlus */
1886 
1887 /* ------------------------------------------------------------------ */
1888 /* decNumberNextToward -- next towards rhs			      */
1889 /*								      */
1890 /*   This computes C = A +/- infinitesimal, rounded towards	      */
1891 /*   +/-Infinity in the direction of B, as per 754r nextafter rules   */
1892 /*								      */
1893 /*   res is C, the result.  C may be A or B.			      */
1894 /*   lhs is A							      */
1895 /*   rhs is B							      */
1896 /*   set is the context						      */
1897 /*								      */
1898 /* This is a generalization of 754r NextAfter.			      */
1899 /* ------------------------------------------------------------------ */
1900 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1901 				const decNumber *rhs, decContext *set) {
1902   decNumber dtiny;			     /* constant */
1903   decContext workset=*set;		     /* work */
1904   Int result;				     /* .. */
1905   uInt status=0;			     /* accumulator */
1906   #if DECCHECK
1907   if (decCheckOperands(res, lhs, rhs, set)) return res;
1908   #endif
1909 
1910   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1911     decNaNs(res, lhs, rhs, set, &status);
1912     }
1913    else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1914     result=decCompare(lhs, rhs, 0);	/* sign matters */
1915     if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1916      else { /* valid compare */
1917       if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1918        else { /* differ: need NextPlus or NextMinus */
1919 	uByte sub;			/* add or subtract */
1920 	if (result<0) {			/* lhs<rhs, do nextplus */
1921 	  /* -Infinity is the special case */
1922 	  if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1923 	    decSetMaxValue(res, set);
1924 	    res->bits=DECNEG;		/* negative */
1925 	    return res;			/* there is no status to set */
1926 	    }
1927 	  workset.round=DEC_ROUND_CEILING;
1928 	  sub=0;			/* add, please */
1929 	  } /* plus */
1930 	 else {				/* lhs>rhs, do nextminus */
1931 	  /* +Infinity is the special case */
1932 	  if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1933 	    decSetMaxValue(res, set);
1934 	    return res;			/* there is no status to set */
1935 	    }
1936 	  workset.round=DEC_ROUND_FLOOR;
1937 	  sub=DECNEG;			/* subtract, please */
1938 	  } /* minus */
1939 	decNumberZero(&dtiny);		/* start with 0 */
1940 	dtiny.lsu[0]=1;			/* make number that is .. */
1941 	dtiny.exponent=DEC_MIN_EMIN-1;	/* .. smaller than tiniest */
1942 	decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1943 	/* turn off exceptions if the result is a normal number */
1944 	/* (including Nmin), otherwise let all status through */
1945 	if (decNumberIsNormal(res, set)) status=0;
1946 	} /* unequal */
1947       } /* compare OK */
1948     } /* numeric */
1949   if (status!=0) decStatus(res, status, set);
1950   return res;
1951   } /* decNumberNextToward */
1952 
1953 /* ------------------------------------------------------------------ */
1954 /* decNumberOr -- OR two Numbers, digitwise			      */
1955 /*								      */
1956 /*   This computes C = A | B					      */
1957 /*								      */
1958 /*   res is C, the result.  C may be A and/or B (e.g., X=X|X)	      */
1959 /*   lhs is A							      */
1960 /*   rhs is B							      */
1961 /*   set is the context (used for result length and error report)     */
1962 /*								      */
1963 /* C must have space for set->digits digits.			      */
1964 /*								      */
1965 /* Logical function restrictions apply (see above); a NaN is	      */
1966 /* returned with Invalid_operation if a restriction is violated.      */
1967 /* ------------------------------------------------------------------ */
1968 decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1969 			const decNumber *rhs, decContext *set) {
1970   const Unit *ua, *ub;			/* -> operands */
1971   const Unit *msua, *msub;		/* -> operand msus */
1972   Unit	*uc, *msuc;			/* -> result and its msu */
1973   Int	msudigs;			/* digits in res msu */
1974   #if DECCHECK
1975   if (decCheckOperands(res, lhs, rhs, set)) return res;
1976   #endif
1977 
1978   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1979    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1980     decStatus(res, DEC_Invalid_operation, set);
1981     return res;
1982     }
1983   /* operands are valid */
1984   ua=lhs->lsu;				/* bottom-up */
1985   ub=rhs->lsu;				/* .. */
1986   uc=res->lsu;				/* .. */
1987   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
1988   msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
1989   msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
1990   msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
1991   for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
1992     Unit a, b;				/* extract units */
1993     if (ua>msua) a=0;
1994      else a=*ua;
1995     if (ub>msub) b=0;
1996      else b=*ub;
1997     *uc=0;				/* can now write back */
1998     if (a|b) {				/* maybe 1 bits to examine */
1999       Int i, j;
2000       /* This loop could be unrolled and/or use BIN2BCD tables */
2001       for (i=0; i<DECDPUN; i++) {
2002 	if ((a|b)&1) *uc=*uc+(Unit)powers[i];	  /* effect OR */
2003 	j=a%10;
2004 	a=a/10;
2005 	j|=b%10;
2006 	b=b/10;
2007 	if (j>1) {
2008 	  decStatus(res, DEC_Invalid_operation, set);
2009 	  return res;
2010 	  }
2011 	if (uc==msuc && i==msudigs-1) break;	  /* just did final digit */
2012 	} /* each digit */
2013       } /* non-zero */
2014     } /* each unit */
2015   /* [here uc-1 is the msu of the result] */
2016   res->digits=decGetDigits(res->lsu, uc-res->lsu);
2017   res->exponent=0;			/* integer */
2018   res->bits=0;				/* sign=0 */
2019   return res;  /* [no status to set] */
2020   } /* decNumberOr */
2021 
2022 /* ------------------------------------------------------------------ */
2023 /* decNumberPlus -- prefix plus operator			      */
2024 /*								      */
2025 /*   This computes C = 0 + A					      */
2026 /*								      */
2027 /*   res is C, the result.  C may be A				      */
2028 /*   rhs is A							      */
2029 /*   set is the context						      */
2030 /*								      */
2031 /* See also decNumberCopy for a quiet bitwise version of this.	      */
2032 /* C must have space for set->digits digits.			      */
2033 /* ------------------------------------------------------------------ */
2034 /* This simply uses AddOp; Add will take fast path after preparing A. */
2035 /* Performance is a concern here, as this routine is often used to    */
2036 /* check operands and apply rounding and overflow/underflow testing.  */
2037 /* ------------------------------------------------------------------ */
2038 decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
2039 			  decContext *set) {
2040   decNumber dzero;
2041   uInt status=0;			/* accumulator */
2042   #if DECCHECK
2043   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2044   #endif
2045 
2046   decNumberZero(&dzero);		/* make 0 */
2047   dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
2048   decAddOp(res, &dzero, rhs, set, 0, &status);
2049   if (status!=0) decStatus(res, status, set);
2050   #if DECCHECK
2051   decCheckInexact(res, set);
2052   #endif
2053   return res;
2054   } /* decNumberPlus */
2055 
2056 /* ------------------------------------------------------------------ */
2057 /* decNumberMultiply -- multiply two Numbers			      */
2058 /*								      */
2059 /*   This computes C = A x B					      */
2060 /*								      */
2061 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
2062 /*   lhs is A							      */
2063 /*   rhs is B							      */
2064 /*   set is the context						      */
2065 /*								      */
2066 /* C must have space for set->digits digits.			      */
2067 /* ------------------------------------------------------------------ */
2068 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
2069 			      const decNumber *rhs, decContext *set) {
2070   uInt status=0;		   /* accumulator */
2071   decMultiplyOp(res, lhs, rhs, set, &status);
2072   if (status!=0) decStatus(res, status, set);
2073   #if DECCHECK
2074   decCheckInexact(res, set);
2075   #endif
2076   return res;
2077   } /* decNumberMultiply */
2078 
2079 /* ------------------------------------------------------------------ */
2080 /* decNumberPower -- raise a number to a power			      */
2081 /*								      */
2082 /*   This computes C = A ** B					      */
2083 /*								      */
2084 /*   res is C, the result.  C may be A and/or B (e.g., X=X**X)	      */
2085 /*   lhs is A							      */
2086 /*   rhs is B							      */
2087 /*   set is the context						      */
2088 /*								      */
2089 /* C must have space for set->digits digits.			      */
2090 /*								      */
2091 /* Mathematical function restrictions apply (see above); a NaN is     */
2092 /* returned with Invalid_operation if a restriction is violated.      */
2093 /*								      */
2094 /* However, if 1999999997<=B<=999999999 and B is an integer then the  */
2095 /* restrictions on A and the context are relaxed to the usual bounds, */
2096 /* for compatibility with the earlier (integer power only) version    */
2097 /* of this function.						      */
2098 /*								      */
2099 /* When B is an integer, the result may be exact, even if rounded.    */
2100 /*								      */
2101 /* The final result is rounded according to the context; it will      */
2102 /* almost always be correctly rounded, but may be up to 1 ulp in      */
2103 /* error in rare cases.						      */
2104 /* ------------------------------------------------------------------ */
2105 decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
2106 			   const decNumber *rhs, decContext *set) {
2107   #if DECSUBSET
2108   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
2109   decNumber *allocrhs=NULL;	   /* .., rhs */
2110   #endif
2111   decNumber *allocdac=NULL;	   /* -> allocated acc buffer, iff used */
2112   decNumber *allocinv=NULL;	   /* -> allocated 1/x buffer, iff used */
2113   Int	reqdigits=set->digits;	   /* requested DIGITS */
2114   Int	n;			   /* rhs in binary */
2115   Flag	rhsint=0;		   /* 1 if rhs is an integer */
2116   Flag	useint=0;		   /* 1 if can use integer calculation */
2117   Flag	isoddint=0;		   /* 1 if rhs is an integer and odd */
2118   Int	i;			   /* work */
2119   #if DECSUBSET
2120   Int	dropped;		   /* .. */
2121   #endif
2122   uInt	needbytes;		   /* buffer size needed */
2123   Flag	seenbit;		   /* seen a bit while powering */
2124   Int	residue=0;		   /* rounding residue */
2125   uInt	status=0;		   /* accumulators */
2126   uByte bits=0;			   /* result sign if errors */
2127   decContext aset;		   /* working context */
2128   decNumber dnOne;		   /* work value 1... */
2129   /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
2130   decNumber dacbuff[D2N(DECBUFFER+9)];
2131   decNumber *dac=dacbuff;	   /* -> result accumulator */
2132   /* same again for possible 1/lhs calculation */
2133   decNumber invbuff[D2N(DECBUFFER+9)];
2134 
2135   #if DECCHECK
2136   if (decCheckOperands(res, lhs, rhs, set)) return res;
2137   #endif
2138 
2139   do {				   /* protect allocated storage */
2140     #if DECSUBSET
2141     if (!set->extended) { /* reduce operands and set status, as needed */
2142       if (lhs->digits>reqdigits) {
2143 	alloclhs=decRoundOperand(lhs, set, &status);
2144 	if (alloclhs==NULL) break;
2145 	lhs=alloclhs;
2146 	}
2147       if (rhs->digits>reqdigits) {
2148 	allocrhs=decRoundOperand(rhs, set, &status);
2149 	if (allocrhs==NULL) break;
2150 	rhs=allocrhs;
2151 	}
2152       }
2153     #endif
2154     /* [following code does not require input rounding] */
2155 
2156     /* handle NaNs and rhs Infinity (lhs infinity is harder) */
2157     if (SPECIALARGS) {
2158       if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
2159 	decNaNs(res, lhs, rhs, set, &status);
2160 	break;}
2161       if (decNumberIsInfinite(rhs)) {	/* rhs Infinity */
2162 	Flag rhsneg=rhs->bits&DECNEG;	/* save rhs sign */
2163 	if (decNumberIsNegative(lhs)	/* lhs<0 */
2164 	 && !decNumberIsZero(lhs))	/* .. */
2165 	  status|=DEC_Invalid_operation;
2166 	 else {				/* lhs >=0 */
2167 	  decNumberZero(&dnOne);	/* set up 1 */
2168 	  dnOne.lsu[0]=1;
2169 	  decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
2170 	  decNumberZero(res);		/* prepare for 0/1/Infinity */
2171 	  if (decNumberIsNegative(dac)) {    /* lhs<1 */
2172 	    if (rhsneg) res->bits|=DECINF;   /* +Infinity [else is +0] */
2173 	    }
2174 	   else if (dac->lsu[0]==0) {	     /* lhs=1 */
2175 	    /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2176 	    Int shift=set->digits-1;
2177 	    *res->lsu=1;		     /* was 0, make int 1 */
2178 	    res->digits=decShiftToMost(res->lsu, 1, shift);
2179 	    res->exponent=-shift;	     /* make 1.0000... */
2180 	    status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2181 	    }
2182 	   else {			     /* lhs>1 */
2183 	    if (!rhsneg) res->bits|=DECINF;  /* +Infinity [else is +0] */
2184 	    }
2185 	  } /* lhs>=0 */
2186 	break;}
2187       /* [lhs infinity drops through] */
2188       } /* specials */
2189 
2190     /* Original rhs may be an integer that fits and is in range */
2191     n=decGetInt(rhs);
2192     if (n!=BADINT) {			/* it is an integer */
2193       rhsint=1;				/* record the fact for 1**n */
2194       isoddint=(Flag)n&1;		/* [works even if big] */
2195       if (n!=BIGEVEN && n!=BIGODD)	/* can use integer path? */
2196 	useint=1;			/* looks good */
2197       }
2198 
2199     if (decNumberIsNegative(lhs)	/* -x .. */
2200       && isoddint) bits=DECNEG;		/* .. to an odd power */
2201 
2202     /* handle LHS infinity */
2203     if (decNumberIsInfinite(lhs)) {	/* [NaNs already handled] */
2204       uByte rbits=rhs->bits;		/* save */
2205       decNumberZero(res);		/* prepare */
2206       if (n==0) *res->lsu=1;		/* [-]Inf**0 => 1 */
2207        else {
2208 	/* -Inf**nonint -> error */
2209 	if (!rhsint && decNumberIsNegative(lhs)) {
2210 	  status|=DEC_Invalid_operation;     /* -Inf**nonint is error */
2211 	  break;}
2212 	if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2213 	/* [otherwise will be 0 or -0] */
2214 	res->bits=bits;
2215 	}
2216       break;}
2217 
2218     /* similarly handle LHS zero */
2219     if (decNumberIsZero(lhs)) {
2220       if (n==0) {			     /* 0**0 => Error */
2221 	#if DECSUBSET
2222 	if (!set->extended) {		     /* [unless subset] */
2223 	  decNumberZero(res);
2224 	  *res->lsu=1;			     /* return 1 */
2225 	  break;}
2226 	#endif
2227 	status|=DEC_Invalid_operation;
2228 	}
2229        else {				     /* 0**x */
2230 	uByte rbits=rhs->bits;		     /* save */
2231 	if (rbits & DECNEG) {		     /* was a 0**(-n) */
2232 	  #if DECSUBSET
2233 	  if (!set->extended) {		     /* [bad if subset] */
2234 	    status|=DEC_Invalid_operation;
2235 	    break;}
2236 	  #endif
2237 	  bits|=DECINF;
2238 	  }
2239 	decNumberZero(res);		     /* prepare */
2240 	/* [otherwise will be 0 or -0] */
2241 	res->bits=bits;
2242 	}
2243       break;}
2244 
2245     /* here both lhs and rhs are finite; rhs==0 is handled in the */
2246     /* integer path.  Next handle the non-integer cases */
2247     if (!useint) {			/* non-integral rhs */
2248       /* any -ve lhs is bad, as is either operand or context out of */
2249       /* bounds */
2250       if (decNumberIsNegative(lhs)) {
2251 	status|=DEC_Invalid_operation;
2252 	break;}
2253       if (decCheckMath(lhs, set, &status)
2254        || decCheckMath(rhs, set, &status)) break; /* variable status */
2255 
2256       decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2257       aset.emax=DEC_MAX_MATH;		/* usual bounds */
2258       aset.emin=-DEC_MAX_MATH;		/* .. */
2259       aset.clamp=0;			/* and no concrete format */
2260 
2261       /* calculate the result using exp(ln(lhs)*rhs), which can */
2262       /* all be done into the accumulator, dac.	 The precision needed */
2263       /* is enough to contain the full information in the lhs (which */
2264       /* is the total digits, including exponent), or the requested */
2265       /* precision, if larger, + 4; 6 is used for the exponent */
2266       /* maximum length, and this is also used when it is shorter */
2267       /* than the requested digits as it greatly reduces the >0.5 ulp */
2268       /* cases at little cost (because Ln doubles digits each */
2269       /* iteration so a few extra digits rarely causes an extra */
2270       /* iteration) */
2271       aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2272       } /* non-integer rhs */
2273 
2274      else { /* rhs is in-range integer */
2275       if (n==0) {			/* x**0 = 1 */
2276 	/* (0**0 was handled above) */
2277 	decNumberZero(res);		/* result=1 */
2278 	*res->lsu=1;			/* .. */
2279 	break;}
2280       /* rhs is a non-zero integer */
2281       if (n<0) n=-n;			/* use abs(n) */
2282 
2283       aset=*set;			/* clone the context */
2284       aset.round=DEC_ROUND_HALF_EVEN;	/* internally use balanced */
2285       /* calculate the working DIGITS */
2286       aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2287       #if DECSUBSET
2288       if (!set->extended) aset.digits--;     /* use classic precision */
2289       #endif
2290       /* it's an error if this is more than can be handled */
2291       if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2292       } /* integer path */
2293 
2294     /* aset.digits is the count of digits for the accumulator needed */
2295     /* if accumulator is too long for local storage, then allocate */
2296     needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2297     /* [needbytes also used below if 1/lhs needed] */
2298     if (needbytes>sizeof(dacbuff)) {
2299       allocdac=(decNumber *)malloc(needbytes);
2300       if (allocdac==NULL) {   /* hopeless -- abandon */
2301 	status|=DEC_Insufficient_storage;
2302 	break;}
2303       dac=allocdac;	      /* use the allocated space */
2304       }
2305     /* here, aset is set up and accumulator is ready for use */
2306 
2307     if (!useint) {			     /* non-integral rhs */
2308       /* x ** y; special-case x=1 here as it will otherwise always */
2309       /* reduce to integer 1; decLnOp has a fastpath which detects */
2310       /* the case of x=1 */
2311       decLnOp(dac, lhs, &aset, &status);     /* dac=ln(lhs) */
2312       /* [no error possible, as lhs 0 already handled] */
2313       if (ISZERO(dac)) {		     /* x==1, 1.0, etc. */
2314 	/* need to return fully-padded 1.0000 etc., but rhsint->1 */
2315 	*dac->lsu=1;			     /* was 0, make int 1 */
2316 	if (!rhsint) {			     /* add padding */
2317 	  Int shift=set->digits-1;
2318 	  dac->digits=decShiftToMost(dac->lsu, 1, shift);
2319 	  dac->exponent=-shift;		     /* make 1.0000... */
2320 	  status|=DEC_Inexact|DEC_Rounded;   /* deemed inexact */
2321 	  }
2322 	}
2323        else {
2324 	decMultiplyOp(dac, dac, rhs, &aset, &status);  /* dac=dac*rhs */
2325 	decExpOp(dac, dac, &aset, &status);	       /* dac=exp(dac) */
2326 	}
2327       /* and drop through for final rounding */
2328       } /* non-integer rhs */
2329 
2330      else {				/* carry on with integer */
2331       decNumberZero(dac);		/* acc=1 */
2332       *dac->lsu=1;			/* .. */
2333 
2334       /* if a negative power the constant 1 is needed, and if not subset */
2335       /* invert the lhs now rather than inverting the result later */
2336       if (decNumberIsNegative(rhs)) {	/* was a **-n [hence digits>0] */
2337 	decNumber *inv=invbuff;		/* assume use fixed buffer */
2338 	decNumberCopy(&dnOne, dac);	/* dnOne=1;  [needed now or later] */
2339 	#if DECSUBSET
2340 	if (set->extended) {		/* need to calculate 1/lhs */
2341 	#endif
2342 	  /* divide lhs into 1, putting result in dac [dac=1/dac] */
2343 	  decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2344 	  /* now locate or allocate space for the inverted lhs */
2345 	  if (needbytes>sizeof(invbuff)) {
2346 	    allocinv=(decNumber *)malloc(needbytes);
2347 	    if (allocinv==NULL) {	/* hopeless -- abandon */
2348 	      status|=DEC_Insufficient_storage;
2349 	      break;}
2350 	    inv=allocinv;		/* use the allocated space */
2351 	    }
2352 	  /* [inv now points to big-enough buffer or allocated storage] */
2353 	  decNumberCopy(inv, dac);	/* copy the 1/lhs */
2354 	  decNumberCopy(dac, &dnOne);	/* restore acc=1 */
2355 	  lhs=inv;			/* .. and go forward with new lhs */
2356 	#if DECSUBSET
2357 	  }
2358 	#endif
2359 	}
2360 
2361       /* Raise-to-the-power loop... */
2362       seenbit=0;		   /* set once a 1-bit is encountered */
2363       for (i=1;;i++){		   /* for each bit [top bit ignored] */
2364 	/* abandon if had overflow or terminal underflow */
2365 	if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2366 	  if (status&DEC_Overflow || ISZERO(dac)) break;
2367 	  }
2368 	/* [the following two lines revealed an optimizer bug in a C++ */
2369 	/* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2370 	n=n<<1;			   /* move next bit to testable position */
2371 	if (n<0) {		   /* top bit is set */
2372 	  seenbit=1;		   /* OK, significant bit seen */
2373 	  decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2374 	  }
2375 	if (i==31) break;	   /* that was the last bit */
2376 	if (!seenbit) continue;	   /* no need to square 1 */
2377 	decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2378 	} /*i*/ /* 32 bits */
2379 
2380       /* complete internal overflow or underflow processing */
2381       if (status & (DEC_Overflow|DEC_Underflow)) {
2382 	#if DECSUBSET
2383 	/* If subset, and power was negative, reverse the kind of -erflow */
2384 	/* [1/x not yet done] */
2385 	if (!set->extended && decNumberIsNegative(rhs)) {
2386 	  if (status & DEC_Overflow)
2387 	    status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2388 	   else { /* trickier -- Underflow may or may not be set */
2389 	    status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2390 	    status|=DEC_Overflow;
2391 	    }
2392 	  }
2393 	#endif
2394 	dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2395 	/* round subnormals [to set.digits rather than aset.digits] */
2396 	/* or set overflow result similarly as required */
2397 	decFinalize(dac, set, &residue, &status);
2398 	decNumberCopy(res, dac);   /* copy to result (is now OK length) */
2399 	break;
2400 	}
2401 
2402       #if DECSUBSET
2403       if (!set->extended &&		     /* subset math */
2404 	  decNumberIsNegative(rhs)) {	     /* was a **-n [hence digits>0] */
2405 	/* so divide result into 1 [dac=1/dac] */
2406 	decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2407 	}
2408       #endif
2409       } /* rhs integer path */
2410 
2411     /* reduce result to the requested length and copy to result */
2412     decCopyFit(res, dac, set, &residue, &status);
2413     decFinish(res, set, &residue, &status);  /* final cleanup */
2414     #if DECSUBSET
2415     if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */
2416     #endif
2417     } while(0);				/* end protected */
2418 
2419   if (allocdac!=NULL) free(allocdac);	/* drop any storage used */
2420   if (allocinv!=NULL) free(allocinv);	/* .. */
2421   #if DECSUBSET
2422   if (alloclhs!=NULL) free(alloclhs);	/* .. */
2423   if (allocrhs!=NULL) free(allocrhs);	/* .. */
2424   #endif
2425   if (status!=0) decStatus(res, status, set);
2426   #if DECCHECK
2427   decCheckInexact(res, set);
2428   #endif
2429   return res;
2430   } /* decNumberPower */
2431 
2432 /* ------------------------------------------------------------------ */
2433 /* decNumberQuantize -- force exponent to requested value	      */
2434 /*								      */
2435 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2436 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2437 /*   of C has exponent of B.  The numerical value of C will equal A,  */
2438 /*   except for the effects of any rounding that occurred.	      */
2439 /*								      */
2440 /*   res is C, the result.  C may be A or B			      */
2441 /*   lhs is A, the number to adjust				      */
2442 /*   rhs is B, the number with exponent to match		      */
2443 /*   set is the context						      */
2444 /*								      */
2445 /* C must have space for set->digits digits.			      */
2446 /*								      */
2447 /* Unless there is an error or the result is infinite, the exponent   */
2448 /* after the operation is guaranteed to be equal to that of B.	      */
2449 /* ------------------------------------------------------------------ */
2450 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2451 			      const decNumber *rhs, decContext *set) {
2452   uInt status=0;			/* accumulator */
2453   decQuantizeOp(res, lhs, rhs, set, 1, &status);
2454   if (status!=0) decStatus(res, status, set);
2455   return res;
2456   } /* decNumberQuantize */
2457 
2458 /* ------------------------------------------------------------------ */
2459 /* decNumberReduce -- remove trailing zeros			      */
2460 /*								      */
2461 /*   This computes C = 0 + A, and normalizes the result		      */
2462 /*								      */
2463 /*   res is C, the result.  C may be A				      */
2464 /*   rhs is A							      */
2465 /*   set is the context						      */
2466 /*								      */
2467 /* C must have space for set->digits digits.			      */
2468 /* ------------------------------------------------------------------ */
2469 /* Previously known as Normalize */
2470 decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2471 			       decContext *set) {
2472   return decNumberReduce(res, rhs, set);
2473   } /* decNumberNormalize */
2474 
2475 decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2476 			    decContext *set) {
2477   #if DECSUBSET
2478   decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
2479   #endif
2480   uInt status=0;		   /* as usual */
2481   Int  residue=0;		   /* as usual */
2482   Int  dropped;			   /* work */
2483 
2484   #if DECCHECK
2485   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2486   #endif
2487 
2488   do {				   /* protect allocated storage */
2489     #if DECSUBSET
2490     if (!set->extended) {
2491       /* reduce operand and set lostDigits status, as needed */
2492       if (rhs->digits>set->digits) {
2493 	allocrhs=decRoundOperand(rhs, set, &status);
2494 	if (allocrhs==NULL) break;
2495 	rhs=allocrhs;
2496 	}
2497       }
2498     #endif
2499     /* [following code does not require input rounding] */
2500 
2501     /* Infinities copy through; NaNs need usual treatment */
2502     if (decNumberIsNaN(rhs)) {
2503       decNaNs(res, rhs, NULL, set, &status);
2504       break;
2505       }
2506 
2507     /* reduce result to the requested length and copy to result */
2508     decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2509     decFinish(res, set, &residue, &status);	  /* cleanup/set flags */
2510     decTrim(res, set, 1, &dropped);		  /* normalize in place */
2511     } while(0);				     /* end protected */
2512 
2513   #if DECSUBSET
2514   if (allocrhs !=NULL) free(allocrhs);	     /* .. */
2515   #endif
2516   if (status!=0) decStatus(res, status, set);/* then report status */
2517   return res;
2518   } /* decNumberReduce */
2519 
2520 /* ------------------------------------------------------------------ */
2521 /* decNumberRescale -- force exponent to requested value	      */
2522 /*								      */
2523 /*   This computes C = op(A, B), where op adjusts the coefficient     */
2524 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
2525 /*   of C has the value B.  The numerical value of C will equal A,    */
2526 /*   except for the effects of any rounding that occurred.	      */
2527 /*								      */
2528 /*   res is C, the result.  C may be A or B			      */
2529 /*   lhs is A, the number to adjust				      */
2530 /*   rhs is B, the requested exponent				      */
2531 /*   set is the context						      */
2532 /*								      */
2533 /* C must have space for set->digits digits.			      */
2534 /*								      */
2535 /* Unless there is an error or the result is infinite, the exponent   */
2536 /* after the operation is guaranteed to be equal to B.		      */
2537 /* ------------------------------------------------------------------ */
2538 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2539 			     const decNumber *rhs, decContext *set) {
2540   uInt status=0;			/* accumulator */
2541   decQuantizeOp(res, lhs, rhs, set, 0, &status);
2542   if (status!=0) decStatus(res, status, set);
2543   return res;
2544   } /* decNumberRescale */
2545 
2546 /* ------------------------------------------------------------------ */
2547 /* decNumberRemainder -- divide and return remainder		      */
2548 /*								      */
2549 /*   This computes C = A % B					      */
2550 /*								      */
2551 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)	      */
2552 /*   lhs is A							      */
2553 /*   rhs is B							      */
2554 /*   set is the context						      */
2555 /*								      */
2556 /* C must have space for set->digits digits.			      */
2557 /* ------------------------------------------------------------------ */
2558 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2559 			       const decNumber *rhs, decContext *set) {
2560   uInt status=0;			/* accumulator */
2561   decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2562   if (status!=0) decStatus(res, status, set);
2563   #if DECCHECK
2564   decCheckInexact(res, set);
2565   #endif
2566   return res;
2567   } /* decNumberRemainder */
2568 
2569 /* ------------------------------------------------------------------ */
2570 /* decNumberRemainderNear -- divide and return remainder from nearest */
2571 /*								      */
2572 /*   This computes C = A % B, where % is the IEEE remainder operator  */
2573 /*								      */
2574 /*   res is C, the result.  C may be A and/or B (e.g., X=X%X)	      */
2575 /*   lhs is A							      */
2576 /*   rhs is B							      */
2577 /*   set is the context						      */
2578 /*								      */
2579 /* C must have space for set->digits digits.			      */
2580 /* ------------------------------------------------------------------ */
2581 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2582 				   const decNumber *rhs, decContext *set) {
2583   uInt status=0;			/* accumulator */
2584   decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2585   if (status!=0) decStatus(res, status, set);
2586   #if DECCHECK
2587   decCheckInexact(res, set);
2588   #endif
2589   return res;
2590   } /* decNumberRemainderNear */
2591 
2592 /* ------------------------------------------------------------------ */
2593 /* decNumberRotate -- rotate the coefficient of a Number left/right   */
2594 /*								      */
2595 /*   This computes C = A rot B	(in base ten and rotating set->digits */
2596 /*   digits).							      */
2597 /*								      */
2598 /*   res is C, the result.  C may be A and/or B (e.g., X=XrotX)	      */
2599 /*   lhs is A							      */
2600 /*   rhs is B, the number of digits to rotate (-ve to right)	      */
2601 /*   set is the context						      */
2602 /*								      */
2603 /* The digits of the coefficient of A are rotated to the left (if B   */
2604 /* is positive) or to the right (if B is negative) without adjusting  */
2605 /* the exponent or the sign of A.  If lhs->digits is less than	      */
2606 /* set->digits the coefficient is padded with zeros on the left	      */
2607 /* before the rotate.  Any leading zeros in the result are removed    */
2608 /* as usual.							      */
2609 /*								      */
2610 /* B must be an integer (q=0) and in the range -set->digits through   */
2611 /* +set->digits.						      */
2612 /* C must have space for set->digits digits.			      */
2613 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2614 /* B must be valid).  No status is set unless B is invalid or an      */
2615 /* operand is an sNaN.						      */
2616 /* ------------------------------------------------------------------ */
2617 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2618 			   const decNumber *rhs, decContext *set) {
2619   uInt status=0;	      /* accumulator */
2620   Int  rotate;		      /* rhs as an Int */
2621 
2622   #if DECCHECK
2623   if (decCheckOperands(res, lhs, rhs, set)) return res;
2624   #endif
2625 
2626   /* NaNs propagate as normal */
2627   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2628     decNaNs(res, lhs, rhs, set, &status);
2629    /* rhs must be an integer */
2630    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2631     status=DEC_Invalid_operation;
2632    else { /* both numeric, rhs is an integer */
2633     rotate=decGetInt(rhs);		     /* [cannot fail] */
2634     if (rotate==BADINT			     /* something bad .. */
2635      || rotate==BIGODD || rotate==BIGEVEN    /* .. very big .. */
2636      || abs(rotate)>set->digits)	     /* .. or out of range */
2637       status=DEC_Invalid_operation;
2638      else {				     /* rhs is OK */
2639       decNumberCopy(res, lhs);
2640       /* convert -ve rotate to equivalent positive rotation */
2641       if (rotate<0) rotate=set->digits+rotate;
2642       if (rotate!=0 && rotate!=set->digits   /* zero or full rotation */
2643        && !decNumberIsInfinite(res)) {	     /* lhs was infinite */
2644 	/* left-rotate to do; 0 < rotate < set->digits */
2645 	uInt units, shift;		     /* work */
2646 	uInt msudigits;			     /* digits in result msu */
2647 	Unit *msu=res->lsu+D2U(res->digits)-1;	  /* current msu */
2648 	Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2649 	for (msu++; msu<=msumax; msu++) *msu=0;	  /* ensure high units=0 */
2650 	res->digits=set->digits;		  /* now full-length */
2651 	msudigits=MSUDIGITS(res->digits);	  /* actual digits in msu */
2652 
2653 	/* rotation here is done in-place, in three steps */
2654 	/* 1. shift all to least up to one unit to unit-align final */
2655 	/*    lsd [any digits shifted out are rotated to the left, */
2656 	/*    abutted to the original msd (which may require split)] */
2657 	/* */
2658 	/*    [if there are no whole units left to rotate, the */
2659 	/*    rotation is now complete] */
2660 	/* */
2661 	/* 2. shift to least, from below the split point only, so that */
2662 	/*    the final msd is in the right place in its Unit [any */
2663 	/*    digits shifted out will fit exactly in the current msu, */
2664 	/*    left aligned, no split required] */
2665 	/* */
2666 	/* 3. rotate all the units by reversing left part, right */
2667 	/*    part, and then whole */
2668 	/* */
2669 	/* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2670 	/* */
2671 	/*   start: 00a bcd efg hij klm npq */
2672 	/* */
2673 	/*	1a  000 0ab cde fgh|ijk lmn [pq saved] */
2674 	/*	1b  00p qab cde fgh|ijk lmn */
2675 	/* */
2676 	/*	2a  00p qab cde fgh|00i jkl [mn saved] */
2677 	/*	2b  mnp qab cde fgh|00i jkl */
2678 	/* */
2679 	/*	3a  fgh cde qab mnp|00i jkl */
2680 	/*	3b  fgh cde qab mnp|jkl 00i */
2681 	/*	3c  00i jkl mnp qab cde fgh */
2682 
2683 	/* Step 1: amount to shift is the partial right-rotate count */
2684 	rotate=set->digits-rotate;	/* make it right-rotate */
2685 	units=rotate/DECDPUN;		/* whole units to rotate */
2686 	shift=rotate%DECDPUN;		/* left-over digits count */
2687 	if (shift>0) {			/* not an exact number of units */
2688 	  uInt save=res->lsu[0]%powers[shift];	  /* save low digit(s) */
2689 	  decShiftToLeast(res->lsu, D2U(res->digits), shift);
2690 	  if (shift>msudigits) {	/* msumax-1 needs >0 digits */
2691 	    uInt rem=save%powers[shift-msudigits];/* split save */
2692 	    *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2693 	    *(msumax-1)=*(msumax-1)
2694 		       +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2695 	    }
2696 	   else { /* all fits in msumax */
2697 	    *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2698 	    }
2699 	  } /* digits shift needed */
2700 
2701 	/* If whole units to rotate... */
2702 	if (units>0) {			/* some to do */
2703 	  /* Step 2: the units to touch are the whole ones in rotate, */
2704 	  /*   if any, and the shift is DECDPUN-msudigits (which may be */
2705 	  /*   0, again) */
2706 	  shift=DECDPUN-msudigits;
2707 	  if (shift>0) {		/* not an exact number of units */
2708 	    uInt save=res->lsu[0]%powers[shift];  /* save low digit(s) */
2709 	    decShiftToLeast(res->lsu, units, shift);
2710 	    *msumax=*msumax+(Unit)(save*powers[msudigits]);
2711 	    } /* partial shift needed */
2712 
2713 	  /* Step 3: rotate the units array using triple reverse */
2714 	  /* (reversing is easy and fast) */
2715 	  decReverse(res->lsu+units, msumax);	  /* left part */
2716 	  decReverse(res->lsu, res->lsu+units-1); /* right part */
2717 	  decReverse(res->lsu, msumax);		  /* whole */
2718 	  } /* whole units to rotate */
2719 	/* the rotation may have left an undetermined number of zeros */
2720 	/* on the left, so true length needs to be calculated */
2721 	res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2722 	} /* rotate needed */
2723       } /* rhs OK */
2724     } /* numerics */
2725   if (status!=0) decStatus(res, status, set);
2726   return res;
2727   } /* decNumberRotate */
2728 
2729 /* ------------------------------------------------------------------ */
2730 /* decNumberSameQuantum -- test for equal exponents		      */
2731 /*								      */
2732 /*   res is the result number, which will contain either 0 or 1	      */
2733 /*   lhs is a number to test					      */
2734 /*   rhs is the second (usually a pattern)			      */
2735 /*								      */
2736 /* No errors are possible and no context is needed.		      */
2737 /* ------------------------------------------------------------------ */
2738 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2739 				 const decNumber *rhs) {
2740   Unit ret=0;			   /* return value */
2741 
2742   #if DECCHECK
2743   if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2744   #endif
2745 
2746   if (SPECIALARGS) {
2747     if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2748      else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2749      /* [anything else with a special gives 0] */
2750     }
2751    else if (lhs->exponent==rhs->exponent) ret=1;
2752 
2753   decNumberZero(res);		   /* OK to overwrite an operand now */
2754   *res->lsu=ret;
2755   return res;
2756   } /* decNumberSameQuantum */
2757 
2758 /* ------------------------------------------------------------------ */
2759 /* decNumberScaleB -- multiply by a power of 10			      */
2760 /*								      */
2761 /* This computes C = A x 10**B where B is an integer (q=0) with	      */
2762 /* maximum magnitude 2*(emax+digits)				      */
2763 /*								      */
2764 /*   res is C, the result.  C may be A or B			      */
2765 /*   lhs is A, the number to adjust				      */
2766 /*   rhs is B, the requested power of ten to use		      */
2767 /*   set is the context						      */
2768 /*								      */
2769 /* C must have space for set->digits digits.			      */
2770 /*								      */
2771 /* The result may underflow or overflow.			      */
2772 /* ------------------------------------------------------------------ */
2773 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2774 			    const decNumber *rhs, decContext *set) {
2775   Int  reqexp;		      /* requested exponent change [B] */
2776   uInt status=0;	      /* accumulator */
2777   Int  residue;		      /* work */
2778 
2779   #if DECCHECK
2780   if (decCheckOperands(res, lhs, rhs, set)) return res;
2781   #endif
2782 
2783   /* Handle special values except lhs infinite */
2784   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2785     decNaNs(res, lhs, rhs, set, &status);
2786     /* rhs must be an integer */
2787    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2788     status=DEC_Invalid_operation;
2789    else {
2790     /* lhs is a number; rhs is a finite with q==0 */
2791     reqexp=decGetInt(rhs);		     /* [cannot fail] */
2792     if (reqexp==BADINT			     /* something bad .. */
2793      || reqexp==BIGODD || reqexp==BIGEVEN    /* .. very big .. */
2794      || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2795       status=DEC_Invalid_operation;
2796      else {				     /* rhs is OK */
2797       decNumberCopy(res, lhs);		     /* all done if infinite lhs */
2798       if (!decNumberIsInfinite(res)) {	     /* prepare to scale */
2799 	res->exponent+=reqexp;		     /* adjust the exponent */
2800 	residue=0;
2801 	decFinalize(res, set, &residue, &status); /* .. and check */
2802 	} /* finite LHS */
2803       } /* rhs OK */
2804     } /* rhs finite */
2805   if (status!=0) decStatus(res, status, set);
2806   return res;
2807   } /* decNumberScaleB */
2808 
2809 /* ------------------------------------------------------------------ */
2810 /* decNumberShift -- shift the coefficient of a Number left or right  */
2811 /*								      */
2812 /*   This computes C = A << B or C = A >> -B  (in base ten).	      */
2813 /*								      */
2814 /*   res is C, the result.  C may be A and/or B (e.g., X=X<<X)	      */
2815 /*   lhs is A							      */
2816 /*   rhs is B, the number of digits to shift (-ve to right)	      */
2817 /*   set is the context						      */
2818 /*								      */
2819 /* The digits of the coefficient of A are shifted to the left (if B   */
2820 /* is positive) or to the right (if B is negative) without adjusting  */
2821 /* the exponent or the sign of A.				      */
2822 /*								      */
2823 /* B must be an integer (q=0) and in the range -set->digits through   */
2824 /* +set->digits.						      */
2825 /* C must have space for set->digits digits.			      */
2826 /* NaNs are propagated as usual.  Infinities are unaffected (but      */
2827 /* B must be valid).  No status is set unless B is invalid or an      */
2828 /* operand is an sNaN.						      */
2829 /* ------------------------------------------------------------------ */
2830 decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2831 			   const decNumber *rhs, decContext *set) {
2832   uInt status=0;	      /* accumulator */
2833   Int  shift;		      /* rhs as an Int */
2834 
2835   #if DECCHECK
2836   if (decCheckOperands(res, lhs, rhs, set)) return res;
2837   #endif
2838 
2839   /* NaNs propagate as normal */
2840   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2841     decNaNs(res, lhs, rhs, set, &status);
2842    /* rhs must be an integer */
2843    else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2844     status=DEC_Invalid_operation;
2845    else { /* both numeric, rhs is an integer */
2846     shift=decGetInt(rhs);		     /* [cannot fail] */
2847     if (shift==BADINT			     /* something bad .. */
2848      || shift==BIGODD || shift==BIGEVEN	     /* .. very big .. */
2849      || abs(shift)>set->digits)		     /* .. or out of range */
2850       status=DEC_Invalid_operation;
2851      else {				     /* rhs is OK */
2852       decNumberCopy(res, lhs);
2853       if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2854 	if (shift>0) {			     /* to left */
2855 	  if (shift==set->digits) {	     /* removing all */
2856 	    *res->lsu=0;		     /* so place 0 */
2857 	    res->digits=1;		     /* .. */
2858 	    }
2859 	   else {			     /* */
2860 	    /* first remove leading digits if necessary */
2861 	    if (res->digits+shift>set->digits) {
2862 	      decDecap(res, res->digits+shift-set->digits);
2863 	      /* that updated res->digits; may have gone to 1 (for a */
2864 	      /* single digit or for zero */
2865 	      }
2866 	    if (res->digits>1 || *res->lsu)  /* if non-zero.. */
2867 	      res->digits=decShiftToMost(res->lsu, res->digits, shift);
2868 	    } /* partial left */
2869 	  } /* left */
2870 	 else { /* to right */
2871 	  if (-shift>=res->digits) {	     /* discarding all */
2872 	    *res->lsu=0;		     /* so place 0 */
2873 	    res->digits=1;		     /* .. */
2874 	    }
2875 	   else {
2876 	    decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2877 	    res->digits-=(-shift);
2878 	    }
2879 	  } /* to right */
2880 	} /* non-0 non-Inf shift */
2881       } /* rhs OK */
2882     } /* numerics */
2883   if (status!=0) decStatus(res, status, set);
2884   return res;
2885   } /* decNumberShift */
2886 
2887 /* ------------------------------------------------------------------ */
2888 /* decNumberSquareRoot -- square root operator			      */
2889 /*								      */
2890 /*   This computes C = squareroot(A)				      */
2891 /*								      */
2892 /*   res is C, the result.  C may be A				      */
2893 /*   rhs is A							      */
2894 /*   set is the context; note that rounding mode has no effect	      */
2895 /*								      */
2896 /* C must have space for set->digits digits.			      */
2897 /* ------------------------------------------------------------------ */
2898 /* This uses the following varying-precision algorithm in:	      */
2899 /*								      */
2900 /*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
2901 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2902 /*   pp229-237, ACM, September 1985.				      */
2903 /*								      */
2904 /* The square-root is calculated using Newton's method, after which   */
2905 /* a check is made to ensure the result is correctly rounded.	      */
2906 /*								      */
2907 /* % [Reformatted original Numerical Turing source code follows.]     */
2908 /* function sqrt(x : real) : real				      */
2909 /* % sqrt(x) returns the properly rounded approximation to the square */
2910 /* % root of x, in the precision of the calling environment, or it    */
2911 /* % fails if x < 0.						      */
2912 /* % t e hull and a abrham, august, 1984			      */
2913 /* if x <= 0 then						      */
2914 /*   if x < 0 then						      */
2915 /*     assert false						      */
2916 /*   else							      */
2917 /*     result 0							      */
2918 /*   end if							      */
2919 /* end if							      */
2920 /* var f := setexp(x, 0)  % fraction part of x	 [0.1 <= x < 1]	      */
2921 /* var e := getexp(x)	  % exponent part of x			      */
2922 /* var approx : real						      */
2923 /* if e mod 2 = 0  then						      */
2924 /*   approx := .259 + .819 * f	 % approx to root of f		      */
2925 /* else								      */
2926 /*   f := f/l0			 % adjustments			      */
2927 /*   e := e + 1			 %   for odd			      */
2928 /*   approx := .0819 + 2.59 * f	 %   exponent			      */
2929 /* end if							      */
2930 /*								      */
2931 /* var p:= 3							      */
2932 /* const maxp := currentprecision + 2				      */
2933 /* loop								      */
2934 /*   p := min(2*p - 2, maxp)	 % p = 4,6,10, . . . , maxp	      */
2935 /*   precision p						      */
2936 /*   approx := .5 * (approx + f/approx)				      */
2937 /*   exit when p = maxp						      */
2938 /* end loop							      */
2939 /*								      */
2940 /* % approx is now within 1 ulp of the properly rounded square root   */
2941 /* % of f; to ensure proper rounding, compare squares of (approx -    */
2942 /* % l/2 ulp) and (approx + l/2 ulp) with f.			      */
2943 /* p := currentprecision					      */
2944 /* begin							      */
2945 /*   precision p + 2						      */
2946 /*   const approxsubhalf := approx - setexp(.5, -p)		      */
2947 /*   if mulru(approxsubhalf, approxsubhalf) > f then		      */
2948 /*     approx := approx - setexp(.l, -p + 1)			      */
2949 /*   else							      */
2950 /*     const approxaddhalf := approx + setexp(.5, -p)		      */
2951 /*     if mulrd(approxaddhalf, approxaddhalf) < f then		      */
2952 /*	 approx := approx + setexp(.l, -p + 1)			      */
2953 /*     end if							      */
2954 /*   end if							      */
2955 /* end								      */
2956 /* result setexp(approx, e div 2)  % fix exponent		      */
2957 /* end sqrt							      */
2958 /* ------------------------------------------------------------------ */
2959 decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2960 				decContext *set) {
2961   decContext workset, approxset;   /* work contexts */
2962   decNumber dzero;		   /* used for constant zero */
2963   Int  maxp;			   /* largest working precision */
2964   Int  workp;			   /* working precision */
2965   Int  residue=0;		   /* rounding residue */
2966   uInt status=0, ignore=0;	   /* status accumulators */
2967   uInt rstatus;			   /* .. */
2968   Int  exp;			   /* working exponent */
2969   Int  ideal;			   /* ideal (preferred) exponent */
2970   Int  needbytes;		   /* work */
2971   Int  dropped;			   /* .. */
2972 
2973   #if DECSUBSET
2974   decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
2975   #endif
2976   /* buffer for f [needs +1 in case DECBUFFER 0] */
2977   decNumber buff[D2N(DECBUFFER+1)];
2978   /* buffer for a [needs +2 to match likely maxp] */
2979   decNumber bufa[D2N(DECBUFFER+2)];
2980   /* buffer for temporary, b [must be same size as a] */
2981   decNumber bufb[D2N(DECBUFFER+2)];
2982   decNumber *allocbuff=NULL;	   /* -> allocated buff, iff allocated */
2983   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
2984   decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
2985   decNumber *f=buff;		   /* reduced fraction */
2986   decNumber *a=bufa;		   /* approximation to result */
2987   decNumber *b=bufb;		   /* intermediate result */
2988   /* buffer for temporary variable, up to 3 digits */
2989   decNumber buft[D2N(3)];
2990   decNumber *t=buft;		   /* up-to-3-digit constant or work */
2991 
2992   #if DECCHECK
2993   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2994   #endif
2995 
2996   do {				   /* protect allocated storage */
2997     #if DECSUBSET
2998     if (!set->extended) {
2999       /* reduce operand and set lostDigits status, as needed */
3000       if (rhs->digits>set->digits) {
3001 	allocrhs=decRoundOperand(rhs, set, &status);
3002 	if (allocrhs==NULL) break;
3003 	/* [Note: 'f' allocation below could reuse this buffer if */
3004 	/* used, but as this is rare they are kept separate for clarity.] */
3005 	rhs=allocrhs;
3006 	}
3007       }
3008     #endif
3009     /* [following code does not require input rounding] */
3010 
3011     /* handle infinities and NaNs */
3012     if (SPECIALARG) {
3013       if (decNumberIsInfinite(rhs)) {	      /* an infinity */
3014 	if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
3015 	 else decNumberCopy(res, rhs);	      /* +Infinity */
3016 	}
3017        else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3018       break;
3019       }
3020 
3021     /* calculate the ideal (preferred) exponent [floor(exp/2)] */
3022     /* [We would like to write: ideal=rhs->exponent>>1, but this */
3023     /* generates a compiler warning.  Generated code is the same.] */
3024     ideal=(rhs->exponent&~1)/2;		/* target */
3025 
3026     /* handle zeros */
3027     if (ISZERO(rhs)) {
3028       decNumberCopy(res, rhs);		/* could be 0 or -0 */
3029       res->exponent=ideal;		/* use the ideal [safe] */
3030       /* use decFinish to clamp any out-of-range exponent, etc. */
3031       decFinish(res, set, &residue, &status);
3032       break;
3033       }
3034 
3035     /* any other -x is an oops */
3036     if (decNumberIsNegative(rhs)) {
3037       status|=DEC_Invalid_operation;
3038       break;
3039       }
3040 
3041     /* space is needed for three working variables */
3042     /*	 f -- the same precision as the RHS, reduced to 0.01->0.99... */
3043     /*	 a -- Hull's approximation -- precision, when assigned, is */
3044     /*	      currentprecision+1 or the input argument precision, */
3045     /*	      whichever is larger (+2 for use as temporary) */
3046     /*	 b -- intermediate temporary result (same size as a) */
3047     /* if any is too long for local storage, then allocate */
3048     workp=MAXI(set->digits+1, rhs->digits);  /* actual rounding precision */
3049     maxp=workp+2;			     /* largest working precision */
3050 
3051     needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
3052     if (needbytes>(Int)sizeof(buff)) {
3053       allocbuff=(decNumber *)malloc(needbytes);
3054       if (allocbuff==NULL) {  /* hopeless -- abandon */
3055 	status|=DEC_Insufficient_storage;
3056 	break;}
3057       f=allocbuff;	      /* use the allocated space */
3058       }
3059     /* a and b both need to be able to hold a maxp-length number */
3060     needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
3061     if (needbytes>(Int)sizeof(bufa)) {		  /* [same applies to b] */
3062       allocbufa=(decNumber *)malloc(needbytes);
3063       allocbufb=(decNumber *)malloc(needbytes);
3064       if (allocbufa==NULL || allocbufb==NULL) {	  /* hopeless */
3065 	status|=DEC_Insufficient_storage;
3066 	break;}
3067       a=allocbufa;	      /* use the allocated spaces */
3068       b=allocbufb;	      /* .. */
3069       }
3070 
3071     /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
3072     decNumberCopy(f, rhs);
3073     exp=f->exponent+f->digits;		     /* adjusted to Hull rules */
3074     f->exponent=-(f->digits);		     /* to range */
3075 
3076     /* set up working context */
3077     decContextDefault(&workset, DEC_INIT_DECIMAL64);
3078 
3079     /* [Until further notice, no error is possible and status bits */
3080     /* (Rounded, etc.) should be ignored, not accumulated.] */
3081 
3082     /* Calculate initial approximation, and allow for odd exponent */
3083     workset.digits=workp;		     /* p for initial calculation */
3084     t->bits=0; t->digits=3;
3085     a->bits=0; a->digits=3;
3086     if ((exp & 1)==0) {			     /* even exponent */
3087       /* Set t=0.259, a=0.819 */
3088       t->exponent=-3;
3089       a->exponent=-3;
3090       #if DECDPUN>=3
3091 	t->lsu[0]=259;
3092 	a->lsu[0]=819;
3093       #elif DECDPUN==2
3094 	t->lsu[0]=59; t->lsu[1]=2;
3095 	a->lsu[0]=19; a->lsu[1]=8;
3096       #else
3097 	t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
3098 	a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
3099       #endif
3100       }
3101      else {				     /* odd exponent */
3102       /* Set t=0.0819, a=2.59 */
3103       f->exponent--;			     /* f=f/10 */
3104       exp++;				     /* e=e+1 */
3105       t->exponent=-4;
3106       a->exponent=-2;
3107       #if DECDPUN>=3
3108 	t->lsu[0]=819;
3109 	a->lsu[0]=259;
3110       #elif DECDPUN==2
3111 	t->lsu[0]=19; t->lsu[1]=8;
3112 	a->lsu[0]=59; a->lsu[1]=2;
3113       #else
3114 	t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
3115 	a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
3116       #endif
3117       }
3118     decMultiplyOp(a, a, f, &workset, &ignore);	  /* a=a*f */
3119     decAddOp(a, a, t, &workset, 0, &ignore);	  /* ..+t */
3120     /* [a is now the initial approximation for sqrt(f), calculated with */
3121     /* currentprecision, which is also a's precision.] */
3122 
3123     /* the main calculation loop */
3124     decNumberZero(&dzero);		     /* make 0 */
3125     decNumberZero(t);			     /* set t = 0.5 */
3126     t->lsu[0]=5;			     /* .. */
3127     t->exponent=-1;			     /* .. */
3128     workset.digits=3;			     /* initial p */
3129     for (;;) {
3130       /* set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp] */
3131       workset.digits=workset.digits*2-2;
3132       if (workset.digits>maxp) workset.digits=maxp;
3133       /* a = 0.5 * (a + f/a) */
3134       /* [calculated at p then rounded to currentprecision] */
3135       decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
3136       decAddOp(b, b, a, &workset, 0, &ignore);	  /* b=b+a */
3137       decMultiplyOp(a, b, t, &workset, &ignore);  /* a=b*0.5 */
3138       if (a->digits==maxp) break;	     /* have required digits */
3139       } /* loop */
3140 
3141     /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
3142     /* now reduce to length, etc.; this needs to be done with a */
3143     /* having the correct exponent so as to handle subnormals */
3144     /* correctly */
3145     approxset=*set;			     /* get emin, emax, etc. */
3146     approxset.round=DEC_ROUND_HALF_EVEN;
3147     a->exponent+=exp/2;			     /* set correct exponent */
3148 
3149     rstatus=0;				     /* clear status */
3150     residue=0;				     /* .. and accumulator */
3151     decCopyFit(a, a, &approxset, &residue, &rstatus);  /* reduce (if needed) */
3152     decFinish(a, &approxset, &residue, &rstatus);      /* clean and finalize */
3153 
3154     /* Overflow was possible if the input exponent was out-of-range, */
3155     /* in which case quit */
3156     if (rstatus&DEC_Overflow) {
3157       status=rstatus;			     /* use the status as-is */
3158       decNumberCopy(res, a);		     /* copy to result */
3159       break;
3160       }
3161 
3162     /* Preserve status except Inexact/Rounded */
3163     status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3164 
3165     /* Carry out the Hull correction */
3166     a->exponent-=exp/2;			     /* back to 0.1->1 */
3167 
3168     /* a is now at final precision and within 1 ulp of the properly */
3169     /* rounded square root of f; to ensure proper rounding, compare */
3170     /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3171     /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3172     /* the ulp */
3173     workset.digits--;				  /* maxp-1 is OK now */
3174     t->exponent=-a->digits-1;			  /* make 0.5 ulp */
3175     decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3176     workset.round=DEC_ROUND_UP;
3177     decMultiplyOp(b, b, b, &workset, &ignore);	  /* b = mulru(b, b) */
3178     decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3179     if (decNumberIsNegative(b)) {		  /* f < b [i.e., b > f] */
3180       /* this is the more common adjustment, though both are rare */
3181       t->exponent++;				  /* make 1.0 ulp */
3182       t->lsu[0]=1;				  /* .. */
3183       decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3184       /* assign to approx [round to length] */
3185       approxset.emin-=exp/2;			  /* adjust to match a */
3186       approxset.emax-=exp/2;
3187       decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3188       }
3189      else {
3190       decAddOp(b, a, t, &workset, 0, &ignore);	  /* b = a + 0.5 ulp */
3191       workset.round=DEC_ROUND_DOWN;
3192       decMultiplyOp(b, b, b, &workset, &ignore);  /* b = mulrd(b, b) */
3193       decCompareOp(b, b, f, &workset, COMPARE, &ignore);   /* b ? f */
3194       if (decNumberIsNegative(b)) {		  /* b < f */
3195 	t->exponent++;				  /* make 1.0 ulp */
3196 	t->lsu[0]=1;				  /* .. */
3197 	decAddOp(a, a, t, &workset, 0, &ignore);  /* a = a + 1 ulp */
3198 	/* assign to approx [round to length] */
3199 	approxset.emin-=exp/2;			  /* adjust to match a */
3200 	approxset.emax-=exp/2;
3201 	decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3202 	}
3203       }
3204     /* [no errors are possible in the above, and rounding/inexact during */
3205     /* estimation are irrelevant, so status was not accumulated] */
3206 
3207     /* Here, 0.1 <= a < 1  (still), so adjust back */
3208     a->exponent+=exp/2;			     /* set correct exponent */
3209 
3210     /* count droppable zeros [after any subnormal rounding] by */
3211     /* trimming a copy */
3212     decNumberCopy(b, a);
3213     decTrim(b, set, 1, &dropped);	     /* [drops trailing zeros] */
3214 
3215     /* Set Inexact and Rounded.	 The answer can only be exact if */
3216     /* it is short enough so that squaring it could fit in workp digits, */
3217     /* and it cannot have trailing zeros due to clamping, so these are */
3218     /* the only (relatively rare) conditions a careful check is needed */
3219     if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */
3220       status|=DEC_Inexact|DEC_Rounded;
3221       }
3222      else {				     /* could be exact/unrounded */
3223       uInt mstatus=0;			     /* local status */
3224       decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3225       if (mstatus&DEC_Overflow) {	     /* result just won't fit */
3226 	status|=DEC_Inexact|DEC_Rounded;
3227 	}
3228        else {				     /* plausible */
3229 	decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3230 	if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3231 	 else {				     /* is Exact */
3232 	  /* here, dropped is the count of trailing zeros in 'a' */
3233 	  /* use closest exponent to ideal... */
3234 	  Int todrop=ideal-a->exponent;	     /* most that can be dropped */
3235 	  if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3236 	   else {			     /* unrounded */
3237 	    if (dropped<todrop) {	     /* clamp to those available */
3238 	      todrop=dropped;
3239 	      status|=DEC_Clamped;
3240 	      }
3241 	    if (todrop>0) {		     /* have some to drop */
3242 	      decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3243 	      a->exponent+=todrop;	     /* maintain numerical value */
3244 	      a->digits-=todrop;	     /* new length */
3245 	      }
3246 	    }
3247 	  }
3248 	}
3249       }
3250 
3251     /* double-check Underflow, as perhaps the result could not have */
3252     /* been subnormal (initial argument too big), or it is now Exact */
3253     if (status&DEC_Underflow) {
3254       Int ae=rhs->exponent+rhs->digits-1;    /* adjusted exponent */
3255       /* check if truly subnormal */
3256       #if DECEXTFLAG			     /* DEC_Subnormal too */
3257 	if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3258       #else
3259 	if (ae>=set->emin*2) status&=~DEC_Underflow;
3260       #endif
3261       /* check if truly inexact */
3262       if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3263       }
3264 
3265     decNumberCopy(res, a);		     /* a is now the result */
3266     } while(0);				     /* end protected */
3267 
3268   if (allocbuff!=NULL) free(allocbuff);	     /* drop any storage used */
3269   if (allocbufa!=NULL) free(allocbufa);	     /* .. */
3270   if (allocbufb!=NULL) free(allocbufb);	     /* .. */
3271   #if DECSUBSET
3272   if (allocrhs !=NULL) free(allocrhs);	     /* .. */
3273   #endif
3274   if (status!=0) decStatus(res, status, set);/* then report status */
3275   #if DECCHECK
3276   decCheckInexact(res, set);
3277   #endif
3278   return res;
3279   } /* decNumberSquareRoot */
3280 
3281 /* ------------------------------------------------------------------ */
3282 /* decNumberSubtract -- subtract two Numbers			      */
3283 /*								      */
3284 /*   This computes C = A - B					      */
3285 /*								      */
3286 /*   res is C, the result.  C may be A and/or B (e.g., X=X-X)	      */
3287 /*   lhs is A							      */
3288 /*   rhs is B							      */
3289 /*   set is the context						      */
3290 /*								      */
3291 /* C must have space for set->digits digits.			      */
3292 /* ------------------------------------------------------------------ */
3293 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3294 			      const decNumber *rhs, decContext *set) {
3295   uInt status=0;			/* accumulator */
3296 
3297   decAddOp(res, lhs, rhs, set, DECNEG, &status);
3298   if (status!=0) decStatus(res, status, set);
3299   #if DECCHECK
3300   decCheckInexact(res, set);
3301   #endif
3302   return res;
3303   } /* decNumberSubtract */
3304 
3305 /* ------------------------------------------------------------------ */
3306 /* decNumberToIntegralExact -- round-to-integral-value with InExact   */
3307 /* decNumberToIntegralValue -- round-to-integral-value		      */
3308 /*								      */
3309 /*   res is the result						      */
3310 /*   rhs is input number					      */
3311 /*   set is the context						      */
3312 /*								      */
3313 /* res must have space for any value of rhs.			      */
3314 /*								      */
3315 /* This implements the IEEE special operators and therefore treats    */
3316 /* special values as valid.  For finite numbers it returns	      */
3317 /* rescale(rhs, 0) if rhs->exponent is <0.			      */
3318 /* Otherwise the result is rhs (so no error is possible, except for   */
3319 /* sNaN).							      */
3320 /*								      */
3321 /* The context is used for rounding mode and status after sNaN, but   */
3322 /* the digits setting is ignored.  The Exact version will signal      */
3323 /* Inexact if the result differs numerically from rhs; the other      */
3324 /* never signals Inexact.					      */
3325 /* ------------------------------------------------------------------ */
3326 decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3327 				     decContext *set) {
3328   decNumber dn;
3329   decContext workset;		   /* working context */
3330   uInt status=0;		   /* accumulator */
3331 
3332   #if DECCHECK
3333   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3334   #endif
3335 
3336   /* handle infinities and NaNs */
3337   if (SPECIALARG) {
3338     if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3339      else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3340     }
3341    else { /* finite */
3342     /* have a finite number; no error possible (res must be big enough) */
3343     if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3344     /* that was easy, but if negative exponent there is work to do... */
3345     workset=*set;		   /* clone rounding, etc. */
3346     workset.digits=rhs->digits;	   /* no length rounding */
3347     workset.traps=0;		   /* no traps */
3348     decNumberZero(&dn);		   /* make a number with exponent 0 */
3349     decNumberQuantize(res, rhs, &dn, &workset);
3350     status|=workset.status;
3351     }
3352   if (status!=0) decStatus(res, status, set);
3353   return res;
3354   } /* decNumberToIntegralExact */
3355 
3356 decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3357 				     decContext *set) {
3358   decContext workset=*set;	   /* working context */
3359   workset.traps=0;		   /* no traps */
3360   decNumberToIntegralExact(res, rhs, &workset);
3361   /* this never affects set, except for sNaNs; NaN will have been set */
3362   /* or propagated already, so no need to call decStatus */
3363   set->status|=workset.status&DEC_Invalid_operation;
3364   return res;
3365   } /* decNumberToIntegralValue */
3366 
3367 /* ------------------------------------------------------------------ */
3368 /* decNumberXor -- XOR two Numbers, digitwise			      */
3369 /*								      */
3370 /*   This computes C = A ^ B					      */
3371 /*								      */
3372 /*   res is C, the result.  C may be A and/or B (e.g., X=X^X)	      */
3373 /*   lhs is A							      */
3374 /*   rhs is B							      */
3375 /*   set is the context (used for result length and error report)     */
3376 /*								      */
3377 /* C must have space for set->digits digits.			      */
3378 /*								      */
3379 /* Logical function restrictions apply (see above); a NaN is	      */
3380 /* returned with Invalid_operation if a restriction is violated.      */
3381 /* ------------------------------------------------------------------ */
3382 decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3383 			 const decNumber *rhs, decContext *set) {
3384   const Unit *ua, *ub;			/* -> operands */
3385   const Unit *msua, *msub;		/* -> operand msus */
3386   Unit	*uc, *msuc;			/* -> result and its msu */
3387   Int	msudigs;			/* digits in res msu */
3388   #if DECCHECK
3389   if (decCheckOperands(res, lhs, rhs, set)) return res;
3390   #endif
3391 
3392   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3393    || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3394     decStatus(res, DEC_Invalid_operation, set);
3395     return res;
3396     }
3397   /* operands are valid */
3398   ua=lhs->lsu;				/* bottom-up */
3399   ub=rhs->lsu;				/* .. */
3400   uc=res->lsu;				/* .. */
3401   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
3402   msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
3403   msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
3404   msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
3405   for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
3406     Unit a, b;				/* extract units */
3407     if (ua>msua) a=0;
3408      else a=*ua;
3409     if (ub>msub) b=0;
3410      else b=*ub;
3411     *uc=0;				/* can now write back */
3412     if (a|b) {				/* maybe 1 bits to examine */
3413       Int i, j;
3414       /* This loop could be unrolled and/or use BIN2BCD tables */
3415       for (i=0; i<DECDPUN; i++) {
3416 	if ((a^b)&1) *uc=*uc+(Unit)powers[i];	  /* effect XOR */
3417 	j=a%10;
3418 	a=a/10;
3419 	j|=b%10;
3420 	b=b/10;
3421 	if (j>1) {
3422 	  decStatus(res, DEC_Invalid_operation, set);
3423 	  return res;
3424 	  }
3425 	if (uc==msuc && i==msudigs-1) break;	  /* just did final digit */
3426 	} /* each digit */
3427       } /* non-zero */
3428     } /* each unit */
3429   /* [here uc-1 is the msu of the result] */
3430   res->digits=decGetDigits(res->lsu, uc-res->lsu);
3431   res->exponent=0;			/* integer */
3432   res->bits=0;				/* sign=0 */
3433   return res;  /* [no status to set] */
3434   } /* decNumberXor */
3435 
3436 
3437 /* ================================================================== */
3438 /* Utility routines						      */
3439 /* ================================================================== */
3440 
3441 /* ------------------------------------------------------------------ */
3442 /* decNumberClass -- return the decClass of a decNumber		      */
3443 /*   dn -- the decNumber to test				      */
3444 /*   set -- the context to use for Emin				      */
3445 /*   returns the decClass enum					      */
3446 /* ------------------------------------------------------------------ */
3447 enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3448   if (decNumberIsSpecial(dn)) {
3449     if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3450     if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3451     /* must be an infinity */
3452     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3453     return DEC_CLASS_POS_INF;
3454     }
3455   /* is finite */
3456   if (decNumberIsNormal(dn, set)) { /* most common */
3457     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3458     return DEC_CLASS_POS_NORMAL;
3459     }
3460   /* is subnormal or zero */
3461   if (decNumberIsZero(dn)) {	/* most common */
3462     if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3463     return DEC_CLASS_POS_ZERO;
3464     }
3465   if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3466   return DEC_CLASS_POS_SUBNORMAL;
3467   } /* decNumberClass */
3468 
3469 /* ------------------------------------------------------------------ */
3470 /* decNumberClassToString -- convert decClass to a string	      */
3471 /*								      */
3472 /*  eclass is a valid decClass					      */
3473 /*  returns a constant string describing the class (max 13+1 chars)   */
3474 /* ------------------------------------------------------------------ */
3475 const char *decNumberClassToString(enum decClass eclass) {
3476   if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
3477   if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
3478   if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
3479   if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
3480   if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3481   if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3482   if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
3483   if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
3484   if (eclass==DEC_CLASS_QNAN)	       return DEC_ClassString_QN;
3485   if (eclass==DEC_CLASS_SNAN)	       return DEC_ClassString_SN;
3486   return DEC_ClassString_UN;	       /* Unknown */
3487   } /* decNumberClassToString */
3488 
3489 /* ------------------------------------------------------------------ */
3490 /* decNumberCopy -- copy a number				      */
3491 /*								      */
3492 /*   dest is the target decNumber				      */
3493 /*   src  is the source decNumber				      */
3494 /*   returns dest						      */
3495 /*								      */
3496 /* (dest==src is allowed and is a no-op)			      */
3497 /* All fields are updated as required.	This is a utility operation,  */
3498 /* so special values are unchanged and no error is possible.	      */
3499 /* ------------------------------------------------------------------ */
3500 decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3501 
3502   #if DECCHECK
3503   if (src==NULL) return decNumberZero(dest);
3504   #endif
3505 
3506   if (dest==src) return dest;		     /* no copy required */
3507 
3508   /* Use explicit assignments here as structure assignment could copy */
3509   /* more than just the lsu (for small DECDPUN).  This would not affect */
3510   /* the value of the results, but could disturb test harness spill */
3511   /* checking. */
3512   dest->bits=src->bits;
3513   dest->exponent=src->exponent;
3514   dest->digits=src->digits;
3515   dest->lsu[0]=src->lsu[0];
3516   if (src->digits>DECDPUN) {		     /* more Units to come */
3517     const Unit *smsup, *s;		     /* work */
3518     Unit  *d;				     /* .. */
3519     /* memcpy for the remaining Units would be safe as they cannot */
3520     /* overlap.	 However, this explicit loop is faster in short cases. */
3521     d=dest->lsu+1;			     /* -> first destination */
3522     smsup=src->lsu+D2U(src->digits);	     /* -> source msu+1 */
3523     for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3524     }
3525   return dest;
3526   } /* decNumberCopy */
3527 
3528 /* ------------------------------------------------------------------ */
3529 /* decNumberCopyAbs -- quiet absolute value operator		      */
3530 /*								      */
3531 /*   This sets C = abs(A)					      */
3532 /*								      */
3533 /*   res is C, the result.  C may be A				      */
3534 /*   rhs is A							      */
3535 /*								      */
3536 /* C must have space for set->digits digits.			      */
3537 /* No exception or error can occur; this is a quiet bitwise operation.*/
3538 /* See also decNumberAbs for a checking version of this.	      */
3539 /* ------------------------------------------------------------------ */
3540 decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3541   #if DECCHECK
3542   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3543   #endif
3544   decNumberCopy(res, rhs);
3545   res->bits&=~DECNEG;			/* turn off sign */
3546   return res;
3547   } /* decNumberCopyAbs */
3548 
3549 /* ------------------------------------------------------------------ */
3550 /* decNumberCopyNegate -- quiet negate value operator		      */
3551 /*								      */
3552 /*   This sets C = negate(A)					      */
3553 /*								      */
3554 /*   res is C, the result.  C may be A				      */
3555 /*   rhs is A							      */
3556 /*								      */
3557 /* C must have space for set->digits digits.			      */
3558 /* No exception or error can occur; this is a quiet bitwise operation.*/
3559 /* See also decNumberMinus for a checking version of this.	      */
3560 /* ------------------------------------------------------------------ */
3561 decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3562   #if DECCHECK
3563   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3564   #endif
3565   decNumberCopy(res, rhs);
3566   res->bits^=DECNEG;			/* invert the sign */
3567   return res;
3568   } /* decNumberCopyNegate */
3569 
3570 /* ------------------------------------------------------------------ */
3571 /* decNumberCopySign -- quiet copy and set sign operator	      */
3572 /*								      */
3573 /*   This sets C = A with the sign of B				      */
3574 /*								      */
3575 /*   res is C, the result.  C may be A				      */
3576 /*   lhs is A							      */
3577 /*   rhs is B							      */
3578 /*								      */
3579 /* C must have space for set->digits digits.			      */
3580 /* No exception or error can occur; this is a quiet bitwise operation.*/
3581 /* ------------------------------------------------------------------ */
3582 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3583 			      const decNumber *rhs) {
3584   uByte sign;				/* rhs sign */
3585   #if DECCHECK
3586   if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3587   #endif
3588   sign=rhs->bits & DECNEG;		/* save sign bit */
3589   decNumberCopy(res, lhs);
3590   res->bits&=~DECNEG;			/* clear the sign */
3591   res->bits|=sign;			/* set from rhs */
3592   return res;
3593   } /* decNumberCopySign */
3594 
3595 /* ------------------------------------------------------------------ */
3596 /* decNumberGetBCD -- get the coefficient in BCD8		      */
3597 /*   dn is the source decNumber					      */
3598 /*   bcd is the uInt array that will receive dn->digits BCD bytes,    */
3599 /*     most-significant at offset 0				      */
3600 /*   returns bcd						      */
3601 /*								      */
3602 /* bcd must have at least dn->digits bytes.  No error is possible; if */
3603 /* dn is a NaN or Infinite, digits must be 1 and the coefficient 0.   */
3604 /* ------------------------------------------------------------------ */
3605 uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) {
3606   uByte *ub=bcd+dn->digits-1;	   /* -> lsd */
3607   const Unit *up=dn->lsu;	   /* Unit pointer, -> lsu */
3608 
3609   #if DECDPUN==1		   /* trivial simple copy */
3610     for (; ub>=bcd; ub--, up++) *ub=*up;
3611   #else				   /* chopping needed */
3612     uInt u=*up;			   /* work */
3613     uInt cut=DECDPUN;		   /* downcounter through unit */
3614     for (; ub>=bcd; ub--) {
3615       *ub=(uByte)(u%10);	   /* [*6554 trick inhibits, here] */
3616       u=u/10;
3617       cut--;
3618       if (cut>0) continue;	   /* more in this unit */
3619       up++;
3620       u=*up;
3621       cut=DECDPUN;
3622       }
3623   #endif
3624   return bcd;
3625   } /* decNumberGetBCD */
3626 
3627 /* ------------------------------------------------------------------ */
3628 /* decNumberSetBCD -- set (replace) the coefficient from BCD8	      */
3629 /*   dn is the target decNumber					      */
3630 /*   bcd is the uInt array that will source n BCD bytes, most-	      */
3631 /*     significant at offset 0					      */
3632 /*   n is the number of digits in the source BCD array (bcd)	      */
3633 /*   returns dn							      */
3634 /*								      */
3635 /* dn must have space for at least n digits.  No error is possible;   */
3636 /* if dn is a NaN, or Infinite, or is to become a zero, n must be 1   */
3637 /* and bcd[0] zero.						      */
3638 /* ------------------------------------------------------------------ */
3639 decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3640   Unit *up = dn->lsu + D2U(n) - 1;      /* -> msu [target pointer] */
3641   const uByte *ub=bcd;			/* -> source msd */
3642 
3643   #if DECDPUN==1			/* trivial simple copy */
3644     for (; ub<bcd+n; ub++, up--) *up=*ub;
3645   #else					/* some assembly needed */
3646     /* calculate how many digits in msu, and hence first cut */
3647     Int cut=MSUDIGITS(n);		/* [faster than remainder] */
3648     for (;up>=dn->lsu; up--) {		/* each Unit from msu */
3649       *up=0;				/* will take <=DECDPUN digits */
3650       for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3651       cut=DECDPUN;			/* next Unit has all digits */
3652       }
3653   #endif
3654   dn->digits=n;				/* set digit count */
3655   return dn;
3656   } /* decNumberSetBCD */
3657 
3658 /* ------------------------------------------------------------------ */
3659 /* decNumberIsNormal -- test normality of a decNumber		      */
3660 /*   dn is the decNumber to test				      */
3661 /*   set is the context to use for Emin				      */
3662 /*   returns 1 if |dn| is finite and >=Nmin, 0 otherwise	      */
3663 /* ------------------------------------------------------------------ */
3664 Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3665   Int ae;				/* adjusted exponent */
3666   #if DECCHECK
3667   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3668   #endif
3669 
3670   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3671   if (decNumberIsZero(dn)) return 0;	/* not non-zero */
3672 
3673   ae=dn->exponent+dn->digits-1;		/* adjusted exponent */
3674   if (ae<set->emin) return 0;		/* is subnormal */
3675   return 1;
3676   } /* decNumberIsNormal */
3677 
3678 /* ------------------------------------------------------------------ */
3679 /* decNumberIsSubnormal -- test subnormality of a decNumber	      */
3680 /*   dn is the decNumber to test				      */
3681 /*   set is the context to use for Emin				      */
3682 /*   returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise    */
3683 /* ------------------------------------------------------------------ */
3684 Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3685   Int ae;				/* adjusted exponent */
3686   #if DECCHECK
3687   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3688   #endif
3689 
3690   if (decNumberIsSpecial(dn)) return 0; /* not finite */
3691   if (decNumberIsZero(dn)) return 0;	/* not non-zero */
3692 
3693   ae=dn->exponent+dn->digits-1;		/* adjusted exponent */
3694   if (ae<set->emin) return 1;		/* is subnormal */
3695   return 0;
3696   } /* decNumberIsSubnormal */
3697 
3698 /* ------------------------------------------------------------------ */
3699 /* decNumberTrim -- remove insignificant zeros			      */
3700 /*								      */
3701 /*   dn is the number to trim					      */
3702 /*   returns dn							      */
3703 /*								      */
3704 /* All fields are updated as required.	This is a utility operation,  */
3705 /* so special values are unchanged and no error is possible.	      */
3706 /* ------------------------------------------------------------------ */
3707 decNumber * decNumberTrim(decNumber *dn) {
3708   Int  dropped;			   /* work */
3709   decContext set;		   /* .. */
3710   #if DECCHECK
3711   if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3712   #endif
3713   decContextDefault(&set, DEC_INIT_BASE);    /* clamp=0 */
3714   return decTrim(dn, &set, 0, &dropped);
3715   } /* decNumberTrim */
3716 
3717 /* ------------------------------------------------------------------ */
3718 /* decNumberVersion -- return the name and version of this module     */
3719 /*								      */
3720 /* No error is possible.					      */
3721 /* ------------------------------------------------------------------ */
3722 const char * decNumberVersion(void) {
3723   return DECVERSION;
3724   } /* decNumberVersion */
3725 
3726 /* ------------------------------------------------------------------ */
3727 /* decNumberZero -- set a number to 0				      */
3728 /*								      */
3729 /*   dn is the number to set, with space for one digit		      */
3730 /*   returns dn							      */
3731 /*								      */
3732 /* No error is possible.					      */
3733 /* ------------------------------------------------------------------ */
3734 /* Memset is not used as it is much slower in some environments. */
3735 decNumber * decNumberZero(decNumber *dn) {
3736 
3737   #if DECCHECK
3738   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3739   #endif
3740 
3741   dn->bits=0;
3742   dn->exponent=0;
3743   dn->digits=1;
3744   dn->lsu[0]=0;
3745   return dn;
3746   } /* decNumberZero */
3747 
3748 /* ================================================================== */
3749 /* Local routines						      */
3750 /* ================================================================== */
3751 
3752 /* ------------------------------------------------------------------ */
3753 /* decToString -- lay out a number into a string		      */
3754 /*								      */
3755 /*   dn	    is the number to lay out				      */
3756 /*   string is where to lay out the number			      */
3757 /*   eng    is 1 if Engineering, 0 if Scientific		      */
3758 /*								      */
3759 /* string must be at least dn->digits+14 characters long	      */
3760 /* No error is possible.					      */
3761 /*								      */
3762 /* Note that this routine can generate a -0 or 0.000.  These are      */
3763 /* never generated in subset to-number or arithmetic, but can occur   */
3764 /* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).	      */
3765 /* ------------------------------------------------------------------ */
3766 /* If DECCHECK is enabled the string "?" is returned if a number is */
3767 /* invalid. */
3768 static void decToString(const decNumber *dn, char *string, Flag eng) {
3769   Int exp=dn->exponent;	      /* local copy */
3770   Int e;		      /* E-part value */
3771   Int pre;		      /* digits before the '.' */
3772   Int cut;		      /* for counting digits in a Unit */
3773   char *c=string;	      /* work [output pointer] */
3774   const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3775   uInt u, pow;		      /* work */
3776 
3777   #if DECCHECK
3778   if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3779     strcpy(string, "?");
3780     return;}
3781   #endif
3782 
3783   if (decNumberIsNegative(dn)) {   /* Negatives get a minus */
3784     *c='-';
3785     c++;
3786     }
3787   if (dn->bits&DECSPECIAL) {	   /* Is a special value */
3788     if (decNumberIsInfinite(dn)) {
3789       strcpy(c,	  "Inf");
3790       strcpy(c+3, "inity");
3791       return;}
3792     /* a NaN */
3793     if (dn->bits&DECSNAN) {	   /* signalling NaN */
3794       *c='s';
3795       c++;
3796       }
3797     strcpy(c, "NaN");
3798     c+=3;			   /* step past */
3799     /* if not a clean non-zero coefficient, that's all there is in a */
3800     /* NaN string */
3801     if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3802     /* [drop through to add integer] */
3803     }
3804 
3805   /* calculate how many digits in msu, and hence first cut */
3806   cut=MSUDIGITS(dn->digits);	   /* [faster than remainder] */
3807   cut--;			   /* power of ten for digit */
3808 
3809   if (exp==0) {			   /* simple integer [common fastpath] */
3810     for (;up>=dn->lsu; up--) {	   /* each Unit from msu */
3811       u=*up;			   /* contains DECDPUN digits to lay out */
3812       for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3813       cut=DECDPUN-1;		   /* next Unit has all digits */
3814       }
3815     *c='\0';			   /* terminate the string */
3816     return;}
3817 
3818   /* non-0 exponent -- assume plain form */
3819   pre=dn->digits+exp;		   /* digits before '.' */
3820   e=0;				   /* no E */
3821   if ((exp>0) || (pre<-5)) {	   /* need exponential form */
3822     e=exp+dn->digits-1;		   /* calculate E value */
3823     pre=1;			   /* assume one digit before '.' */
3824     if (eng && (e!=0)) {	   /* engineering: may need to adjust */
3825       Int adj;			   /* adjustment */
3826       /* The C remainder operator is undefined for negative numbers, so */
3827       /* a positive remainder calculation must be used here */
3828       if (e<0) {
3829 	adj=(-e)%3;
3830 	if (adj!=0) adj=3-adj;
3831 	}
3832        else { /* e>0 */
3833 	adj=e%3;
3834 	}
3835       e=e-adj;
3836       /* if dealing with zero still produce an exponent which is a */
3837       /* multiple of three, as expected, but there will only be the */
3838       /* one zero before the E, still.	Otherwise note the padding. */
3839       if (!ISZERO(dn)) pre+=adj;
3840        else {  /* is zero */
3841 	if (adj!=0) {		   /* 0.00Esnn needed */
3842 	  e=e+3;
3843 	  pre=-(2-adj);
3844 	  }
3845 	} /* zero */
3846       } /* eng */
3847     } /* need exponent */
3848 
3849   /* lay out the digits of the coefficient, adding 0s and . as needed */
3850   u=*up;
3851   if (pre>0) {			   /* xxx.xxx or xx00 (engineering) form */
3852     Int n=pre;
3853     for (; pre>0; pre--, c++, cut--) {
3854       if (cut<0) {		   /* need new Unit */
3855 	if (up==dn->lsu) break;	   /* out of input digits (pre>digits) */
3856 	up--;
3857 	cut=DECDPUN-1;
3858 	u=*up;
3859 	}
3860       TODIGIT(u, cut, c, pow);
3861       }
3862     if (n<dn->digits) {		   /* more to come, after '.' */
3863       *c='.'; c++;
3864       for (;; c++, cut--) {
3865 	if (cut<0) {		   /* need new Unit */
3866 	  if (up==dn->lsu) break;  /* out of input digits */
3867 	  up--;
3868 	  cut=DECDPUN-1;
3869 	  u=*up;
3870 	  }
3871 	TODIGIT(u, cut, c, pow);
3872 	}
3873       }
3874      else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3875     }
3876    else {			   /* 0.xxx or 0.000xxx form */
3877     *c='0'; c++;
3878     *c='.'; c++;
3879     for (; pre<0; pre++, c++) *c='0';	/* add any 0's after '.' */
3880     for (; ; c++, cut--) {
3881       if (cut<0) {		   /* need new Unit */
3882 	if (up==dn->lsu) break;	   /* out of input digits */
3883 	up--;
3884 	cut=DECDPUN-1;
3885 	u=*up;
3886 	}
3887       TODIGIT(u, cut, c, pow);
3888       }
3889     }
3890 
3891   /* Finally add the E-part, if needed.	 It will never be 0, has a
3892      base maximum and minimum of +999999999 through -999999999, but
3893      could range down to -1999999998 for anormal numbers */
3894   if (e!=0) {
3895     Flag had=0;		      /* 1=had non-zero */
3896     *c='E'; c++;
3897     *c='+'; c++;	      /* assume positive */
3898     u=e;		      /* .. */
3899     if (e<0) {
3900       *(c-1)='-';	      /* oops, need - */
3901       u=-e;		      /* uInt, please */
3902       }
3903     /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3904     for (cut=9; cut>=0; cut--) {
3905       TODIGIT(u, cut, c, pow);
3906       if (*c=='0' && !had) continue;	/* skip leading zeros */
3907       had=1;				/* had non-0 */
3908       c++;				/* step for next */
3909       } /* cut */
3910     }
3911   *c='\0';	    /* terminate the string (all paths) */
3912   return;
3913   } /* decToString */
3914 
3915 /* ------------------------------------------------------------------ */
3916 /* decAddOp -- add/subtract operation				      */
3917 /*								      */
3918 /*   This computes C = A + B					      */
3919 /*								      */
3920 /*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
3921 /*   lhs is A							      */
3922 /*   rhs is B							      */
3923 /*   set is the context						      */
3924 /*   negate is DECNEG if rhs should be negated, or 0 otherwise	      */
3925 /*   status accumulates status for the caller			      */
3926 /*								      */
3927 /* C must have space for set->digits digits.			      */
3928 /* Inexact in status must be 0 for correct Exact zero sign in result  */
3929 /* ------------------------------------------------------------------ */
3930 /* If possible, the coefficient is calculated directly into C.	      */
3931 /* However, if:							      */
3932 /*   -- a digits+1 calculation is needed because the numbers are      */
3933 /*	unaligned and span more than set->digits digits		      */
3934 /*   -- a carry to digits+1 digits looks possible		      */
3935 /*   -- C is the same as A or B, and the result would destructively   */
3936 /*	overlap the A or B coefficient				      */
3937 /* then the result must be calculated into a temporary buffer.	In    */
3938 /* this case a local (stack) buffer is used if possible, and only if  */
3939 /* too long for that does malloc become the final resort.	      */
3940 /*								      */
3941 /* Misalignment is handled as follows:				      */
3942 /*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
3943 /*   BPad: Apply the padding by a combination of shifting (whole      */
3944 /*	   units) and multiplication (part units).		      */
3945 /*								      */
3946 /* Addition, especially x=x+1, is speed-critical.		      */
3947 /* The static buffer is larger than might be expected to allow for    */
3948 /* calls from higher-level functions (notably exp).		      */
3949 /* ------------------------------------------------------------------ */
3950 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3951 			    const decNumber *rhs, decContext *set,
3952 			    uByte negate, uInt *status) {
3953   #if DECSUBSET
3954   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
3955   decNumber *allocrhs=NULL;	   /* .., rhs */
3956   #endif
3957   Int	rhsshift;		   /* working shift (in Units) */
3958   Int	maxdigits;		   /* longest logical length */
3959   Int	mult;			   /* multiplier */
3960   Int	residue;		   /* rounding accumulator */
3961   uByte bits;			   /* result bits */
3962   Flag	diffsign;		   /* non-0 if arguments have different sign */
3963   Unit	*acc;			   /* accumulator for result */
3964   Unit	accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3965 				   /* allocations when called from */
3966 				   /* other operations, notable exp] */
3967   Unit	*allocacc=NULL;		   /* -> allocated acc buffer, iff allocated */
3968   Int	reqdigits=set->digits;	   /* local copy; requested DIGITS */
3969   Int	padding;		   /* work */
3970 
3971   #if DECCHECK
3972   if (decCheckOperands(res, lhs, rhs, set)) return res;
3973   #endif
3974 
3975   do {				   /* protect allocated storage */
3976     #if DECSUBSET
3977     if (!set->extended) {
3978       /* reduce operands and set lostDigits status, as needed */
3979       if (lhs->digits>reqdigits) {
3980 	alloclhs=decRoundOperand(lhs, set, status);
3981 	if (alloclhs==NULL) break;
3982 	lhs=alloclhs;
3983 	}
3984       if (rhs->digits>reqdigits) {
3985 	allocrhs=decRoundOperand(rhs, set, status);
3986 	if (allocrhs==NULL) break;
3987 	rhs=allocrhs;
3988 	}
3989       }
3990     #endif
3991     /* [following code does not require input rounding] */
3992 
3993     /* note whether signs differ [used all paths] */
3994     diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3995 
3996     /* handle infinities and NaNs */
3997     if (SPECIALARGS) {			/* a special bit set */
3998       if (SPECIALARGS & (DECSNAN | DECNAN))  /* a NaN */
3999 	decNaNs(res, lhs, rhs, set, status);
4000        else { /* one or two infinities */
4001 	if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
4002 	  /* two infinities with different signs is invalid */
4003 	  if (decNumberIsInfinite(rhs) && diffsign) {
4004 	    *status|=DEC_Invalid_operation;
4005 	    break;
4006 	    }
4007 	  bits=lhs->bits & DECNEG;	/* get sign from LHS */
4008 	  }
4009 	 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
4010 	bits|=DECINF;
4011 	decNumberZero(res);
4012 	res->bits=bits;			/* set +/- infinity */
4013 	} /* an infinity */
4014       break;
4015       }
4016 
4017     /* Quick exit for add 0s; return the non-0, modified as need be */
4018     if (ISZERO(lhs)) {
4019       Int adjust;			/* work */
4020       Int lexp=lhs->exponent;		/* save in case LHS==RES */
4021       bits=lhs->bits;			/* .. */
4022       residue=0;			/* clear accumulator */
4023       decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
4024       res->bits^=negate;		/* flip if rhs was negated */
4025       #if DECSUBSET
4026       if (set->extended) {		/* exponents on zeros count */
4027       #endif
4028 	/* exponent will be the lower of the two */
4029 	adjust=lexp-res->exponent;	/* adjustment needed [if -ve] */
4030 	if (ISZERO(res)) {		/* both 0: special IEEE 854 rules */
4031 	  if (adjust<0) res->exponent=lexp;  /* set exponent */
4032 	  /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
4033 	  if (diffsign) {
4034 	    if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
4035 	     else res->bits=DECNEG;	/* preserve 0 sign */
4036 	    }
4037 	  }
4038 	 else { /* non-0 res */
4039 	  if (adjust<0) {     /* 0-padding needed */
4040 	    if ((res->digits-adjust)>set->digits) {
4041 	      adjust=res->digits-set->digits;	  /* to fit exactly */
4042 	      *status|=DEC_Rounded;		  /* [but exact] */
4043 	      }
4044 	    res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
4045 	    res->exponent+=adjust;		  /* set the exponent. */
4046 	    }
4047 	  } /* non-0 res */
4048       #if DECSUBSET
4049 	} /* extended */
4050       #endif
4051       decFinish(res, set, &residue, status);	  /* clean and finalize */
4052       break;}
4053 
4054     if (ISZERO(rhs)) {			/* [lhs is non-zero] */
4055       Int adjust;			/* work */
4056       Int rexp=rhs->exponent;		/* save in case RHS==RES */
4057       bits=rhs->bits;			/* be clean */
4058       residue=0;			/* clear accumulator */
4059       decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
4060       #if DECSUBSET
4061       if (set->extended) {		/* exponents on zeros count */
4062       #endif
4063 	/* exponent will be the lower of the two */
4064 	/* [0-0 case handled above] */
4065 	adjust=rexp-res->exponent;	/* adjustment needed [if -ve] */
4066 	if (adjust<0) {	    /* 0-padding needed */
4067 	  if ((res->digits-adjust)>set->digits) {
4068 	    adjust=res->digits-set->digits;	/* to fit exactly */
4069 	    *status|=DEC_Rounded;		/* [but exact] */
4070 	    }
4071 	  res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
4072 	  res->exponent+=adjust;		/* set the exponent. */
4073 	  }
4074       #if DECSUBSET
4075 	} /* extended */
4076       #endif
4077       decFinish(res, set, &residue, status);	  /* clean and finalize */
4078       break;}
4079 
4080     /* [NB: both fastpath and mainpath code below assume these cases */
4081     /* (notably 0-0) have already been handled] */
4082 
4083     /* calculate the padding needed to align the operands */
4084     padding=rhs->exponent-lhs->exponent;
4085 
4086     /* Fastpath cases where the numbers are aligned and normal, the RHS */
4087     /* is all in one unit, no operand rounding is needed, and no carry, */
4088     /* lengthening, or borrow is needed */
4089     if (padding==0
4090 	&& rhs->digits<=DECDPUN
4091 	&& rhs->exponent>=set->emin	/* [some normals drop through] */
4092 	&& rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
4093 	&& rhs->digits<=reqdigits
4094 	&& lhs->digits<=reqdigits) {
4095       Int partial=*lhs->lsu;
4096       if (!diffsign) {			/* adding */
4097 	partial+=*rhs->lsu;
4098 	if ((partial<=DECDPUNMAX)	/* result fits in unit */
4099 	 && (lhs->digits>=DECDPUN ||	/* .. and no digits-count change */
4100 	     partial<(Int)powers[lhs->digits])) { /* .. */
4101 	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4102 	  *res->lsu=(Unit)partial;	/* [copy could have overwritten RHS] */
4103 	  break;
4104 	  }
4105 	/* else drop out for careful add */
4106 	}
4107        else {				/* signs differ */
4108 	partial-=*rhs->lsu;
4109 	if (partial>0) { /* no borrow needed, and non-0 result */
4110 	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4111 	  *res->lsu=(Unit)partial;
4112 	  /* this could have reduced digits [but result>0] */
4113 	  res->digits=decGetDigits(res->lsu, D2U(res->digits));
4114 	  break;
4115 	  }
4116 	/* else drop out for careful subtract */
4117 	}
4118       }
4119 
4120     /* Now align (pad) the lhs or rhs so they can be added or */
4121     /* subtracted, as necessary.  If one number is much larger than */
4122     /* the other (that is, if in plain form there is a least one */
4123     /* digit between the lowest digit of one and the highest of the */
4124     /* other) padding with up to DIGITS-1 trailing zeros may be */
4125     /* needed; then apply rounding (as exotic rounding modes may be */
4126     /* affected by the residue). */
4127     rhsshift=0;		      /* rhs shift to left (padding) in Units */
4128     bits=lhs->bits;	      /* assume sign is that of LHS */
4129     mult=1;		      /* likely multiplier */
4130 
4131     /* [if padding==0 the operands are aligned; no padding is needed] */
4132     if (padding!=0) {
4133       /* some padding needed; always pad the RHS, as any required */
4134       /* padding can then be effected by a simple combination of */
4135       /* shifts and a multiply */
4136       Flag swapped=0;
4137       if (padding<0) {			/* LHS needs the padding */
4138 	const decNumber *t;
4139 	padding=-padding;		/* will be +ve */
4140 	bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
4141 	t=lhs; lhs=rhs; rhs=t;
4142 	swapped=1;
4143 	}
4144 
4145       /* If, after pad, rhs would be longer than lhs by digits+1 or */
4146       /* more then lhs cannot affect the answer, except as a residue, */
4147       /* so only need to pad up to a length of DIGITS+1. */
4148       if (rhs->digits+padding > lhs->digits+reqdigits+1) {
4149 	/* The RHS is sufficient */
4150 	/* for residue use the relative sign indication... */
4151 	Int shift=reqdigits-rhs->digits;     /* left shift needed */
4152 	residue=1;			     /* residue for rounding */
4153 	if (diffsign) residue=-residue;	     /* signs differ */
4154 	/* copy, shortening if necessary */
4155 	decCopyFit(res, rhs, set, &residue, status);
4156 	/* if it was already shorter, then need to pad with zeros */
4157 	if (shift>0) {
4158 	  res->digits=decShiftToMost(res->lsu, res->digits, shift);
4159 	  res->exponent-=shift;		     /* adjust the exponent. */
4160 	  }
4161 	/* flip the result sign if unswapped and rhs was negated */
4162 	if (!swapped) res->bits^=negate;
4163 	decFinish(res, set, &residue, status);	  /* done */
4164 	break;}
4165 
4166       /* LHS digits may affect result */
4167       rhsshift=D2U(padding+1)-1;	/* this much by Unit shift .. */
4168       mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4169       } /* padding needed */
4170 
4171     if (diffsign) mult=-mult;		/* signs differ */
4172 
4173     /* determine the longer operand */
4174     maxdigits=rhs->digits+padding;	/* virtual length of RHS */
4175     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4176 
4177     /* Decide on the result buffer to use; if possible place directly */
4178     /* into result. */
4179     acc=res->lsu;			/* assume add direct to result */
4180     /* If destructive overlap, or the number is too long, or a carry or */
4181     /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4182     /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4183     if ((maxdigits>=reqdigits)		/* is, or could be, too large */
4184      || (res==rhs && rhsshift>0)) {	/* destructive overlap */
4185       /* buffer needed, choose it; units for maxdigits digits will be */
4186       /* needed, +1 Unit for carry or borrow */
4187       Int need=D2U(maxdigits)+1;
4188       acc=accbuff;			/* assume use local buffer */
4189       if (need*sizeof(Unit)>sizeof(accbuff)) {
4190 	/* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4191 	allocacc=(Unit *)malloc(need*sizeof(Unit));
4192 	if (allocacc==NULL) {		/* hopeless -- abandon */
4193 	  *status|=DEC_Insufficient_storage;
4194 	  break;}
4195 	acc=allocacc;
4196 	}
4197       }
4198 
4199     res->bits=(uByte)(bits&DECNEG);	/* it's now safe to overwrite.. */
4200     res->exponent=lhs->exponent;	/* .. operands (even if aliased) */
4201 
4202     #if DECTRACE
4203       decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4204       decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4205       printf("	:h: %ld %ld\n", rhsshift, mult);
4206     #endif
4207 
4208     /* add [A+B*m] or subtract [A+B*(-m)] */
4209     res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4210 			      rhs->lsu, D2U(rhs->digits),
4211 			      rhsshift, acc, mult)
4212 	       *DECDPUN;	   /* [units -> digits] */
4213     if (res->digits<0) {	   /* borrowed... */
4214       res->digits=-res->digits;
4215       res->bits^=DECNEG;	   /* flip the sign */
4216       }
4217     #if DECTRACE
4218       decDumpAr('+', acc, D2U(res->digits));
4219     #endif
4220 
4221     /* If a buffer was used the result must be copied back, possibly */
4222     /* shortening.  (If no buffer was used then the result must have */
4223     /* fit, so can't need rounding and residue must be 0.) */
4224     residue=0;			   /* clear accumulator */
4225     if (acc!=res->lsu) {
4226       #if DECSUBSET
4227       if (set->extended) {	   /* round from first significant digit */
4228       #endif
4229 	/* remove leading zeros that were added due to rounding up to */
4230 	/* integral Units -- before the test for rounding. */
4231 	if (res->digits>reqdigits)
4232 	  res->digits=decGetDigits(acc, D2U(res->digits));
4233 	decSetCoeff(res, set, acc, res->digits, &residue, status);
4234       #if DECSUBSET
4235 	}
4236        else { /* subset arithmetic rounds from original significant digit */
4237 	/* May have an underestimate.  This only occurs when both */
4238 	/* numbers fit in DECDPUN digits and are padding with a */
4239 	/* negative multiple (-10, -100...) and the top digit(s) become */
4240 	/* 0.  (This only matters when using X3.274 rules where the */
4241 	/* leading zero could be included in the rounding.) */
4242 	if (res->digits<maxdigits) {
4243 	  *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4244 	  res->digits=maxdigits;
4245 	  }
4246 	 else {
4247 	  /* remove leading zeros that added due to rounding up to */
4248 	  /* integral Units (but only those in excess of the original */
4249 	  /* maxdigits length, unless extended) before test for rounding. */
4250 	  if (res->digits>reqdigits) {
4251 	    res->digits=decGetDigits(acc, D2U(res->digits));
4252 	    if (res->digits<maxdigits) res->digits=maxdigits;
4253 	    }
4254 	  }
4255 	decSetCoeff(res, set, acc, res->digits, &residue, status);
4256 	/* Now apply rounding if needed before removing leading zeros. */
4257 	/* This is safe because subnormals are not a possibility */
4258 	if (residue!=0) {
4259 	  decApplyRound(res, set, residue, status);
4260 	  residue=0;		     /* did what needed to be done */
4261 	  }
4262 	} /* subset */
4263       #endif
4264       } /* used buffer */
4265 
4266     /* strip leading zeros [these were left on in case of subset subtract] */
4267     res->digits=decGetDigits(res->lsu, D2U(res->digits));
4268 
4269     /* apply checks and rounding */
4270     decFinish(res, set, &residue, status);
4271 
4272     /* "When the sum of two operands with opposite signs is exactly */
4273     /* zero, the sign of that sum shall be '+' in all rounding modes */
4274     /* except round toward -Infinity, in which mode that sign shall be */
4275     /* '-'."  [Subset zeros also never have '-', set by decFinish.] */
4276     if (ISZERO(res) && diffsign
4277      #if DECSUBSET
4278      && set->extended
4279      #endif
4280      && (*status&DEC_Inexact)==0) {
4281       if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   /* sign - */
4282 				  else res->bits&=~DECNEG;  /* sign + */
4283       }
4284     } while(0);				     /* end protected */
4285 
4286   if (allocacc!=NULL) free(allocacc);	     /* drop any storage used */
4287   #if DECSUBSET
4288   if (allocrhs!=NULL) free(allocrhs);	     /* .. */
4289   if (alloclhs!=NULL) free(alloclhs);	     /* .. */
4290   #endif
4291   return res;
4292   } /* decAddOp */
4293 
4294 /* ------------------------------------------------------------------ */
4295 /* decDivideOp -- division operation				      */
4296 /*								      */
4297 /*  This routine performs the calculations for all four division      */
4298 /*  operators (divide, divideInteger, remainder, remainderNear).      */
4299 /*								      */
4300 /*  C=A op B							      */
4301 /*								      */
4302 /*   res is C, the result.  C may be A and/or B (e.g., X=X/X)	      */
4303 /*   lhs is A							      */
4304 /*   rhs is B							      */
4305 /*   set is the context						      */
4306 /*   op	 is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
4307 /*   status is the usual accumulator				      */
4308 /*								      */
4309 /* C must have space for set->digits digits.			      */
4310 /*								      */
4311 /* ------------------------------------------------------------------ */
4312 /*   The underlying algorithm of this routine is the same as in the   */
4313 /*   1981 S/370 implementation, that is, non-restoring long division  */
4314 /*   with bi-unit (rather than bi-digit) estimation for each unit     */
4315 /*   multiplier.  In this pseudocode overview, complications for the  */
4316 /*   Remainder operators and division residues for exact rounding are */
4317 /*   omitted for clarity.					      */
4318 /*								      */
4319 /*     Prepare operands and handle special values		      */
4320 /*     Test for x/0 and then 0/x				      */
4321 /*     Exp =Exp1 - Exp2						      */
4322 /*     Exp =Exp +len(var1) -len(var2)				      */
4323 /*     Sign=Sign1 * Sign2					      */
4324 /*     Pad accumulator (Var1) to double-length with 0's (pad1)	      */
4325 /*     Pad Var2 to same length as Var1				      */
4326 /*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
4327 /*     have=0							      */
4328 /*     Do until (have=digits+1 OR residue=0)			      */
4329 /*	 if exp<0 then if integer divide/residue then leave	      */
4330 /*	 this_unit=0						      */
4331 /*	 Do forever						      */
4332 /*	    compare numbers					      */
4333 /*	    if <0 then leave inner_loop				      */
4334 /*	    if =0 then (* quick exit without subtract *) do	      */
4335 /*	       this_unit=this_unit+1; output this_unit		      */
4336 /*	       leave outer_loop; end				      */
4337 /*	    Compare lengths of numbers (mantissae):		      */
4338 /*	    If same then tops2=msu2pair -- {units 1&2 of var2}	      */
4339 /*		    else tops2=msu2plus -- {0, unit 1 of var2}	      */
4340 /*	    tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4341 /*	    mult=tops1/tops2  -- Good and safe guess at divisor	      */
4342 /*	    if mult=0 then mult=1				      */
4343 /*	    this_unit=this_unit+mult				      */
4344 /*	    subtract						      */
4345 /*	    end inner_loop					      */
4346 /*	  if have\=0 | this_unit\=0 then do			      */
4347 /*	    output this_unit					      */
4348 /*	    have=have+1; end					      */
4349 /*	  var2=var2/10						      */
4350 /*	  exp=exp-1						      */
4351 /*	  end outer_loop					      */
4352 /*     exp=exp+1   -- set the proper exponent			      */
4353 /*     if have=0 then generate answer=0				      */
4354 /*     Return (Result is defined by Var1)			      */
4355 /*								      */
4356 /* ------------------------------------------------------------------ */
4357 /* Two working buffers are needed during the division; one (digits+   */
4358 /* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
4359 /* long subtractions.  These are acc and var1 respectively.	      */
4360 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4361 /* The static buffers may be larger than might be expected to allow   */
4362 /* for calls from higher-level functions (notably exp).		      */
4363 /* ------------------------------------------------------------------ */
4364 static decNumber * decDivideOp(decNumber *res,
4365 			       const decNumber *lhs, const decNumber *rhs,
4366 			       decContext *set, Flag op, uInt *status) {
4367   #if DECSUBSET
4368   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
4369   decNumber *allocrhs=NULL;	   /* .., rhs */
4370   #endif
4371   Unit	accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4372   Unit	*acc=accbuff;		   /* -> accumulator array for result */
4373   Unit	*allocacc=NULL;		   /* -> allocated buffer, iff allocated */
4374   Unit	*accnext;		   /* -> where next digit will go */
4375   Int	acclength;		   /* length of acc needed [Units] */
4376   Int	accunits;		   /* count of units accumulated */
4377   Int	accdigits;		   /* count of digits accumulated */
4378 
4379   Unit	varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */
4380   Unit	*var1=varbuff;		   /* -> var1 array for long subtraction */
4381   Unit	*varalloc=NULL;		   /* -> allocated buffer, iff used */
4382   Unit	*msu1;			   /* -> msu of var1 */
4383 
4384   const Unit *var2;		   /* -> var2 array */
4385   const Unit *msu2;		   /* -> msu of var2 */
4386   Int	msu2plus;		   /* msu2 plus one [does not vary] */
4387   eInt	msu2pair;		   /* msu2 pair plus one [does not vary] */
4388 
4389   Int	var1units, var2units;	   /* actual lengths */
4390   Int	var2ulen;		   /* logical length (units) */
4391   Int	var1initpad=0;		   /* var1 initial padding (digits) */
4392   Int	maxdigits;		   /* longest LHS or required acc length */
4393   Int	mult;			   /* multiplier for subtraction */
4394   Unit	thisunit;		   /* current unit being accumulated */
4395   Int	residue;		   /* for rounding */
4396   Int	reqdigits=set->digits;	   /* requested DIGITS */
4397   Int	exponent;		   /* working exponent */
4398   Int	maxexponent=0;		   /* DIVIDE maximum exponent if unrounded */
4399   uByte bits;			   /* working sign */
4400   Unit	*target;		   /* work */
4401   const Unit *source;		   /* .. */
4402   uLong const *pow;                /* .. */
4403   Int	shift, cut;		   /* .. */
4404   #if DECSUBSET
4405   Int	dropped;		   /* work */
4406   #endif
4407 
4408   #if DECCHECK
4409   if (decCheckOperands(res, lhs, rhs, set)) return res;
4410   #endif
4411 
4412   do {				   /* protect allocated storage */
4413     #if DECSUBSET
4414     if (!set->extended) {
4415       /* reduce operands and set lostDigits status, as needed */
4416       if (lhs->digits>reqdigits) {
4417 	alloclhs=decRoundOperand(lhs, set, status);
4418 	if (alloclhs==NULL) break;
4419 	lhs=alloclhs;
4420 	}
4421       if (rhs->digits>reqdigits) {
4422 	allocrhs=decRoundOperand(rhs, set, status);
4423 	if (allocrhs==NULL) break;
4424 	rhs=allocrhs;
4425 	}
4426       }
4427     #endif
4428     /* [following code does not require input rounding] */
4429 
4430     bits=(lhs->bits^rhs->bits)&DECNEG;	/* assumed sign for divisions */
4431 
4432     /* handle infinities and NaNs */
4433     if (SPECIALARGS) {			/* a special bit set */
4434       if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4435 	decNaNs(res, lhs, rhs, set, status);
4436 	break;
4437 	}
4438       /* one or two infinities */
4439       if (decNumberIsInfinite(lhs)) {	/* LHS (dividend) is infinite */
4440 	if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4441 	    op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4442 	  *status|=DEC_Invalid_operation;
4443 	  break;
4444 	  }
4445 	/* [Note that infinity/0 raises no exceptions] */
4446 	decNumberZero(res);
4447 	res->bits=bits|DECINF;		/* set +/- infinity */
4448 	break;
4449 	}
4450        else {				/* RHS (divisor) is infinite */
4451 	residue=0;
4452 	if (op&(REMAINDER|REMNEAR)) {
4453 	  /* result is [finished clone of] lhs */
4454 	  decCopyFit(res, lhs, set, &residue, status);
4455 	  }
4456 	 else {	 /* a division */
4457 	  decNumberZero(res);
4458 	  res->bits=bits;		/* set +/- zero */
4459 	  /* for DIVIDEINT the exponent is always 0.  For DIVIDE, result */
4460 	  /* is a 0 with infinitely negative exponent, clamped to minimum */
4461 	  if (op&DIVIDE) {
4462 	    res->exponent=set->emin-set->digits+1;
4463 	    *status|=DEC_Clamped;
4464 	    }
4465 	  }
4466 	decFinish(res, set, &residue, status);
4467 	break;
4468 	}
4469       }
4470 
4471     /* handle 0 rhs (x/0) */
4472     if (ISZERO(rhs)) {			/* x/0 is always exceptional */
4473       if (ISZERO(lhs)) {
4474 	decNumberZero(res);		/* [after lhs test] */
4475 	*status|=DEC_Division_undefined;/* 0/0 will become NaN */
4476 	}
4477        else {
4478 	decNumberZero(res);
4479 	if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4480 	 else {
4481 	  *status|=DEC_Division_by_zero; /* x/0 */
4482 	  res->bits=bits|DECINF;	 /* .. is +/- Infinity */
4483 	  }
4484 	}
4485       break;}
4486 
4487     /* handle 0 lhs (0/x) */
4488     if (ISZERO(lhs)) {			/* 0/x [x!=0] */
4489       #if DECSUBSET
4490       if (!set->extended) decNumberZero(res);
4491        else {
4492       #endif
4493 	if (op&DIVIDE) {
4494 	  residue=0;
4495 	  exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4496 	  decNumberCopy(res, lhs);	/* [zeros always fit] */
4497 	  res->bits=bits;		/* sign as computed */
4498 	  res->exponent=exponent;	/* exponent, too */
4499 	  decFinalize(res, set, &residue, status);   /* check exponent */
4500 	  }
4501 	 else if (op&DIVIDEINT) {
4502 	  decNumberZero(res);		/* integer 0 */
4503 	  res->bits=bits;		/* sign as computed */
4504 	  }
4505 	 else {				/* a remainder */
4506 	  exponent=rhs->exponent;	/* [save in case overwrite] */
4507 	  decNumberCopy(res, lhs);	/* [zeros always fit] */
4508 	  if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4509 	  }
4510       #if DECSUBSET
4511 	}
4512       #endif
4513       break;}
4514 
4515     /* Precalculate exponent.  This starts off adjusted (and hence fits */
4516     /* in 31 bits) and becomes the usual unadjusted exponent as the */
4517     /* division proceeds.  The order of evaluation is important, here, */
4518     /* to avoid wrap. */
4519     exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4520 
4521     /* If the working exponent is -ve, then some quick exits are */
4522     /* possible because the quotient is known to be <1 */
4523     /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4524     if (exponent<0 && !(op==DIVIDE)) {
4525       if (op&DIVIDEINT) {
4526 	decNumberZero(res);		     /* integer part is 0 */
4527 	#if DECSUBSET
4528 	if (set->extended)
4529 	#endif
4530 	  res->bits=bits;		     /* set +/- zero */
4531 	break;}
4532       /* fastpath remainders so long as the lhs has the smaller */
4533       /* (or equal) exponent */
4534       if (lhs->exponent<=rhs->exponent) {
4535 	if (op&REMAINDER || exponent<-1) {
4536 	  /* It is REMAINDER or safe REMNEAR; result is [finished */
4537 	  /* clone of] lhs  (r = x - 0*y) */
4538 	  residue=0;
4539 	  decCopyFit(res, lhs, set, &residue, status);
4540 	  decFinish(res, set, &residue, status);
4541 	  break;
4542 	  }
4543 	/* [unsafe REMNEAR drops through] */
4544 	}
4545       } /* fastpaths */
4546 
4547     /* Long (slow) division is needed; roll up the sleeves... */
4548 
4549     /* The accumulator will hold the quotient of the division. */
4550     /* If it needs to be too long for stack storage, then allocate. */
4551     acclength=D2U(reqdigits+DECDPUN);	/* in Units */
4552     if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4553       /* printf("malloc dvacc %ld units\n", acclength); */
4554       allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4555       if (allocacc==NULL) {		/* hopeless -- abandon */
4556 	*status|=DEC_Insufficient_storage;
4557 	break;}
4558       acc=allocacc;			/* use the allocated space */
4559       }
4560 
4561     /* var1 is the padded LHS ready for subtractions. */
4562     /* If it needs to be too long for stack storage, then allocate. */
4563     /* The maximum units needed for var1 (long subtraction) is: */
4564     /* Enough for */
4565     /*	   (rhs->digits+reqdigits-1) -- to allow full slide to right */
4566     /* or  (lhs->digits)	     -- to allow for long lhs */
4567     /* whichever is larger */
4568     /*	 +1		   -- for rounding of slide to right */
4569     /*	 +1		   -- for leading 0s */
4570     /*	 +1		   -- for pre-adjust if a remainder or DIVIDEINT */
4571     /* [Note: unused units do not participate in decUnitAddSub data] */
4572     maxdigits=rhs->digits+reqdigits-1;
4573     if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4574     var1units=D2U(maxdigits)+2;
4575     /* allocate a guard unit above msu1 for REMAINDERNEAR */
4576     if (!(op&DIVIDE)) var1units++;
4577     if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4578       /* printf("malloc dvvar %ld units\n", var1units+1); */
4579       varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4580       if (varalloc==NULL) {		/* hopeless -- abandon */
4581 	*status|=DEC_Insufficient_storage;
4582 	break;}
4583       var1=varalloc;			/* use the allocated space */
4584       }
4585 
4586     /* Extend the lhs and rhs to full long subtraction length.	The lhs */
4587     /* is truly extended into the var1 buffer, with 0 padding, so a */
4588     /* subtract in place is always possible.  The rhs (var2) has */
4589     /* virtual padding (implemented by decUnitAddSub). */
4590     /* One guard unit was allocated above msu1 for rem=rem+rem in */
4591     /* REMAINDERNEAR. */
4592     msu1=var1+var1units-1;		/* msu of var1 */
4593     source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4594     for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4595     for (; target>=var1; target--) *target=0;
4596 
4597     /* rhs (var2) is left-aligned with var1 at the start */
4598     var2ulen=var1units;			/* rhs logical length (units) */
4599     var2units=D2U(rhs->digits);		/* rhs actual length (units) */
4600     var2=rhs->lsu;			/* -> rhs array */
4601     msu2=var2+var2units-1;		/* -> msu of var2 [never changes] */
4602     /* now set up the variables which will be used for estimating the */
4603     /* multiplication factor.  If these variables are not exact, add */
4604     /* 1 to make sure that the multiplier is never overestimated. */
4605     msu2plus=*msu2;			/* it's value .. */
4606     if (var2units>1) msu2plus++;	/* .. +1 if any more */
4607     msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4608     if (var2units>1) {			/* .. [else treat 2nd as 0] */
4609       msu2pair+=*(msu2-1);		/* .. */
4610       if (var2units>2) msu2pair++;	/* .. +1 if any more */
4611       }
4612 
4613     /* The calculation is working in units, which may have leading zeros, */
4614     /* but the exponent was calculated on the assumption that they are */
4615     /* both left-aligned.  Adjust the exponent to compensate: add the */
4616     /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4617     /* [This is actually done by counting the digits and negating, as */
4618     /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4619     for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4620     for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4621 
4622     /* Now, if doing an integer divide or remainder, ensure that */
4623     /* the result will be Unit-aligned.	 To do this, shift the var1 */
4624     /* accumulator towards least if need be.  (It's much easier to */
4625     /* do this now than to reassemble the residue afterwards, if */
4626     /* doing a remainder.)  Also ensure the exponent is not negative. */
4627     if (!(op&DIVIDE)) {
4628       Unit *u;				/* work */
4629       /* save the initial 'false' padding of var1, in digits */
4630       var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4631       /* Determine the shift to do. */
4632       if (exponent<0) cut=-exponent;
4633        else cut=DECDPUN-exponent%DECDPUN;
4634       decShiftToLeast(var1, var1units, cut);
4635       exponent+=cut;			/* maintain numerical value */
4636       var1initpad-=cut;			/* .. and reduce padding */
4637       /* clean any most-significant units which were just emptied */
4638       for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4639       } /* align */
4640      else { /* is DIVIDE */
4641       maxexponent=lhs->exponent-rhs->exponent;	  /* save */
4642       /* optimization: if the first iteration will just produce 0, */
4643       /* preadjust to skip it [valid for DIVIDE only] */
4644       if (*msu1<*msu2) {
4645 	var2ulen--;			/* shift down */
4646 	exponent-=DECDPUN;		/* update the exponent */
4647 	}
4648       }
4649 
4650     /* ---- start the long-division loops ------------------------------ */
4651     accunits=0;				/* no units accumulated yet */
4652     accdigits=0;			/* .. or digits */
4653     accnext=acc+acclength-1;		/* -> msu of acc [NB: allows digits+1] */
4654     for (;;) {				/* outer forever loop */
4655       thisunit=0;			/* current unit assumed 0 */
4656       /* find the next unit */
4657       for (;;) {			/* inner forever loop */
4658 	/* strip leading zero units [from either pre-adjust or from */
4659 	/* subtract last time around].	Leave at least one unit. */
4660 	for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4661 
4662 	if (var1units<var2ulen) break;	     /* var1 too low for subtract */
4663 	if (var1units==var2ulen) {	     /* unit-by-unit compare needed */
4664 	  /* compare the two numbers, from msu */
4665 	  const Unit *pv1, *pv2;
4666 	  Unit v2;			     /* units to compare */
4667 	  pv2=msu2;			     /* -> msu */
4668 	  for (pv1=msu1; ; pv1--, pv2--) {
4669 	    /* v1=*pv1 -- always OK */
4670 	    v2=0;			     /* assume in padding */
4671 	    if (pv2>=var2) v2=*pv2;	     /* in range */
4672 	    if (*pv1!=v2) break;	     /* no longer the same */
4673 	    if (pv1==var1) break;	     /* done; leave pv1 as is */
4674 	    }
4675 	  /* here when all inspected or a difference seen */
4676 	  if (*pv1<v2) break;		     /* var1 too low to subtract */
4677 	  if (*pv1==v2) {		     /* var1 == var2 */
4678 	    /* reach here if var1 and var2 are identical; subtraction */
4679 	    /* would increase digit by one, and the residue will be 0 so */
4680 	    /* the calculation is done; leave the loop with residue=0. */
4681 	    thisunit++;			     /* as though subtracted */
4682 	    *var1=0;			     /* set var1 to 0 */
4683 	    var1units=1;		     /* .. */
4684 	    break;  /* from inner */
4685 	    } /* var1 == var2 */
4686 	  /* *pv1>v2.  Prepare for real subtraction; the lengths are equal */
4687 	  /* Estimate the multiplier (there's always a msu1-1)... */
4688 	  /* Bring in two units of var2 to provide a good estimate. */
4689 	  mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4690 	  } /* lengths the same */
4691 	 else { /* var1units > var2ulen, so subtraction is safe */
4692 	  /* The var2 msu is one unit towards the lsu of the var1 msu, */
4693 	  /* so only one unit for var2 can be used. */
4694 	  mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4695 	  }
4696 	if (mult==0) mult=1;		     /* must always be at least 1 */
4697 	/* subtraction needed; var1 is > var2 */
4698 	thisunit=(Unit)(thisunit+mult);	     /* accumulate */
4699 	/* subtract var1-var2, into var1; only the overlap needs */
4700 	/* processing, as this is an in-place calculation */
4701 	shift=var2ulen-var2units;
4702 	#if DECTRACE
4703 	  decDumpAr('1', &var1[shift], var1units-shift);
4704 	  decDumpAr('2', var2, var2units);
4705 	  printf("m=%ld\n", -mult);
4706 	#endif
4707 	decUnitAddSub(&var1[shift], var1units-shift,
4708 		      var2, var2units, 0,
4709 		      &var1[shift], -mult);
4710 	#if DECTRACE
4711 	  decDumpAr('#', &var1[shift], var1units-shift);
4712 	#endif
4713 	/* var1 now probably has leading zeros; these are removed at the */
4714 	/* top of the inner loop. */
4715 	} /* inner loop */
4716 
4717       /* The next unit has been calculated in full; unless it's a */
4718       /* leading zero, add to acc */
4719       if (accunits!=0 || thisunit!=0) {	     /* is first or non-zero */
4720 	*accnext=thisunit;		     /* store in accumulator */
4721 	/* account exactly for the new digits */
4722 	if (accunits==0) {
4723 	  accdigits++;			     /* at least one */
4724 	  for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4725 	  }
4726 	 else accdigits+=DECDPUN;
4727 	accunits++;			     /* update count */
4728 	accnext--;			     /* ready for next */
4729 	if (accdigits>reqdigits) break;	     /* have enough digits */
4730 	}
4731 
4732       /* if the residue is zero, the operation is done (unless divide */
4733       /* or divideInteger and still not enough digits yet) */
4734       if (*var1==0 && var1units==1) {	     /* residue is 0 */
4735 	if (op&(REMAINDER|REMNEAR)) break;
4736 	if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4737 	/* [drop through if divideInteger] */
4738 	}
4739       /* also done enough if calculating remainder or integer */
4740       /* divide and just did the last ('units') unit */
4741       if (exponent==0 && !(op&DIVIDE)) break;
4742 
4743       /* to get here, var1 is less than var2, so divide var2 by the per- */
4744       /* Unit power of ten and go for the next digit */
4745       var2ulen--;			     /* shift down */
4746       exponent-=DECDPUN;		     /* update the exponent */
4747       } /* outer loop */
4748 
4749     /* ---- division is complete --------------------------------------- */
4750     /* here: acc      has at least reqdigits+1 of good results (or fewer */
4751     /*		      if early stop), starting at accnext+1 (its lsu) */
4752     /*	     var1     has any residue at the stopping point */
4753     /*	     accunits is the number of digits collected in acc */
4754     if (accunits==0) {		   /* acc is 0 */
4755       accunits=1;		   /* show have a unit .. */
4756       accdigits=1;		   /* .. */
4757       *accnext=0;		   /* .. whose value is 0 */
4758       }
4759      else accnext++;		   /* back to last placed */
4760     /* accnext now -> lowest unit of result */
4761 
4762     residue=0;			   /* assume no residue */
4763     if (op&DIVIDE) {
4764       /* record the presence of any residue, for rounding */
4765       if (*var1!=0 || var1units>1) residue=1;
4766        else { /* no residue */
4767 	/* Had an exact division; clean up spurious trailing 0s. */
4768 	/* There will be at most DECDPUN-1, from the final multiply, */
4769 	/* and then only if the result is non-0 (and even) and the */
4770 	/* exponent is 'loose'. */
4771 	#if DECDPUN>1
4772 	Unit lsu=*accnext;
4773 	if (!(lsu&0x01) && (lsu!=0)) {
4774 	  /* count the trailing zeros */
4775 	  Int drop=0;
4776 	  for (;; drop++) {    /* [will terminate because lsu!=0] */
4777 	    if (exponent>=maxexponent) break;	  /* don't chop real 0s */
4778 	    #if DECDPUN<=4
4779 	      if ((lsu-QUOT10(lsu, drop+1)
4780 		  *powers[drop+1])!=0) break;	  /* found non-0 digit */
4781 	    #else
4782 	      if (lsu%powers[drop+1]!=0) break;	  /* found non-0 digit */
4783 	    #endif
4784 	    exponent++;
4785 	    }
4786 	  if (drop>0) {
4787 	    accunits=decShiftToLeast(accnext, accunits, drop);
4788 	    accdigits=decGetDigits(accnext, accunits);
4789 	    accunits=D2U(accdigits);
4790 	    /* [exponent was adjusted in the loop] */
4791 	    }
4792 	  } /* neither odd nor 0 */
4793 	#endif
4794 	} /* exact divide */
4795       } /* divide */
4796      else /* op!=DIVIDE */ {
4797       /* check for coefficient overflow */
4798       if (accdigits+exponent>reqdigits) {
4799 	*status|=DEC_Division_impossible;
4800 	break;
4801 	}
4802       if (op & (REMAINDER|REMNEAR)) {
4803 	/* [Here, the exponent will be 0, because var1 was adjusted */
4804 	/* appropriately.] */
4805 	Int postshift;			     /* work */
4806 	Flag wasodd=0;			     /* integer was odd */
4807 	Unit *quotlsu;			     /* for save */
4808 	Int  quotdigits;		     /* .. */
4809 
4810 	bits=lhs->bits;			     /* remainder sign is always as lhs */
4811 
4812 	/* Fastpath when residue is truly 0 is worthwhile [and */
4813 	/* simplifies the code below] */
4814 	if (*var1==0 && var1units==1) {	     /* residue is 0 */
4815 	  Int exp=lhs->exponent;	     /* save min(exponents) */
4816 	  if (rhs->exponent<exp) exp=rhs->exponent;
4817 	  decNumberZero(res);		     /* 0 coefficient */
4818 	  #if DECSUBSET
4819 	  if (set->extended)
4820 	  #endif
4821 	  res->exponent=exp;		     /* .. with proper exponent */
4822 	  res->bits=(uByte)(bits&DECNEG);	   /* [cleaned] */
4823 	  decFinish(res, set, &residue, status);   /* might clamp */
4824 	  break;
4825 	  }
4826 	/* note if the quotient was odd */
4827 	if (*accnext & 0x01) wasodd=1;	     /* acc is odd */
4828 	quotlsu=accnext;		     /* save in case need to reinspect */
4829 	quotdigits=accdigits;		     /* .. */
4830 
4831 	/* treat the residue, in var1, as the value to return, via acc */
4832 	/* calculate the unused zero digits.  This is the smaller of: */
4833 	/*   var1 initial padding (saved above) */
4834 	/*   var2 residual padding, which happens to be given by: */
4835 	postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4836 	/* [the 'exponent' term accounts for the shifts during divide] */
4837 	if (var1initpad<postshift) postshift=var1initpad;
4838 
4839 	/* shift var1 the requested amount, and adjust its digits */
4840 	var1units=decShiftToLeast(var1, var1units, postshift);
4841 	accnext=var1;
4842 	accdigits=decGetDigits(var1, var1units);
4843 	accunits=D2U(accdigits);
4844 
4845 	exponent=lhs->exponent;		/* exponent is smaller of lhs & rhs */
4846 	if (rhs->exponent<exponent) exponent=rhs->exponent;
4847 
4848 	/* Now correct the result if doing remainderNear; if it */
4849 	/* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4850 	/* the integer was odd then the result should be rem-rhs. */
4851 	if (op&REMNEAR) {
4852 	  Int compare, tarunits;	/* work */
4853 	  Unit *up;			/* .. */
4854 	  /* calculate remainder*2 into the var1 buffer (which has */
4855 	  /* 'headroom' of an extra unit and hence enough space) */
4856 	  /* [a dedicated 'double' loop would be faster, here] */
4857 	  tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4858 				 0, accnext, 1);
4859 	  /* decDumpAr('r', accnext, tarunits); */
4860 
4861 	  /* Here, accnext (var1) holds tarunits Units with twice the */
4862 	  /* remainder's coefficient, which must now be compared to the */
4863 	  /* RHS.  The remainder's exponent may be smaller than the RHS's. */
4864 	  compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4865 				 rhs->exponent-exponent);
4866 	  if (compare==BADINT) {	     /* deep trouble */
4867 	    *status|=DEC_Insufficient_storage;
4868 	    break;}
4869 
4870 	  /* now restore the remainder by dividing by two; the lsu */
4871 	  /* is known to be even. */
4872 	  for (up=accnext; up<accnext+tarunits; up++) {
4873 	    Int half;		   /* half to add to lower unit */
4874 	    half=*up & 0x01;
4875 	    *up/=2;		   /* [shift] */
4876 	    if (!half) continue;
4877 	    *(up-1)+=DIV_ROUND_UP(DECDPUNMAX, 2);
4878 	    }
4879 	  /* [accunits still describes the original remainder length] */
4880 
4881 	  if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4882 	    Int exp, expunits, exprem;	     /* work */
4883 	    /* This is effectively causing round-up of the quotient, */
4884 	    /* so if it was the rare case where it was full and all */
4885 	    /* nines, it would overflow and hence division-impossible */
4886 	    /* should be raised */
4887 	    Flag allnines=0;		     /* 1 if quotient all nines */
4888 	    if (quotdigits==reqdigits) {     /* could be borderline */
4889 	      for (up=quotlsu; ; up++) {
4890 		if (quotdigits>DECDPUN) {
4891 		  if (*up!=DECDPUNMAX) break;/* non-nines */
4892 		  }
4893 		 else {			     /* this is the last Unit */
4894 		  if (*up==powers[quotdigits]-1) allnines=1;
4895 		  break;
4896 		  }
4897 		quotdigits-=DECDPUN;	     /* checked those digits */
4898 		} /* up */
4899 	      } /* borderline check */
4900 	    if (allnines) {
4901 	      *status|=DEC_Division_impossible;
4902 	      break;}
4903 
4904 	    /* rem-rhs is needed; the sign will invert.	 Again, var1 */
4905 	    /* can safely be used for the working Units array. */
4906 	    exp=rhs->exponent-exponent;	     /* RHS padding needed */
4907 	    /* Calculate units and remainder from exponent. */
4908 	    expunits=exp/DECDPUN;
4909 	    exprem=exp%DECDPUN;
4910 	    /* subtract [A+B*(-m)]; the result will always be negative */
4911 	    accunits=-decUnitAddSub(accnext, accunits,
4912 				    rhs->lsu, D2U(rhs->digits),
4913 				    expunits, accnext, -(Int)powers[exprem]);
4914 	    accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4915 	    accunits=D2U(accdigits);	/* and recalculate the units for copy */
4916 	    /* [exponent is as for original remainder] */
4917 	    bits^=DECNEG;		/* flip the sign */
4918 	    }
4919 	  } /* REMNEAR */
4920 	} /* REMAINDER or REMNEAR */
4921       } /* not DIVIDE */
4922 
4923     /* Set exponent and bits */
4924     res->exponent=exponent;
4925     res->bits=(uByte)(bits&DECNEG);	     /* [cleaned] */
4926 
4927     /* Now the coefficient. */
4928     decSetCoeff(res, set, accnext, accdigits, &residue, status);
4929 
4930     decFinish(res, set, &residue, status);   /* final cleanup */
4931 
4932     #if DECSUBSET
4933     /* If a divide then strip trailing zeros if subset [after round] */
4934     if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped);
4935     #endif
4936     } while(0);				     /* end protected */
4937 
4938   if (varalloc!=NULL) free(varalloc);	/* drop any storage used */
4939   if (allocacc!=NULL) free(allocacc);	/* .. */
4940   #if DECSUBSET
4941   if (allocrhs!=NULL) free(allocrhs);	/* .. */
4942   if (alloclhs!=NULL) free(alloclhs);	/* .. */
4943   #endif
4944   return res;
4945   } /* decDivideOp */
4946 
4947 /* ------------------------------------------------------------------ */
4948 /* decMultiplyOp -- multiplication operation			      */
4949 /*								      */
4950 /*  This routine performs the multiplication C=A x B.		      */
4951 /*								      */
4952 /*   res is C, the result.  C may be A and/or B (e.g., X=X*X)	      */
4953 /*   lhs is A							      */
4954 /*   rhs is B							      */
4955 /*   set is the context						      */
4956 /*   status is the usual accumulator				      */
4957 /*								      */
4958 /* C must have space for set->digits digits.			      */
4959 /*								      */
4960 /* ------------------------------------------------------------------ */
4961 /* 'Classic' multiplication is used rather than Karatsuba, as the     */
4962 /* latter would give only a minor improvement for the short numbers   */
4963 /* expected to be handled most (and uses much more memory).	      */
4964 /*								      */
4965 /* There are two major paths here: the general-purpose ('old code')   */
4966 /* path which handles all DECDPUN values, and a fastpath version      */
4967 /* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
4968 /* than two calls to decUnitAddSub would be made.		      */
4969 /*								      */
4970 /* The fastpath version lumps units together into 8-digit or 9-digit  */
4971 /* chunks, and also uses a lazy carry strategy to minimise expensive  */
4972 /* 64-bit divisions.  The chunks are then broken apart again into     */
4973 /* units for continuing processing.  Despite this overhead, the	      */
4974 /* fastpath can speed up some 16-digit operations by 10x (and much    */
4975 /* more for higher-precision calculations).			      */
4976 /*								      */
4977 /* A buffer always has to be used for the accumulator; in the	      */
4978 /* fastpath, buffers are also always needed for the chunked copies of */
4979 /* of the operand coefficients.					      */
4980 /* Static buffers are larger than needed just for multiply, to allow  */
4981 /* for calls from other operations (notably exp).		      */
4982 /* ------------------------------------------------------------------ */
4983 #define FASTMUL (DECUSE64 && DECDPUN<5)
4984 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4985 				 const decNumber *rhs, decContext *set,
4986 				 uInt *status) {
4987   Int	 accunits;		   /* Units of accumulator in use */
4988   Int	 exponent;		   /* work */
4989   Int	 residue=0;		   /* rounding residue */
4990   uByte	 bits;			   /* result sign */
4991   Unit	*acc;			   /* -> accumulator Unit array */
4992   Int	 needbytes;		   /* size calculator */
4993   void	*allocacc=NULL;		   /* -> allocated accumulator, iff allocated */
4994   Unit	accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4995 				   /* *4 for calls from other operations) */
4996   const Unit *mer, *mermsup;	   /* work */
4997   Int	madlength;		   /* Units in multiplicand */
4998   Int	shift;			   /* Units to shift multiplicand by */
4999 
5000   #if FASTMUL
5001     /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
5002     /* (DECDPUN is 2 or 4) then work in base 10**8 */
5003     #if DECDPUN & 1		   /* odd */
5004       #define FASTBASE 1000000000  /* base */
5005       #define FASTDIGS		9  /* digits in base */
5006       #define FASTLAZY	       18  /* carry resolution point [1->18] */
5007     #else
5008       #define FASTBASE	100000000
5009       #define FASTDIGS		8
5010       #define FASTLAZY	     1844  /* carry resolution point [1->1844] */
5011     #endif
5012     /* three buffers are used, two for chunked copies of the operands */
5013     /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
5014     /* lazy carry evaluation */
5015     uInt   zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
5016     uInt  *zlhi=zlhibuff;		  /* -> lhs array */
5017     uInt  *alloclhi=NULL;		  /* -> allocated buffer, iff allocated */
5018     uInt   zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
5019     uInt  *zrhi=zrhibuff;		  /* -> rhs array */
5020     uInt  *allocrhi=NULL;		  /* -> allocated buffer, iff allocated */
5021     uLong  zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
5022     /* [allocacc is shared for both paths, as only one will run] */
5023     uLong *zacc=zaccbuff;	   /* -> accumulator array for exact result */
5024     #if DECDPUN==1
5025     Int	   zoff;		   /* accumulator offset */
5026     #endif
5027     uInt  *lip, *rip;		   /* item pointers */
5028     uInt  *lmsi, *rmsi;		   /* most significant items */
5029     Int	   ilhs, irhs, iacc;	   /* item counts in the arrays */
5030     Int	   lazy;		   /* lazy carry counter */
5031     uLong  lcarry;		   /* uLong carry */
5032     uInt   carry;		   /* carry (NB not uLong) */
5033     Int	   count;		   /* work */
5034     const  Unit *cup;		   /* .. */
5035     Unit  *up;			   /* .. */
5036     uLong *lp;			   /* .. */
5037     Int	   p;			   /* .. */
5038   #endif
5039 
5040   #if DECSUBSET
5041     decNumber *alloclhs=NULL;	   /* -> allocated buffer, iff allocated */
5042     decNumber *allocrhs=NULL;	   /* -> allocated buffer, iff allocated */
5043   #endif
5044 
5045   #if DECCHECK
5046   if (decCheckOperands(res, lhs, rhs, set)) return res;
5047   #endif
5048 
5049   /* precalculate result sign */
5050   bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
5051 
5052   /* handle infinities and NaNs */
5053   if (SPECIALARGS) {		   /* a special bit set */
5054     if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
5055       decNaNs(res, lhs, rhs, set, status);
5056       return res;}
5057     /* one or two infinities; Infinity * 0 is invalid */
5058     if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
5059       ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
5060       *status|=DEC_Invalid_operation;
5061       return res;}
5062     decNumberZero(res);
5063     res->bits=bits|DECINF;	   /* infinity */
5064     return res;}
5065 
5066   /* For best speed, as in DMSRCN [the original Rexx numerics */
5067   /* module], use the shorter number as the multiplier (rhs) and */
5068   /* the longer as the multiplicand (lhs) to minimise the number of */
5069   /* adds (partial products) */
5070   if (lhs->digits<rhs->digits) {   /* swap... */
5071     const decNumber *hold=lhs;
5072     lhs=rhs;
5073     rhs=hold;
5074     }
5075 
5076   do {				   /* protect allocated storage */
5077     #if DECSUBSET
5078     if (!set->extended) {
5079       /* reduce operands and set lostDigits status, as needed */
5080       if (lhs->digits>set->digits) {
5081 	alloclhs=decRoundOperand(lhs, set, status);
5082 	if (alloclhs==NULL) break;
5083 	lhs=alloclhs;
5084 	}
5085       if (rhs->digits>set->digits) {
5086 	allocrhs=decRoundOperand(rhs, set, status);
5087 	if (allocrhs==NULL) break;
5088 	rhs=allocrhs;
5089 	}
5090       }
5091     #endif
5092     /* [following code does not require input rounding] */
5093 
5094     #if FASTMUL			   /* fastpath can be used */
5095     /* use the fast path if there are enough digits in the shorter */
5096     /* operand to make the setup and takedown worthwhile */
5097     #define NEEDTWO (DECDPUN*2)	   /* within two decUnitAddSub calls */
5098     if (rhs->digits>NEEDTWO) {	   /* use fastpath... */
5099       /* calculate the number of elements in each array */
5100       ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
5101       irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
5102       iacc=ilhs+irhs;
5103 
5104       /* allocate buffers if required, as usual */
5105       needbytes=ilhs*sizeof(uInt);
5106       if (needbytes>(Int)sizeof(zlhibuff)) {
5107 	alloclhi=(uInt *)malloc(needbytes);
5108 	zlhi=alloclhi;}
5109       needbytes=irhs*sizeof(uInt);
5110       if (needbytes>(Int)sizeof(zrhibuff)) {
5111 	allocrhi=(uInt *)malloc(needbytes);
5112 	zrhi=allocrhi;}
5113 
5114       /* Allocating the accumulator space needs a special case when */
5115       /* DECDPUN=1 because when converting the accumulator to Units */
5116       /* after the multiplication each 8-byte item becomes 9 1-byte */
5117       /* units.	 Therefore iacc extra bytes are needed at the front */
5118       /* (rounded up to a multiple of 8 bytes), and the uLong */
5119       /* accumulator starts offset the appropriate number of units */
5120       /* to the right to avoid overwrite during the unchunking. */
5121       needbytes=iacc*sizeof(uLong);
5122       #if DECDPUN==1
5123       zoff=(iacc+7)/8;	      /* items to offset by */
5124       needbytes+=zoff*8;
5125       #endif
5126       if (needbytes>(Int)sizeof(zaccbuff)) {
5127 	allocacc=(uLong *)malloc(needbytes);
5128 	zacc=(uLong *)allocacc;}
5129       if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
5130 	*status|=DEC_Insufficient_storage;
5131 	break;}
5132 
5133       acc=(Unit *)zacc;	      /* -> target Unit array */
5134       #if DECDPUN==1
5135       zacc+=zoff;	      /* start uLong accumulator to right */
5136       #endif
5137 
5138       /* assemble the chunked copies of the left and right sides */
5139       for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
5140 	for (p=0, *lip=0; p<FASTDIGS && count>0;
5141 	     p+=DECDPUN, cup++, count-=DECDPUN)
5142 	  *lip+=*cup*powers[p];
5143       lmsi=lip-1;     /* save -> msi */
5144       for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
5145 	for (p=0, *rip=0; p<FASTDIGS && count>0;
5146 	     p+=DECDPUN, cup++, count-=DECDPUN)
5147 	  *rip+=*cup*powers[p];
5148       rmsi=rip-1;     /* save -> msi */
5149 
5150       /* zero the accumulator */
5151       for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
5152 
5153       /* Start the multiplication */
5154       /* Resolving carries can dominate the cost of accumulating the */
5155       /* partial products, so this is only done when necessary. */
5156       /* Each uLong item in the accumulator can hold values up to */
5157       /* 2**64-1, and each partial product can be as large as */
5158       /* (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to */
5159       /* itself 18.4 times in a uLong without overflowing, so during */
5160       /* the main calculation resolution is carried out every 18th */
5161       /* add -- every 162 digits.  Similarly, when FASTDIGS=8, the */
5162       /* partial products can be added to themselves 1844.6 times in */
5163       /* a uLong without overflowing, so intermediate carry */
5164       /* resolution occurs only every 14752 digits.  Hence for common */
5165       /* short numbers usually only the one final carry resolution */
5166       /* occurs. */
5167       /* (The count is set via FASTLAZY to simplify experiments to */
5168       /* measure the value of this approach: a 35% improvement on a */
5169       /* [34x34] multiply.) */
5170       lazy=FASTLAZY;			     /* carry delay count */
5171       for (rip=zrhi; rip<=rmsi; rip++) {     /* over each item in rhs */
5172 	lp=zacc+(rip-zrhi);		     /* where to add the lhs */
5173 	for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5174 	  *lp+=(uLong)(*lip)*(*rip);	     /* [this should in-line] */
5175 	  } /* lip loop */
5176 	lazy--;
5177 	if (lazy>0 && rip!=rmsi) continue;
5178 	lazy=FASTLAZY;			     /* reset delay count */
5179 	/* spin up the accumulator resolving overflows */
5180 	for (lp=zacc; lp<zacc+iacc; lp++) {
5181 	  if (*lp<FASTBASE) continue;	     /* it fits */
5182 	  lcarry=*lp/FASTBASE;		     /* top part [slow divide] */
5183 	  /* lcarry can exceed 2**32-1, so check again; this check */
5184 	  /* and occasional extra divide (slow) is well worth it, as */
5185 	  /* it allows FASTLAZY to be increased to 18 rather than 4 */
5186 	  /* in the FASTDIGS=9 case */
5187 	  if (lcarry<FASTBASE) carry=(uInt)lcarry;  /* [usual] */
5188 	   else { /* two-place carry [fairly rare] */
5189 	    uInt carry2=(uInt)(lcarry/FASTBASE);    /* top top part */
5190 	    *(lp+2)+=carry2;			    /* add to item+2 */
5191 	    *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5192 	    carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5193 	    }
5194 	  *(lp+1)+=carry;		     /* add to item above [inline] */
5195 	  *lp-=((uLong)FASTBASE*carry);	     /* [inline] */
5196 	  } /* carry resolution */
5197 	} /* rip loop */
5198 
5199       /* The multiplication is complete; time to convert back into */
5200       /* units.	 This can be done in-place in the accumulator and in */
5201       /* 32-bit operations, because carries were resolved after the */
5202       /* final add.  This needs N-1 divides and multiplies for */
5203       /* each item in the accumulator (which will become up to N */
5204       /* units, where 2<=N<=9). */
5205       for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5206 	uInt item=(uInt)*lp;		     /* decapitate to uInt */
5207 	for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5208 	  uInt part=item/(DECDPUNMAX+1);
5209 	  *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5210 	  item=part;
5211 	  } /* p */
5212 	*up=(Unit)item; up++;		     /* [final needs no division] */
5213 	} /* lp */
5214       accunits=up-acc;			     /* count of units */
5215       }
5216      else { /* here to use units directly, without chunking ['old code'] */
5217     #endif
5218 
5219       /* if accumulator will be too long for local storage, then allocate */
5220       acc=accbuff;		   /* -> assume buffer for accumulator */
5221       needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5222       if (needbytes>(Int)sizeof(accbuff)) {
5223 	allocacc=(Unit *)malloc(needbytes);
5224 	if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5225 	acc=(Unit *)allocacc;		     /* use the allocated space */
5226 	}
5227 
5228       /* Now the main long multiplication loop */
5229       /* Unlike the equivalent in the IBM Java implementation, there */
5230       /* is no advantage in calculating from msu to lsu.  So, do it */
5231       /* by the book, as it were. */
5232       /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5233       accunits=1;		   /* accumulator starts at '0' */
5234       *acc=0;			   /* .. (lsu=0) */
5235       shift=0;			   /* no multiplicand shift at first */
5236       madlength=D2U(lhs->digits);  /* this won't change */
5237       mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5238 
5239       for (mer=rhs->lsu; mer<mermsup; mer++) {
5240 	/* Here, *mer is the next Unit in the multiplier to use */
5241 	/* If non-zero [optimization] add it... */
5242 	if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5243 					    lhs->lsu, madlength, 0,
5244 					    &acc[shift], *mer)
5245 					    + shift;
5246 	 else { /* extend acc with a 0; it will be used shortly */
5247 	  *(acc+accunits)=0;	   /* [this avoids length of <=0 later] */
5248 	  accunits++;
5249 	  }
5250 	/* multiply multiplicand by 10**DECDPUN for next Unit to left */
5251 	shift++;		   /* add this for 'logical length' */
5252 	} /* n */
5253     #if FASTMUL
5254       } /* unchunked units */
5255     #endif
5256     /* common end-path */
5257     #if DECTRACE
5258       decDumpAr('*', acc, accunits);	     /* Show exact result */
5259     #endif
5260 
5261     /* acc now contains the exact result of the multiplication, */
5262     /* possibly with a leading zero unit; build the decNumber from */
5263     /* it, noting if any residue */
5264     res->bits=bits;			     /* set sign */
5265     res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5266 
5267     /* There can be a 31-bit wrap in calculating the exponent. */
5268     /* This can only happen if both input exponents are negative and */
5269     /* both their magnitudes are large.	 If there was a wrap, set a */
5270     /* safe very negative exponent, from which decFinalize() will */
5271     /* raise a hard underflow shortly. */
5272     exponent=lhs->exponent+rhs->exponent;    /* calculate exponent */
5273     if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5274       exponent=-2*DECNUMMAXE;		     /* force underflow */
5275     res->exponent=exponent;		     /* OK to overwrite now */
5276 
5277 
5278     /* Set the coefficient.  If any rounding, residue records */
5279     decSetCoeff(res, set, acc, res->digits, &residue, status);
5280     decFinish(res, set, &residue, status);   /* final cleanup */
5281     } while(0);				/* end protected */
5282 
5283   if (allocacc!=NULL) free(allocacc);	/* drop any storage used */
5284   #if DECSUBSET
5285   if (allocrhs!=NULL) free(allocrhs);	/* .. */
5286   if (alloclhs!=NULL) free(alloclhs);	/* .. */
5287   #endif
5288   #if FASTMUL
5289   if (allocrhi!=NULL) free(allocrhi);	/* .. */
5290   if (alloclhi!=NULL) free(alloclhi);	/* .. */
5291   #endif
5292   return res;
5293   } /* decMultiplyOp */
5294 
5295 /* ------------------------------------------------------------------ */
5296 /* decExpOp -- effect exponentiation				      */
5297 /*								      */
5298 /*   This computes C = exp(A)					      */
5299 /*								      */
5300 /*   res is C, the result.  C may be A				      */
5301 /*   rhs is A							      */
5302 /*   set is the context; note that rounding mode has no effect	      */
5303 /*								      */
5304 /* C must have space for set->digits digits. status is updated but    */
5305 /* not set.							      */
5306 /*								      */
5307 /* Restrictions:						      */
5308 /*								      */
5309 /*   digits, emax, and -emin in the context must be less than	      */
5310 /*   2*DEC_MAX_MATH (1999998), and the rhs must be within these	      */
5311 /*   bounds or a zero.	This is an internal routine, so these	      */
5312 /*   restrictions are contractual and not enforced.		      */
5313 /*								      */
5314 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5315 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5316 /* error in rare cases.						      */
5317 /*								      */
5318 /* Finite results will always be full precision and Inexact, except   */
5319 /* when A is a zero or -Infinity (giving 1 or 0 respectively).	      */
5320 /* ------------------------------------------------------------------ */
5321 /* This approach used here is similar to the algorithm described in   */
5322 /*								      */
5323 /*   Variable Precision Exponential Function, T. E. Hull and	      */
5324 /*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5325 /*   pp79-91, ACM, June 1986.					      */
5326 /*								      */
5327 /* with the main difference being that the iterations in the series   */
5328 /* evaluation are terminated dynamically (which does not require the  */
5329 /* extra variable-precision variables which are expensive in this     */
5330 /* context).							      */
5331 /*								      */
5332 /* The error analysis in Hull & Abrham's paper applies except for the */
5333 /* round-off error accumulation during the series evaluation.  This   */
5334 /* code does not precalculate the number of iterations and so cannot  */
5335 /* use Horner's scheme.	 Instead, the accumulation is done at double- */
5336 /* precision, which ensures that the additions of the terms are exact */
5337 /* and do not accumulate round-off (and any round-off errors in the   */
5338 /* terms themselves move 'to the right' faster than they can	      */
5339 /* accumulate).	 This code also extends the calculation by allowing,  */
5340 /* in the spirit of other decNumber operators, the input to be more   */
5341 /* precise than the result (the precision used is based on the more   */
5342 /* precise of the input or requested result).			      */
5343 /*								      */
5344 /* Implementation notes:					      */
5345 /*								      */
5346 /* 1. This is separated out as decExpOp so it can be called from      */
5347 /*    other Mathematical functions (notably Ln) with a wider range    */
5348 /*    than normal.  In particular, it can handle the slightly wider   */
5349 /*    (double) range needed by Ln (which has to be able to calculate  */
5350 /*    exp(-x) where x can be the tiniest number (Ntiny).	      */
5351 /*								      */
5352 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop	      */
5353 /*    iterations by approximately a third with additional (although    */
5354 /*    diminishing) returns as the range is reduced to even smaller    */
5355 /*    fractions.  However, h (the power of 10 used to correct the     */
5356 /*    result at the end, see below) must be kept <=8 as otherwise     */
5357 /*    the final result cannot be computed.  Hence the leverage is a   */
5358 /*    sliding value (8-h), where potentially the range is reduced     */
5359 /*    more for smaller values.					      */
5360 /*								      */
5361 /*    The leverage that can be applied in this way is severely	      */
5362 /*    limited by the cost of the raise-to-the power at the end,	      */
5363 /*    which dominates when the number of iterations is small (less    */
5364 /*    than ten) or when rhs is short.  As an example, the adjustment  */
5365 /*    x**10,000,000 needs 31 multiplications, all but one full-width. */
5366 /*								      */
5367 /* 3. The restrictions (especially precision) could be raised with    */
5368 /*    care, but the full decNumber range seems very hard within the   */
5369 /*    32-bit limits.						      */
5370 /*								      */
5371 /* 4. The working precisions for the static buffers are twice the     */
5372 /*    obvious size to allow for calls from decNumberPower.	      */
5373 /* ------------------------------------------------------------------ */
5374 static decNumber *decExpOp(decNumber *res, const decNumber *rhs,
5375                            decContext *set, uInt *status) {
5376   uInt ignore=0;		   /* working status */
5377   Int h;			   /* adjusted exponent for 0.xxxx */
5378   Int p;			   /* working precision */
5379   Int residue;			   /* rounding residue */
5380   uInt needbytes;		   /* for space calculations */
5381   const decNumber *x=rhs;	   /* (may point to safe copy later) */
5382   decContext aset, tset, dset;	   /* working contexts */
5383   Int comp;			   /* work */
5384 
5385   /* the argument is often copied to normalize it, so (unusually) it */
5386   /* is treated like other buffers, using DECBUFFER, +1 in case */
5387   /* DECBUFFER is 0 */
5388   decNumber bufr[D2N(DECBUFFER*2+1)];
5389   decNumber *allocrhs=NULL;	   /* non-NULL if rhs buffer allocated */
5390 
5391   /* the working precision will be no more than set->digits+8+1 */
5392   /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5393   /* is 0 (and twice that for the accumulator) */
5394 
5395   /* buffer for t, term (working precision plus) */
5396   decNumber buft[D2N(DECBUFFER*2+9+1)];
5397   decNumber *allocbuft=NULL;	   /* -> allocated buft, iff allocated */
5398   decNumber *t=buft;		   /* term */
5399   /* buffer for a, accumulator (working precision * 2), at least 9 */
5400   decNumber bufa[D2N(DECBUFFER*4+18+1)];
5401   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
5402   decNumber *a=bufa;		   /* accumulator */
5403   /* decNumber for the divisor term; this needs at most 9 digits */
5404   /* and so can be fixed size [16 so can use standard context] */
5405   decNumber bufd[D2N(16)];
5406   decNumber *d=bufd;		   /* divisor */
5407   decNumber numone;		   /* constant 1 */
5408 
5409   #if DECCHECK
5410   Int iterations=0;		   /* for later sanity check */
5411   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5412   #endif
5413 
5414   do {					/* protect allocated storage */
5415     if (SPECIALARG) {			/* handle infinities and NaNs */
5416       if (decNumberIsInfinite(rhs)) {	/* an infinity */
5417 	if (decNumberIsNegative(rhs))	/* -Infinity -> +0 */
5418 	  decNumberZero(res);
5419 	 else decNumberCopy(res, rhs);	/* +Infinity -> self */
5420 	}
5421        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5422       break;}
5423 
5424     if (ISZERO(rhs)) {			/* zeros -> exact 1 */
5425       decNumberZero(res);		/* make clean 1 */
5426       *res->lsu=1;			/* .. */
5427       break;}				/* [no status to set] */
5428 
5429     /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5430     /* positive and negative tiny cases which will result in inexact */
5431     /* 1.  This also allows the later add-accumulate to always be */
5432     /* exact (because its length will never be more than twice the */
5433     /* working precision). */
5434     /* The comparator (tiny) needs just one digit, so use the */
5435     /* decNumber d for it (reused as the divisor, etc., below); its */
5436     /* exponent is such that if x is positive it will have */
5437     /* set->digits-1 zeros between the decimal point and the digit, */
5438     /* which is 4, and if x is negative one more zero there as the */
5439     /* more precise result will be of the form 0.9999999 rather than */
5440     /* 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0 */
5441     /* or 0.00000004 if digits=7 and x<0.  If RHS not larger than */
5442     /* this then the result will be 1.000000 */
5443     decNumberZero(d);			/* clean */
5444     *d->lsu=4;				/* set 4 .. */
5445     d->exponent=-set->digits;		/* * 10**(-d) */
5446     if (decNumberIsNegative(rhs)) d->exponent--;  /* negative case */
5447     comp=decCompare(d, rhs, 1);		/* signless compare */
5448     if (comp==BADINT) {
5449       *status|=DEC_Insufficient_storage;
5450       break;}
5451     if (comp>=0) {			/* rhs < d */
5452       Int shift=set->digits-1;
5453       decNumberZero(res);		/* set 1 */
5454       *res->lsu=1;			/* .. */
5455       res->digits=decShiftToMost(res->lsu, 1, shift);
5456       res->exponent=-shift;		     /* make 1.0000... */
5457       *status|=DEC_Inexact | DEC_Rounded;    /* .. inexactly */
5458       break;} /* tiny */
5459 
5460     /* set up the context to be used for calculating a, as this is */
5461     /* used on both paths below */
5462     decContextDefault(&aset, DEC_INIT_DECIMAL64);
5463     /* accumulator bounds are as requested (could underflow) */
5464     aset.emax=set->emax;		/* usual bounds */
5465     aset.emin=set->emin;		/* .. */
5466     aset.clamp=0;			/* and no concrete format */
5467 
5468     /* calculate the adjusted (Hull & Abrham) exponent (where the */
5469     /* decimal point is just to the left of the coefficient msd) */
5470     h=rhs->exponent+rhs->digits;
5471     /* if h>8 then 10**h cannot be calculated safely; however, when */
5472     /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5473     /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5474     /* overflow (or underflow to 0) is guaranteed -- so this case can */
5475     /* be handled by simply forcing the appropriate excess */
5476     if (h>8) {				/* overflow/underflow */
5477       /* set up here so Power call below will over or underflow to */
5478       /* zero; set accumulator to either 2 or 0.02 */
5479       /* [stack buffer for a is always big enough for this] */
5480       decNumberZero(a);
5481       *a->lsu=2;			/* not 1 but < exp(1) */
5482       if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5483       h=8;				/* clamp so 10**h computable */
5484       p=9;				/* set a working precision */
5485       }
5486      else {				/* h<=8 */
5487       Int maxlever=(rhs->digits>8?1:0);
5488       /* [could/should increase this for precisions >40 or so, too] */
5489 
5490       /* if h is 8, cannot normalize to a lower upper limit because */
5491       /* the final result will not be computable (see notes above), */
5492       /* but leverage can be applied whenever h is less than 8. */
5493       /* Apply as much as possible, up to a MAXLEVER digits, which */
5494       /* sets the tradeoff against the cost of the later a**(10**h). */
5495       /* As h is increased, the working precision below also */
5496       /* increases to compensate for the "constant digits at the */
5497       /* front" effect. */
5498       Int lever=MINI(8-h, maxlever);	/* leverage attainable */
5499       Int use=-rhs->digits-lever;	/* exponent to use for RHS */
5500       h+=lever;				/* apply leverage selected */
5501       if (h<0) {			/* clamp */
5502 	use+=h;				/* [may end up subnormal] */
5503 	h=0;
5504 	}
5505       /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5506       if (rhs->exponent!=use) {
5507 	decNumber *newrhs=bufr;		/* assume will fit on stack */
5508 	needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5509 	if (needbytes>sizeof(bufr)) {	/* need malloc space */
5510 	  allocrhs=(decNumber *)malloc(needbytes);
5511 	  if (allocrhs==NULL) {		/* hopeless -- abandon */
5512 	    *status|=DEC_Insufficient_storage;
5513 	    break;}
5514 	  newrhs=allocrhs;		/* use the allocated space */
5515 	  }
5516 	decNumberCopy(newrhs, rhs);	/* copy to safe space */
5517 	newrhs->exponent=use;		/* normalize; now <1 */
5518 	x=newrhs;			/* ready for use */
5519 	/* decNumberShow(x); */
5520 	}
5521 
5522       /* Now use the usual power series to evaluate exp(x).  The */
5523       /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5524       /* third term by setting the term variable t=x, the accumulator */
5525       /* a=1, and the divisor d=2. */
5526 
5527       /* First determine the working precision.	 From Hull & Abrham */
5528       /* this is set->digits+h+2.  However, if x is 'over-precise' we */
5529       /* need to allow for all its digits to potentially participate */
5530       /* (consider an x where all the excess digits are 9s) so in */
5531       /* this case use x->digits+h+2 */
5532       p=MAXI(x->digits, set->digits)+h+2;    /* [h<=8] */
5533 
5534       /* a and t are variable precision, and depend on p, so space */
5535       /* must be allocated for them if necessary */
5536 
5537       /* the accumulator needs to be able to hold 2p digits so that */
5538       /* the additions on the second and subsequent iterations are */
5539       /* sufficiently exact. */
5540       needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5541       if (needbytes>sizeof(bufa)) {	/* need malloc space */
5542 	allocbufa=(decNumber *)malloc(needbytes);
5543 	if (allocbufa==NULL) {		/* hopeless -- abandon */
5544 	  *status|=DEC_Insufficient_storage;
5545 	  break;}
5546 	a=allocbufa;			/* use the allocated space */
5547 	}
5548       /* the term needs to be able to hold p digits (which is */
5549       /* guaranteed to be larger than x->digits, so the initial copy */
5550       /* is safe); it may also be used for the raise-to-power */
5551       /* calculation below, which needs an extra two digits */
5552       needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5553       if (needbytes>sizeof(buft)) {	/* need malloc space */
5554 	allocbuft=(decNumber *)malloc(needbytes);
5555 	if (allocbuft==NULL) {		/* hopeless -- abandon */
5556 	  *status|=DEC_Insufficient_storage;
5557 	  break;}
5558 	t=allocbuft;			/* use the allocated space */
5559 	}
5560 
5561       decNumberCopy(t, x);		/* term=x */
5562       decNumberZero(a); *a->lsu=1;	/* accumulator=1 */
5563       decNumberZero(d); *d->lsu=2;	/* divisor=2 */
5564       decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5565 
5566       /* set up the contexts for calculating a, t, and d */
5567       decContextDefault(&tset, DEC_INIT_DECIMAL64);
5568       dset=tset;
5569       /* accumulator bounds are set above, set precision now */
5570       aset.digits=p*2;			/* double */
5571       /* term bounds avoid any underflow or overflow */
5572       tset.digits=p;
5573       tset.emin=DEC_MIN_EMIN;		/* [emax is plenty] */
5574       /* [dset.digits=16, etc., are sufficient] */
5575 
5576       /* finally ready to roll */
5577       for (;;) {
5578 	#if DECCHECK
5579 	iterations++;
5580 	#endif
5581 	/* only the status from the accumulation is interesting */
5582 	/* [but it should remain unchanged after first add] */
5583 	decAddOp(a, a, t, &aset, 0, status);	       /* a=a+t */
5584 	decMultiplyOp(t, t, x, &tset, &ignore);	       /* t=t*x */
5585 	decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  /* t=t/d */
5586 	/* the iteration ends when the term cannot affect the result, */
5587 	/* if rounded to p digits, which is when its value is smaller */
5588 	/* than the accumulator by p+1 digits.	There must also be */
5589 	/* full precision in a. */
5590 	if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5591 	    && (a->digits>=p)) break;
5592 	decAddOp(d, d, &numone, &dset, 0, &ignore);    /* d=d+1 */
5593 	} /* iterate */
5594 
5595       #if DECCHECK
5596       /* just a sanity check; comment out test to show always */
5597       if (iterations>p+3)
5598 	printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5599 	       iterations, *status, p, x->digits);
5600       #endif
5601       } /* h<=8 */
5602 
5603     /* apply postconditioning: a=a**(10**h) -- this is calculated */
5604     /* at a slightly higher precision than Hull & Abrham suggest */
5605     if (h>0) {
5606       Int seenbit=0;		   /* set once a 1-bit is seen */
5607       Int i;			   /* counter */
5608       Int n=powers[h];		   /* always positive */
5609       aset.digits=p+2;		   /* sufficient precision */
5610       /* avoid the overhead and many extra digits of decNumberPower */
5611       /* as all that is needed is the short 'multipliers' loop; here */
5612       /* accumulate the answer into t */
5613       decNumberZero(t); *t->lsu=1; /* acc=1 */
5614       for (i=1;;i++){		   /* for each bit [top bit ignored] */
5615 	/* abandon if have had overflow or terminal underflow */
5616 	if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5617 	  if (*status&DEC_Overflow || ISZERO(t)) break;}
5618 	n=n<<1;			   /* move next bit to testable position */
5619 	if (n<0) {		   /* top bit is set */
5620 	  seenbit=1;		   /* OK, have a significant bit */
5621 	  decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5622 	  }
5623 	if (i==31) break;	   /* that was the last bit */
5624 	if (!seenbit) continue;	   /* no need to square 1 */
5625 	decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5626 	} /*i*/ /* 32 bits */
5627       /* decNumberShow(t); */
5628       a=t;			   /* and carry on using t instead of a */
5629       }
5630 
5631     /* Copy and round the result to res */
5632     residue=1;				/* indicate dirt to right .. */
5633     if (ISZERO(a)) residue=0;		/* .. unless underflowed to 0 */
5634     aset.digits=set->digits;		/* [use default rounding] */
5635     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5636     decFinish(res, set, &residue, status);	 /* cleanup/set flags */
5637     } while(0);				/* end protected */
5638 
5639   if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
5640   if (allocbufa!=NULL) free(allocbufa); /* .. */
5641   if (allocbuft!=NULL) free(allocbuft); /* .. */
5642   /* [status is handled by caller] */
5643   return res;
5644   } /* decExpOp */
5645 
5646 /* ------------------------------------------------------------------ */
5647 /* Initial-estimate natural logarithm table			      */
5648 /*								      */
5649 /*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
5650 /*	     The result is a 4-digit encode of the coefficient (c=the */
5651 /*	     top 14 bits encoding 0-9999) and a 2-digit encode of the */
5652 /*	     exponent (e=the bottom 2 bits encoding 0-3)	      */
5653 /*								      */
5654 /*	     The resulting value is given by:			      */
5655 /*								      */
5656 /*	       v = -c * 10**(-e-3)				      */
5657 /*								      */
5658 /*	     where e and c are extracted from entry k = LNnn[x-10]    */
5659 /*	     where x is truncated (NB) into the range 10 through 99,  */
5660 /*	     and then c = k>>2 and e = k&3.			      */
5661 /* ------------------------------------------------------------------ */
5662 static const uShort LNnn[90] = {
5663   9016,  8652,  8316,  8008,  7724,  7456,  7208,
5664   6972,	 6748,	6540,  6340,  6148,  5968,  5792,  5628,  5464,	 5312,
5665   5164,	 5020,	4884,  4748,  4620,  4496,  4376,  4256,  4144,	 4032,
5666  39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5667  29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5668  22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5669  15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5670  10197,	 9685,	9177,  8677,  8185,  7697,  7213,  6737,  6269,	 5801,
5671   5341,	 4889,	4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5672  10130,	 6046, 20055};
5673 
5674 /* ------------------------------------------------------------------ */
5675 /* decLnOp -- effect natural logarithm				      */
5676 /*								      */
5677 /*   This computes C = ln(A)					      */
5678 /*								      */
5679 /*   res is C, the result.  C may be A				      */
5680 /*   rhs is A							      */
5681 /*   set is the context; note that rounding mode has no effect	      */
5682 /*								      */
5683 /* C must have space for set->digits digits.			      */
5684 /*								      */
5685 /* Notable cases:						      */
5686 /*   A<0 -> Invalid						      */
5687 /*   A=0 -> -Infinity (Exact)					      */
5688 /*   A=+Infinity -> +Infinity (Exact)				      */
5689 /*   A=1 exactly -> 0 (Exact)					      */
5690 /*								      */
5691 /* Restrictions (as for Exp):					      */
5692 /*								      */
5693 /*   digits, emax, and -emin in the context must be less than	      */
5694 /*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
5695 /*   bounds or a zero.	This is an internal routine, so these	      */
5696 /*   restrictions are contractual and not enforced.		      */
5697 /*								      */
5698 /* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5699 /* almost always be correctly rounded, but may be up to 1 ulp in      */
5700 /* error in rare cases.						      */
5701 /* ------------------------------------------------------------------ */
5702 /* The result is calculated using Newton's method, with each	      */
5703 /* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
5704 /* Epperson 1989.						      */
5705 /*								      */
5706 /* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5707 /* This has to be calculated at the sum of the precision of x and the */
5708 /* working precision.						      */
5709 /*								      */
5710 /* Implementation notes:					      */
5711 /*								      */
5712 /* 1. This is separated out as decLnOp so it can be called from	      */
5713 /*    other Mathematical functions (e.g., Log 10) with a wider range  */
5714 /*    than normal.  In particular, it can handle the slightly wider   */
5715 /*    (+9+2) range needed by a power function.			      */
5716 /*								      */
5717 /* 2. The speed of this function is about 10x slower than exp, as     */
5718 /*    it typically needs 4-6 iterations for short numbers, and the    */
5719 /*    extra precision needed adds a squaring effect, twice.	      */
5720 /*								      */
5721 /* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
5722 /*    as these are common requests.  ln(10) is used by log10(x).      */
5723 /*								      */
5724 /* 4. An iteration might be saved by widening the LNnn table, and     */
5725 /*    would certainly save at least one if it were made ten times     */
5726 /*    bigger, too (for truncated fractions 0.100 through 0.999).      */
5727 /*    However, for most practical evaluations, at least four or five  */
5728 /*    iterations will be needed -- so this would only speed up by      */
5729 /*    20-25% and that probably does not justify increasing the table  */
5730 /*    size.							      */
5731 /*								      */
5732 /* 5. The static buffers are larger than might be expected to allow   */
5733 /*    for calls from decNumberPower.				      */
5734 /* ------------------------------------------------------------------ */
5735 static decNumber *decLnOp(decNumber *res, const decNumber *rhs,
5736                           decContext *set, uInt *status) {
5737   uInt ignore=0;		   /* working status accumulator */
5738   uInt needbytes;		   /* for space calculations */
5739   Int residue;			   /* rounding residue */
5740   Int r;			   /* rhs=f*10**r [see below] */
5741   Int p;			   /* working precision */
5742   Int pp;			   /* precision for iteration */
5743   Int t;			   /* work */
5744 
5745   /* buffers for a (accumulator, typically precision+2) and b */
5746   /* (adjustment calculator, same size) */
5747   decNumber bufa[D2N(DECBUFFER+12)];
5748   decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
5749   decNumber *a=bufa;		   /* accumulator/work */
5750   decNumber bufb[D2N(DECBUFFER*2+2)];
5751   decNumber *allocbufb=NULL;	   /* -> allocated bufa, iff allocated */
5752   decNumber *b=bufb;		   /* adjustment/work */
5753 
5754   decNumber  numone;		   /* constant 1 */
5755   decNumber  cmp;		   /* work */
5756   decContext aset, bset;	   /* working contexts */
5757 
5758   #if DECCHECK
5759   Int iterations=0;		   /* for later sanity check */
5760   if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5761   #endif
5762 
5763   do {					/* protect allocated storage */
5764     if (SPECIALARG) {			/* handle infinities and NaNs */
5765       if (decNumberIsInfinite(rhs)) {	/* an infinity */
5766 	if (decNumberIsNegative(rhs))	/* -Infinity -> error */
5767 	  *status|=DEC_Invalid_operation;
5768 	 else decNumberCopy(res, rhs);	/* +Infinity -> self */
5769 	}
5770        else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5771       break;}
5772 
5773     if (ISZERO(rhs)) {			/* +/- zeros -> -Infinity */
5774       decNumberZero(res);		/* make clean */
5775       res->bits=DECINF|DECNEG;		/* set - infinity */
5776       break;}				/* [no status to set] */
5777 
5778     /* Non-zero negatives are bad... */
5779     if (decNumberIsNegative(rhs)) {	/* -x -> error */
5780       *status|=DEC_Invalid_operation;
5781       break;}
5782 
5783     /* Here, rhs is positive, finite, and in range */
5784 
5785     /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5786     if (rhs->exponent==0 && set->digits<=40) {
5787       #if DECDPUN==1
5788       if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5789       #else
5790       if (rhs->lsu[0]==10 && rhs->digits==2) {			/* ln(10) */
5791       #endif
5792 	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5793 	#define LN10 "2.302585092994045684017991454684364207601"
5794 	decNumberFromString(res, LN10, &aset);
5795 	*status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5796 	break;}
5797       if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5798 	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5799 	#define LN2 "0.6931471805599453094172321214581765680755"
5800 	decNumberFromString(res, LN2, &aset);
5801 	*status|=(DEC_Inexact | DEC_Rounded);
5802 	break;}
5803       } /* integer and short */
5804 
5805     /* Determine the working precision.	 This is normally the */
5806     /* requested precision + 2, with a minimum of 9.  However, if */
5807     /* the rhs is 'over-precise' then allow for all its digits to */
5808     /* potentially participate (consider an rhs where all the excess */
5809     /* digits are 9s) so in this case use rhs->digits+2. */
5810     p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5811 
5812     /* Allocate space for the accumulator and the high-precision */
5813     /* adjustment calculator, if necessary.  The accumulator must */
5814     /* be able to hold p digits, and the adjustment up to */
5815     /* rhs->digits+p digits.  They are also made big enough for 16 */
5816     /* digits so that they can be used for calculating the initial */
5817     /* estimate. */
5818     needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5819     if (needbytes>sizeof(bufa)) {     /* need malloc space */
5820       allocbufa=(decNumber *)malloc(needbytes);
5821       if (allocbufa==NULL) {	      /* hopeless -- abandon */
5822 	*status|=DEC_Insufficient_storage;
5823 	break;}
5824       a=allocbufa;		      /* use the allocated space */
5825       }
5826     pp=p+rhs->digits;
5827     needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5828     if (needbytes>sizeof(bufb)) {     /* need malloc space */
5829       allocbufb=(decNumber *)malloc(needbytes);
5830       if (allocbufb==NULL) {	      /* hopeless -- abandon */
5831 	*status|=DEC_Insufficient_storage;
5832 	break;}
5833       b=allocbufb;		      /* use the allocated space */
5834       }
5835 
5836     /* Prepare an initial estimate in acc. Calculate this by */
5837     /* considering the coefficient of x to be a normalized fraction, */
5838     /* f, with the decimal point at far left and multiplied by */
5839     /* 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and */
5840     /*	 ln(x) = ln(f) + ln(10)*r */
5841     /* Get the initial estimate for ln(f) from a small lookup */
5842     /* table (see above) indexed by the first two digits of f, */
5843     /* truncated. */
5844 
5845     decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5846     r=rhs->exponent+rhs->digits;	/* 'normalised' exponent */
5847     decNumberFromInt32(a, r);		/* a=r */
5848     decNumberFromInt32(b, 2302585);	/* b=ln(10) (2.302585) */
5849     b->exponent=-6;			/*  .. */
5850     decMultiplyOp(a, a, b, &aset, &ignore);  /* a=a*b */
5851     /* now get top two digits of rhs into b by simple truncate and */
5852     /* force to integer */
5853     residue=0;				/* (no residue) */
5854     aset.digits=2; aset.round=DEC_ROUND_DOWN;
5855     decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5856     b->exponent=0;			/* make integer */
5857     t=decGetInt(b);			/* [cannot fail] */
5858     if (t<10) t=X10(t);			/* adjust single-digit b */
5859     t=LNnn[t-10];			/* look up ln(b) */
5860     decNumberFromInt32(b, t>>2);	/* b=ln(b) coefficient */
5861     b->exponent=-(t&3)-3;		/* set exponent */
5862     b->bits=DECNEG;			/* ln(0.10)->ln(0.99) always -ve */
5863     aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5864     decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5865     /* the initial estimate is now in a, with up to 4 digits correct. */
5866     /* When rhs is at or near Nmax the estimate will be low, so we */
5867     /* will approach it from below, avoiding overflow when calling exp. */
5868 
5869     decNumberZero(&numone); *numone.lsu=1;   /* constant 1 for adjustment */
5870 
5871     /* accumulator bounds are as requested (could underflow, but */
5872     /* cannot overflow) */
5873     aset.emax=set->emax;
5874     aset.emin=set->emin;
5875     aset.clamp=0;			/* no concrete format */
5876     /* set up a context to be used for the multiply and subtract */
5877     bset=aset;
5878     bset.emax=DEC_MAX_MATH*2;		/* use double bounds for the */
5879     bset.emin=-DEC_MAX_MATH*2;		/* adjustment calculation */
5880 					/* [see decExpOp call below] */
5881     /* for each iteration double the number of digits to calculate, */
5882     /* up to a maximum of p */
5883     pp=9;				/* initial precision */
5884     /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5885     /* 34+2, which is ideal for standard-sized numbers] */
5886     aset.digits=pp;			/* working context */
5887     bset.digits=pp+rhs->digits;		/* wider context */
5888     for (;;) {				/* iterate */
5889       #if DECCHECK
5890       iterations++;
5891       if (iterations>24) break;		/* consider 9 * 2**24 */
5892       #endif
5893       /* calculate the adjustment (exp(-a)*x-1) into b.	 This is a */
5894       /* catastrophic subtraction but it really is the difference */
5895       /* from 1 that is of interest. */
5896       /* Use the internal entry point to Exp as it allows the double */
5897       /* range for calculating exp(-a) when a is the tiniest subnormal. */
5898       a->bits^=DECNEG;			/* make -a */
5899       decExpOp(b, a, &bset, &ignore);	/* b=exp(-a) */
5900       a->bits^=DECNEG;			/* restore sign of a */
5901       /* now multiply by rhs and subtract 1, at the wider precision */
5902       decMultiplyOp(b, b, rhs, &bset, &ignore);	       /* b=b*rhs */
5903       decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5904 
5905       /* the iteration ends when the adjustment cannot affect the */
5906       /* result by >=0.5 ulp (at the requested digits), which */
5907       /* is when its value is smaller than the accumulator by */
5908       /* set->digits+1 digits (or it is zero) -- this is a looser */
5909       /* requirement than for Exp because all that happens to the */
5910       /* accumulator after this is the final rounding (but note that */
5911       /* there must also be full precision in a, or a=0). */
5912 
5913       if (decNumberIsZero(b) ||
5914 	  (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5915 	if (a->digits==p) break;
5916 	if (decNumberIsZero(a)) {
5917 	  decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5918 	  if (cmp.lsu[0]==0) a->exponent=0;	       /* yes, exact 0 */
5919 	   else *status|=(DEC_Inexact | DEC_Rounded);  /* no, inexact */
5920 	  break;
5921 	  }
5922 	/* force padding if adjustment has gone to 0 before full length */
5923 	if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5924 	}
5925 
5926       /* not done yet ... */
5927       decAddOp(a, a, b, &aset, 0, &ignore);  /* a=a+b for next estimate */
5928       if (pp==p) continue;		     /* precision is at maximum */
5929       /* lengthen the next calculation */
5930       pp=pp*2;				     /* double precision */
5931       if (pp>p) pp=p;			     /* clamp to maximum */
5932       aset.digits=pp;			     /* working context */
5933       bset.digits=pp+rhs->digits;	     /* wider context */
5934       } /* Newton's iteration */
5935 
5936     #if DECCHECK
5937     /* just a sanity check; remove the test to show always */
5938     if (iterations>24)
5939       printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5940 	    iterations, *status, p, rhs->digits);
5941     #endif
5942 
5943     /* Copy and round the result to res */
5944     residue=1;				/* indicate dirt to right */
5945     if (ISZERO(a)) residue=0;		/* .. unless underflowed to 0 */
5946     aset.digits=set->digits;		/* [use default rounding] */
5947     decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5948     decFinish(res, set, &residue, status);	 /* cleanup/set flags */
5949     } while(0);				/* end protected */
5950 
5951   if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
5952   if (allocbufb!=NULL) free(allocbufb); /* .. */
5953   /* [status is handled by caller] */
5954   return res;
5955   } /* decLnOp */
5956 
5957 /* ------------------------------------------------------------------ */
5958 /* decQuantizeOp  -- force exponent to requested value		      */
5959 /*								      */
5960 /*   This computes C = op(A, B), where op adjusts the coefficient     */
5961 /*   of C (by rounding or shifting) such that the exponent (-scale)   */
5962 /*   of C has the value B or matches the exponent of B.		      */
5963 /*   The numerical value of C will equal A, except for the effects of */
5964 /*   any rounding that occurred.				      */
5965 /*								      */
5966 /*   res is C, the result.  C may be A or B			      */
5967 /*   lhs is A, the number to adjust				      */
5968 /*   rhs is B, the requested exponent				      */
5969 /*   set is the context						      */
5970 /*   quant is 1 for quantize or 0 for rescale			      */
5971 /*   status is the status accumulator (this can be called without     */
5972 /*	    risk of control loss)				      */
5973 /*								      */
5974 /* C must have space for set->digits digits.			      */
5975 /*								      */
5976 /* Unless there is an error or the result is infinite, the exponent   */
5977 /* after the operation is guaranteed to be that requested.	      */
5978 /* ------------------------------------------------------------------ */
5979 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5980 				 const decNumber *rhs, decContext *set,
5981 				 Flag quant, uInt *status) {
5982   #if DECSUBSET
5983   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
5984   decNumber *allocrhs=NULL;	   /* .., rhs */
5985   #endif
5986   const decNumber *inrhs=rhs;	   /* save original rhs */
5987   Int	reqdigits=set->digits;	   /* requested DIGITS */
5988   Int	reqexp;			   /* requested exponent [-scale] */
5989   Int	residue=0;		   /* rounding residue */
5990   Int	etiny=set->emin-(reqdigits-1);
5991 
5992   #if DECCHECK
5993   if (decCheckOperands(res, lhs, rhs, set)) return res;
5994   #endif
5995 
5996   do {				   /* protect allocated storage */
5997     #if DECSUBSET
5998     if (!set->extended) {
5999       /* reduce operands and set lostDigits status, as needed */
6000       if (lhs->digits>reqdigits) {
6001 	alloclhs=decRoundOperand(lhs, set, status);
6002 	if (alloclhs==NULL) break;
6003 	lhs=alloclhs;
6004 	}
6005       if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
6006 	allocrhs=decRoundOperand(rhs, set, status);
6007 	if (allocrhs==NULL) break;
6008 	rhs=allocrhs;
6009 	}
6010       }
6011     #endif
6012     /* [following code does not require input rounding] */
6013 
6014     /* Handle special values */
6015     if (SPECIALARGS) {
6016       /* NaNs get usual processing */
6017       if (SPECIALARGS & (DECSNAN | DECNAN))
6018 	decNaNs(res, lhs, rhs, set, status);
6019       /* one infinity but not both is bad */
6020       else if ((lhs->bits ^ rhs->bits) & DECINF)
6021 	*status|=DEC_Invalid_operation;
6022       /* both infinity: return lhs */
6023       else decNumberCopy(res, lhs);	     /* [nop if in place] */
6024       break;
6025       }
6026 
6027     /* set requested exponent */
6028     if (quant) reqexp=inrhs->exponent;	/* quantize -- match exponents */
6029      else {				/* rescale -- use value of rhs */
6030       /* Original rhs must be an integer that fits and is in range, */
6031       /* which could be from -1999999997 to +999999999, thanks to */
6032       /* subnormals */
6033       reqexp=decGetInt(inrhs);		     /* [cannot fail] */
6034       }
6035 
6036     #if DECSUBSET
6037     if (!set->extended) etiny=set->emin;     /* no subnormals */
6038     #endif
6039 
6040     if (reqexp==BADINT			     /* bad (rescale only) or .. */
6041      || reqexp==BIGODD || reqexp==BIGEVEN    /* very big (ditto) or .. */
6042      || (reqexp<etiny)			     /* < lowest */
6043      || (reqexp>set->emax)) {		     /* > emax */
6044       *status|=DEC_Invalid_operation;
6045       break;}
6046 
6047     /* the RHS has been processed, so it can be overwritten now if necessary */
6048     if (ISZERO(lhs)) {			     /* zero coefficient unchanged */
6049       decNumberCopy(res, lhs);		     /* [nop if in place] */
6050       res->exponent=reqexp;		     /* .. just set exponent */
6051       #if DECSUBSET
6052       if (!set->extended) res->bits=0;	     /* subset specification; no -0 */
6053       #endif
6054       }
6055      else {				     /* non-zero lhs */
6056       Int adjust=reqexp-lhs->exponent;	     /* digit adjustment needed */
6057       /* if adjusted coefficient will definitely not fit, give up now */
6058       if ((lhs->digits-adjust)>reqdigits) {
6059 	*status|=DEC_Invalid_operation;
6060 	break;
6061 	}
6062 
6063       if (adjust>0) {			     /* increasing exponent */
6064 	/* this will decrease the length of the coefficient by adjust */
6065 	/* digits, and must round as it does so */
6066 	decContext workset;		     /* work */
6067 	workset=*set;			     /* clone rounding, etc. */
6068 	workset.digits=lhs->digits-adjust;   /* set requested length */
6069 	/* [note that the latter can be <1, here] */
6070 	decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
6071 	decApplyRound(res, &workset, residue, status);	  /* .. and round */
6072 	residue=0;					  /* [used] */
6073 	/* If just rounded a 999s case, exponent will be off by one; */
6074 	/* adjust back (after checking space), if so. */
6075 	if (res->exponent>reqexp) {
6076 	  /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
6077 	  /* set->digits==3 */
6078 	  if (res->digits==reqdigits) {	     /* cannot shift by 1 */
6079 	    *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
6080 	    *status|=DEC_Invalid_operation;
6081 	    break;
6082 	    }
6083 	  res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
6084 	  res->exponent--;		     /* (re)adjust the exponent. */
6085 	  }
6086 	#if DECSUBSET
6087 	if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
6088 	#endif
6089 	} /* increase */
6090        else /* adjust<=0 */ {		     /* decreasing or = exponent */
6091 	/* this will increase the length of the coefficient by -adjust */
6092 	/* digits, by adding zero or more trailing zeros; this is */
6093 	/* already checked for fit, above */
6094 	decNumberCopy(res, lhs);	     /* [it will fit] */
6095 	/* if padding needed (adjust<0), add it now... */
6096 	if (adjust<0) {
6097 	  res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
6098 	  res->exponent+=adjust;	     /* adjust the exponent */
6099 	  }
6100 	} /* decrease */
6101       } /* non-zero */
6102 
6103     /* Check for overflow [do not use Finalize in this case, as an */
6104     /* overflow here is a "don't fit" situation] */
6105     if (res->exponent>set->emax-res->digits+1) {  /* too big */
6106       *status|=DEC_Invalid_operation;
6107       break;
6108       }
6109      else {
6110       decFinalize(res, set, &residue, status);	  /* set subnormal flags */
6111       *status&=~DEC_Underflow;		/* suppress Underflow [754r] */
6112       }
6113     } while(0);				/* end protected */
6114 
6115   #if DECSUBSET
6116   if (allocrhs!=NULL) free(allocrhs);	/* drop any storage used */
6117   if (alloclhs!=NULL) free(alloclhs);	/* .. */
6118   #endif
6119   return res;
6120   } /* decQuantizeOp */
6121 
6122 /* ------------------------------------------------------------------ */
6123 /* decCompareOp -- compare, min, or max two Numbers		      */
6124 /*								      */
6125 /*   This computes C = A ? B and carries out one of four operations:  */
6126 /*     COMPARE	  -- returns the signum (as a number) giving the      */
6127 /*		     result of a comparison unless one or both	      */
6128 /*		     operands is a NaN (in which case a NaN results)  */
6129 /*     COMPSIG	  -- as COMPARE except that a quiet NaN raises	      */
6130 /*		     Invalid operation.				      */
6131 /*     COMPMAX	  -- returns the larger of the operands, using the    */
6132 /*		     754r maxnum operation			      */
6133 /*     COMPMAXMAG -- ditto, comparing absolute values		      */
6134 /*     COMPMIN	  -- the 754r minnum operation			      */
6135 /*     COMPMINMAG -- ditto, comparing absolute values		      */
6136 /*     COMTOTAL	  -- returns the signum (as a number) giving the      */
6137 /*		     result of a comparison using 754r total ordering */
6138 /*								      */
6139 /*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
6140 /*   lhs is A							      */
6141 /*   rhs is B							      */
6142 /*   set is the context						      */
6143 /*   op	 is the operation flag					      */
6144 /*   status is the usual accumulator				      */
6145 /*								      */
6146 /* C must have space for one digit for COMPARE or set->digits for     */
6147 /* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG.			      */
6148 /* ------------------------------------------------------------------ */
6149 /* The emphasis here is on speed for common cases, and avoiding	      */
6150 /* coefficient comparison if possible.				      */
6151 /* ------------------------------------------------------------------ */
6152 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs,
6153                                const decNumber *rhs, decContext *set,
6154                                Flag op, uInt *status) {
6155   #if DECSUBSET
6156   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
6157   decNumber *allocrhs=NULL;	   /* .., rhs */
6158   #endif
6159   Int	result=0;		   /* default result value */
6160   uByte merged;			   /* work */
6161 
6162   #if DECCHECK
6163   if (decCheckOperands(res, lhs, rhs, set)) return res;
6164   #endif
6165 
6166   do {				   /* protect allocated storage */
6167     #if DECSUBSET
6168     if (!set->extended) {
6169       /* reduce operands and set lostDigits status, as needed */
6170       if (lhs->digits>set->digits) {
6171 	alloclhs=decRoundOperand(lhs, set, status);
6172 	if (alloclhs==NULL) {result=BADINT; break;}
6173 	lhs=alloclhs;
6174 	}
6175       if (rhs->digits>set->digits) {
6176 	allocrhs=decRoundOperand(rhs, set, status);
6177 	if (allocrhs==NULL) {result=BADINT; break;}
6178 	rhs=allocrhs;
6179 	}
6180       }
6181     #endif
6182     /* [following code does not require input rounding] */
6183 
6184     /* If total ordering then handle differing signs 'up front' */
6185     if (op==COMPTOTAL) {		/* total ordering */
6186       if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6187 	result=-1;
6188 	break;
6189 	}
6190       if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6191 	result=+1;
6192 	break;
6193 	}
6194       }
6195 
6196     /* handle NaNs specially; let infinities drop through */
6197     /* This assumes sNaN (even just one) leads to NaN. */
6198     merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6199     if (merged) {			/* a NaN bit set */
6200       if (op==COMPARE);			/* result will be NaN */
6201        else if (op==COMPSIG)		/* treat qNaN as sNaN */
6202 	*status|=DEC_Invalid_operation | DEC_sNaN;
6203        else if (op==COMPTOTAL) {	/* total ordering, always finite */
6204 	/* signs are known to be the same; compute the ordering here */
6205 	/* as if the signs are both positive, then invert for negatives */
6206 	if (!decNumberIsNaN(lhs)) result=-1;
6207 	 else if (!decNumberIsNaN(rhs)) result=+1;
6208 	 /* here if both NaNs */
6209 	 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6210 	 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6211 	 else { /* both NaN or both sNaN */
6212 	  /* now it just depends on the payload */
6213 	  result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6214 				rhs->lsu, D2U(rhs->digits), 0);
6215 	  /* [Error not possible, as these are 'aligned'] */
6216 	  } /* both same NaNs */
6217 	if (decNumberIsNegative(lhs)) result=-result;
6218 	break;
6219 	} /* total order */
6220 
6221        else if (merged & DECSNAN);	     /* sNaN -> qNaN */
6222        else { /* here if MIN or MAX and one or two quiet NaNs */
6223 	/* min or max -- 754r rules ignore single NaN */
6224 	if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6225 	  /* just one NaN; force choice to be the non-NaN operand */
6226 	  op=COMPMAX;
6227 	  if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6228 			     else result=+1; /* pick lhs */
6229 	  break;
6230 	  }
6231 	} /* max or min */
6232       op=COMPNAN;			     /* use special path */
6233       decNaNs(res, lhs, rhs, set, status);   /* propagate NaN */
6234       break;
6235       }
6236     /* have numbers */
6237     if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6238      else result=decCompare(lhs, rhs, 0);    /* sign matters */
6239     } while(0);				     /* end protected */
6240 
6241   if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6242    else {
6243     if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6244       if (op==COMPTOTAL && result==0) {
6245 	/* operands are numerically equal or same NaN (and same sign, */
6246 	/* tested first); if identical, leave result 0 */
6247 	if (lhs->exponent!=rhs->exponent) {
6248 	  if (lhs->exponent<rhs->exponent) result=-1;
6249 	   else result=+1;
6250 	  if (decNumberIsNegative(lhs)) result=-result;
6251 	  } /* lexp!=rexp */
6252 	} /* total-order by exponent */
6253       decNumberZero(res);		/* [always a valid result] */
6254       if (result!=0) {			/* must be -1 or +1 */
6255 	*res->lsu=1;
6256 	if (result<0) res->bits=DECNEG;
6257 	}
6258       }
6259      else if (op==COMPNAN);		/* special, drop through */
6260      else {				/* MAX or MIN, non-NaN result */
6261       Int residue=0;			/* rounding accumulator */
6262       /* choose the operand for the result */
6263       const decNumber *choice;
6264       if (result==0) { /* operands are numerically equal */
6265 	/* choose according to sign then exponent (see 754r) */
6266 	uByte slhs=(lhs->bits & DECNEG);
6267 	uByte srhs=(rhs->bits & DECNEG);
6268 	#if DECSUBSET
6269 	if (!set->extended) {		/* subset: force left-hand */
6270 	  op=COMPMAX;
6271 	  result=+1;
6272 	  }
6273 	else
6274 	#endif
6275 	if (slhs!=srhs) {	   /* signs differ */
6276 	  if (slhs) result=-1;	   /* rhs is max */
6277 	       else result=+1;	   /* lhs is max */
6278 	  }
6279 	 else if (slhs && srhs) {  /* both negative */
6280 	  if (lhs->exponent<rhs->exponent) result=+1;
6281 				      else result=-1;
6282 	  /* [if equal, use lhs, technically identical] */
6283 	  }
6284 	 else {			   /* both positive */
6285 	  if (lhs->exponent>rhs->exponent) result=+1;
6286 				      else result=-1;
6287 	  /* [ditto] */
6288 	  }
6289 	} /* numerically equal */
6290       /* here result will be non-0; reverse if looking for MIN */
6291       if (op==COMPMIN || op==COMPMINMAG) result=-result;
6292       choice=(result>0 ? lhs : rhs);	/* choose */
6293       /* copy chosen to result, rounding if need be */
6294       decCopyFit(res, choice, set, &residue, status);
6295       decFinish(res, set, &residue, status);
6296       }
6297     }
6298   #if DECSUBSET
6299   if (allocrhs!=NULL) free(allocrhs);	/* free any storage used */
6300   if (alloclhs!=NULL) free(alloclhs);	/* .. */
6301   #endif
6302   return res;
6303   } /* decCompareOp */
6304 
6305 /* ------------------------------------------------------------------ */
6306 /* decCompare -- compare two decNumbers by numerical value	      */
6307 /*								      */
6308 /*  This routine compares A ? B without altering them.		      */
6309 /*								      */
6310 /*  Arg1 is A, a decNumber which is not a NaN			      */
6311 /*  Arg2 is B, a decNumber which is not a NaN			      */
6312 /*  Arg3 is 1 for a sign-independent compare, 0 otherwise	      */
6313 /*								      */
6314 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6315 /*  (the only possible failure is an allocation error)		      */
6316 /* ------------------------------------------------------------------ */
6317 static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6318 		      Flag abs) {
6319   Int	result;			   /* result value */
6320   Int	sigr;			   /* rhs signum */
6321   Int	compare;		   /* work */
6322 
6323   result=1;				     /* assume signum(lhs) */
6324   if (ISZERO(lhs)) result=0;
6325   if (abs) {
6326     if (ISZERO(rhs)) return result;	     /* LHS wins or both 0 */
6327     /* RHS is non-zero */
6328     if (result==0) return -1;		     /* LHS is 0; RHS wins */
6329     /* [here, both non-zero, result=1] */
6330     }
6331    else {				     /* signs matter */
6332     if (result && decNumberIsNegative(lhs)) result=-1;
6333     sigr=1;				     /* compute signum(rhs) */
6334     if (ISZERO(rhs)) sigr=0;
6335      else if (decNumberIsNegative(rhs)) sigr=-1;
6336     if (result > sigr) return +1;	     /* L > R, return 1 */
6337     if (result < sigr) return -1;	     /* L < R, return -1 */
6338     if (result==0) return 0;		       /* both 0 */
6339     }
6340 
6341   /* signums are the same; both are non-zero */
6342   if ((lhs->bits | rhs->bits) & DECINF) {    /* one or more infinities */
6343     if (decNumberIsInfinite(rhs)) {
6344       if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6345        else result=-result;		     /* only rhs infinite */
6346       }
6347     return result;
6348     }
6349   /* must compare the coefficients, allowing for exponents */
6350   if (lhs->exponent>rhs->exponent) {	     /* LHS exponent larger */
6351     /* swap sides, and sign */
6352     const decNumber *temp=lhs;
6353     lhs=rhs;
6354     rhs=temp;
6355     result=-result;
6356     }
6357   compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6358 			 rhs->lsu, D2U(rhs->digits),
6359 			 rhs->exponent-lhs->exponent);
6360   if (compare!=BADINT) compare*=result;	     /* comparison succeeded */
6361   return compare;
6362   } /* decCompare */
6363 
6364 /* ------------------------------------------------------------------ */
6365 /* decUnitCompare -- compare two >=0 integers in Unit arrays	      */
6366 /*								      */
6367 /*  This routine compares A ? B*10**E where A and B are unit arrays   */
6368 /*  A is a plain integer					      */
6369 /*  B has an exponent of E (which must be non-negative)		      */
6370 /*								      */
6371 /*  Arg1 is A first Unit (lsu)					      */
6372 /*  Arg2 is A length in Units					      */
6373 /*  Arg3 is B first Unit (lsu)					      */
6374 /*  Arg4 is B length in Units					      */
6375 /*  Arg5 is E (0 if the units are aligned)			      */
6376 /*								      */
6377 /*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6378 /*  (the only possible failure is an allocation error, which can      */
6379 /*  only occur if E!=0)						      */
6380 /* ------------------------------------------------------------------ */
6381 static Int decUnitCompare(const Unit *a, Int alength,
6382 			  const Unit *b, Int blength, Int exp) {
6383   Unit	*acc;			   /* accumulator for result */
6384   Unit	accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6385   Unit	*allocacc=NULL;		   /* -> allocated acc buffer, iff allocated */
6386   Int	accunits, need;		   /* units in use or needed for acc */
6387   const Unit *l, *r, *u;	   /* work */
6388   Int	expunits, exprem, result;  /* .. */
6389 
6390   if (exp==0) {			   /* aligned; fastpath */
6391     if (alength>blength) return 1;
6392     if (alength<blength) return -1;
6393     /* same number of units in both -- need unit-by-unit compare */
6394     l=a+alength-1;
6395     r=b+alength-1;
6396     for (;l>=a; l--, r--) {
6397       if (*l>*r) return 1;
6398       if (*l<*r) return -1;
6399       }
6400     return 0;			   /* all units match */
6401     } /* aligned */
6402 
6403   /* Unaligned.	 If one is >1 unit longer than the other, padded */
6404   /* approximately, then can return easily */
6405   if (alength>blength+(Int)D2U(exp)) return 1;
6406   if (alength+1<blength+(Int)D2U(exp)) return -1;
6407 
6408   /* Need to do a real subtract.  For this, a result buffer is needed */
6409   /* even though only the sign is of interest.	Its length needs */
6410   /* to be the larger of alength and padded blength, +2 */
6411   need=blength+D2U(exp);		/* maximum real length of B */
6412   if (need<alength) need=alength;
6413   need+=2;
6414   acc=accbuff;				/* assume use local buffer */
6415   if (need*sizeof(Unit)>sizeof(accbuff)) {
6416     allocacc=(Unit *)malloc(need*sizeof(Unit));
6417     if (allocacc==NULL) return BADINT;	/* hopeless -- abandon */
6418     acc=allocacc;
6419     }
6420   /* Calculate units and remainder from exponent. */
6421   expunits=exp/DECDPUN;
6422   exprem=exp%DECDPUN;
6423   /* subtract [A+B*(-m)] */
6424   accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6425 			 -(Int)powers[exprem]);
6426   /* [UnitAddSub result may have leading zeros, even on zero] */
6427   if (accunits<0) result=-1;		/* negative result */
6428    else {				/* non-negative result */
6429     /* check units of the result before freeing any storage */
6430     for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6431     result=(*u==0 ? 0 : +1);
6432     }
6433   /* clean up and return the result */
6434   if (allocacc!=NULL) free(allocacc);	/* drop any storage used */
6435   return result;
6436   } /* decUnitCompare */
6437 
6438 /* ------------------------------------------------------------------ */
6439 /* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
6440 /*								      */
6441 /*  This routine performs the calculation:			      */
6442 /*								      */
6443 /*  C=A+(B*M)							      */
6444 /*								      */
6445 /*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.	      */
6446 /*								      */
6447 /*  A may be shorter or longer than B.				      */
6448 /*								      */
6449 /*  Leading zeros are not removed after a calculation.	The result is */
6450 /*  either the same length as the longer of A and B (adding any	      */
6451 /*  shift), or one Unit longer than that (if a Unit carry occurred).  */
6452 /*								      */
6453 /*  A and B content are not altered unless C is also A or B.	      */
6454 /*  C may be the same array as A or B, but only if no zero padding is */
6455 /*  requested (that is, C may be B only if bshift==0).		      */
6456 /*  C is filled from the lsu; only those units necessary to complete  */
6457 /*  the calculation are referenced.				      */
6458 /*								      */
6459 /*  Arg1 is A first Unit (lsu)					      */
6460 /*  Arg2 is A length in Units					      */
6461 /*  Arg3 is B first Unit (lsu)					      */
6462 /*  Arg4 is B length in Units					      */
6463 /*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
6464 /*  Arg6 is C first Unit (lsu)					      */
6465 /*  Arg7 is M, the multiplier					      */
6466 /*								      */
6467 /*  returns the count of Units written to C, which will be non-zero   */
6468 /*  and negated if the result is negative.  That is, the sign of the  */
6469 /*  returned Int is the sign of the result (positive for zero) and    */
6470 /*  the absolute value of the Int is the count of Units.	      */
6471 /*								      */
6472 /*  It is the caller's responsibility to make sure that C size is     */
6473 /*  safe, allowing space if necessary for a one-Unit carry.	      */
6474 /*								      */
6475 /*  This routine is severely performance-critical; *any* change here  */
6476 /*  must be measured (timed) to assure no performance degradation.    */
6477 /*  In particular, trickery here tends to be counter-productive, as   */
6478 /*  increased complexity of code hurts register optimizations on      */
6479 /*  register-poor architectures.  Avoiding divisions is nearly	      */
6480 /*  always a Good Idea, however.				      */
6481 /*								      */
6482 /* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
6483 /* (IBM Warwick, UK) for some of the ideas used in this routine.      */
6484 /* ------------------------------------------------------------------ */
6485 static Int decUnitAddSub(const Unit *a, Int alength,
6486 			 const Unit *b, Int blength, Int bshift,
6487 			 Unit *c, Int m) {
6488   const Unit *alsu=a;		   /* A lsu [need to remember it] */
6489   Unit *clsu=c;			   /* C ditto */
6490   Unit *minC;			   /* low water mark for C */
6491   Unit *maxC;			   /* high water mark for C */
6492   eInt carry=0;			   /* carry integer (could be Long) */
6493   Int  add;			   /* work */
6494   #if DECDPUN<=4		   /* myriadal, millenary, etc. */
6495   Int  est;			   /* estimated quotient */
6496   #endif
6497 
6498   #if DECTRACE
6499   if (alength<1 || blength<1)
6500     printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6501   #endif
6502 
6503   maxC=c+alength;		   /* A is usually the longer */
6504   minC=c+blength;		   /* .. and B the shorter */
6505   if (bshift!=0) {		   /* B is shifted; low As copy across */
6506     minC+=bshift;
6507     /* if in place [common], skip copy unless there's a gap [rare] */
6508     if (a==c && bshift<=alength) {
6509       c+=bshift;
6510       a+=bshift;
6511       }
6512      else for (; c<clsu+bshift; a++, c++) {  /* copy needed */
6513       if (a<alsu+alength) *c=*a;
6514        else *c=0;
6515       }
6516     }
6517   if (minC>maxC) { /* swap */
6518     Unit *hold=minC;
6519     minC=maxC;
6520     maxC=hold;
6521     }
6522 
6523   /* For speed, do the addition as two loops; the first where both A */
6524   /* and B contribute, and the second (if necessary) where only one or */
6525   /* other of the numbers contribute. */
6526   /* Carry handling is the same (i.e., duplicated) in each case. */
6527   for (; c<minC; c++) {
6528     carry+=*a;
6529     a++;
6530     carry+=((eInt)*b)*m;		/* [special-casing m=1/-1 */
6531     b++;				/* here is not a win] */
6532     /* here carry is new Unit of digits; it could be +ve or -ve */
6533     if ((ueInt)carry<=DECDPUNMAX) {	/* fastpath 0-DECDPUNMAX */
6534       *c=(Unit)carry;
6535       carry=0;
6536       continue;
6537       }
6538     #if DECDPUN==4			     /* use divide-by-multiply */
6539       if (carry>=0) {
6540 	est=(((ueInt)carry>>11)*53687)>>18;
6541 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6542 	carry=est;			     /* likely quotient [89%] */
6543 	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6544 	carry++;
6545 	*c-=DECDPUNMAX+1;
6546 	continue;
6547 	}
6548       /* negative case */
6549       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6550       est=(((ueInt)carry>>11)*53687)>>18;
6551       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6552       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6553       if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6554       carry++;
6555       *c-=DECDPUNMAX+1;
6556     #elif DECDPUN==3
6557       if (carry>=0) {
6558 	est=(((ueInt)carry>>3)*16777)>>21;
6559 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6560 	carry=est;			     /* likely quotient [99%] */
6561 	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6562 	carry++;
6563 	*c-=DECDPUNMAX+1;
6564 	continue;
6565 	}
6566       /* negative case */
6567       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6568       est=(((ueInt)carry>>3)*16777)>>21;
6569       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6570       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6571       if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6572       carry++;
6573       *c-=DECDPUNMAX+1;
6574     #elif DECDPUN<=2
6575       /* Can use QUOT10 as carry <= 4 digits */
6576       if (carry>=0) {
6577 	est=QUOT10(carry, DECDPUN);
6578 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6579 	carry=est;			     /* quotient */
6580 	continue;
6581 	}
6582       /* negative case */
6583       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6584       est=QUOT10(carry, DECDPUN);
6585       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6586       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6587     #else
6588       /* remainder operator is undefined if negative, so must test */
6589       if ((ueInt)carry<(DECDPUNMAX+1)*2) {   /* fastpath carry +1 */
6590 	*c=(Unit)(carry-(DECDPUNMAX+1));     /* [helps additions] */
6591 	carry=1;
6592 	continue;
6593 	}
6594       if (carry>=0) {
6595 	*c=(Unit)(carry%(DECDPUNMAX+1));
6596 	carry=carry/(DECDPUNMAX+1);
6597 	continue;
6598 	}
6599       /* negative case */
6600       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6601       *c=(Unit)(carry%(DECDPUNMAX+1));
6602       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6603     #endif
6604     } /* c */
6605 
6606   /* now may have one or other to complete */
6607   /* [pretest to avoid loop setup/shutdown] */
6608   if (c<maxC) for (; c<maxC; c++) {
6609     if (a<alsu+alength) {		/* still in A */
6610       carry+=*a;
6611       a++;
6612       }
6613      else {				/* inside B */
6614       carry+=((eInt)*b)*m;
6615       b++;
6616       }
6617     /* here carry is new Unit of digits; it could be +ve or -ve and */
6618     /* magnitude up to DECDPUNMAX squared */
6619     if ((ueInt)carry<=DECDPUNMAX) {	/* fastpath 0-DECDPUNMAX */
6620       *c=(Unit)carry;
6621       carry=0;
6622       continue;
6623       }
6624     /* result for this unit is negative or >DECDPUNMAX */
6625     #if DECDPUN==4			     /* use divide-by-multiply */
6626       if (carry>=0) {
6627 	est=(((ueInt)carry>>11)*53687)>>18;
6628 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6629 	carry=est;			     /* likely quotient [79.7%] */
6630 	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6631 	carry++;
6632 	*c-=DECDPUNMAX+1;
6633 	continue;
6634 	}
6635       /* negative case */
6636       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6637       est=(((ueInt)carry>>11)*53687)>>18;
6638       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6639       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6640       if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6641       carry++;
6642       *c-=DECDPUNMAX+1;
6643     #elif DECDPUN==3
6644       if (carry>=0) {
6645 	est=(((ueInt)carry>>3)*16777)>>21;
6646 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6647 	carry=est;			     /* likely quotient [99%] */
6648 	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6649 	carry++;
6650 	*c-=DECDPUNMAX+1;
6651 	continue;
6652 	}
6653       /* negative case */
6654       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6655       est=(((ueInt)carry>>3)*16777)>>21;
6656       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6657       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6658       if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6659       carry++;
6660       *c-=DECDPUNMAX+1;
6661     #elif DECDPUN<=2
6662       if (carry>=0) {
6663 	est=QUOT10(carry, DECDPUN);
6664 	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6665 	carry=est;			     /* quotient */
6666 	continue;
6667 	}
6668       /* negative case */
6669       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6670       est=QUOT10(carry, DECDPUN);
6671       *c=(Unit)(carry-est*(DECDPUNMAX+1));
6672       carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6673     #else
6674       if ((ueInt)carry<(DECDPUNMAX+1)*2){    /* fastpath carry 1 */
6675 	*c=(Unit)(carry-(DECDPUNMAX+1));
6676 	carry=1;
6677 	continue;
6678 	}
6679       /* remainder operator is undefined if negative, so must test */
6680       if (carry>=0) {
6681 	*c=(Unit)(carry%(DECDPUNMAX+1));
6682 	carry=carry/(DECDPUNMAX+1);
6683 	continue;
6684 	}
6685       /* negative case */
6686       carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6687       *c=(Unit)(carry%(DECDPUNMAX+1));
6688       carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6689     #endif
6690     } /* c */
6691 
6692   /* OK, all A and B processed; might still have carry or borrow */
6693   /* return number of Units in the result, negated if a borrow */
6694   if (carry==0) return c-clsu;	   /* no carry, so no more to do */
6695   if (carry>0) {		   /* positive carry */
6696     *c=(Unit)carry;		   /* place as new unit */
6697     c++;			   /* .. */
6698     return c-clsu;
6699     }
6700   /* -ve carry: it's a borrow; complement needed */
6701   add=1;			   /* temporary carry... */
6702   for (c=clsu; c<maxC; c++) {
6703     add=DECDPUNMAX+add-*c;
6704     if (add<=DECDPUNMAX) {
6705       *c=(Unit)add;
6706       add=0;
6707       }
6708      else {
6709       *c=0;
6710       add=1;
6711       }
6712     }
6713   /* add an extra unit iff it would be non-zero */
6714   #if DECTRACE
6715     printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6716   #endif
6717   if ((add-carry-1)!=0) {
6718     *c=(Unit)(add-carry-1);
6719     c++;		      /* interesting, include it */
6720     }
6721   return clsu-c;	      /* -ve result indicates borrowed */
6722   } /* decUnitAddSub */
6723 
6724 /* ------------------------------------------------------------------ */
6725 /* decTrim -- trim trailing zeros or normalize			      */
6726 /*								      */
6727 /*   dn is the number to trim or normalize			      */
6728 /*   set is the context to use to check for clamp		      */
6729 /*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
6730 /*   dropped returns the number of discarded trailing zeros	      */
6731 /*   returns dn							      */
6732 /*								      */
6733 /* If clamp is set in the context then the number of zeros trimmed    */
6734 /* may be limited if the exponent is high.			      */
6735 /* All fields are updated as required.	This is a utility operation,  */
6736 /* so special values are unchanged and no error is possible.	      */
6737 /* ------------------------------------------------------------------ */
6738 static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6739 			   Int *dropped) {
6740   Int	d, exp;			   /* work */
6741   uInt	cut;			   /* .. */
6742   Unit	*up;			   /* -> current Unit */
6743 
6744   #if DECCHECK
6745   if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6746   #endif
6747 
6748   *dropped=0;				/* assume no zeros dropped */
6749   if ((dn->bits & DECSPECIAL)		/* fast exit if special .. */
6750     || (*dn->lsu & 0x01)) return dn;	/* .. or odd */
6751   if (ISZERO(dn)) {			/* .. or 0 */
6752     dn->exponent=0;			/* (sign is preserved) */
6753     return dn;
6754     }
6755 
6756   /* have a finite number which is even */
6757   exp=dn->exponent;
6758   cut=1;			   /* digit (1-DECDPUN) in Unit */
6759   up=dn->lsu;			   /* -> current Unit */
6760   for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6761     /* slice by powers */
6762     #if DECDPUN<=4
6763       uInt quot=QUOT10(*up, cut);
6764       if ((*up-quot*powers[cut])!=0) break;  /* found non-0 digit */
6765     #else
6766       if (*up%powers[cut]!=0) break;	     /* found non-0 digit */
6767     #endif
6768     /* have a trailing 0 */
6769     if (!all) {			   /* trimming */
6770       /* [if exp>0 then all trailing 0s are significant for trim] */
6771       if (exp<=0) {		   /* if digit might be significant */
6772 	if (exp==0) break;	   /* then quit */
6773 	exp++;			   /* next digit might be significant */
6774 	}
6775       }
6776     cut++;			   /* next power */
6777     if (cut>DECDPUN) {		   /* need new Unit */
6778       up++;
6779       cut=1;
6780       }
6781     } /* d */
6782   if (d==0) return dn;		   /* none to drop */
6783 
6784   /* may need to limit drop if clamping */
6785   if (set->clamp) {
6786     Int maxd=set->emax-set->digits+1-dn->exponent;
6787     if (maxd<=0) return dn;	   /* nothing possible */
6788     if (d>maxd) d=maxd;
6789     }
6790 
6791   /* effect the drop */
6792   decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6793   dn->exponent+=d;		   /* maintain numerical value */
6794   dn->digits-=d;		   /* new length */
6795   *dropped=d;			   /* report the count */
6796   return dn;
6797   } /* decTrim */
6798 
6799 /* ------------------------------------------------------------------ */
6800 /* decReverse -- reverse a Unit array in place			      */
6801 /*								      */
6802 /*   ulo    is the start of the array				      */
6803 /*   uhi    is the end of the array (highest Unit to include)	      */
6804 /*								      */
6805 /* The units ulo through uhi are reversed in place (if the number     */
6806 /* of units is odd, the middle one is untouched).  Note that the      */
6807 /* digit(s) in each unit are unaffected.			      */
6808 /* ------------------------------------------------------------------ */
6809 static void decReverse(Unit *ulo, Unit *uhi) {
6810   Unit temp;
6811   for (; ulo<uhi; ulo++, uhi--) {
6812     temp=*ulo;
6813     *ulo=*uhi;
6814     *uhi=temp;
6815     }
6816   return;
6817   } /* decReverse */
6818 
6819 /* ------------------------------------------------------------------ */
6820 /* decShiftToMost -- shift digits in array towards most significant   */
6821 /*								      */
6822 /*   uar    is the array					      */
6823 /*   digits is the count of digits in use in the array		      */
6824 /*   shift  is the number of zeros to pad with (least significant);   */
6825 /*     it must be zero or positive				      */
6826 /*								      */
6827 /*   returns the new length of the integer in the array, in digits    */
6828 /*								      */
6829 /* No overflow is permitted (that is, the uar array must be known to  */
6830 /* be large enough to hold the result, after shifting).		      */
6831 /* ------------------------------------------------------------------ */
6832 static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6833   Unit	*target, *source, *first;  /* work */
6834   Int	cut;			   /* odd 0's to add */
6835   uInt	next;			   /* work */
6836 
6837   if (shift==0) return digits;	   /* [fastpath] nothing to do */
6838   if ((digits+shift)<=DECDPUN) {   /* [fastpath] single-unit case */
6839     *uar=(Unit)(*uar*powers[shift]);
6840     return digits+shift;
6841     }
6842 
6843   next=0;			   /* all paths */
6844   source=uar+D2U(digits)-1;	   /* where msu comes from */
6845   target=source+D2U(shift);	   /* where upper part of first cut goes */
6846   cut=DECDPUN-MSUDIGITS(shift);	   /* where to slice */
6847   if (cut==0) {			   /* unit-boundary case */
6848     for (; source>=uar; source--, target--) *target=*source;
6849     }
6850    else {
6851     first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6852     for (; source>=uar; source--, target--) {
6853       /* split the source Unit and accumulate remainder for next */
6854       #if DECDPUN<=4
6855 	uInt quot=QUOT10(*source, cut);
6856 	uInt rem=*source-quot*powers[cut];
6857 	next+=quot;
6858       #else
6859 	uInt rem=*source%powers[cut];
6860 	next+=*source/powers[cut];
6861       #endif
6862       if (target<=first) *target=(Unit)next;   /* write to target iff valid */
6863       next=rem*powers[DECDPUN-cut];	       /* save remainder for next Unit */
6864       }
6865     } /* shift-move */
6866 
6867   /* propagate any partial unit to one below and clear the rest */
6868   for (; target>=uar; target--) {
6869     *target=(Unit)next;
6870     next=0;
6871     }
6872   return digits+shift;
6873   } /* decShiftToMost */
6874 
6875 /* ------------------------------------------------------------------ */
6876 /* decShiftToLeast -- shift digits in array towards least significant */
6877 /*								      */
6878 /*   uar   is the array						      */
6879 /*   units is length of the array, in units			      */
6880 /*   shift is the number of digits to remove from the lsu end; it     */
6881 /*     must be zero or positive and <= than units*DECDPUN.	      */
6882 /*								      */
6883 /*   returns the new length of the integer in the array, in units     */
6884 /*								      */
6885 /* Removed digits are discarded (lost).	 Units not required to hold   */
6886 /* the final result are unchanged.				      */
6887 /* ------------------------------------------------------------------ */
6888 static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6889   Unit	*target, *up;		   /* work */
6890   Int	cut, count;		   /* work */
6891   Int	quot, rem;		   /* for division */
6892 
6893   if (shift==0) return units;	   /* [fastpath] nothing to do */
6894   if (shift==units*DECDPUN) {	   /* [fastpath] little to do */
6895     *uar=0;			   /* all digits cleared gives zero */
6896     return 1;			   /* leaves just the one */
6897     }
6898 
6899   target=uar;			   /* both paths */
6900   cut=MSUDIGITS(shift);
6901   if (cut==DECDPUN) {		   /* unit-boundary case; easy */
6902     up=uar+D2U(shift);
6903     for (; up<uar+units; target++, up++) *target=*up;
6904     return target-uar;
6905     }
6906 
6907   /* messier */
6908   up=uar+D2U(shift-cut);	   /* source; correct to whole Units */
6909   count=units*DECDPUN-shift;	   /* the maximum new length */
6910   #if DECDPUN<=4
6911     quot=QUOT10(*up, cut);
6912   #else
6913     quot=*up/powers[cut];
6914   #endif
6915   for (; ; target++) {
6916     *target=(Unit)quot;
6917     count-=(DECDPUN-cut);
6918     if (count<=0) break;
6919     up++;
6920     quot=*up;
6921     #if DECDPUN<=4
6922       quot=QUOT10(quot, cut);
6923       rem=*up-quot*powers[cut];
6924     #else
6925       rem=quot%powers[cut];
6926       quot=quot/powers[cut];
6927     #endif
6928     *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6929     count-=cut;
6930     if (count<=0) break;
6931     }
6932   return target-uar+1;
6933   } /* decShiftToLeast */
6934 
6935 #if DECSUBSET
6936 /* ------------------------------------------------------------------ */
6937 /* decRoundOperand -- round an operand	[used for subset only]	      */
6938 /*								      */
6939 /*   dn is the number to round (dn->digits is > set->digits)	      */
6940 /*   set is the relevant context				      */
6941 /*   status is the status accumulator				      */
6942 /*								      */
6943 /*   returns an allocated decNumber with the rounded result.	      */
6944 /*								      */
6945 /* lostDigits and other status may be set by this.		      */
6946 /*								      */
6947 /* Since the input is an operand, it must not be modified.	      */
6948 /* Instead, return an allocated decNumber, rounded as required.	      */
6949 /* It is the caller's responsibility to free the allocated storage.   */
6950 /*								      */
6951 /* If no storage is available then the result cannot be used, so NULL */
6952 /* is returned.							      */
6953 /* ------------------------------------------------------------------ */
6954 static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6955 				  uInt *status) {
6956   decNumber *res;			/* result structure */
6957   uInt newstatus=0;			/* status from round */
6958   Int  residue=0;			/* rounding accumulator */
6959 
6960   /* Allocate storage for the returned decNumber, big enough for the */
6961   /* length specified by the context */
6962   res=(decNumber *)malloc(sizeof(decNumber)
6963 			  +(D2U(set->digits)-1)*sizeof(Unit));
6964   if (res==NULL) {
6965     *status|=DEC_Insufficient_storage;
6966     return NULL;
6967     }
6968   decCopyFit(res, dn, set, &residue, &newstatus);
6969   decApplyRound(res, set, residue, &newstatus);
6970 
6971   /* If that set Inexact then "lost digits" is raised... */
6972   if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6973   *status|=newstatus;
6974   return res;
6975   } /* decRoundOperand */
6976 #endif
6977 
6978 /* ------------------------------------------------------------------ */
6979 /* decCopyFit -- copy a number, truncating the coefficient if needed  */
6980 /*								      */
6981 /*   dest is the target decNumber				      */
6982 /*   src  is the source decNumber				      */
6983 /*   set is the context [used for length (digits) and rounding mode]  */
6984 /*   residue is the residue accumulator				      */
6985 /*   status contains the current status to be updated		      */
6986 /*								      */
6987 /* (dest==src is allowed and will be a no-op if fits)		      */
6988 /* All fields are updated as required.				      */
6989 /* ------------------------------------------------------------------ */
6990 static void decCopyFit(decNumber *dest, const decNumber *src,
6991 		       decContext *set, Int *residue, uInt *status) {
6992   dest->bits=src->bits;
6993   dest->exponent=src->exponent;
6994   decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6995   } /* decCopyFit */
6996 
6997 /* ------------------------------------------------------------------ */
6998 /* decSetCoeff -- set the coefficient of a number		      */
6999 /*								      */
7000 /*   dn	   is the number whose coefficient array is to be set.	      */
7001 /*	   It must have space for set->digits digits		      */
7002 /*   set   is the context [for size]				      */
7003 /*   lsu   -> lsu of the source coefficient [may be dn->lsu]	      */
7004 /*   len   is digits in the source coefficient [may be dn->digits]    */
7005 /*   residue is the residue accumulator.  This has values as in	      */
7006 /*	   decApplyRound, and will be unchanged unless the	      */
7007 /*	   target size is less than len.  In this case, the	      */
7008 /*	   coefficient is truncated and the residue is updated to     */
7009 /*	   reflect the previous residue and the dropped digits.	      */
7010 /*   status is the status accumulator, as usual			      */
7011 /*								      */
7012 /* The coefficient may already be in the number, or it can be an      */
7013 /* external intermediate array.	 If it is in the number, lsu must ==  */
7014 /* dn->lsu and len must == dn->digits.				      */
7015 /*								      */
7016 /* Note that the coefficient length (len) may be < set->digits, and   */
7017 /* in this case this merely copies the coefficient (or is a no-op     */
7018 /* if dn->lsu==lsu).						      */
7019 /*								      */
7020 /* Note also that (only internally, from decQuantizeOp and	      */
7021 /* decSetSubnormal) the value of set->digits may be less than one,    */
7022 /* indicating a round to left.	This routine handles that case	      */
7023 /* correctly; caller ensures space.				      */
7024 /*								      */
7025 /* dn->digits, dn->lsu (and as required), and dn->exponent are	      */
7026 /* updated as necessary.   dn->bits (sign) is unchanged.	      */
7027 /*								      */
7028 /* DEC_Rounded status is set if any digits are discarded.	      */
7029 /* DEC_Inexact status is set if any non-zero digits are discarded, or */
7030 /*			 incoming residue was non-0 (implies rounded) */
7031 /* ------------------------------------------------------------------ */
7032 /* mapping array: maps 0-9 to canonical residues, so that a residue */
7033 /* can be adjusted in the range [-1, +1] and achieve correct rounding */
7034 /*			       0  1  2	3  4  5	 6  7  8  9 */
7035 static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
7036 static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
7037 			Int len, Int *residue, uInt *status) {
7038   Int	discard;	      /* number of digits to discard */
7039   uInt	cut;		      /* cut point in Unit */
7040   const Unit *up;	      /* work */
7041   Unit	*target;	      /* .. */
7042   Int	count;		      /* .. */
7043   #if DECDPUN<=4
7044   uInt	temp;		      /* .. */
7045   #endif
7046 
7047   discard=len-set->digits;    /* digits to discard */
7048   if (discard<=0) {	      /* no digits are being discarded */
7049     if (dn->lsu!=lsu) {	      /* copy needed */
7050       /* copy the coefficient array to the result number; no shift needed */
7051       count=len;	      /* avoids D2U */
7052       up=lsu;
7053       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7054 	*target=*up;
7055       dn->digits=len;	      /* set the new length */
7056       }
7057     /* dn->exponent and residue are unchanged, record any inexactitude */
7058     if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
7059     return;
7060     }
7061 
7062   /* some digits must be discarded ... */
7063   dn->exponent+=discard;      /* maintain numerical value */
7064   *status|=DEC_Rounded;	      /* accumulate Rounded status */
7065   if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
7066 
7067   if (discard>len) {	      /* everything, +1, is being discarded */
7068     /* guard digit is 0 */
7069     /* residue is all the number [NB could be all 0s] */
7070     if (*residue<=0) {	      /* not already positive */
7071       count=len;	      /* avoids D2U */
7072       for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
7073 	*residue=1;
7074 	break;		      /* no need to check any others */
7075 	}
7076       }
7077     if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7078     *dn->lsu=0;		      /* coefficient will now be 0 */
7079     dn->digits=1;	      /* .. */
7080     return;
7081     } /* total discard */
7082 
7083   /* partial discard [most common case] */
7084   /* here, at least the first (most significant) discarded digit exists */
7085 
7086   /* spin up the number, noting residue during the spin, until get to */
7087   /* the Unit with the first discarded digit.  When reach it, extract */
7088   /* it and remember its position */
7089   count=0;
7090   for (up=lsu;; up++) {
7091     count+=DECDPUN;
7092     if (count>=discard) break; /* full ones all checked */
7093     if (*up!=0) *residue=1;
7094     } /* up */
7095 
7096   /* here up -> Unit with first discarded digit */
7097   cut=discard-(count-DECDPUN)-1;
7098   if (cut==DECDPUN-1) {	      /* unit-boundary case (fast) */
7099     Unit half=(Unit)powers[DECDPUN]>>1;
7100     /* set residue directly */
7101     if (*up>=half) {
7102       if (*up>half) *residue=7;
7103       else *residue+=5;	      /* add sticky bit */
7104       }
7105      else { /* <half */
7106       if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
7107       }
7108     if (set->digits<=0) {     /* special for Quantize/Subnormal :-( */
7109       *dn->lsu=0;	      /* .. result is 0 */
7110       dn->digits=1;	      /* .. */
7111       }
7112      else {		      /* shift to least */
7113       count=set->digits;      /* now digits to end up with */
7114       dn->digits=count;	      /* set the new length */
7115       up++;		      /* move to next */
7116       /* on unit boundary, so shift-down copy loop is simple */
7117       for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7118 	*target=*up;
7119       }
7120     } /* unit-boundary case */
7121 
7122    else { /* discard digit is in low digit(s), and not top digit */
7123     uInt  discard1;		   /* first discarded digit */
7124     uInt  quot, rem;		   /* for divisions */
7125     if (cut==0) quot=*up;	   /* is at bottom of unit */
7126      else /* cut>0 */ {		   /* it's not at bottom of unit */
7127       #if DECDPUN<=4
7128 	quot=QUOT10(*up, cut);
7129 	rem=*up-quot*powers[cut];
7130       #else
7131 	rem=*up%powers[cut];
7132 	quot=*up/powers[cut];
7133       #endif
7134       if (rem!=0) *residue=1;
7135       }
7136     /* discard digit is now at bottom of quot */
7137     #if DECDPUN<=4
7138       temp=(quot*6554)>>16;	   /* fast /10 */
7139       /* Vowels algorithm here not a win (9 instructions) */
7140       discard1=quot-X10(temp);
7141       quot=temp;
7142     #else
7143       discard1=quot%10;
7144       quot=quot/10;
7145     #endif
7146     /* here, discard1 is the guard digit, and residue is everything */
7147     /* else [use mapping array to accumulate residue safely] */
7148     *residue+=resmap[discard1];
7149     cut++;			   /* update cut */
7150     /* here: up -> Unit of the array with bottom digit */
7151     /*	     cut is the division point for each Unit */
7152     /*	     quot holds the uncut high-order digits for the current unit */
7153     if (set->digits<=0) {	   /* special for Quantize/Subnormal :-( */
7154       *dn->lsu=0;		   /* .. result is 0 */
7155       dn->digits=1;		   /* .. */
7156       }
7157      else {			   /* shift to least needed */
7158       count=set->digits;	   /* now digits to end up with */
7159       dn->digits=count;		   /* set the new length */
7160       /* shift-copy the coefficient array to the result number */
7161       for (target=dn->lsu; ; target++) {
7162 	*target=(Unit)quot;
7163 	count-=(DECDPUN-cut);
7164 	if (count<=0) break;
7165 	up++;
7166 	quot=*up;
7167 	#if DECDPUN<=4
7168 	  quot=QUOT10(quot, cut);
7169 	  rem=*up-quot*powers[cut];
7170 	#else
7171 	  rem=quot%powers[cut];
7172 	  quot=quot/powers[cut];
7173 	#endif
7174 	*target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7175 	count-=cut;
7176 	if (count<=0) break;
7177 	} /* shift-copy loop */
7178       } /* shift to least */
7179     } /* not unit boundary */
7180 
7181   if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7182   return;
7183   } /* decSetCoeff */
7184 
7185 /* ------------------------------------------------------------------ */
7186 /* decApplyRound -- apply pending rounding to a number		      */
7187 /*								      */
7188 /*   dn	   is the number, with space for set->digits digits	      */
7189 /*   set   is the context [for size and rounding mode]		      */
7190 /*   residue indicates pending rounding, being any accumulated	      */
7191 /*	   guard and sticky information.  It may be:		      */
7192 /*	   6-9: rounding digit is >5				      */
7193 /*	   5:	rounding digit is exactly half-way		      */
7194 /*	   1-4: rounding digit is <5 and >0			      */
7195 /*	   0:	the coefficient is exact			      */
7196 /*	  -1:	as 1, but the hidden digits are subtractive, that     */
7197 /*		is, of the opposite sign to dn.	 In this case the     */
7198 /*		coefficient must be non-0.  This case occurs when     */
7199 /*		subtracting a small number (which can be reduced to   */
7200 /*		a sticky bit); see decAddOp.			      */
7201 /*   status is the status accumulator, as usual			      */
7202 /*								      */
7203 /* This routine applies rounding while keeping the length of the      */
7204 /* coefficient constant.  The exponent and status are unchanged	      */
7205 /* except if:							      */
7206 /*								      */
7207 /*   -- the coefficient was increased and is all nines (in which      */
7208 /*	case Overflow could occur, and is handled directly here so    */
7209 /*	the caller does not need to re-test for overflow)	      */
7210 /*								      */
7211 /*   -- the coefficient was decreased and becomes all nines (in which */
7212 /*	case Underflow could occur, and is also handled directly).    */
7213 /*								      */
7214 /* All fields in dn are updated as required.			      */
7215 /*								      */
7216 /* ------------------------------------------------------------------ */
7217 static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7218 			  uInt *status) {
7219   Int  bump;		      /* 1 if coefficient needs to be incremented */
7220 			      /* -1 if coefficient needs to be decremented */
7221 
7222   if (residue==0) return;     /* nothing to apply */
7223 
7224   bump=0;		      /* assume a smooth ride */
7225 
7226   /* now decide whether, and how, to round, depending on mode */
7227   switch (set->round) {
7228     case DEC_ROUND_05UP: {    /* round zero or five up (for reround) */
7229       /* This is the same as DEC_ROUND_DOWN unless there is a */
7230       /* positive residue and the lsd of dn is 0 or 5, in which case */
7231       /* it is bumped; when residue is <0, the number is therefore */
7232       /* bumped down unless the final digit was 1 or 6 (in which */
7233       /* case it is bumped down and then up -- a no-op) */
7234       Int lsd5=*dn->lsu%5;     /* get lsd and quintate */
7235       if (residue<0 && lsd5!=1) bump=-1;
7236        else if (residue>0 && lsd5==0) bump=1;
7237       /* [bump==1 could be applied directly; use common path for clarity] */
7238       break;} /* r-05 */
7239 
7240     case DEC_ROUND_DOWN: {
7241       /* no change, except if negative residue */
7242       if (residue<0) bump=-1;
7243       break;} /* r-d */
7244 
7245     case DEC_ROUND_HALF_DOWN: {
7246       if (residue>5) bump=1;
7247       break;} /* r-h-d */
7248 
7249     case DEC_ROUND_HALF_EVEN: {
7250       if (residue>5) bump=1;		/* >0.5 goes up */
7251        else if (residue==5) {		/* exactly 0.5000... */
7252 	/* 0.5 goes up iff [new] lsd is odd */
7253 	if (*dn->lsu & 0x01) bump=1;
7254 	}
7255       break;} /* r-h-e */
7256 
7257     case DEC_ROUND_HALF_UP: {
7258       if (residue>=5) bump=1;
7259       break;} /* r-h-u */
7260 
7261     case DEC_ROUND_UP: {
7262       if (residue>0) bump=1;
7263       break;} /* r-u */
7264 
7265     case DEC_ROUND_CEILING: {
7266       /* same as _UP for positive numbers, and as _DOWN for negatives */
7267       /* [negative residue cannot occur on 0] */
7268       if (decNumberIsNegative(dn)) {
7269 	if (residue<0) bump=-1;
7270 	}
7271        else {
7272 	if (residue>0) bump=1;
7273 	}
7274       break;} /* r-c */
7275 
7276     case DEC_ROUND_FLOOR: {
7277       /* same as _UP for negative numbers, and as _DOWN for positive */
7278       /* [negative residue cannot occur on 0] */
7279       if (!decNumberIsNegative(dn)) {
7280 	if (residue<0) bump=-1;
7281 	}
7282        else {
7283 	if (residue>0) bump=1;
7284 	}
7285       break;} /* r-f */
7286 
7287     default: {	    /* e.g., DEC_ROUND_MAX */
7288       *status|=DEC_Invalid_context;
7289       #if DECTRACE || (DECCHECK && DECVERB)
7290       printf("Unknown rounding mode: %d\n", set->round);
7291       #endif
7292       break;}
7293     } /* switch */
7294 
7295   /* now bump the number, up or down, if need be */
7296   if (bump==0) return;			     /* no action required */
7297 
7298   /* Simply use decUnitAddSub unless bumping up and the number is */
7299   /* all nines.	 In this special case set to 100... explicitly */
7300   /* and adjust the exponent by one (as otherwise could overflow */
7301   /* the array) */
7302   /* Similarly handle all-nines result if bumping down. */
7303   if (bump>0) {
7304     Unit *up;				     /* work */
7305     uInt count=dn->digits;		     /* digits to be checked */
7306     for (up=dn->lsu; ; up++) {
7307       if (count<=DECDPUN) {
7308 	/* this is the last Unit (the msu) */
7309 	if (*up!=powers[count]-1) break;     /* not still 9s */
7310 	/* here if it, too, is all nines */
7311 	*up=(Unit)powers[count-1];	     /* here 999 -> 100 etc. */
7312 	for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7313 	dn->exponent++;			     /* and bump exponent */
7314 	/* [which, very rarely, could cause Overflow...] */
7315 	if ((dn->exponent+dn->digits)>set->emax+1) {
7316 	  decSetOverflow(dn, set, status);
7317 	  }
7318 	return;				     /* done */
7319 	}
7320       /* a full unit to check, with more to come */
7321       if (*up!=DECDPUNMAX) break;	     /* not still 9s */
7322       count-=DECDPUN;
7323       } /* up */
7324     } /* bump>0 */
7325    else {				     /* -1 */
7326     /* here checking for a pre-bump of 1000... (leading 1, all */
7327     /* other digits zero) */
7328     Unit *up, *sup;			     /* work */
7329     uInt count=dn->digits;		     /* digits to be checked */
7330     for (up=dn->lsu; ; up++) {
7331       if (count<=DECDPUN) {
7332 	/* this is the last Unit (the msu) */
7333 	if (*up!=powers[count-1]) break;     /* not 100.. */
7334 	/* here if have the 1000... case */
7335 	sup=up;				     /* save msu pointer */
7336 	*up=(Unit)powers[count]-1;	     /* here 100 in msu -> 999 */
7337 	/* others all to all-nines, too */
7338 	for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7339 	dn->exponent--;			     /* and bump exponent */
7340 
7341 	/* iff the number was at the subnormal boundary (exponent=etiny) */
7342 	/* then the exponent is now out of range, so it will in fact get */
7343 	/* clamped to etiny and the final 9 dropped. */
7344 	/* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7345 	/*	  dn->exponent, set->digits); */
7346 	if (dn->exponent+1==set->emin-set->digits+1) {
7347 	  if (count==1 && dn->digits==1) *sup=0;  /* here 9 -> 0[.9] */
7348 	   else {
7349 	    *sup=(Unit)powers[count-1]-1;    /* here 999.. in msu -> 99.. */
7350 	    dn->digits--;
7351 	    }
7352 	  dn->exponent++;
7353 	  *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7354 	  }
7355 	return;				     /* done */
7356 	}
7357 
7358       /* a full unit to check, with more to come */
7359       if (*up!=0) break;		     /* not still 0s */
7360       count-=DECDPUN;
7361       } /* up */
7362 
7363     } /* bump<0 */
7364 
7365   /* Actual bump needed.  Do it. */
7366   decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7367   } /* decApplyRound */
7368 
7369 #if DECSUBSET
7370 /* ------------------------------------------------------------------ */
7371 /* decFinish -- finish processing a number			      */
7372 /*								      */
7373 /*   dn is the number						      */
7374 /*   set is the context						      */
7375 /*   residue is the rounding accumulator (as in decApplyRound)	      */
7376 /*   status is the accumulator					      */
7377 /*								      */
7378 /* This finishes off the current number by:			      */
7379 /*    1. If not extended:					      */
7380 /*	 a. Converting a zero result to clean '0'		      */
7381 /*	 b. Reducing positive exponents to 0, if would fit in digits  */
7382 /*    2. Checking for overflow and subnormals (always)		      */
7383 /* Note this is just Finalize when no subset arithmetic.	      */
7384 /* All fields are updated as required.				      */
7385 /* ------------------------------------------------------------------ */
7386 static void decFinish(decNumber *dn, decContext *set, Int *residue,
7387 		      uInt *status) {
7388   if (!set->extended) {
7389     if ISZERO(dn) {		   /* value is zero */
7390       dn->exponent=0;		   /* clean exponent .. */
7391       dn->bits=0;		   /* .. and sign */
7392       return;			   /* no error possible */
7393       }
7394     if (dn->exponent>=0) {	   /* non-negative exponent */
7395       /* >0; reduce to integer if possible */
7396       if (set->digits >= (dn->exponent+dn->digits)) {
7397 	dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7398 	dn->exponent=0;
7399 	}
7400       }
7401     } /* !extended */
7402 
7403   decFinalize(dn, set, residue, status);
7404   } /* decFinish */
7405 #endif
7406 
7407 /* ------------------------------------------------------------------ */
7408 /* decFinalize -- final check, clamp, and round of a number	      */
7409 /*								      */
7410 /*   dn is the number						      */
7411 /*   set is the context						      */
7412 /*   residue is the rounding accumulator (as in decApplyRound)	      */
7413 /*   status is the status accumulator				      */
7414 /*								      */
7415 /* This finishes off the current number by checking for subnormal     */
7416 /* results, applying any pending rounding, checking for overflow,     */
7417 /* and applying any clamping.					      */
7418 /* Underflow and overflow conditions are raised as appropriate.	      */
7419 /* All fields are updated as required.				      */
7420 /* ------------------------------------------------------------------ */
7421 static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7422 			uInt *status) {
7423   Int shift;				/* shift needed if clamping */
7424   Int tinyexp=set->emin-dn->digits+1;	/* precalculate subnormal boundary */
7425 
7426   /* Must be careful, here, when checking the exponent as the */
7427   /* adjusted exponent could overflow 31 bits [because it may already */
7428   /* be up to twice the expected]. */
7429 
7430   /* First test for subnormal.	This must be done before any final */
7431   /* round as the result could be rounded to Nmin or 0. */
7432   if (dn->exponent<=tinyexp) {		/* prefilter */
7433     Int comp;
7434     decNumber nmin;
7435     /* A very nasty case here is dn == Nmin and residue<0 */
7436     if (dn->exponent<tinyexp) {
7437       /* Go handle subnormals; this will apply round if needed. */
7438       decSetSubnormal(dn, set, residue, status);
7439       return;
7440       }
7441     /* Equals case: only subnormal if dn=Nmin and negative residue */
7442     decNumberZero(&nmin);
7443     nmin.lsu[0]=1;
7444     nmin.exponent=set->emin;
7445     comp=decCompare(dn, &nmin, 1);		  /* (signless compare) */
7446     if (comp==BADINT) {				  /* oops */
7447       *status|=DEC_Insufficient_storage;	  /* abandon... */
7448       return;
7449       }
7450     if (*residue<0 && comp==0) {		  /* neg residue and dn==Nmin */
7451       decApplyRound(dn, set, *residue, status);	  /* might force down */
7452       decSetSubnormal(dn, set, residue, status);
7453       return;
7454       }
7455     }
7456 
7457   /* now apply any pending round (this could raise overflow). */
7458   if (*residue!=0) decApplyRound(dn, set, *residue, status);
7459 
7460   /* Check for overflow [redundant in the 'rare' case] or clamp */
7461   if (dn->exponent<=set->emax-set->digits+1) return;   /* neither needed */
7462 
7463 
7464   /* here when might have an overflow or clamp to do */
7465   if (dn->exponent>set->emax-dn->digits+1) {	       /* too big */
7466     decSetOverflow(dn, set, status);
7467     return;
7468     }
7469   /* here when the result is normal but in clamp range */
7470   if (!set->clamp) return;
7471 
7472   /* here when need to apply the IEEE exponent clamp (fold-down) */
7473   shift=dn->exponent-(set->emax-set->digits+1);
7474 
7475   /* shift coefficient (if non-zero) */
7476   if (!ISZERO(dn)) {
7477     dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7478     }
7479   dn->exponent-=shift;	 /* adjust the exponent to match */
7480   *status|=DEC_Clamped;	 /* and record the dirty deed */
7481   return;
7482   } /* decFinalize */
7483 
7484 /* ------------------------------------------------------------------ */
7485 /* decSetOverflow -- set number to proper overflow value	      */
7486 /*								      */
7487 /*   dn is the number (used for sign [only] and result)		      */
7488 /*   set is the context [used for the rounding mode, etc.]	      */
7489 /*   status contains the current status to be updated		      */
7490 /*								      */
7491 /* This sets the sign of a number and sets its value to either	      */
7492 /* Infinity or the maximum finite value, depending on the sign of     */
7493 /* dn and the rounding mode, following IEEE 854 rules.		      */
7494 /* ------------------------------------------------------------------ */
7495 static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7496   Flag needmax=0;		   /* result is maximum finite value */
7497   uByte sign=dn->bits&DECNEG;	   /* clean and save sign bit */
7498 
7499   if (ISZERO(dn)) {		   /* zero does not overflow magnitude */
7500     Int emax=set->emax;			     /* limit value */
7501     if (set->clamp) emax-=set->digits-1;     /* lower if clamping */
7502     if (dn->exponent>emax) {		     /* clamp required */
7503       dn->exponent=emax;
7504       *status|=DEC_Clamped;
7505       }
7506     return;
7507     }
7508 
7509   decNumberZero(dn);
7510   switch (set->round) {
7511     case DEC_ROUND_DOWN: {
7512       needmax=1;		   /* never Infinity */
7513       break;} /* r-d */
7514     case DEC_ROUND_05UP: {
7515       needmax=1;		   /* never Infinity */
7516       break;} /* r-05 */
7517     case DEC_ROUND_CEILING: {
7518       if (sign) needmax=1;	   /* Infinity if non-negative */
7519       break;} /* r-c */
7520     case DEC_ROUND_FLOOR: {
7521       if (!sign) needmax=1;	   /* Infinity if negative */
7522       break;} /* r-f */
7523     default: break;		   /* Infinity in all other cases */
7524     }
7525   if (needmax) {
7526     decSetMaxValue(dn, set);
7527     dn->bits=sign;		   /* set sign */
7528     }
7529    else dn->bits=sign|DECINF;	   /* Value is +/-Infinity */
7530   *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7531   } /* decSetOverflow */
7532 
7533 /* ------------------------------------------------------------------ */
7534 /* decSetMaxValue -- set number to +Nmax (maximum normal value)	      */
7535 /*								      */
7536 /*   dn is the number to set					      */
7537 /*   set is the context [used for digits and emax]		      */
7538 /*								      */
7539 /* This sets the number to the maximum positive value.		      */
7540 /* ------------------------------------------------------------------ */
7541 static void decSetMaxValue(decNumber *dn, decContext *set) {
7542   Unit *up;			   /* work */
7543   Int count=set->digits;	   /* nines to add */
7544   dn->digits=count;
7545   /* fill in all nines to set maximum value */
7546   for (up=dn->lsu; ; up++) {
7547     if (count>DECDPUN) *up=DECDPUNMAX;	/* unit full o'nines */
7548      else {				/* this is the msu */
7549       *up=(Unit)(powers[count]-1);
7550       break;
7551       }
7552     count-=DECDPUN;		   /* filled those digits */
7553     } /* up */
7554   dn->bits=0;			   /* + sign */
7555   dn->exponent=set->emax-set->digits+1;
7556   } /* decSetMaxValue */
7557 
7558 /* ------------------------------------------------------------------ */
7559 /* decSetSubnormal -- process value whose exponent is <Emin	      */
7560 /*								      */
7561 /*   dn is the number (used as input as well as output; it may have   */
7562 /*	   an allowed subnormal value, which may need to be rounded)  */
7563 /*   set is the context [used for the rounding mode]		      */
7564 /*   residue is any pending residue				      */
7565 /*   status contains the current status to be updated		      */
7566 /*								      */
7567 /* If subset mode, set result to zero and set Underflow flags.	      */
7568 /*								      */
7569 /* Value may be zero with a low exponent; this does not set Subnormal */
7570 /* but the exponent will be clamped to Etiny.			      */
7571 /*								      */
7572 /* Otherwise ensure exponent is not out of range, and round as	      */
7573 /* necessary.  Underflow is set if the result is Inexact.	      */
7574 /* ------------------------------------------------------------------ */
7575 static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7576 			    uInt *status) {
7577   decContext workset;	      /* work */
7578   Int	     etiny, adjust;   /* .. */
7579 
7580   #if DECSUBSET
7581   /* simple set to zero and 'hard underflow' for subset */
7582   if (!set->extended) {
7583     decNumberZero(dn);
7584     /* always full overflow */
7585     *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7586     return;
7587     }
7588   #endif
7589 
7590   /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7591   /* (Etiny) if needed */
7592   etiny=set->emin-(set->digits-1);	/* smallest allowed exponent */
7593 
7594   if ISZERO(dn) {			/* value is zero */
7595     /* residue can never be non-zero here */
7596     #if DECCHECK
7597       if (*residue!=0) {
7598 	printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7599 	*status|=DEC_Invalid_operation;
7600 	}
7601     #endif
7602     if (dn->exponent<etiny) {		/* clamp required */
7603       dn->exponent=etiny;
7604       *status|=DEC_Clamped;
7605       }
7606     return;
7607     }
7608 
7609   *status|=DEC_Subnormal;		/* have a non-zero subnormal */
7610   adjust=etiny-dn->exponent;		/* calculate digits to remove */
7611   if (adjust<=0) {			/* not out of range; unrounded */
7612     /* residue can never be non-zero here, except in the Nmin-residue */
7613     /* case (which is a subnormal result), so can take fast-path here */
7614     /* it may already be inexact (from setting the coefficient) */
7615     if (*status&DEC_Inexact) *status|=DEC_Underflow;
7616     return;
7617     }
7618 
7619   /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7620   /* [this code is similar to that in rescale] */
7621   workset=*set;				/* clone rounding, etc. */
7622   workset.digits=dn->digits-adjust;	/* set requested length */
7623   workset.emin-=adjust;			/* and adjust emin to match */
7624   /* [note that the latter can be <1, here, similar to Rescale case] */
7625   decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7626   decApplyRound(dn, &workset, *residue, status);
7627 
7628   /* Use 754R/854 default rule: Underflow is set iff Inexact */
7629   /* [independent of whether trapped] */
7630   if (*status&DEC_Inexact) *status|=DEC_Underflow;
7631 
7632   /* if rounded up a 999s case, exponent will be off by one; adjust */
7633   /* back if so [it will fit, because it was shortened earlier] */
7634   if (dn->exponent>etiny) {
7635     dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7636     dn->exponent--;			/* (re)adjust the exponent. */
7637     }
7638 
7639   /* if rounded to zero, it is by definition clamped... */
7640   if (ISZERO(dn)) *status|=DEC_Clamped;
7641   } /* decSetSubnormal */
7642 
7643 /* ------------------------------------------------------------------ */
7644 /* decCheckMath - check entry conditions for a math function	      */
7645 /*								      */
7646 /*   This checks the context and the operand			      */
7647 /*								      */
7648 /*   rhs is the operand to check				      */
7649 /*   set is the context to check				      */
7650 /*   status is unchanged if both are good			      */
7651 /*								      */
7652 /* returns non-zero if status is changed, 0 otherwise		      */
7653 /*								      */
7654 /* Restrictions enforced:					      */
7655 /*								      */
7656 /*   digits, emax, and -emin in the context must be less than	      */
7657 /*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
7658 /*   non-zero.	Invalid_operation is set in the status if a	      */
7659 /*   restriction is violated.					      */
7660 /* ------------------------------------------------------------------ */
7661 static uInt decCheckMath(const decNumber *rhs, decContext *set,
7662 			 uInt *status) {
7663   uInt save=*status;			     /* record */
7664   if (set->digits>DEC_MAX_MATH
7665    || set->emax>DEC_MAX_MATH
7666    || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7667    else if ((rhs->digits>DEC_MAX_MATH
7668      || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7669      || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7670      && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7671   return (*status!=save);
7672   } /* decCheckMath */
7673 
7674 /* ------------------------------------------------------------------ */
7675 /* decGetInt -- get integer from a number			      */
7676 /*								      */
7677 /*   dn is the number [which will not be altered]		      */
7678 /*								      */
7679 /*   returns one of:						      */
7680 /*     BADINT if there is a non-zero fraction			      */
7681 /*     the converted integer					      */
7682 /*     BIGEVEN if the integer is even and magnitude > 2*10**9	      */
7683 /*     BIGODD  if the integer is odd  and magnitude > 2*10**9	      */
7684 /*								      */
7685 /* This checks and gets a whole number from the input decNumber.      */
7686 /* The sign can be determined from dn by the caller when BIGEVEN or   */
7687 /* BIGODD is returned.						      */
7688 /* ------------------------------------------------------------------ */
7689 static Int decGetInt(const decNumber *dn) {
7690   Int  theInt;				/* result accumulator */
7691   const Unit *up;			/* work */
7692   Int  got;				/* digits (real or not) processed */
7693   Int  ilength=dn->digits+dn->exponent; /* integral length */
7694   Flag neg=decNumberIsNegative(dn);	/* 1 if -ve */
7695 
7696   /* The number must be an integer that fits in 10 digits */
7697   /* Assert, here, that 10 is enough for any rescale Etiny */
7698   #if DEC_MAX_EMAX > 999999999
7699     #error GetInt may need updating [for Emax]
7700   #endif
7701   #if DEC_MIN_EMIN < -999999999
7702     #error GetInt may need updating [for Emin]
7703   #endif
7704   if (ISZERO(dn)) return 0;		/* zeros are OK, with any exponent */
7705 
7706   up=dn->lsu;				/* ready for lsu */
7707   theInt=0;				/* ready to accumulate */
7708   if (dn->exponent>=0) {		/* relatively easy */
7709     /* no fractional part [usual]; allow for positive exponent */
7710     got=dn->exponent;
7711     }
7712    else { /* -ve exponent; some fractional part to check and discard */
7713     Int count=-dn->exponent;		/* digits to discard */
7714     /* spin up whole units until reach the Unit with the unit digit */
7715     for (; count>=DECDPUN; up++) {
7716       if (*up!=0) return BADINT;	/* non-zero Unit to discard */
7717       count-=DECDPUN;
7718       }
7719     if (count==0) got=0;		/* [a multiple of DECDPUN] */
7720      else {				/* [not multiple of DECDPUN] */
7721       Int rem;				/* work */
7722       /* slice off fraction digits and check for non-zero */
7723       #if DECDPUN<=4
7724 	theInt=QUOT10(*up, count);
7725 	rem=*up-theInt*powers[count];
7726       #else
7727 	rem=*up%powers[count];		/* slice off discards */
7728 	theInt=*up/powers[count];
7729       #endif
7730       if (rem!=0) return BADINT;	/* non-zero fraction */
7731       /* it looks good */
7732       got=DECDPUN-count;		/* number of digits so far */
7733       up++;				/* ready for next */
7734       }
7735     }
7736   /* now it's known there's no fractional part */
7737 
7738   /* tricky code now, to accumulate up to 9.3 digits */
7739   if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7740 
7741   if (ilength<11) {
7742     Int save=theInt;
7743     /* collect any remaining unit(s) */
7744     for (; got<ilength; up++) {
7745       theInt+=*up*powers[got];
7746       got+=DECDPUN;
7747       }
7748     if (ilength==10) {			/* need to check for wrap */
7749       if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7750 	 /* [that test also disallows the BADINT result case] */
7751        else if (neg && theInt>1999999997) ilength=11;
7752        else if (!neg && theInt>999999999) ilength=11;
7753       if (ilength==11) theInt=save;	/* restore correct low bit */
7754       }
7755     }
7756 
7757   if (ilength>10) {			/* too big */
7758     if (theInt&1) return BIGODD;	/* bottom bit 1 */
7759     return BIGEVEN;			/* bottom bit 0 */
7760     }
7761 
7762   if (neg) theInt=-theInt;		/* apply sign */
7763   return theInt;
7764   } /* decGetInt */
7765 
7766 /* ------------------------------------------------------------------ */
7767 /* decDecap -- decapitate the coefficient of a number		      */
7768 /*								      */
7769 /*   dn	  is the number to be decapitated			      */
7770 /*   drop is the number of digits to be removed from the left of dn;  */
7771 /*     this must be <= dn->digits (if equal, the coefficient is	      */
7772 /*     set to 0)						      */
7773 /*								      */
7774 /* Returns dn; dn->digits will be <= the initial digits less drop     */
7775 /* (after removing drop digits there may be leading zero digits	      */
7776 /* which will also be removed).	 Only dn->lsu and dn->digits change.  */
7777 /* ------------------------------------------------------------------ */
7778 static decNumber *decDecap(decNumber *dn, Int drop) {
7779   Unit *msu;				/* -> target cut point */
7780   Int cut;				/* work */
7781   if (drop>=dn->digits) {		/* losing the whole thing */
7782     #if DECCHECK
7783     if (drop>dn->digits)
7784       printf("decDecap called with drop>digits [%ld>%ld]\n",
7785 	     (LI)drop, (LI)dn->digits);
7786     #endif
7787     dn->lsu[0]=0;
7788     dn->digits=1;
7789     return dn;
7790     }
7791   msu=dn->lsu+D2U(dn->digits-drop)-1;	/* -> likely msu */
7792   cut=MSUDIGITS(dn->digits-drop);	/* digits to be in use in msu */
7793   if (cut!=DECDPUN) *msu%=powers[cut];	/* clear left digits */
7794   /* that may have left leading zero digits, so do a proper count... */
7795   dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7796   return dn;
7797   } /* decDecap */
7798 
7799 /* ------------------------------------------------------------------ */
7800 /* decBiStr -- compare string with pairwise options		      */
7801 /*								      */
7802 /*   targ is the string to compare				      */
7803 /*   str1 is one of the strings to compare against (length may be 0)  */
7804 /*   str2 is the other; it must be the same length as str1	      */
7805 /*								      */
7806 /*   returns 1 if strings compare equal, (that is, it is the same     */
7807 /*   length as str1 and str2, and each character of targ is in either */
7808 /*   str1 or str2 in the corresponding position), or 0 otherwise      */
7809 /*								      */
7810 /* This is used for generic caseless compare, including the awkward   */
7811 /* case of the Turkish dotted and dotless Is.  Use as (for example):  */
7812 /*   if (decBiStr(test, "mike", "MIKE")) ...			      */
7813 /* ------------------------------------------------------------------ */
7814 static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7815   for (;;targ++, str1++, str2++) {
7816     if (*targ!=*str1 && *targ!=*str2) return 0;
7817     /* *targ has a match in one (or both, if terminator) */
7818     if (*targ=='\0') break;
7819     } /* forever */
7820   return 1;
7821   } /* decBiStr */
7822 
7823 /* ------------------------------------------------------------------ */
7824 /* decNaNs -- handle NaN operand or operands			      */
7825 /*								      */
7826 /*   res     is the result number				      */
7827 /*   lhs     is the first operand				      */
7828 /*   rhs     is the second operand, or NULL if none		      */
7829 /*   context is used to limit payload length			      */
7830 /*   status  contains the current status			      */
7831 /*   returns res in case convenient				      */
7832 /*								      */
7833 /* Called when one or both operands is a NaN, and propagates the      */
7834 /* appropriate result to res.  When an sNaN is found, it is changed   */
7835 /* to a qNaN and Invalid operation is set.			      */
7836 /* ------------------------------------------------------------------ */
7837 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7838 			   const decNumber *rhs, decContext *set,
7839 			   uInt *status) {
7840   /* This decision tree ends up with LHS being the source pointer, */
7841   /* and status updated if need be */
7842   if (lhs->bits & DECSNAN)
7843     *status|=DEC_Invalid_operation | DEC_sNaN;
7844    else if (rhs==NULL);
7845    else if (rhs->bits & DECSNAN) {
7846     lhs=rhs;
7847     *status|=DEC_Invalid_operation | DEC_sNaN;
7848     }
7849    else if (lhs->bits & DECNAN);
7850    else lhs=rhs;
7851 
7852   /* propagate the payload */
7853   if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7854    else { /* too long */
7855     const Unit *ul;
7856     Unit *ur, *uresp1;
7857     /* copy safe number of units, then decapitate */
7858     res->bits=lhs->bits;		/* need sign etc. */
7859     uresp1=res->lsu+D2U(set->digits);
7860     for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7861     res->digits=D2U(set->digits)*DECDPUN;
7862     /* maybe still too long */
7863     if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7864     }
7865 
7866   res->bits&=~DECSNAN;	      /* convert any sNaN to NaN, while */
7867   res->bits|=DECNAN;	      /* .. preserving sign */
7868   res->exponent=0;	      /* clean exponent */
7869 			      /* [coefficient was copied/decapitated] */
7870   return res;
7871   } /* decNaNs */
7872 
7873 /* ------------------------------------------------------------------ */
7874 /* decStatus -- apply non-zero status				      */
7875 /*								      */
7876 /*   dn	    is the number to set if error			      */
7877 /*   status contains the current status (not yet in context)	      */
7878 /*   set    is the context					      */
7879 /*								      */
7880 /* If the status is an error status, the number is set to a NaN,      */
7881 /* unless the error was an overflow, divide-by-zero, or underflow,    */
7882 /* in which case the number will have already been set.		      */
7883 /*								      */
7884 /* The context status is then updated with the new status.  Note that */
7885 /* this may raise a signal, so control may never return from this     */
7886 /* routine (hence resources must be recovered before it is called).   */
7887 /* ------------------------------------------------------------------ */
7888 static void decStatus(decNumber *dn, uInt status, decContext *set) {
7889   if (status & DEC_NaNs) {		/* error status -> NaN */
7890     /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7891     if (status & DEC_sNaN) status&=~DEC_sNaN;
7892      else {
7893       decNumberZero(dn);		/* other error: clean throughout */
7894       dn->bits=DECNAN;			/* and make a quiet NaN */
7895       }
7896     }
7897   decContextSetStatus(set, status);	/* [may not return] */
7898   return;
7899   } /* decStatus */
7900 
7901 /* ------------------------------------------------------------------ */
7902 /* decGetDigits -- count digits in a Units array		      */
7903 /*								      */
7904 /*   uar is the Unit array holding the number (this is often an	      */
7905 /*	    accumulator of some sort)				      */
7906 /*   len is the length of the array in units [>=1]		      */
7907 /*								      */
7908 /*   returns the number of (significant) digits in the array	      */
7909 /*								      */
7910 /* All leading zeros are excluded, except the last if the array has   */
7911 /* only zero Units.						      */
7912 /* ------------------------------------------------------------------ */
7913 /* This may be called twice during some operations. */
7914 static Int decGetDigits(Unit *uar, Int len) {
7915   Unit *up=uar+(len-1);		   /* -> msu */
7916   Int  digits=(len-1)*DECDPUN+1;   /* possible digits excluding msu */
7917   #if DECDPUN>4
7918   uInt const *pow;		   /* work */
7919   #endif
7920 				   /* (at least 1 in final msu) */
7921   #if DECCHECK
7922   if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7923   #endif
7924 
7925   for (; up>=uar; up--) {
7926     if (*up==0) {		   /* unit is all 0s */
7927       if (digits==1) break;	   /* a zero has one digit */
7928       digits-=DECDPUN;		   /* adjust for 0 unit */
7929       continue;}
7930     /* found the first (most significant) non-zero Unit */
7931     #if DECDPUN>1		   /* not done yet */
7932     if (*up<10) break;		   /* is 1-9 */
7933     digits++;
7934     #if DECDPUN>2		   /* not done yet */
7935     if (*up<100) break;		   /* is 10-99 */
7936     digits++;
7937     #if DECDPUN>3		   /* not done yet */
7938     if (*up<1000) break;	   /* is 100-999 */
7939     digits++;
7940     #if DECDPUN>4		   /* count the rest ... */
7941     for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7942     #endif
7943     #endif
7944     #endif
7945     #endif
7946     break;
7947     } /* up */
7948   return digits;
7949   } /* decGetDigits */
7950 
7951 /* ------------------------------------------------------------------ */
7952 /* mulUInt128ByPowOf10 -- multiply a 128-bit unsigned integer by a    */
7953 /* power of 10.                                                       */
7954 /*                                                                    */
7955 /*   The 128-bit factor composed of plow and phigh is multiplied      */
7956 /*   by 10^exp.                                                       */
7957 /*                                                                    */
7958 /*   plow   pointer to the low 64 bits of the first factor            */
7959 /*   phigh  pointer to the high 64 bits of the first factor           */
7960 /*   exp    the exponent of the power of 10 of the second factor      */
7961 /*                                                                    */
7962 /* If the result fits in 128 bits, returns false and the              */
7963 /* multiplication result through plow and phigh.                      */
7964 /* Otherwise, returns true.                                           */
7965 /* ------------------------------------------------------------------ */
7966 static bool mulUInt128ByPowOf10(uLong *plow, uLong *phigh, uInt pow10)
7967 {
7968     while (pow10 >= ARRAY_SIZE(powers)) {
7969         if (mulu128(plow, phigh, powers[ARRAY_SIZE(powers) - 1])) {
7970             /* Overflow */
7971             return true;
7972         }
7973         pow10 -= ARRAY_SIZE(powers) - 1;
7974     }
7975 
7976     if (pow10 > 0) {
7977         return mulu128(plow, phigh, powers[pow10]);
7978     } else {
7979         return false;
7980     }
7981 }
7982 
7983 #if DECTRACE | DECCHECK
7984 /* ------------------------------------------------------------------ */
7985 /* decNumberShow -- display a number [debug aid]		      */
7986 /*   dn is the number to show					      */
7987 /*								      */
7988 /* Shows: sign, exponent, coefficient (msu first), digits	      */
7989 /*    or: sign, special-value					      */
7990 /* ------------------------------------------------------------------ */
7991 /* this is public so other modules can use it */
7992 void decNumberShow(const decNumber *dn) {
7993   const Unit *up;		   /* work */
7994   uInt u, d;			   /* .. */
7995   Int cut;			   /* .. */
7996   char isign='+';		   /* main sign */
7997   if (dn==NULL) {
7998     printf("NULL\n");
7999     return;}
8000   if (decNumberIsNegative(dn)) isign='-';
8001   printf(" >> %c ", isign);
8002   if (dn->bits&DECSPECIAL) {	   /* Is a special value */
8003     if (decNumberIsInfinite(dn)) printf("Infinity");
8004      else {				     /* a NaN */
8005       if (dn->bits&DECSNAN) printf("sNaN");  /* signalling NaN */
8006        else printf("NaN");
8007       }
8008     /* if coefficient and exponent are 0, no more to do */
8009     if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
8010       printf("\n");
8011       return;}
8012     /* drop through to report other information */
8013     printf(" ");
8014     }
8015 
8016   /* now carefully display the coefficient */
8017   up=dn->lsu+D2U(dn->digits)-1;		/* msu */
8018   printf("%ld", (LI)*up);
8019   for (up=up-1; up>=dn->lsu; up--) {
8020     u=*up;
8021     printf(":");
8022     for (cut=DECDPUN-1; cut>=0; cut--) {
8023       d=u/powers[cut];
8024       u-=d*powers[cut];
8025       printf("%ld", (LI)d);
8026       } /* cut */
8027     } /* up */
8028   if (dn->exponent!=0) {
8029     char esign='+';
8030     if (dn->exponent<0) esign='-';
8031     printf(" E%c%ld", esign, (LI)abs(dn->exponent));
8032     }
8033   printf(" [%ld]\n", (LI)dn->digits);
8034   } /* decNumberShow */
8035 #endif
8036 
8037 #if DECTRACE || DECCHECK
8038 /* ------------------------------------------------------------------ */
8039 /* decDumpAr -- display a unit array [debug/check aid]		      */
8040 /*   name is a single-character tag name			      */
8041 /*   ar	  is the array to display				      */
8042 /*   len  is the length of the array in Units			      */
8043 /* ------------------------------------------------------------------ */
8044 static void decDumpAr(char name, const Unit *ar, Int len) {
8045   Int i;
8046   const char *spec;
8047   #if DECDPUN==9
8048     spec="%09d ";
8049   #elif DECDPUN==8
8050     spec="%08d ";
8051   #elif DECDPUN==7
8052     spec="%07d ";
8053   #elif DECDPUN==6
8054     spec="%06d ";
8055   #elif DECDPUN==5
8056     spec="%05d ";
8057   #elif DECDPUN==4
8058     spec="%04d ";
8059   #elif DECDPUN==3
8060     spec="%03d ";
8061   #elif DECDPUN==2
8062     spec="%02d ";
8063   #else
8064     spec="%d ";
8065   #endif
8066   printf("  :%c: ", name);
8067   for (i=len-1; i>=0; i--) {
8068     if (i==len-1) printf("%ld ", (LI)ar[i]);
8069      else printf(spec, ar[i]);
8070     }
8071   printf("\n");
8072   return;}
8073 #endif
8074 
8075 #if DECCHECK
8076 /* ------------------------------------------------------------------ */
8077 /* decCheckOperands -- check operand(s) to a routine		      */
8078 /*   res is the result structure (not checked; it will be set to      */
8079 /*	    quiet NaN if error found (and it is not NULL))	      */
8080 /*   lhs is the first operand (may be DECUNRESU)		      */
8081 /*   rhs is the second (may be DECUNUSED)			      */
8082 /*   set is the context (may be DECUNCONT)			      */
8083 /*   returns 0 if both operands, and the context are clean, or 1      */
8084 /*     otherwise (in which case the context will show an error,	      */
8085 /*     unless NULL).  Note that res is not cleaned; caller should     */
8086 /*     handle this so res=NULL case is safe.			      */
8087 /* The caller is expected to abandon immediately if 1 is returned.    */
8088 /* ------------------------------------------------------------------ */
8089 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
8090 			     const decNumber *rhs, decContext *set) {
8091   Flag bad=0;
8092   if (set==NULL) {		   /* oops; hopeless */
8093     #if DECTRACE || DECVERB
8094     printf("Reference to context is NULL.\n");
8095     #endif
8096     bad=1;
8097     return 1;}
8098    else if (set!=DECUNCONT
8099      && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
8100     bad=1;
8101     #if DECTRACE || DECVERB
8102     printf("Bad context [digits=%ld round=%ld].\n",
8103 	   (LI)set->digits, (LI)set->round);
8104     #endif
8105     }
8106    else {
8107     if (res==NULL) {
8108       bad=1;
8109       #if DECTRACE
8110       /* this one not DECVERB as standard tests include NULL */
8111       printf("Reference to result is NULL.\n");
8112       #endif
8113       }
8114     if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
8115     if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
8116     }
8117   if (bad) {
8118     if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
8119     if (res!=DECUNRESU && res!=NULL) {
8120       decNumberZero(res);
8121       res->bits=DECNAN;	      /* qNaN */
8122       }
8123     }
8124   return bad;
8125   } /* decCheckOperands */
8126 
8127 /* ------------------------------------------------------------------ */
8128 /* decCheckNumber -- check a number				      */
8129 /*   dn is the number to check					      */
8130 /*   returns 0 if the number is clean, or 1 otherwise		      */
8131 /*								      */
8132 /* The number is considered valid if it could be a result from some   */
8133 /* operation in some valid context.				      */
8134 /* ------------------------------------------------------------------ */
8135 static Flag decCheckNumber(const decNumber *dn) {
8136   const Unit *up;	      /* work */
8137   uInt maxuint;		      /* .. */
8138   Int ae, d, digits;	      /* .. */
8139   Int emin, emax;	      /* .. */
8140 
8141   if (dn==NULL) {	      /* hopeless */
8142     #if DECTRACE
8143     /* this one not DECVERB as standard tests include NULL */
8144     printf("Reference to decNumber is NULL.\n");
8145     #endif
8146     return 1;}
8147 
8148   /* check special values */
8149   if (dn->bits & DECSPECIAL) {
8150     if (dn->exponent!=0) {
8151       #if DECTRACE || DECVERB
8152       printf("Exponent %ld (not 0) for a special value [%02x].\n",
8153 	     (LI)dn->exponent, dn->bits);
8154       #endif
8155       return 1;}
8156 
8157     /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
8158     if (decNumberIsInfinite(dn)) {
8159       if (dn->digits!=1) {
8160 	#if DECTRACE || DECVERB
8161 	printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
8162 	#endif
8163 	return 1;}
8164       if (*dn->lsu!=0) {
8165 	#if DECTRACE || DECVERB
8166 	printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
8167 	#endif
8168 	decDumpAr('I', dn->lsu, D2U(dn->digits));
8169 	return 1;}
8170       } /* Inf */
8171     /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
8172     /*		   concrete formats (decimal64, etc.). */
8173     return 0;
8174     }
8175 
8176   /* check the coefficient */
8177   if (dn->digits<1 || dn->digits>DECNUMMAXP) {
8178     #if DECTRACE || DECVERB
8179     printf("Digits %ld in number.\n", (LI)dn->digits);
8180     #endif
8181     return 1;}
8182 
8183   d=dn->digits;
8184 
8185   for (up=dn->lsu; d>0; up++) {
8186     if (d>DECDPUN) maxuint=DECDPUNMAX;
8187      else {		      /* reached the msu */
8188       maxuint=powers[d]-1;
8189       if (dn->digits>1 && *up<powers[d-1]) {
8190 	#if DECTRACE || DECVERB
8191 	printf("Leading 0 in number.\n");
8192 	decNumberShow(dn);
8193 	#endif
8194 	return 1;}
8195       }
8196     if (*up>maxuint) {
8197       #if DECTRACE || DECVERB
8198       printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8199 	      (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8200       #endif
8201       return 1;}
8202     d-=DECDPUN;
8203     }
8204 
8205   /* check the exponent.  Note that input operands can have exponents */
8206   /* which are out of the set->emin/set->emax and set->digits range */
8207   /* (just as they can have more digits than set->digits). */
8208   ae=dn->exponent+dn->digits-1;	   /* adjusted exponent */
8209   emax=DECNUMMAXE;
8210   emin=DECNUMMINE;
8211   digits=DECNUMMAXP;
8212   if (ae<emin-(digits-1)) {
8213     #if DECTRACE || DECVERB
8214     printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8215     decNumberShow(dn);
8216     #endif
8217     return 1;}
8218   if (ae>+emax) {
8219     #if DECTRACE || DECVERB
8220     printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8221     decNumberShow(dn);
8222     #endif
8223     return 1;}
8224 
8225   return 0;		 /* it's OK */
8226   } /* decCheckNumber */
8227 
8228 /* ------------------------------------------------------------------ */
8229 /* decCheckInexact -- check a normal finite inexact result has digits */
8230 /*   dn is the number to check					      */
8231 /*   set is the context (for status and precision)		      */
8232 /*   sets Invalid operation, etc., if some digits are missing	      */
8233 /* [this check is not made for DECSUBSET compilation or when	      */
8234 /* subnormal is not set]					      */
8235 /* ------------------------------------------------------------------ */
8236 static void decCheckInexact(const decNumber *dn, decContext *set) {
8237   #if !DECSUBSET && DECEXTFLAG
8238     if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8239      && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8240       #if DECTRACE || DECVERB
8241       printf("Insufficient digits [%ld] on normal Inexact result.\n",
8242 	     (LI)dn->digits);
8243       decNumberShow(dn);
8244       #endif
8245       decContextSetStatus(set, DEC_Invalid_operation);
8246       }
8247   #else
8248     /* next is a noop for quiet compiler */
8249     if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8250   #endif
8251   return;
8252   } /* decCheckInexact */
8253 #endif
8254 
8255 #if DECALLOC
8256 #undef malloc
8257 #undef free
8258 /* ------------------------------------------------------------------ */
8259 /* decMalloc -- accountable allocation routine			      */
8260 /*   n is the number of bytes to allocate			      */
8261 /*								      */
8262 /* Semantics is the same as the stdlib malloc routine, but bytes      */
8263 /* allocated are accounted for globally, and corruption fences are    */
8264 /* added before and after the 'actual' storage.			      */
8265 /* ------------------------------------------------------------------ */
8266 /* This routine allocates storage with an extra twelve bytes; 8 are   */
8267 /* at the start and hold:					      */
8268 /*   0-3 the original length requested				      */
8269 /*   4-7 buffer corruption detection fence (DECFENCE, x4)	      */
8270 /* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8271 /* ------------------------------------------------------------------ */
8272 static void *decMalloc(size_t n) {
8273   uInt	size=n+12;		   /* true size */
8274   void	*alloc;			   /* -> allocated storage */
8275   uInt	*j;			   /* work */
8276   uByte *b, *b0;		   /* .. */
8277 
8278   alloc=malloc(size);		   /* -> allocated storage */
8279   if (alloc==NULL) return NULL;	   /* out of strorage */
8280   b0=(uByte *)alloc;		   /* as bytes */
8281   decAllocBytes+=n;		   /* account for storage */
8282   j=(uInt *)alloc;		   /* -> first four bytes */
8283   *j=n;				   /* save n */
8284   /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */
8285   for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8286   for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8287   return b0+8;			   /* -> play area */
8288   } /* decMalloc */
8289 
8290 /* ------------------------------------------------------------------ */
8291 /* decFree -- accountable free routine				      */
8292 /*   alloc is the storage to free				      */
8293 /*								      */
8294 /* Semantics is the same as the stdlib malloc routine, except that    */
8295 /* the global storage accounting is updated and the fences are	      */
8296 /* checked to ensure that no routine has written 'out of bounds'.     */
8297 /* ------------------------------------------------------------------ */
8298 /* This routine first checks that the fences have not been corrupted. */
8299 /* It then frees the storage using the 'truw' storage address (that   */
8300 /* is, offset by 8).						      */
8301 /* ------------------------------------------------------------------ */
8302 static void decFree(void *alloc) {
8303   uInt	*j, n;			   /* pointer, original length */
8304   uByte *b, *b0;		   /* work */
8305 
8306   if (alloc==NULL) return;	   /* allowed; it's a nop */
8307   b0=(uByte *)alloc;		   /* as bytes */
8308   b0-=8;			   /* -> true start of storage */
8309   j=(uInt *)b0;			   /* -> first four bytes */
8310   n=*j;				   /* lift */
8311   for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8312     printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8313 	   b-b0-8, (Int)b0);
8314   for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8315     printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8316 	   b-b0-8, (Int)b0, n);
8317   free(b0);			   /* drop the storage */
8318   decAllocBytes-=n;		   /* account for storage */
8319   /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8320   } /* decFree */
8321 #define malloc(a) decMalloc(a)
8322 #define free(a) decFree(a)
8323 #endif
8324