1	/* Decimal number arithmetic module for the decNumber C Library.
2	Copyright (C) 2005-2024 Free Software Foundation, Inc.
3	Contributed by IBM Corporation. Author Mike Cowlishaw.
4
5	This file is part of GCC.
6
7	GCC is free software; you can redistribute it and/or modify it under
8	the terms of the GNU General Public License as published by the Free
9	Software Foundation; either version 3, or (at your option) any later
10	version.
11
12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15	for more details.
16
17	Under Section 7 of GPL version 3, you are granted additional
18	permissions described in the GCC Runtime Library Exception, version
19	3.1, as published by the Free Software Foundation.
20
21	You should have received a copy of the GNU General Public License and
22	a copy of the GCC Runtime Library Exception along with this program;
23	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24	<http://www.gnu.org/licenses/>. */
25
26	/* ------------------------------------------------------------------ */
27	/* Decimal Number arithmetic module */
28	/* ------------------------------------------------------------------ */
29	/* This module comprises the routines for arbitrary-precision General */
30	/* Decimal Arithmetic as defined in the specification which may be */
31	/* found on the General Decimal Arithmetic pages. It implements both */
32	/* the full ('extended') arithmetic and the simpler ('subset') */
33	/* arithmetic. */
34	/* */
35	/* Usage notes: */
36	/* */
37	/* 1. This code is ANSI C89 except: */
38	/* */
39	/* a) C99 line comments (double forward slash) are used. (Most C */
40	/* compilers accept these. If yours does not, a simple script */
41	/* can be used to convert them to ANSI C comments.) */
42	/* */
43	/* b) Types from C99 stdint.h are used. If you do not have this */
44	/* header file, see the User's Guide section of the decNumber */
45	/* documentation; this lists the necessary definitions. */
46	/* */
47	/* c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and */
48	/* uint64_t types may be used. To avoid these, set DECUSE64=0 */
49	/* and DECDPUN<=4 (see documentation). */
50	/* */
51	/* The code also conforms to C99 restrictions; in particular, */
52	/* strict aliasing rules are observed. */
53	/* */
54	/* 2. The decNumber format which this library uses is optimized for */
55	/* efficient processing of relatively short numbers; in particular */
56	/* it allows the use of fixed sized structures and minimizes copy */
57	/* and move operations. It does, however, support arbitrary */
58	/* precision (up to 999,999,999 digits) and arbitrary exponent */
59	/* range (Emax in the range 0 through 999,999,999 and Emin in the */
60	/* range -999,999,999 through 0). Mathematical functions (for */
61	/* example decNumberExp) as identified below are restricted more */
62	/* tightly: digits, emax, and -emin in the context must be <= */
63	/* DEC_MAX_MATH (999999), and their operand(s) must be within */
64	/* these bounds. */
65	/* */
66	/* 3. Logical functions are further restricted; their operands must */
67	/* be finite, positive, have an exponent of zero, and all digits */
68	/* must be either 0 or 1. The result will only contain digits */
69	/* which are 0 or 1 (and will have exponent=0 and a sign of 0). */
70	/* */
71	/* 4. Operands to operator functions are never modified unless they */
72	/* are also specified to be the result number (which is always */
73	/* permitted). Other than that case, operands must not overlap. */
74	/* */
75	/* 5. Error handling: the type of the error is ORed into the status */
76	/* flags in the current context (decContext structure). The */
77	/* SIGFPE signal is then raised if the corresponding trap-enabler */
78	/* flag in the decContext is set (is 1). */
79	/* */
80	/* It is the responsibility of the caller to clear the status */
81	/* flags as required. */
82	/* */
83	/* The result of any routine which returns a number will always */
84	/* be a valid number (which may be a special value, such as an */
85	/* Infinity or NaN). */
86	/* */
87	/* 6. The decNumber format is not an exchangeable concrete */
88	/* representation as it comprises fields which may be machine- */
89	/* dependent (packed or unpacked, or special length, for example). */
90	/* Canonical conversions to and from strings are provided; other */
91	/* conversions are available in separate modules. */
92	/* */
93	/* 7. Normally, input operands are assumed to be valid. Set DECCHECK */
94	/* to 1 for extended operand checking (including NULL operands). */
95	/* Results are undefined if a badly-formed structure (or a NULL */
96	/* pointer to a structure) is provided, though with DECCHECK */
97	/* enabled the operator routines are protected against exceptions. */
98	/* (Except if the result pointer is NULL, which is unrecoverable.) */
99	/* */
100	/* However, the routines will never cause exceptions if they are */
101	/* given well-formed operands, even if the value of the operands */
102	/* is inappropriate for the operation and DECCHECK is not set. */
103	/* (Except for SIGFPE, as and where documented.) */
104	/* */
105	/* 8. Subset arithmetic is available only if DECSUBSET is set to 1. */
106	/* ------------------------------------------------------------------ */
107	/* Implementation notes for maintenance of this module: */
108	/* */
109	/* 1. Storage leak protection: Routines which use malloc are not */
110	/* permitted to use return for fastpath or error exits (i.e., */
111	/* they follow strict structured programming conventions). */
112	/* Instead they have a do{}while(0); construct surrounding the */
113	/* code which is protected -- break may be used to exit this. */
114	/* Other routines can safely use the return statement inline. */
115	/* */
116	/* Storage leak accounting can be enabled using DECALLOC. */
117	/* */
118	/* 2. All loops use the for(;;) construct. Any do construct does */
119	/* not loop; it is for allocation protection as just described. */
120	/* */
121	/* 3. Setting status in the context must always be the very last */
122	/* action in a routine, as non-0 status may raise a trap and hence */
123	/* the call to set status may not return (if the handler uses long */
124	/* jump). Therefore all cleanup must be done first. In general, */
125	/* to achieve this status is accumulated and is only applied just */
126	/* before return by calling decContextSetStatus (via decStatus). */
127	/* */
128	/* Routines which allocate storage cannot, in general, use the */
129	/* 'top level' routines which could cause a non-returning */
130	/* transfer of control. The decXxxxOp routines are safe (do not */
131	/* call decStatus even if traps are set in the context) and should */
132	/* be used instead (they are also a little faster). */
133	/* */
134	/* 4. Exponent checking is minimized by allowing the exponent to */
135	/* grow outside its limits during calculations, provided that */
136	/* the decFinalize function is called later. Multiplication and */
137	/* division, and intermediate calculations in exponentiation, */
138	/* require more careful checks because of the risk of 31-bit */
139	/* overflow (the most negative valid exponent is -1999999997, for */
140	/* a 999999999-digit number with adjusted exponent of -999999999). */
141	/* */
142	/* 5. Rounding is deferred until finalization of results, with any */
143	/* 'off to the right' data being represented as a single digit */
144	/* residue (in the range -1 through 9). This avoids any double- */
145	/* rounding when more than one shortening takes place (for */
146	/* example, when a result is subnormal). */
147	/* */
148	/* 6. The digits count is allowed to rise to a multiple of DECDPUN */
149	/* during many operations, so whole Units are handled and exact */
150	/* accounting of digits is not needed. The correct digits value */
151	/* is found by decGetDigits, which accounts for leading zeros. */
152	/* This must be called before any rounding if the number of digits */
153	/* is not known exactly. */
154	/* */
155	/* 7. The multiply-by-reciprocal 'trick' is used for partitioning */
156	/* numbers up to four digits, using appropriate constants. This */
157	/* is not useful for longer numbers because overflow of 32 bits */
158	/* would lead to 4 multiplies, which is almost as expensive as */
159	/* a divide (unless a floating-point or 64-bit multiply is */
160	/* assumed to be available). */
161	/* */
162	/* 8. Unusual abbreviations that may be used in the commentary: */
163	/* lhs -- left hand side (operand, of an operation) */
164	/* lsd -- least significant digit (of coefficient) */
165	/* lsu -- least significant Unit (of coefficient) */
166	/* msd -- most significant digit (of coefficient) */
167	/* msi -- most significant item (in an array) */
168	/* msu -- most significant Unit (of coefficient) */
169	/* rhs -- right hand side (operand, of an operation) */
170	/* +ve -- positive */
171	/* -ve -- negative */
172	/* ** -- raise to the power */
173	/* ------------------------------------------------------------------ */
174
175	#include <stdlib.h> /* for malloc, free, etc. */
176	#include <stdio.h> /* for printf [if needed] */
177	#include <string.h> /* for strcpy */
178	#include <ctype.h> /* for lower */
179	#include "dconfig.h" /* for GCC definitions */
180	#include "decNumber.h" /* base number library */
181	#include "decNumberLocal.h" /* decNumber local types, etc. */
182
183	/* Constants */
184	/* Public lookup table used by the D2U macro */
185	const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
186
187	#define DECVERB 1 /* set to 1 for verbose DECCHECK */
188	#define powers DECPOWERS /* old internal name */
189
190	/* Local constants */
191	#define DIVIDE 0x80 /* Divide operators */
192	#define REMAINDER 0x40 /* .. */
193	#define DIVIDEINT 0x20 /* .. */
194	#define REMNEAR 0x10 /* .. */
195	#define COMPARE 0x01 /* Compare operators */
196	#define COMPMAX 0x02 /* .. */
197	#define COMPMIN 0x03 /* .. */
198	#define COMPTOTAL 0x04 /* .. */
199	#define COMPNAN 0x05 /* .. [NaN processing] */
200	#define COMPSIG 0x06 /* .. [signaling COMPARE] */
201	#define COMPMAXMAG 0x07 /* .. */
202	#define COMPMINMAG 0x08 /* .. */
203
204	#define DEC_sNaN 0x40000000 /* local status: sNaN signal */
205	#define BADINT (Int)0x80000000 /* most-negative Int; error indicator */
206	/* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
207	#define BIGEVEN (Int)0x80000002
208	#define BIGODD (Int)0x80000003
209
210	static Unit uarrone[1]={1}; /* Unit array of 1, used for incrementing */
211
212	/* Granularity-dependent code */
213	#if DECDPUN<=4
214	#define eInt Int /* extended integer */
215	#define ueInt uInt /* unsigned extended integer */
216	/* Constant multipliers for divide-by-power-of five using reciprocal */
217	/* multiply, after removing powers of 2 by shifting, and final shift */
218	/* of 17 [we only need up to **4] */
219	static const uInt multies[]={131073, 26215, 5243, 1049, 210};
220	/* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
221	#define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
222	#else
223	/* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
224	#if !DECUSE64
225	#error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
226	#endif
227	#define eInt Long /* extended integer */
228	#define ueInt uLong /* unsigned extended integer */
229	#endif
230
231	/* Local routines */
232	static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
233	decContext *, uByte, uInt *);
234	static Flag decBiStr(const char *, const char *, const char *);
235	static uInt decCheckMath(const decNumber *, decContext *, uInt *);
236	static void decApplyRound(decNumber *, decContext *, Int, uInt *);
237	static Int decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
238	static decNumber * decCompareOp(decNumber *, const decNumber *,
239	const decNumber *, decContext *,
240	Flag, uInt *);
241	static void decCopyFit(decNumber *, const decNumber *, decContext *,
242	Int *, uInt *);
243	static decNumber * decDecap(decNumber *, Int);
244	static decNumber * decDivideOp(decNumber *, const decNumber *,
245	const decNumber *, decContext *, Flag, uInt *);
246	static decNumber * decExpOp(decNumber *, const decNumber *,
247	decContext *, uInt *);
248	static void decFinalize(decNumber *, decContext *, Int *, uInt *);
249	static Int decGetDigits(Unit *, Int);
250	static Int decGetInt(const decNumber *);
251	static decNumber * decLnOp(decNumber *, const decNumber *,
252	decContext *, uInt *);
253	static decNumber * decMultiplyOp(decNumber *, const decNumber *,
254	const decNumber *, decContext *,
255	uInt *);
256	static decNumber * decNaNs(decNumber *, const decNumber *,
257	const decNumber *, decContext *, uInt *);
258	static decNumber * decQuantizeOp(decNumber *, const decNumber *,
259	const decNumber *, decContext *, Flag,
260	uInt *);
261	static void decReverse(Unit *, Unit *);
262	static void decSetCoeff(decNumber *, decContext *, const Unit *,
263	Int, Int *, uInt *);
264	static void decSetMaxValue(decNumber *, decContext *);
265	static void decSetOverflow(decNumber *, decContext *, uInt *);
266	static void decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
267	static Int decShiftToLeast(Unit *, Int, Int);
268	static Int decShiftToMost(Unit *, Int, Int);
269	static void decStatus(decNumber *, uInt, decContext *);
270	static void decToString(const decNumber *, char[], Flag);
271	static decNumber * decTrim(decNumber *, decContext *, Flag, Flag, Int *);
272	static Int decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
273	Unit *, Int);
274	static Int decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
275
276	#if !DECSUBSET
277	/* decFinish == decFinalize when no subset arithmetic needed */
278	#define decFinish(a,b,c,d) decFinalize(a,b,c,d)
279	#else
280	static void decFinish(decNumber *, decContext *, Int *, uInt *);
281	static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
282	#endif
283
284	/* Local macros */
285	/* masked special-values bits */
286	#define SPECIALARG (rhs->bits & DECSPECIAL)
287	#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
288
289	/* Diagnostic macros, etc. */
290	#if DECALLOC
291	/* Handle malloc/free accounting. If enabled, our accountable routines */
292	/* are used; otherwise the code just goes straight to the system malloc */
293	/* and free routines. */
294	#define malloc(a) decMalloc(a)
295	#define free(a) decFree(a)
296	#define DECFENCE 0x5a /* corruption detector */
297	/* 'Our' malloc and free: */
298	static void *decMalloc(size_t);
299	static void decFree(void *);
300	uInt decAllocBytes=0; /* count of bytes allocated */
301	/* Note that DECALLOC code only checks for storage buffer overflow. */
302	/* To check for memory leaks, the decAllocBytes variable must be */
303	/* checked to be 0 at appropriate times (e.g., after the test */
304	/* harness completes a set of tests). This checking may be unreliable */
305	/* if the testing is done in a multi-thread environment. */
306	#endif
307
308	#if DECCHECK
309	/* Optional checking routines. Enabling these means that decNumber */
310	/* and decContext operands to operator routines are checked for */
311	/* correctness. This roughly doubles the execution time of the */
312	/* fastest routines (and adds 600+ bytes), so should not normally be */
313	/* used in 'production'. */
314	/* decCheckInexact is used to check that inexact results have a full */
315	/* complement of digits (where appropriate -- this is not the case */
316	/* for Quantize, for example) */
317	#define DECUNRESU ((decNumber *)(void *)0xffffffff)
318	#define DECUNUSED ((const decNumber *)(void *)0xffffffff)
319	#define DECUNCONT ((decContext *)(void *)(0xffffffff))
320	static Flag decCheckOperands(decNumber *, const decNumber *,
321	const decNumber *, decContext *);
322	static Flag decCheckNumber(const decNumber *);
323	static void decCheckInexact(const decNumber *, decContext *);
324	#endif
325
326	#if DECTRACE || DECCHECK
327	/* Optional trace/debugging routines (may or may not be used) */
328	void decNumberShow(const decNumber *); /* displays the components of a number */
329	static void decDumpAr(char, const Unit *, Int);
330	#endif
331
332	/* ================================================================== */
333	/* Conversions */
334	/* ================================================================== */
335
336	/* ------------------------------------------------------------------ */
337	/* from-int32 -- conversion from Int or uInt */
338	/* */
339	/* dn is the decNumber to receive the integer */
340	/* in or uin is the integer to be converted */
341	/* returns dn */
342	/* */
343	/* No error is possible. */
344	/* ------------------------------------------------------------------ */
345	decNumber * decNumberFromInt32(decNumber *dn, Int in) {
346	uInt unsig;
347	if (in>=0) unsig=in;
348	else { /* negative (possibly BADINT) */
349	if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
350	else unsig=-in; /* invert */
351	}
352	/* in is now positive */
353	decNumberFromUInt32(dn, unsig);
354	if (in<0) dn->bits=DECNEG; /* sign needed */
355	return dn;
356	} /* decNumberFromInt32 */
357
358	decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
359	Unit *up; /* work pointer */
360	decNumberZero(dn); /* clean */
361	if (uin==0) return dn; /* [or decGetDigits bad call] */
362	for (up=dn->lsu; uin>0; up++) {
363	*up=(Unit)(uin%(DECDPUNMAX+1));
364	uin=uin/(DECDPUNMAX+1);
365	}
366	dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
367	return dn;
368	} /* decNumberFromUInt32 */
369
370	/* ------------------------------------------------------------------ */
371	/* to-int32 -- conversion to Int or uInt */
372	/* */
373	/* dn is the decNumber to convert */
374	/* set is the context for reporting errors */
375	/* returns the converted decNumber, or 0 if Invalid is set */
376	/* */
377	/* Invalid is set if the decNumber does not have exponent==0 or if */
378	/* it is a NaN, Infinite, or out-of-range. */
379	/* ------------------------------------------------------------------ */
380	Int decNumberToInt32(const decNumber *dn, decContext *set) {
381	#if DECCHECK
382	if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
383	#endif
384
385	/* special or too many digits, or bad exponent */
386	if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
387	else { /* is a finite integer with 10 or fewer digits */
388	Int d; /* work */
389	const Unit *up; /* .. */
390	uInt hi=0, lo; /* .. */
391	up=dn->lsu; /* -> lsu */
392	lo=*up; /* get 1 to 9 digits */
393	#if DECDPUN>1 /* split to higher */
394	hi=lo/10;
395	lo=lo%10;
396	#endif
397	up++;
398	/* collect remaining Units, if any, into hi */
399	for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
400	/* now low has the lsd, hi the remainder */
401	if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
402	/* most-negative is a reprieve */
403	if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
404	/* bad -- drop through */
405	}
406	else { /* in-range always */
407	Int i=X10(hi)+lo;
408	if (dn->bits&DECNEG) return -i;
409	return i;
410	}
411	} /* integer */
412	decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
413	return 0;
414	} /* decNumberToInt32 */
415
416	uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
417	#if DECCHECK
418	if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
419	#endif
420	/* special or too many digits, or bad exponent, or negative (<0) */
421	if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
422	|| (dn->bits&DECNEG && !ISZERO(dn))); /* bad */
423	else { /* is a finite integer with 10 or fewer digits */
424	Int d; /* work */
425	const Unit *up; /* .. */
426	uInt hi=0, lo; /* .. */
427	up=dn->lsu; /* -> lsu */
428	lo=*up; /* get 1 to 9 digits */
429	#if DECDPUN>1 /* split to higher */
430	hi=lo/10;
431	lo=lo%10;
432	#endif
433	up++;
434	/* collect remaining Units, if any, into hi */
435	for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
436
437	/* now low has the lsd, hi the remainder */
438	if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
439	else return X10(hi)+lo;
440	} /* integer */
441	decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
442	return 0;
443	} /* decNumberToUInt32 */
444
445	/* ------------------------------------------------------------------ */
446	/* to-scientific-string -- conversion to numeric string */
447	/* to-engineering-string -- conversion to numeric string */
448	/* */
449	/* decNumberToString(dn, string); */
450	/* decNumberToEngString(dn, string); */
451	/* */
452	/* dn is the decNumber to convert */
453	/* string is the string where the result will be laid out */
454	/* */
455	/* string must be at least dn->digits+14 characters long */
456	/* */
457	/* No error is possible, and no status can be set. */
458	/* ------------------------------------------------------------------ */
459	char * decNumberToString(const decNumber *dn, char *string){
460	decToString(dn, string, 0);
461	return string;
462	} /* DecNumberToString */
463
464	char * decNumberToEngString(const decNumber *dn, char *string){
465	decToString(dn, string, 1);
466	return string;
467	} /* DecNumberToEngString */
468
469	/* ------------------------------------------------------------------ */
470	/* to-number -- conversion from numeric string */
471	/* */
472	/* decNumberFromString -- convert string to decNumber */
473	/* dn -- the number structure to fill */
474	/* chars[] -- the string to convert ('\0' terminated) */
475	/* set -- the context used for processing any error, */
476	/* determining the maximum precision available */
477	/* (set.digits), determining the maximum and minimum */
478	/* exponent (set.emax and set.emin), determining if */
479	/* extended values are allowed, and checking the */
480	/* rounding mode if overflow occurs or rounding is */
481	/* needed. */
482	/* */
483	/* The length of the coefficient and the size of the exponent are */
484	/* checked by this routine, so the correct error (Underflow or */
485	/* Overflow) can be reported or rounding applied, as necessary. */
486	/* */
487	/* If bad syntax is detected, the result will be a quiet NaN. */
488	/* ------------------------------------------------------------------ */
489	decNumber * decNumberFromString(decNumber *dn, const char chars[],
490	decContext *set) {
491	Int exponent=0; /* working exponent [assume 0] */
492	uByte bits=0; /* working flags [assume +ve] */
493	Unit *res; /* where result will be built */
494	Unit resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
495	/* [+9 allows for ln() constants] */
496	Unit *allocres=NULL; /* -> allocated result, iff allocated */
497	Int d=0; /* count of digits found in decimal part */
498	const char *dotchar=NULL; /* where dot was found */
499	const char *cfirst=chars; /* -> first character of decimal part */
500	const char *last=NULL; /* -> last digit of decimal part */
501	const char *c; /* work */
502	Unit *up; /* .. */
503	#if DECDPUN>1
504	Int cut, out; /* .. */
505	#endif
506	Int residue; /* rounding residue */
507	uInt status=0; /* error code */
508
509	#if DECCHECK
510	if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
511	return decNumberZero(dn);
512	#endif
513
514	do { /* status & malloc protection */
515	for (c=chars;; c++) { /* -> input character */
516	if (*c>='0' && *c<='9') { /* test for Arabic digit */
517	last=c;
518	d++; /* count of real digits */
519	continue; /* still in decimal part */
520	}
521	if (*c=='.' && dotchar==NULL) { /* first '.' */
522	dotchar=c; /* record offset into decimal part */
523	if (c==cfirst) cfirst++; /* first digit must follow */
524	continue;}
525	if (c==chars) { /* first in string... */
526	if (*c=='-') { /* valid - sign */
527	cfirst++;
528	bits=DECNEG;
529	continue;}
530	if (*c=='+') { /* valid + sign */
531	cfirst++;
532	continue;}
533	}
534	/* *c is not a digit, or a valid +, -, or '.' */
535	break;
536	} /* c */
537
538	if (last==NULL) { /* no digits yet */
539	status=DEC_Conversion_syntax;/* assume the worst */
540	if (*c=='\0') break; /* and no more to come... */
541	#if DECSUBSET
542	/* if subset then infinities and NaNs are not allowed */
543	if (!set->extended) break; /* hopeless */
544	#endif
545	/* Infinities and NaNs are possible, here */
546	if (dotchar!=NULL) break; /* .. unless had a dot */
547	decNumberZero(dn); /* be optimistic */
548	if (decBiStr(c, "infinity", "INFINITY")
549	|| decBiStr(c, "inf", "INF")) {
550	dn->bits=bits | DECINF;
551	status=0; /* is OK */
552	break; /* all done */
553	}
554	/* a NaN expected */
555	/* 2003.09.10 NaNs are now permitted to have a sign */
556	dn->bits=bits | DECNAN; /* assume simple NaN */
557	if (*c=='s' || *c=='S') { /* looks like an sNaN */
558	c++;
559	dn->bits=bits | DECSNAN;
560	}
561	if (*c!='n' && *c!='N') break; /* check caseless "NaN" */
562	c++;
563	if (*c!='a' && *c!='A') break; /* .. */
564	c++;
565	if (*c!='n' && *c!='N') break; /* .. */
566	c++;
567	/* now either nothing, or nnnn payload, expected */
568	/* -> start of integer and skip leading 0s [including plain 0] */
569	for (cfirst=c; *cfirst=='0';) cfirst++;
570	if (*cfirst=='\0') { /* "NaN" or "sNaN", maybe with all 0s */
571	status=0; /* it's good */
572	break; /* .. */
573	}
574	/* something other than 0s; setup last and d as usual [no dots] */
575	for (c=cfirst;; c++, d++) {
576	if (*c<'0' || *c>'9') break; /* test for Arabic digit */
577	last=c;
578	}
579	if (*c!='\0') break; /* not all digits */
580	if (d>set->digits-1) {
581	/* [NB: payload in a decNumber can be full length unless */
582	/* clamped, in which case can only be digits-1] */
583	if (set->clamp) break;
584	if (d>set->digits) break;
585	} /* too many digits? */
586	/* good; drop through to convert the integer to coefficient */
587	status=0; /* syntax is OK */
588	bits=dn->bits; /* for copy-back */
589	} /* last==NULL */
590
591	else if (*c!='\0') { /* more to process... */
592	/* had some digits; exponent is only valid sequence now */
593	Flag nege; /* 1=negative exponent */
594	const char *firstexp; /* -> first significant exponent digit */
595	status=DEC_Conversion_syntax;/* assume the worst */
596	if (*c!='e' && *c!='E') break;
597	/* Found 'e' or 'E' -- now process explicit exponent */
598	/* 1998.07.11: sign no longer required */
599	nege=0;
600	c++; /* to (possible) sign */
601	if (*c=='-') {nege=1; c++;}
602	else if (*c=='+') c++;
603	if (*c=='\0') break;
604
605	for (; *c=='0' && *(c+1)!='\0';) c++; /* strip insignificant zeros */
606	firstexp=c; /* save exponent digit place */
607	for (; ;c++) {
608	if (*c<'0' || *c>'9') break; /* not a digit */
609	exponent=X10(exponent)+(Int)*c-(Int)'0';
610	} /* c */
611	/* if not now on a '\0', *c must not be a digit */
612	if (*c!='\0') break;
613
614	/* (this next test must be after the syntax checks) */
615	/* if it was too long the exponent may have wrapped, so check */
616	/* carefully and set it to a certain overflow if wrap possible */
617	if (c>=firstexp+9+1) {
618	if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
619	/* [up to 1999999999 is OK, for example 1E-1000000998] */
620	}
621	if (nege) exponent=-exponent; /* was negative */
622	status=0; /* is OK */
623	} /* stuff after digits */
624
625	/* Here when whole string has been inspected; syntax is good */
626	/* cfirst->first digit (never dot), last->last digit (ditto) */
627
628	/* strip leading zeros/dot [leave final 0 if all 0's] */
629	if (*cfirst=='0') { /* [cfirst has stepped over .] */
630	for (c=cfirst; c<last; c++, cfirst++) {
631	if (*c=='.') continue; /* ignore dots */
632	if (*c!='0') break; /* non-zero found */
633	d--; /* 0 stripped */
634	} /* c */
635	#if DECSUBSET
636	/* make a rapid exit for easy zeros if !extended */
637	if (*cfirst=='0' && !set->extended) {
638	decNumberZero(dn); /* clean result */
639	break; /* [could be return] */
640	}
641	#endif
642	} /* at least one leading 0 */
643
644	/* Handle decimal point... */
645	if (dotchar!=NULL && dotchar<last) /* non-trailing '.' found? */
646	exponent-=(last-dotchar); /* adjust exponent */
647	/* [we can now ignore the .] */
648
649	/* OK, the digits string is good. Assemble in the decNumber, or in */
650	/* a temporary units array if rounding is needed */
651	if (d<=set->digits) res=dn->lsu; /* fits into supplied decNumber */
652	else { /* rounding needed */
653	Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
654	res=resbuff; /* assume use local buffer */
655	if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
656	allocres=(Unit *)malloc(size: needbytes);
657	if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
658	res=allocres;
659	}
660	}
661	/* res now -> number lsu, buffer, or allocated storage for Unit array */
662
663	/* Place the coefficient into the selected Unit array */
664	/* [this is often 70% of the cost of this function when DECDPUN>1] */
665	#if DECDPUN>1
666	out=0; /* accumulator */
667	up=res+D2U(d)-1; /* -> msu */
668	cut=d-(up-res)*DECDPUN; /* digits in top unit */
669	for (c=cfirst;; c++) { /* along the digits */
670	if (*c=='.') continue; /* ignore '.' [don't decrement cut] */
671	out=X10(out)+(Int)*c-(Int)'0';
672	if (c==last) break; /* done [never get to trailing '.'] */
673	cut--;
674	if (cut>0) continue; /* more for this unit */
675	*up=(Unit)out; /* write unit */
676	up--; /* prepare for unit below.. */
677	cut=DECDPUN; /* .. */
678	out=0; /* .. */
679	} /* c */
680	*up=(Unit)out; /* write lsu */
681
682	#else
683	/* DECDPUN==1 */
684	up=res; /* -> lsu */
685	for (c=last; c>=cfirst; c--) { /* over each character, from least */
686	if (*c=='.') continue; /* ignore . [don't step up] */
687	*up=(Unit)((Int)*c-(Int)'0');
688	up++;
689	} /* c */
690	#endif
691
692	dn->bits=bits;
693	dn->exponent=exponent;
694	dn->digits=d;
695
696	/* if not in number (too long) shorten into the number */
697	if (d>set->digits) {
698	residue=0;
699	decSetCoeff(dn, set, res, d, &residue, &status);
700	/* always check for overflow or subnormal and round as needed */
701	decFinalize(dn, set, &residue, &status);
702	}
703	else { /* no rounding, but may still have overflow or subnormal */
704	/* [these tests are just for performance; finalize repeats them] */
705	if ((dn->exponent-1<set->emin-dn->digits)
706	|| (dn->exponent-1>set->emax-set->digits)) {
707	residue=0;
708	decFinalize(dn, set, &residue, &status);
709	}
710	}
711	/* decNumberShow(dn); */
712	} while(0); /* [for break] */
713
714	free(ptr: allocres); /* drop any storage used */
715	if (status!=0) decStatus(dn, status, set);
716	return dn;
717	} /* decNumberFromString */
718
719	/* ================================================================== */
720	/* Operators */
721	/* ================================================================== */
722
723	/* ------------------------------------------------------------------ */
724	/* decNumberAbs -- absolute value operator */
725	/* */
726	/* This computes C = abs(A) */
727	/* */
728	/* res is C, the result. C may be A */
729	/* rhs is A */
730	/* set is the context */
731	/* */
732	/* See also decNumberCopyAbs for a quiet bitwise version of this. */
733	/* C must have space for set->digits digits. */
734	/* ------------------------------------------------------------------ */
735	/* This has the same effect as decNumberPlus unless A is negative, */
736	/* in which case it has the same effect as decNumberMinus. */
737	/* ------------------------------------------------------------------ */
738	decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
739	decContext *set) {
740	decNumber dzero; /* for 0 */
741	uInt status=0; /* accumulator */
742
743	#if DECCHECK
744	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
745	#endif
746
747	decNumberZero(&dzero); /* set 0 */
748	dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
749	decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
750	if (status!=0) decStatus(res, status, set);
751	#if DECCHECK
752	decCheckInexact(res, set);
753	#endif
754	return res;
755	} /* decNumberAbs */
756
757	/* ------------------------------------------------------------------ */
758	/* decNumberAdd -- add two Numbers */
759	/* */
760	/* This computes C = A + B */
761	/* */
762	/* res is C, the result. C may be A and/or B (e.g., X=X+X) */
763	/* lhs is A */
764	/* rhs is B */
765	/* set is the context */
766	/* */
767	/* C must have space for set->digits digits. */
768	/* ------------------------------------------------------------------ */
769	/* This just calls the routine shared with Subtract */
770	decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
771	const decNumber *rhs, decContext *set) {
772	uInt status=0; /* accumulator */
773	decAddOp(res, lhs, rhs, set, 0, &status);
774	if (status!=0) decStatus(res, status, set);
775	#if DECCHECK
776	decCheckInexact(res, set);
777	#endif
778	return res;
779	} /* decNumberAdd */
780
781	/* ------------------------------------------------------------------ */
782	/* decNumberAnd -- AND two Numbers, digitwise */
783	/* */
784	/* This computes C = A & B */
785	/* */
786	/* res is C, the result. C may be A and/or B (e.g., X=X&X) */
787	/* lhs is A */
788	/* rhs is B */
789	/* set is the context (used for result length and error report) */
790	/* */
791	/* C must have space for set->digits digits. */
792	/* */
793	/* Logical function restrictions apply (see above); a NaN is */
794	/* returned with Invalid_operation if a restriction is violated. */
795	/* ------------------------------------------------------------------ */
796	decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
797	const decNumber *rhs, decContext *set) {
798	const Unit *ua, *ub; /* -> operands */
799	const Unit *msua, *msub; /* -> operand msus */
800	Unit *uc, *msuc; /* -> result and its msu */
801	Int msudigs; /* digits in res msu */
802	#if DECCHECK
803	if (decCheckOperands(res, lhs, rhs, set)) return res;
804	#endif
805
806	if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
807	|| rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
808	decStatus(res, DEC_Invalid_operation, set);
809	return res;
810	}
811
812	/* operands are valid */
813	ua=lhs->lsu; /* bottom-up */
814	ub=rhs->lsu; /* .. */
815	uc=res->lsu; /* .. */
816	msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
817	msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
818	msuc=uc+D2U(set->digits)-1; /* -> msu of result */
819	msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
820	for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
821	Unit a, b; /* extract units */
822	if (ua>msua) a=0;
823	else a=*ua;
824	if (ub>msub) b=0;
825	else b=*ub;
826	*uc=0; /* can now write back */
827	if (a|b) { /* maybe 1 bits to examine */
828	Int i, j;
829	*uc=0; /* can now write back */
830	/* This loop could be unrolled and/or use BIN2BCD tables */
831	for (i=0; i<DECDPUN; i++) {
832	if (a&b&1) *uc=*uc+(Unit)powers[i]; /* effect AND */
833	j=a%10;
834	a=a/10;
835	j|=b%10;
836	b=b/10;
837	if (j>1) {
838	decStatus(res, DEC_Invalid_operation, set);
839	return res;
840	}
841	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
842	} /* each digit */
843	} /* both OK */
844	} /* each unit */
845	/* [here uc-1 is the msu of the result] */
846	res->digits=decGetDigits(res->lsu, uc-res->lsu);
847	res->exponent=0; /* integer */
848	res->bits=0; /* sign=0 */
849	return res; /* [no status to set] */
850	} /* decNumberAnd */
851
852	/* ------------------------------------------------------------------ */
853	/* decNumberCompare -- compare two Numbers */
854	/* */
855	/* This computes C = A ? B */
856	/* */
857	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
858	/* lhs is A */
859	/* rhs is B */
860	/* set is the context */
861	/* */
862	/* C must have space for one digit (or NaN). */
863	/* ------------------------------------------------------------------ */
864	decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
865	const decNumber *rhs, decContext *set) {
866	uInt status=0; /* accumulator */
867	decCompareOp(res, lhs, rhs, set, COMPARE, &status);
868	if (status!=0) decStatus(res, status, set);
869	return res;
870	} /* decNumberCompare */
871
872	/* ------------------------------------------------------------------ */
873	/* decNumberCompareSignal -- compare, signalling on all NaNs */
874	/* */
875	/* This computes C = A ? B */
876	/* */
877	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
878	/* lhs is A */
879	/* rhs is B */
880	/* set is the context */
881	/* */
882	/* C must have space for one digit (or NaN). */
883	/* ------------------------------------------------------------------ */
884	decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
885	const decNumber *rhs, decContext *set) {
886	uInt status=0; /* accumulator */
887	decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
888	if (status!=0) decStatus(res, status, set);
889	return res;
890	} /* decNumberCompareSignal */
891
892	/* ------------------------------------------------------------------ */
893	/* decNumberCompareTotal -- compare two Numbers, using total ordering */
894	/* */
895	/* This computes C = A ? B, under total ordering */
896	/* */
897	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
898	/* lhs is A */
899	/* rhs is B */
900	/* set is the context */
901	/* */
902	/* C must have space for one digit; the result will always be one of */
903	/* -1, 0, or 1. */
904	/* ------------------------------------------------------------------ */
905	decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
906	const decNumber *rhs, decContext *set) {
907	uInt status=0; /* accumulator */
908	decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
909	if (status!=0) decStatus(res, status, set);
910	return res;
911	} /* decNumberCompareTotal */
912
913	/* ------------------------------------------------------------------ */
914	/* decNumberCompareTotalMag -- compare, total ordering of magnitudes */
915	/* */
916	/* This computes C = |A| ? |B|, under total ordering */
917	/* */
918	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
919	/* lhs is A */
920	/* rhs is B */
921	/* set is the context */
922	/* */
923	/* C must have space for one digit; the result will always be one of */
924	/* -1, 0, or 1. */
925	/* ------------------------------------------------------------------ */
926	decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
927	const decNumber *rhs, decContext *set) {
928	uInt status=0; /* accumulator */
929	uInt needbytes; /* for space calculations */
930	decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
931	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
932	decNumber bufb[D2N(DECBUFFER+1)];
933	decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
934	decNumber *a, *b; /* temporary pointers */
935
936	#if DECCHECK
937	if (decCheckOperands(res, lhs, rhs, set)) return res;
938	#endif
939
940	do { /* protect allocated storage */
941	/* if either is negative, take a copy and absolute */
942	if (decNumberIsNegative(lhs)) { /* lhs<0 */
943	a=bufa;
944	needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
945	if (needbytes>sizeof(bufa)) { /* need malloc space */
946	allocbufa=(decNumber *)malloc(size: needbytes);
947	if (allocbufa==NULL) { /* hopeless -- abandon */
948	status|=DEC_Insufficient_storage;
949	break;}
950	a=allocbufa; /* use the allocated space */
951	}
952	decNumberCopy(a, lhs); /* copy content */
953	a->bits&=~DECNEG; /* .. and clear the sign */
954	lhs=a; /* use copy from here on */
955	}
956	if (decNumberIsNegative(rhs)) { /* rhs<0 */
957	b=bufb;
958	needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
959	if (needbytes>sizeof(bufb)) { /* need malloc space */
960	allocbufb=(decNumber *)malloc(size: needbytes);
961	if (allocbufb==NULL) { /* hopeless -- abandon */
962	status|=DEC_Insufficient_storage;
963	break;}
964	b=allocbufb; /* use the allocated space */
965	}
966	decNumberCopy(b, rhs); /* copy content */
967	b->bits&=~DECNEG; /* .. and clear the sign */
968	rhs=b; /* use copy from here on */
969	}
970	decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
971	} while(0); /* end protected */
972
973	free(ptr: allocbufa); /* drop any storage used */
974	free(ptr: allocbufb); /* .. */
975	if (status!=0) decStatus(res, status, set);
976	return res;
977	} /* decNumberCompareTotalMag */
978
979	/* ------------------------------------------------------------------ */
980	/* decNumberDivide -- divide one number by another */
981	/* */
982	/* This computes C = A / B */
983	/* */
984	/* res is C, the result. C may be A and/or B (e.g., X=X/X) */
985	/* lhs is A */
986	/* rhs is B */
987	/* set is the context */
988	/* */
989	/* C must have space for set->digits digits. */
990	/* ------------------------------------------------------------------ */
991	decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
992	const decNumber *rhs, decContext *set) {
993	uInt status=0; /* accumulator */
994	decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
995	if (status!=0) decStatus(res, status, set);
996	#if DECCHECK
997	decCheckInexact(res, set);
998	#endif
999	return res;
1000	} /* decNumberDivide */
1001
1002	/* ------------------------------------------------------------------ */
1003	/* decNumberDivideInteger -- divide and return integer quotient */
1004	/* */
1005	/* This computes C = A # B, where # is the integer divide operator */
1006	/* */
1007	/* res is C, the result. C may be A and/or B (e.g., X=X#X) */
1008	/* lhs is A */
1009	/* rhs is B */
1010	/* set is the context */
1011	/* */
1012	/* C must have space for set->digits digits. */
1013	/* ------------------------------------------------------------------ */
1014	decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1015	const decNumber *rhs, decContext *set) {
1016	uInt status=0; /* accumulator */
1017	decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1018	if (status!=0) decStatus(res, status, set);
1019	return res;
1020	} /* decNumberDivideInteger */
1021
1022	/* ------------------------------------------------------------------ */
1023	/* decNumberExp -- exponentiation */
1024	/* */
1025	/* This computes C = exp(A) */
1026	/* */
1027	/* res is C, the result. C may be A */
1028	/* rhs is A */
1029	/* set is the context; note that rounding mode has no effect */
1030	/* */
1031	/* C must have space for set->digits digits. */
1032	/* */
1033	/* Mathematical function restrictions apply (see above); a NaN is */
1034	/* returned with Invalid_operation if a restriction is violated. */
1035	/* */
1036	/* Finite results will always be full precision and Inexact, except */
1037	/* when A is a zero or -Infinity (giving 1 or 0 respectively). */
1038	/* */
1039	/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1040	/* almost always be correctly rounded, but may be up to 1 ulp in */
1041	/* error in rare cases. */
1042	/* ------------------------------------------------------------------ */
1043	/* This is a wrapper for decExpOp which can handle the slightly wider */
1044	/* (double) range needed by Ln (which has to be able to calculate */
1045	/* exp(-a) where a can be the tiniest number (Ntiny). */
1046	/* ------------------------------------------------------------------ */
1047	decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1048	decContext *set) {
1049	uInt status=0; /* accumulator */
1050	#if DECSUBSET
1051	decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1052	#endif
1053
1054	#if DECCHECK
1055	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1056	#endif
1057
1058	/* Check restrictions; these restrictions ensure that if h=8 (see */
1059	/* decExpOp) then the result will either overflow or underflow to 0. */
1060	/* Other math functions restrict the input range, too, for inverses. */
1061	/* If not violated then carry out the operation. */
1062	if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1063	#if DECSUBSET
1064	if (!set->extended) {
1065	/* reduce operand and set lostDigits status, as needed */
1066	if (rhs->digits>set->digits) {
1067	allocrhs=decRoundOperand(rhs, set, &status);
1068	if (allocrhs==NULL) break;
1069	rhs=allocrhs;
1070	}
1071	}
1072	#endif
1073	decExpOp(res, rhs, set, &status);
1074	} while(0); /* end protected */
1075
1076	#if DECSUBSET
1077	free(allocrhs); /* drop any storage used */
1078	#endif
1079	/* apply significant status */
1080	if (status!=0) decStatus(res, status, set);
1081	#if DECCHECK
1082	decCheckInexact(res, set);
1083	#endif
1084	return res;
1085	} /* decNumberExp */
1086
1087	/* ------------------------------------------------------------------ */
1088	/* decNumberFMA -- fused multiply add */
1089	/* */
1090	/* This computes D = (A * B) + C with only one rounding */
1091	/* */
1092	/* res is D, the result. D may be A or B or C (e.g., X=FMA(X,X,X)) */
1093	/* lhs is A */
1094	/* rhs is B */
1095	/* fhs is C [far hand side] */
1096	/* set is the context */
1097	/* */
1098	/* Mathematical function restrictions apply (see above); a NaN is */
1099	/* returned with Invalid_operation if a restriction is violated. */
1100	/* */
1101	/* C must have space for set->digits digits. */
1102	/* ------------------------------------------------------------------ */
1103	decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1104	const decNumber *rhs, const decNumber *fhs,
1105	decContext *set) {
1106	uInt status=0; /* accumulator */
1107	decContext dcmul; /* context for the multiplication */
1108	uInt needbytes; /* for space calculations */
1109	decNumber bufa[D2N(DECBUFFER*2+1)];
1110	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1111	decNumber *acc; /* accumulator pointer */
1112	decNumber dzero; /* work */
1113
1114	#if DECCHECK
1115	if (decCheckOperands(res, lhs, rhs, set)) return res;
1116	if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1117	#endif
1118
1119	do { /* protect allocated storage */
1120	#if DECSUBSET
1121	if (!set->extended) { /* [undefined if subset] */
1122	status|=DEC_Invalid_operation;
1123	break;}
1124	#endif
1125	/* Check math restrictions [these ensure no overflow or underflow] */
1126	if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1127	|| (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1128	|| (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1129	/* set up context for multiply */
1130	dcmul=*set;
1131	dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1132	/* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1133	dcmul.emax=DEC_MAX_EMAX; /* effectively unbounded .. */
1134	dcmul.emin=DEC_MIN_EMIN; /* [thanks to Math restrictions] */
1135	/* set up decNumber space to receive the result of the multiply */
1136	acc=bufa; /* may fit */
1137	needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1138	if (needbytes>sizeof(bufa)) { /* need malloc space */
1139	allocbufa=(decNumber *)malloc(size: needbytes);
1140	if (allocbufa==NULL) { /* hopeless -- abandon */
1141	status|=DEC_Insufficient_storage;
1142	break;}
1143	acc=allocbufa; /* use the allocated space */
1144	}
1145	/* multiply with extended range and necessary precision */
1146	/*printf("emin=%ld\n", dcmul.emin); */
1147	decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1148	/* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1149	/* status; if either is seen than ignore fhs (in case it is */
1150	/* another sNaN) and set acc to NaN unless we had an sNaN */
1151	/* [decMultiplyOp leaves that to caller] */
1152	/* Note sNaN has to go through addOp to shorten payload if */
1153	/* necessary */
1154	if ((status&DEC_Invalid_operation)!=0) {
1155	if (!(status&DEC_sNaN)) { /* but be true invalid */
1156	decNumberZero(res); /* acc not yet set */
1157	res->bits=DECNAN;
1158	break;
1159	}
1160	decNumberZero(&dzero); /* make 0 (any non-NaN would do) */
1161	fhs=&dzero; /* use that */
1162	}
1163	#if DECCHECK
1164	else { /* multiply was OK */
1165	if (status!=0) printf("Status=%08lx after FMA multiply\n", (LI)status);
1166	}
1167	#endif
1168	/* add the third operand and result -> res, and all is done */
1169	decAddOp(res, acc, fhs, set, 0, &status);
1170	} while(0); /* end protected */
1171
1172	free(ptr: allocbufa); /* drop any storage used */
1173	if (status!=0) decStatus(res, status, set);
1174	#if DECCHECK
1175	decCheckInexact(res, set);
1176	#endif
1177	return res;
1178	} /* decNumberFMA */
1179
1180	/* ------------------------------------------------------------------ */
1181	/* decNumberInvert -- invert a Number, digitwise */
1182	/* */
1183	/* This computes C = ~A */
1184	/* */
1185	/* res is C, the result. C may be A (e.g., X=~X) */
1186	/* rhs is A */
1187	/* set is the context (used for result length and error report) */
1188	/* */
1189	/* C must have space for set->digits digits. */
1190	/* */
1191	/* Logical function restrictions apply (see above); a NaN is */
1192	/* returned with Invalid_operation if a restriction is violated. */
1193	/* ------------------------------------------------------------------ */
1194	decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1195	decContext *set) {
1196	const Unit *ua, *msua; /* -> operand and its msu */
1197	Unit *uc, *msuc; /* -> result and its msu */
1198	Int msudigs; /* digits in res msu */
1199	#if DECCHECK
1200	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1201	#endif
1202
1203	if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1204	decStatus(res, DEC_Invalid_operation, set);
1205	return res;
1206	}
1207	/* operand is valid */
1208	ua=rhs->lsu; /* bottom-up */
1209	uc=res->lsu; /* .. */
1210	msua=ua+D2U(rhs->digits)-1; /* -> msu of rhs */
1211	msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1212	msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1213	for (; uc<=msuc; ua++, uc++) { /* Unit loop */
1214	Unit a; /* extract unit */
1215	Int i, j; /* work */
1216	if (ua>msua) a=0;
1217	else a=*ua;
1218	*uc=0; /* can now write back */
1219	/* always need to examine all bits in rhs */
1220	/* This loop could be unrolled and/or use BIN2BCD tables */
1221	for (i=0; i<DECDPUN; i++) {
1222	if ((~a)&1) *uc=*uc+(Unit)powers[i]; /* effect INVERT */
1223	j=a%10;
1224	a=a/10;
1225	if (j>1) {
1226	decStatus(res, DEC_Invalid_operation, set);
1227	return res;
1228	}
1229	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1230	} /* each digit */
1231	} /* each unit */
1232	/* [here uc-1 is the msu of the result] */
1233	res->digits=decGetDigits(res->lsu, uc-res->lsu);
1234	res->exponent=0; /* integer */
1235	res->bits=0; /* sign=0 */
1236	return res; /* [no status to set] */
1237	} /* decNumberInvert */
1238
1239	/* ------------------------------------------------------------------ */
1240	/* decNumberLn -- natural logarithm */
1241	/* */
1242	/* This computes C = ln(A) */
1243	/* */
1244	/* res is C, the result. C may be A */
1245	/* rhs is A */
1246	/* set is the context; note that rounding mode has no effect */
1247	/* */
1248	/* C must have space for set->digits digits. */
1249	/* */
1250	/* Notable cases: */
1251	/* A<0 -> Invalid */
1252	/* A=0 -> -Infinity (Exact) */
1253	/* A=+Infinity -> +Infinity (Exact) */
1254	/* A=1 exactly -> 0 (Exact) */
1255	/* */
1256	/* Mathematical function restrictions apply (see above); a NaN is */
1257	/* returned with Invalid_operation if a restriction is violated. */
1258	/* */
1259	/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1260	/* almost always be correctly rounded, but may be up to 1 ulp in */
1261	/* error in rare cases. */
1262	/* ------------------------------------------------------------------ */
1263	/* This is a wrapper for decLnOp which can handle the slightly wider */
1264	/* (+11) range needed by Ln, Log10, etc. (which may have to be able */
1265	/* to calculate at p+e+2). */
1266	/* ------------------------------------------------------------------ */
1267	decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1268	decContext *set) {
1269	uInt status=0; /* accumulator */
1270	#if DECSUBSET
1271	decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1272	#endif
1273
1274	#if DECCHECK
1275	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1276	#endif
1277
1278	/* Check restrictions; this is a math function; if not violated */
1279	/* then carry out the operation. */
1280	if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1281	#if DECSUBSET
1282	if (!set->extended) {
1283	/* reduce operand and set lostDigits status, as needed */
1284	if (rhs->digits>set->digits) {
1285	allocrhs=decRoundOperand(rhs, set, &status);
1286	if (allocrhs==NULL) break;
1287	rhs=allocrhs;
1288	}
1289	/* special check in subset for rhs=0 */
1290	if (ISZERO(rhs)) { /* +/- zeros -> error */
1291	status|=DEC_Invalid_operation;
1292	break;}
1293	} /* extended=0 */
1294	#endif
1295	decLnOp(res, rhs, set, &status);
1296	} while(0); /* end protected */
1297
1298	#if DECSUBSET
1299	free(allocrhs); /* drop any storage used */
1300	#endif
1301	/* apply significant status */
1302	if (status!=0) decStatus(res, status, set);
1303	#if DECCHECK
1304	decCheckInexact(res, set);
1305	#endif
1306	return res;
1307	} /* decNumberLn */
1308
1309	/* ------------------------------------------------------------------ */
1310	/* decNumberLogB - get adjusted exponent, by 754 rules */
1311	/* */
1312	/* This computes C = adjustedexponent(A) */
1313	/* */
1314	/* res is C, the result. C may be A */
1315	/* rhs is A */
1316	/* set is the context, used only for digits and status */
1317	/* */
1318	/* C must have space for 10 digits (A might have 10**9 digits and */
1319	/* an exponent of +999999999, or one digit and an exponent of */
1320	/* -1999999999). */
1321	/* */
1322	/* This returns the adjusted exponent of A after (in theory) padding */
1323	/* with zeros on the right to set->digits digits while keeping the */
1324	/* same value. The exponent is not limited by emin/emax. */
1325	/* */
1326	/* Notable cases: */
1327	/* A<0 -> Use |A| */
1328	/* A=0 -> -Infinity (Division by zero) */
1329	/* A=Infinite -> +Infinity (Exact) */
1330	/* A=1 exactly -> 0 (Exact) */
1331	/* NaNs are propagated as usual */
1332	/* ------------------------------------------------------------------ */
1333	decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1334	decContext *set) {
1335	uInt status=0; /* accumulator */
1336
1337	#if DECCHECK
1338	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1339	#endif
1340
1341	/* NaNs as usual; Infinities return +Infinity; 0->oops */
1342	if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1343	else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1344	else if (decNumberIsZero(rhs)) {
1345	decNumberZero(res); /* prepare for Infinity */
1346	res->bits=DECNEG|DECINF; /* -Infinity */
1347	status|=DEC_Division_by_zero; /* as per 754 */
1348	}
1349	else { /* finite non-zero */
1350	Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1351	decNumberFromInt32(dn: res, in: ae); /* lay it out */
1352	}
1353
1354	if (status!=0) decStatus(res, status, set);
1355	return res;
1356	} /* decNumberLogB */
1357
1358	/* ------------------------------------------------------------------ */
1359	/* decNumberLog10 -- logarithm in base 10 */
1360	/* */
1361	/* This computes C = log10(A) */
1362	/* */
1363	/* res is C, the result. C may be A */
1364	/* rhs is A */
1365	/* set is the context; note that rounding mode has no effect */
1366	/* */
1367	/* C must have space for set->digits digits. */
1368	/* */
1369	/* Notable cases: */
1370	/* A<0 -> Invalid */
1371	/* A=0 -> -Infinity (Exact) */
1372	/* A=+Infinity -> +Infinity (Exact) */
1373	/* A=10**n (if n is an integer) -> n (Exact) */
1374	/* */
1375	/* Mathematical function restrictions apply (see above); a NaN is */
1376	/* returned with Invalid_operation if a restriction is violated. */
1377	/* */
1378	/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will */
1379	/* almost always be correctly rounded, but may be up to 1 ulp in */
1380	/* error in rare cases. */
1381	/* ------------------------------------------------------------------ */
1382	/* This calculates ln(A)/ln(10) using appropriate precision. For */
1383	/* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the */
1384	/* requested digits and t is the number of digits in the exponent */
1385	/* (maximum 6). For ln(10) it is p + 3; this is often handled by the */
1386	/* fastpath in decLnOp. The final division is done to the requested */
1387	/* precision. */
1388	/* ------------------------------------------------------------------ */
1389	decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1390	decContext *set) {
1391	uInt status=0, ignore=0; /* status accumulators */
1392	uInt needbytes; /* for space calculations */
1393	Int p; /* working precision */
1394	Int t; /* digits in exponent of A */
1395
1396	/* buffers for a and b working decimals */
1397	/* (adjustment calculator, same size) */
1398	decNumber bufa[D2N(DECBUFFER+2)];
1399	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
1400	decNumber *a=bufa; /* temporary a */
1401	decNumber bufb[D2N(DECBUFFER+2)];
1402	decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
1403	decNumber *b=bufb; /* temporary b */
1404	decNumber bufw[D2N(10)]; /* working 2-10 digit number */
1405	decNumber *w=bufw; /* .. */
1406	#if DECSUBSET
1407	decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
1408	#endif
1409
1410	decContext aset; /* working context */
1411
1412	#if DECCHECK
1413	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1414	#endif
1415
1416	/* Check restrictions; this is a math function; if not violated */
1417	/* then carry out the operation. */
1418	if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1419	#if DECSUBSET
1420	if (!set->extended) {
1421	/* reduce operand and set lostDigits status, as needed */
1422	if (rhs->digits>set->digits) {
1423	allocrhs=decRoundOperand(rhs, set, &status);
1424	if (allocrhs==NULL) break;
1425	rhs=allocrhs;
1426	}
1427	/* special check in subset for rhs=0 */
1428	if (ISZERO(rhs)) { /* +/- zeros -> error */
1429	status|=DEC_Invalid_operation;
1430	break;}
1431	} /* extended=0 */
1432	#endif
1433
1434	decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1435
1436	/* handle exact powers of 10; only check if +ve finite */
1437	if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1438	Int residue=0; /* (no residue) */
1439	uInt copystat=0; /* clean status */
1440
1441	/* round to a single digit... */
1442	aset.digits=1;
1443	decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1444	/* if exact and the digit is 1, rhs is a power of 10 */
1445	if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1446	/* the exponent, conveniently, is the power of 10; making */
1447	/* this the result needs a little care as it might not fit, */
1448	/* so first convert it into the working number, and then move */
1449	/* to res */
1450	decNumberFromInt32(dn: w, in: w->exponent);
1451	residue=0;
1452	decCopyFit(res, w, set, &residue, &status); /* copy & round */
1453	decFinish(res, set, &residue, &status); /* cleanup/set flags */
1454	break;
1455	} /* not a power of 10 */
1456	} /* not a candidate for exact */
1457
1458	/* simplify the information-content calculation to use 'total */
1459	/* number of digits in a, including exponent' as compared to the */
1460	/* requested digits, as increasing this will only rarely cost an */
1461	/* iteration in ln(a) anyway */
1462	t=6; /* it can never be >6 */
1463
1464	/* allocate space when needed... */
1465	p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1466	needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1467	if (needbytes>sizeof(bufa)) { /* need malloc space */
1468	allocbufa=(decNumber *)malloc(size: needbytes);
1469	if (allocbufa==NULL) { /* hopeless -- abandon */
1470	status|=DEC_Insufficient_storage;
1471	break;}
1472	a=allocbufa; /* use the allocated space */
1473	}
1474	aset.digits=p; /* as calculated */
1475	aset.emax=DEC_MAX_MATH; /* usual bounds */
1476	aset.emin=-DEC_MAX_MATH; /* .. */
1477	aset.clamp=0; /* and no concrete format */
1478	decLnOp(a, rhs, &aset, &status); /* a=ln(rhs) */
1479
1480	/* skip the division if the result so far is infinite, NaN, or */
1481	/* zero, or there was an error; note NaN from sNaN needs copy */
1482	if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1483	if (a->bits&DECSPECIAL || ISZERO(a)) {
1484	decNumberCopy(res, a); /* [will fit] */
1485	break;}
1486
1487	/* for ln(10) an extra 3 digits of precision are needed */
1488	p=set->digits+3;
1489	needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1490	if (needbytes>sizeof(bufb)) { /* need malloc space */
1491	allocbufb=(decNumber *)malloc(size: needbytes);
1492	if (allocbufb==NULL) { /* hopeless -- abandon */
1493	status|=DEC_Insufficient_storage;
1494	break;}
1495	b=allocbufb; /* use the allocated space */
1496	}
1497	decNumberZero(w); /* set up 10... */
1498	#if DECDPUN==1
1499	w->lsu[1]=1; w->lsu[0]=0; /* .. */
1500	#else
1501	w->lsu[0]=10; /* .. */
1502	#endif
1503	w->digits=2; /* .. */
1504
1505	aset.digits=p;
1506	decLnOp(b, w, &aset, &ignore); /* b=ln(10) */
1507
1508	aset.digits=set->digits; /* for final divide */
1509	decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1510	} while(0); /* [for break] */
1511
1512	free(ptr: allocbufa); /* drop any storage used */
1513	free(ptr: allocbufb); /* .. */
1514	#if DECSUBSET
1515	free(allocrhs); /* .. */
1516	#endif
1517	/* apply significant status */
1518	if (status!=0) decStatus(res, status, set);
1519	#if DECCHECK
1520	decCheckInexact(res, set);
1521	#endif
1522	return res;
1523	} /* decNumberLog10 */
1524
1525	/* ------------------------------------------------------------------ */
1526	/* decNumberMax -- compare two Numbers and return the maximum */
1527	/* */
1528	/* This computes C = A ? B, returning the maximum by 754 rules */
1529	/* */
1530	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1531	/* lhs is A */
1532	/* rhs is B */
1533	/* set is the context */
1534	/* */
1535	/* C must have space for set->digits digits. */
1536	/* ------------------------------------------------------------------ */
1537	decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1538	const decNumber *rhs, decContext *set) {
1539	uInt status=0; /* accumulator */
1540	decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1541	if (status!=0) decStatus(res, status, set);
1542	#if DECCHECK
1543	decCheckInexact(res, set);
1544	#endif
1545	return res;
1546	} /* decNumberMax */
1547
1548	/* ------------------------------------------------------------------ */
1549	/* decNumberMaxMag -- compare and return the maximum by magnitude */
1550	/* */
1551	/* This computes C = A ? B, returning the maximum by 754 rules */
1552	/* */
1553	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1554	/* lhs is A */
1555	/* rhs is B */
1556	/* set is the context */
1557	/* */
1558	/* C must have space for set->digits digits. */
1559	/* ------------------------------------------------------------------ */
1560	decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1561	const decNumber *rhs, decContext *set) {
1562	uInt status=0; /* accumulator */
1563	decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1564	if (status!=0) decStatus(res, status, set);
1565	#if DECCHECK
1566	decCheckInexact(res, set);
1567	#endif
1568	return res;
1569	} /* decNumberMaxMag */
1570
1571	/* ------------------------------------------------------------------ */
1572	/* decNumberMin -- compare two Numbers and return the minimum */
1573	/* */
1574	/* This computes C = A ? B, returning the minimum by 754 rules */
1575	/* */
1576	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1577	/* lhs is A */
1578	/* rhs is B */
1579	/* set is the context */
1580	/* */
1581	/* C must have space for set->digits digits. */
1582	/* ------------------------------------------------------------------ */
1583	decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1584	const decNumber *rhs, decContext *set) {
1585	uInt status=0; /* accumulator */
1586	decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1587	if (status!=0) decStatus(res, status, set);
1588	#if DECCHECK
1589	decCheckInexact(res, set);
1590	#endif
1591	return res;
1592	} /* decNumberMin */
1593
1594	/* ------------------------------------------------------------------ */
1595	/* decNumberMinMag -- compare and return the minimum by magnitude */
1596	/* */
1597	/* This computes C = A ? B, returning the minimum by 754 rules */
1598	/* */
1599	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
1600	/* lhs is A */
1601	/* rhs is B */
1602	/* set is the context */
1603	/* */
1604	/* C must have space for set->digits digits. */
1605	/* ------------------------------------------------------------------ */
1606	decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1607	const decNumber *rhs, decContext *set) {
1608	uInt status=0; /* accumulator */
1609	decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1610	if (status!=0) decStatus(res, status, set);
1611	#if DECCHECK
1612	decCheckInexact(res, set);
1613	#endif
1614	return res;
1615	} /* decNumberMinMag */
1616
1617	/* ------------------------------------------------------------------ */
1618	/* decNumberMinus -- prefix minus operator */
1619	/* */
1620	/* This computes C = 0 - A */
1621	/* */
1622	/* res is C, the result. C may be A */
1623	/* rhs is A */
1624	/* set is the context */
1625	/* */
1626	/* See also decNumberCopyNegate for a quiet bitwise version of this. */
1627	/* C must have space for set->digits digits. */
1628	/* ------------------------------------------------------------------ */
1629	/* Simply use AddOp for the subtract, which will do the necessary. */
1630	/* ------------------------------------------------------------------ */
1631	decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1632	decContext *set) {
1633	decNumber dzero;
1634	uInt status=0; /* accumulator */
1635
1636	#if DECCHECK
1637	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1638	#endif
1639
1640	decNumberZero(&dzero); /* make 0 */
1641	dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1642	decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1643	if (status!=0) decStatus(res, status, set);
1644	#if DECCHECK
1645	decCheckInexact(res, set);
1646	#endif
1647	return res;
1648	} /* decNumberMinus */
1649
1650	/* ------------------------------------------------------------------ */
1651	/* decNumberNextMinus -- next towards -Infinity */
1652	/* */
1653	/* This computes C = A - infinitesimal, rounded towards -Infinity */
1654	/* */
1655	/* res is C, the result. C may be A */
1656	/* rhs is A */
1657	/* set is the context */
1658	/* */
1659	/* This is a generalization of 754 NextDown. */
1660	/* ------------------------------------------------------------------ */
1661	decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1662	decContext *set) {
1663	decNumber dtiny; /* constant */
1664	decContext workset=*set; /* work */
1665	uInt status=0; /* accumulator */
1666	#if DECCHECK
1667	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1668	#endif
1669
1670	/* +Infinity is the special case */
1671	if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1672	decSetMaxValue(res, set); /* is +ve */
1673	/* there is no status to set */
1674	return res;
1675	}
1676	decNumberZero(&dtiny); /* start with 0 */
1677	dtiny.lsu[0]=1; /* make number that is .. */
1678	dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1679	workset.round=DEC_ROUND_FLOOR;
1680	decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1681	status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1682	if (status!=0) decStatus(res, status, set);
1683	return res;
1684	} /* decNumberNextMinus */
1685
1686	/* ------------------------------------------------------------------ */
1687	/* decNumberNextPlus -- next towards +Infinity */
1688	/* */
1689	/* This computes C = A + infinitesimal, rounded towards +Infinity */
1690	/* */
1691	/* res is C, the result. C may be A */
1692	/* rhs is A */
1693	/* set is the context */
1694	/* */
1695	/* This is a generalization of 754 NextUp. */
1696	/* ------------------------------------------------------------------ */
1697	decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1698	decContext *set) {
1699	decNumber dtiny; /* constant */
1700	decContext workset=*set; /* work */
1701	uInt status=0; /* accumulator */
1702	#if DECCHECK
1703	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1704	#endif
1705
1706	/* -Infinity is the special case */
1707	if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1708	decSetMaxValue(res, set);
1709	res->bits=DECNEG; /* negative */
1710	/* there is no status to set */
1711	return res;
1712	}
1713	decNumberZero(&dtiny); /* start with 0 */
1714	dtiny.lsu[0]=1; /* make number that is .. */
1715	dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1716	workset.round=DEC_ROUND_CEILING;
1717	decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1718	status&=DEC_Invalid_operation|DEC_sNaN; /* only sNaN Invalid please */
1719	if (status!=0) decStatus(res, status, set);
1720	return res;
1721	} /* decNumberNextPlus */
1722
1723	/* ------------------------------------------------------------------ */
1724	/* decNumberNextToward -- next towards rhs */
1725	/* */
1726	/* This computes C = A +/- infinitesimal, rounded towards */
1727	/* +/-Infinity in the direction of B, as per 754-1985 nextafter */
1728	/* modified during revision but dropped from 754-2008. */
1729	/* */
1730	/* res is C, the result. C may be A or B. */
1731	/* lhs is A */
1732	/* rhs is B */
1733	/* set is the context */
1734	/* */
1735	/* This is a generalization of 754-1985 NextAfter. */
1736	/* ------------------------------------------------------------------ */
1737	decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1738	const decNumber *rhs, decContext *set) {
1739	decNumber dtiny; /* constant */
1740	decContext workset=*set; /* work */
1741	Int result; /* .. */
1742	uInt status=0; /* accumulator */
1743	#if DECCHECK
1744	if (decCheckOperands(res, lhs, rhs, set)) return res;
1745	#endif
1746
1747	if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1748	decNaNs(res, lhs, rhs, set, &status);
1749	}
1750	else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1751	result=decCompare(lhs, rhs, 0); /* sign matters */
1752	if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1753	else { /* valid compare */
1754	if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1755	else { /* differ: need NextPlus or NextMinus */
1756	uByte sub; /* add or subtract */
1757	if (result<0) { /* lhs<rhs, do nextplus */
1758	/* -Infinity is the special case */
1759	if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1760	decSetMaxValue(res, set);
1761	res->bits=DECNEG; /* negative */
1762	return res; /* there is no status to set */
1763	}
1764	workset.round=DEC_ROUND_CEILING;
1765	sub=0; /* add, please */
1766	} /* plus */
1767	else { /* lhs>rhs, do nextminus */
1768	/* +Infinity is the special case */
1769	if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1770	decSetMaxValue(res, set);
1771	return res; /* there is no status to set */
1772	}
1773	workset.round=DEC_ROUND_FLOOR;
1774	sub=DECNEG; /* subtract, please */
1775	} /* minus */
1776	decNumberZero(&dtiny); /* start with 0 */
1777	dtiny.lsu[0]=1; /* make number that is .. */
1778	dtiny.exponent=DEC_MIN_EMIN-1; /* .. smaller than tiniest */
1779	decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1780	/* turn off exceptions if the result is a normal number */
1781	/* (including Nmin), otherwise let all status through */
1782	if (decNumberIsNormal(res, set)) status=0;
1783	} /* unequal */
1784	} /* compare OK */
1785	} /* numeric */
1786	if (status!=0) decStatus(res, status, set);
1787	return res;
1788	} /* decNumberNextToward */
1789
1790	/* ------------------------------------------------------------------ */
1791	/* decNumberOr -- OR two Numbers, digitwise */
1792	/* */
1793	/* This computes C = A | B */
1794	/* */
1795	/* res is C, the result. C may be A and/or B (e.g., X=X|X) */
1796	/* lhs is A */
1797	/* rhs is B */
1798	/* set is the context (used for result length and error report) */
1799	/* */
1800	/* C must have space for set->digits digits. */
1801	/* */
1802	/* Logical function restrictions apply (see above); a NaN is */
1803	/* returned with Invalid_operation if a restriction is violated. */
1804	/* ------------------------------------------------------------------ */
1805	decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1806	const decNumber *rhs, decContext *set) {
1807	const Unit *ua, *ub; /* -> operands */
1808	const Unit *msua, *msub; /* -> operand msus */
1809	Unit *uc, *msuc; /* -> result and its msu */
1810	Int msudigs; /* digits in res msu */
1811	#if DECCHECK
1812	if (decCheckOperands(res, lhs, rhs, set)) return res;
1813	#endif
1814
1815	if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1816	|| rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1817	decStatus(res, DEC_Invalid_operation, set);
1818	return res;
1819	}
1820	/* operands are valid */
1821	ua=lhs->lsu; /* bottom-up */
1822	ub=rhs->lsu; /* .. */
1823	uc=res->lsu; /* .. */
1824	msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
1825	msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
1826	msuc=uc+D2U(set->digits)-1; /* -> msu of result */
1827	msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
1828	for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
1829	Unit a, b; /* extract units */
1830	if (ua>msua) a=0;
1831	else a=*ua;
1832	if (ub>msub) b=0;
1833	else b=*ub;
1834	*uc=0; /* can now write back */
1835	if (a|b) { /* maybe 1 bits to examine */
1836	Int i, j;
1837	/* This loop could be unrolled and/or use BIN2BCD tables */
1838	for (i=0; i<DECDPUN; i++) {
1839	if ((a|b)&1) *uc=*uc+(Unit)powers[i]; /* effect OR */
1840	j=a%10;
1841	a=a/10;
1842	j|=b%10;
1843	b=b/10;
1844	if (j>1) {
1845	decStatus(res, DEC_Invalid_operation, set);
1846	return res;
1847	}
1848	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1849	} /* each digit */
1850	} /* non-zero */
1851	} /* each unit */
1852	/* [here uc-1 is the msu of the result] */
1853	res->digits=decGetDigits(res->lsu, uc-res->lsu);
1854	res->exponent=0; /* integer */
1855	res->bits=0; /* sign=0 */
1856	return res; /* [no status to set] */
1857	} /* decNumberOr */
1858
1859	/* ------------------------------------------------------------------ */
1860	/* decNumberPlus -- prefix plus operator */
1861	/* */
1862	/* This computes C = 0 + A */
1863	/* */
1864	/* res is C, the result. C may be A */
1865	/* rhs is A */
1866	/* set is the context */
1867	/* */
1868	/* See also decNumberCopy for a quiet bitwise version of this. */
1869	/* C must have space for set->digits digits. */
1870	/* ------------------------------------------------------------------ */
1871	/* This simply uses AddOp; Add will take fast path after preparing A. */
1872	/* Performance is a concern here, as this routine is often used to */
1873	/* check operands and apply rounding and overflow/underflow testing. */
1874	/* ------------------------------------------------------------------ */
1875	decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
1876	decContext *set) {
1877	decNumber dzero;
1878	uInt status=0; /* accumulator */
1879	#if DECCHECK
1880	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1881	#endif
1882
1883	decNumberZero(&dzero); /* make 0 */
1884	dzero.exponent=rhs->exponent; /* [no coefficient expansion] */
1885	decAddOp(res, &dzero, rhs, set, 0, &status);
1886	if (status!=0) decStatus(res, status, set);
1887	#if DECCHECK
1888	decCheckInexact(res, set);
1889	#endif
1890	return res;
1891	} /* decNumberPlus */
1892
1893	/* ------------------------------------------------------------------ */
1894	/* decNumberMultiply -- multiply two Numbers */
1895	/* */
1896	/* This computes C = A x B */
1897	/* */
1898	/* res is C, the result. C may be A and/or B (e.g., X=X+X) */
1899	/* lhs is A */
1900	/* rhs is B */
1901	/* set is the context */
1902	/* */
1903	/* C must have space for set->digits digits. */
1904	/* ------------------------------------------------------------------ */
1905	decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
1906	const decNumber *rhs, decContext *set) {
1907	uInt status=0; /* accumulator */
1908	decMultiplyOp(res, lhs, rhs, set, &status);
1909	if (status!=0) decStatus(res, status, set);
1910	#if DECCHECK
1911	decCheckInexact(res, set);
1912	#endif
1913	return res;
1914	} /* decNumberMultiply */
1915
1916	/* ------------------------------------------------------------------ */
1917	/* decNumberPower -- raise a number to a power */
1918	/* */
1919	/* This computes C = A ** B */
1920	/* */
1921	/* res is C, the result. C may be A and/or B (e.g., X=X**X) */
1922	/* lhs is A */
1923	/* rhs is B */
1924	/* set is the context */
1925	/* */
1926	/* C must have space for set->digits digits. */
1927	/* */
1928	/* Mathematical function restrictions apply (see above); a NaN is */
1929	/* returned with Invalid_operation if a restriction is violated. */
1930	/* */
1931	/* However, if 1999999997<=B<=999999999 and B is an integer then the */
1932	/* restrictions on A and the context are relaxed to the usual bounds, */
1933	/* for compatibility with the earlier (integer power only) version */
1934	/* of this function. */
1935	/* */
1936	/* When B is an integer, the result may be exact, even if rounded. */
1937	/* */
1938	/* The final result is rounded according to the context; it will */
1939	/* almost always be correctly rounded, but may be up to 1 ulp in */
1940	/* error in rare cases. */
1941	/* ------------------------------------------------------------------ */
1942	decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
1943	const decNumber *rhs, decContext *set) {
1944	#if DECSUBSET
1945	decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
1946	decNumber *allocrhs=NULL; /* .., rhs */
1947	#endif
1948	decNumber *allocdac=NULL; /* -> allocated acc buffer, iff used */
1949	decNumber *allocinv=NULL; /* -> allocated 1/x buffer, iff used */
1950	Int reqdigits=set->digits; /* requested DIGITS */
1951	Int n; /* rhs in binary */
1952	Flag rhsint=0; /* 1 if rhs is an integer */
1953	Flag useint=0; /* 1 if can use integer calculation */
1954	Flag isoddint=0; /* 1 if rhs is an integer and odd */
1955	Int i; /* work */
1956	#if DECSUBSET
1957	Int dropped; /* .. */
1958	#endif
1959	uInt needbytes; /* buffer size needed */
1960	Flag seenbit; /* seen a bit while powering */
1961	Int residue=0; /* rounding residue */
1962	uInt status=0; /* accumulators */
1963	uByte bits=0; /* result sign if errors */
1964	decContext aset; /* working context */
1965	decNumber dnOne; /* work value 1... */
1966	/* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
1967	decNumber dacbuff[D2N(DECBUFFER+9)];
1968	decNumber *dac=dacbuff; /* -> result accumulator */
1969	/* same again for possible 1/lhs calculation */
1970	decNumber invbuff[D2N(DECBUFFER+9)];
1971
1972	#if DECCHECK
1973	if (decCheckOperands(res, lhs, rhs, set)) return res;
1974	#endif
1975
1976	do { /* protect allocated storage */
1977	#if DECSUBSET
1978	if (!set->extended) { /* reduce operands and set status, as needed */
1979	if (lhs->digits>reqdigits) {
1980	alloclhs=decRoundOperand(lhs, set, &status);
1981	if (alloclhs==NULL) break;
1982	lhs=alloclhs;
1983	}
1984	if (rhs->digits>reqdigits) {
1985	allocrhs=decRoundOperand(rhs, set, &status);
1986	if (allocrhs==NULL) break;
1987	rhs=allocrhs;
1988	}
1989	}
1990	#endif
1991	/* [following code does not require input rounding] */
1992
1993	/* handle NaNs and rhs Infinity (lhs infinity is harder) */
1994	if (SPECIALARGS) {
1995	if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
1996	decNaNs(res, lhs, rhs, set, &status);
1997	break;}
1998	if (decNumberIsInfinite(rhs)) { /* rhs Infinity */
1999	Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */
2000	if (decNumberIsNegative(lhs) /* lhs<0 */
2001	&& !decNumberIsZero(lhs)) /* .. */
2002	status|=DEC_Invalid_operation;
2003	else { /* lhs >=0 */
2004	decNumberZero(&dnOne); /* set up 1 */
2005	dnOne.lsu[0]=1;
2006	decNumberCompare(res: dac, lhs, rhs: &dnOne, set); /* lhs ? 1 */
2007	decNumberZero(res); /* prepare for 0/1/Infinity */
2008	if (decNumberIsNegative(dac)) { /* lhs<1 */
2009	if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2010	}
2011	else if (dac->lsu[0]==0) { /* lhs=1 */
2012	/* 1**Infinity is inexact, so return fully-padded 1.0000 */
2013	Int shift=set->digits-1;
2014	*res->lsu=1; /* was 0, make int 1 */
2015	res->digits=decShiftToMost(res->lsu, 1, shift);
2016	res->exponent=-shift; /* make 1.0000... */
2017	status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2018	}
2019	else { /* lhs>1 */
2020	if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2021	}
2022	} /* lhs>=0 */
2023	break;}
2024	/* [lhs infinity drops through] */
2025	} /* specials */
2026
2027	/* Original rhs may be an integer that fits and is in range */
2028	n=decGetInt(rhs);
2029	if (n!=BADINT) { /* it is an integer */
2030	rhsint=1; /* record the fact for 1**n */
2031	isoddint=(Flag)n&1; /* [works even if big] */
2032	if (n!=BIGEVEN && n!=BIGODD) /* can use integer path? */
2033	useint=1; /* looks good */
2034	}
2035
2036	if (decNumberIsNegative(lhs) /* -x .. */
2037	&& isoddint) bits=DECNEG; /* .. to an odd power */
2038
2039	/* handle LHS infinity */
2040	if (decNumberIsInfinite(lhs)) { /* [NaNs already handled] */
2041	uByte rbits=rhs->bits; /* save */
2042	decNumberZero(res); /* prepare */
2043	if (n==0) *res->lsu=1; /* [-]Inf**0 => 1 */
2044	else {
2045	/* -Inf**nonint -> error */
2046	if (!rhsint && decNumberIsNegative(lhs)) {
2047	status|=DEC_Invalid_operation; /* -Inf**nonint is error */
2048	break;}
2049	if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2050	/* [otherwise will be 0 or -0] */
2051	res->bits=bits;
2052	}
2053	break;}
2054
2055	/* similarly handle LHS zero */
2056	if (decNumberIsZero(lhs)) {
2057	if (n==0) { /* 0**0 => Error */
2058	#if DECSUBSET
2059	if (!set->extended) { /* [unless subset] */
2060	decNumberZero(res);
2061	*res->lsu=1; /* return 1 */
2062	break;}
2063	#endif
2064	status|=DEC_Invalid_operation;
2065	}
2066	else { /* 0**x */
2067	uByte rbits=rhs->bits; /* save */
2068	if (rbits & DECNEG) { /* was a 0**(-n) */
2069	#if DECSUBSET
2070	if (!set->extended) { /* [bad if subset] */
2071	status|=DEC_Invalid_operation;
2072	break;}
2073	#endif
2074	bits|=DECINF;
2075	}
2076	decNumberZero(res); /* prepare */
2077	/* [otherwise will be 0 or -0] */
2078	res->bits=bits;
2079	}
2080	break;}
2081
2082	/* here both lhs and rhs are finite; rhs==0 is handled in the */
2083	/* integer path. Next handle the non-integer cases */
2084	if (!useint) { /* non-integral rhs */
2085	/* any -ve lhs is bad, as is either operand or context out of */
2086	/* bounds */
2087	if (decNumberIsNegative(lhs)) {
2088	status|=DEC_Invalid_operation;
2089	break;}
2090	if (decCheckMath(lhs, set, &status)
2091	|| decCheckMath(rhs, set, &status)) break; /* variable status */
2092
2093	decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2094	aset.emax=DEC_MAX_MATH; /* usual bounds */
2095	aset.emin=-DEC_MAX_MATH; /* .. */
2096	aset.clamp=0; /* and no concrete format */
2097
2098	/* calculate the result using exp(ln(lhs)*rhs), which can */
2099	/* all be done into the accumulator, dac. The precision needed */
2100	/* is enough to contain the full information in the lhs (which */
2101	/* is the total digits, including exponent), or the requested */
2102	/* precision, if larger, + 4; 6 is used for the exponent */
2103	/* maximum length, and this is also used when it is shorter */
2104	/* than the requested digits as it greatly reduces the >0.5 ulp */
2105	/* cases at little cost (because Ln doubles digits each */
2106	/* iteration so a few extra digits rarely causes an extra */
2107	/* iteration) */
2108	aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2109	} /* non-integer rhs */
2110
2111	else { /* rhs is in-range integer */
2112	if (n==0) { /* x**0 = 1 */
2113	/* (0**0 was handled above) */
2114	decNumberZero(res); /* result=1 */
2115	*res->lsu=1; /* .. */
2116	break;}
2117	/* rhs is a non-zero integer */
2118	if (n<0) n=-n; /* use abs(n) */
2119
2120	aset=*set; /* clone the context */
2121	aset.round=DEC_ROUND_HALF_EVEN; /* internally use balanced */
2122	/* calculate the working DIGITS */
2123	aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2124	#if DECSUBSET
2125	if (!set->extended) aset.digits--; /* use classic precision */
2126	#endif
2127	/* it's an error if this is more than can be handled */
2128	if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2129	} /* integer path */
2130
2131	/* aset.digits is the count of digits for the accumulator needed */
2132	/* if accumulator is too long for local storage, then allocate */
2133	needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2134	/* [needbytes also used below if 1/lhs needed] */
2135	if (needbytes>sizeof(dacbuff)) {
2136	allocdac=(decNumber *)malloc(size: needbytes);
2137	if (allocdac==NULL) { /* hopeless -- abandon */
2138	status|=DEC_Insufficient_storage;
2139	break;}
2140	dac=allocdac; /* use the allocated space */
2141	}
2142	/* here, aset is set up and accumulator is ready for use */
2143
2144	if (!useint) { /* non-integral rhs */
2145	/* x ** y; special-case x=1 here as it will otherwise always */
2146	/* reduce to integer 1; decLnOp has a fastpath which detects */
2147	/* the case of x=1 */
2148	decLnOp(dac, lhs, &aset, &status); /* dac=ln(lhs) */
2149	/* [no error possible, as lhs 0 already handled] */
2150	if (ISZERO(dac)) { /* x==1, 1.0, etc. */
2151	/* need to return fully-padded 1.0000 etc., but rhsint->1 */
2152	*dac->lsu=1; /* was 0, make int 1 */
2153	if (!rhsint) { /* add padding */
2154	Int shift=set->digits-1;
2155	dac->digits=decShiftToMost(dac->lsu, 1, shift);
2156	dac->exponent=-shift; /* make 1.0000... */
2157	status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2158	}
2159	}
2160	else {
2161	decMultiplyOp(dac, dac, rhs, &aset, &status); /* dac=dac*rhs */
2162	decExpOp(dac, dac, &aset, &status); /* dac=exp(dac) */
2163	}
2164	/* and drop through for final rounding */
2165	} /* non-integer rhs */
2166
2167	else { /* carry on with integer */
2168	decNumberZero(dac); /* acc=1 */
2169	*dac->lsu=1; /* .. */
2170
2171	/* if a negative power the constant 1 is needed, and if not subset */
2172	/* invert the lhs now rather than inverting the result later */
2173	if (decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2174	decNumber *inv=invbuff; /* assume use fixed buffer */
2175	decNumberCopy(&dnOne, dac); /* dnOne=1; [needed now or later] */
2176	#if DECSUBSET
2177	if (set->extended) { /* need to calculate 1/lhs */
2178	#endif
2179	/* divide lhs into 1, putting result in dac [dac=1/dac] */
2180	decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2181	/* now locate or allocate space for the inverted lhs */
2182	if (needbytes>sizeof(invbuff)) {
2183	allocinv=(decNumber *)malloc(size: needbytes);
2184	if (allocinv==NULL) { /* hopeless -- abandon */
2185	status|=DEC_Insufficient_storage;
2186	break;}
2187	inv=allocinv; /* use the allocated space */
2188	}
2189	/* [inv now points to big-enough buffer or allocated storage] */
2190	decNumberCopy(inv, dac); /* copy the 1/lhs */
2191	decNumberCopy(dac, &dnOne); /* restore acc=1 */
2192	lhs=inv; /* .. and go forward with new lhs */
2193	#if DECSUBSET
2194	}
2195	#endif
2196	}
2197
2198	/* Raise-to-the-power loop... */
2199	seenbit=0; /* set once a 1-bit is encountered */
2200	for (i=1;;i++){ /* for each bit [top bit ignored] */
2201	/* abandon if had overflow or terminal underflow */
2202	if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2203	if (status&DEC_Overflow || ISZERO(dac)) break;
2204	}
2205	/* [the following two lines revealed an optimizer bug in a C++ */
2206	/* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2207	n=n<<1; /* move next bit to testable position */
2208	if (n<0) { /* top bit is set */
2209	seenbit=1; /* OK, significant bit seen */
2210	decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2211	}
2212	if (i==31) break; /* that was the last bit */
2213	if (!seenbit) continue; /* no need to square 1 */
2214	decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2215	} /*i*/ /* 32 bits */
2216
2217	/* complete internal overflow or underflow processing */
2218	if (status & (DEC_Overflow|DEC_Underflow)) {
2219	#if DECSUBSET
2220	/* If subset, and power was negative, reverse the kind of -erflow */
2221	/* [1/x not yet done] */
2222	if (!set->extended && decNumberIsNegative(rhs)) {
2223	if (status & DEC_Overflow)
2224	status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2225	else { /* trickier -- Underflow may or may not be set */
2226	status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2227	status|=DEC_Overflow;
2228	}
2229	}
2230	#endif
2231	dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2232	/* round subnormals [to set.digits rather than aset.digits] */
2233	/* or set overflow result similarly as required */
2234	decFinalize(dac, set, &residue, &status);
2235	decNumberCopy(res, dac); /* copy to result (is now OK length) */
2236	break;
2237	}
2238
2239	#if DECSUBSET
2240	if (!set->extended && /* subset math */
2241	decNumberIsNegative(rhs)) { /* was a **-n [hence digits>0] */
2242	/* so divide result into 1 [dac=1/dac] */
2243	decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2244	}
2245	#endif
2246	} /* rhs integer path */
2247
2248	/* reduce result to the requested length and copy to result */
2249	decCopyFit(res, dac, set, &residue, &status);
2250	decFinish(res, set, &residue, &status); /* final cleanup */
2251	#if DECSUBSET
2252	if (!set->extended) decTrim(res, set, 0, 1, &dropped); /* trailing zeros */
2253	#endif
2254	} while(0); /* end protected */
2255
2256	free(ptr: allocdac); /* drop any storage used */
2257	free(ptr: allocinv); /* .. */
2258	#if DECSUBSET
2259	free(alloclhs); /* .. */
2260	free(allocrhs); /* .. */
2261	#endif
2262	if (status!=0) decStatus(res, status, set);
2263	#if DECCHECK
2264	decCheckInexact(res, set);
2265	#endif
2266	return res;
2267	} /* decNumberPower */
2268
2269	/* ------------------------------------------------------------------ */
2270	/* decNumberQuantize -- force exponent to requested value */
2271	/* */
2272	/* This computes C = op(A, B), where op adjusts the coefficient */
2273	/* of C (by rounding or shifting) such that the exponent (-scale) */
2274	/* of C has exponent of B. The numerical value of C will equal A, */
2275	/* except for the effects of any rounding that occurred. */
2276	/* */
2277	/* res is C, the result. C may be A or B */
2278	/* lhs is A, the number to adjust */
2279	/* rhs is B, the number with exponent to match */
2280	/* set is the context */
2281	/* */
2282	/* C must have space for set->digits digits. */
2283	/* */
2284	/* Unless there is an error or the result is infinite, the exponent */
2285	/* after the operation is guaranteed to be equal to that of B. */
2286	/* ------------------------------------------------------------------ */
2287	decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2288	const decNumber *rhs, decContext *set) {
2289	uInt status=0; /* accumulator */
2290	decQuantizeOp(res, lhs, rhs, set, 1, &status);
2291	if (status!=0) decStatus(res, status, set);
2292	return res;
2293	} /* decNumberQuantize */
2294
2295	/* ------------------------------------------------------------------ */
2296	/* decNumberReduce -- remove trailing zeros */
2297	/* */
2298	/* This computes C = 0 + A, and normalizes the result */
2299	/* */
2300	/* res is C, the result. C may be A */
2301	/* rhs is A */
2302	/* set is the context */
2303	/* */
2304	/* C must have space for set->digits digits. */
2305	/* ------------------------------------------------------------------ */
2306	/* Previously known as Normalize */
2307	decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2308	decContext *set) {
2309	return decNumberReduce(res, rhs, set);
2310	} /* decNumberNormalize */
2311
2312	decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2313	decContext *set) {
2314	#if DECSUBSET
2315	decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2316	#endif
2317	uInt status=0; /* as usual */
2318	Int residue=0; /* as usual */
2319	Int dropped; /* work */
2320
2321	#if DECCHECK
2322	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2323	#endif
2324
2325	do { /* protect allocated storage */
2326	#if DECSUBSET
2327	if (!set->extended) {
2328	/* reduce operand and set lostDigits status, as needed */
2329	if (rhs->digits>set->digits) {
2330	allocrhs=decRoundOperand(rhs, set, &status);
2331	if (allocrhs==NULL) break;
2332	rhs=allocrhs;
2333	}
2334	}
2335	#endif
2336	/* [following code does not require input rounding] */
2337
2338	/* Infinities copy through; NaNs need usual treatment */
2339	if (decNumberIsNaN(rhs)) {
2340	decNaNs(res, rhs, NULL, set, &status);
2341	break;
2342	}
2343
2344	/* reduce result to the requested length and copy to result */
2345	decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2346	decFinish(res, set, &residue, &status); /* cleanup/set flags */
2347	decTrim(res, set, 1, 0, &dropped); /* normalize in place */
2348	/* [may clamp] */
2349	} while(0); /* end protected */
2350
2351	#if DECSUBSET
2352	free(allocrhs); /* .. */
2353	#endif
2354	if (status!=0) decStatus(res, status, set);/* then report status */
2355	return res;
2356	} /* decNumberReduce */
2357
2358	/* ------------------------------------------------------------------ */
2359	/* decNumberRescale -- force exponent to requested value */
2360	/* */
2361	/* This computes C = op(A, B), where op adjusts the coefficient */
2362	/* of C (by rounding or shifting) such that the exponent (-scale) */
2363	/* of C has the value B. The numerical value of C will equal A, */
2364	/* except for the effects of any rounding that occurred. */
2365	/* */
2366	/* res is C, the result. C may be A or B */
2367	/* lhs is A, the number to adjust */
2368	/* rhs is B, the requested exponent */
2369	/* set is the context */
2370	/* */
2371	/* C must have space for set->digits digits. */
2372	/* */
2373	/* Unless there is an error or the result is infinite, the exponent */
2374	/* after the operation is guaranteed to be equal to B. */
2375	/* ------------------------------------------------------------------ */
2376	decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2377	const decNumber *rhs, decContext *set) {
2378	uInt status=0; /* accumulator */
2379	decQuantizeOp(res, lhs, rhs, set, 0, &status);
2380	if (status!=0) decStatus(res, status, set);
2381	return res;
2382	} /* decNumberRescale */
2383
2384	/* ------------------------------------------------------------------ */
2385	/* decNumberRemainder -- divide and return remainder */
2386	/* */
2387	/* This computes C = A % B */
2388	/* */
2389	/* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2390	/* lhs is A */
2391	/* rhs is B */
2392	/* set is the context */
2393	/* */
2394	/* C must have space for set->digits digits. */
2395	/* ------------------------------------------------------------------ */
2396	decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2397	const decNumber *rhs, decContext *set) {
2398	uInt status=0; /* accumulator */
2399	decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2400	if (status!=0) decStatus(res, status, set);
2401	#if DECCHECK
2402	decCheckInexact(res, set);
2403	#endif
2404	return res;
2405	} /* decNumberRemainder */
2406
2407	/* ------------------------------------------------------------------ */
2408	/* decNumberRemainderNear -- divide and return remainder from nearest */
2409	/* */
2410	/* This computes C = A % B, where % is the IEEE remainder operator */
2411	/* */
2412	/* res is C, the result. C may be A and/or B (e.g., X=X%X) */
2413	/* lhs is A */
2414	/* rhs is B */
2415	/* set is the context */
2416	/* */
2417	/* C must have space for set->digits digits. */
2418	/* ------------------------------------------------------------------ */
2419	decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2420	const decNumber *rhs, decContext *set) {
2421	uInt status=0; /* accumulator */
2422	decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2423	if (status!=0) decStatus(res, status, set);
2424	#if DECCHECK
2425	decCheckInexact(res, set);
2426	#endif
2427	return res;
2428	} /* decNumberRemainderNear */
2429
2430	/* ------------------------------------------------------------------ */
2431	/* decNumberRotate -- rotate the coefficient of a Number left/right */
2432	/* */
2433	/* This computes C = A rot B (in base ten and rotating set->digits */
2434	/* digits). */
2435	/* */
2436	/* res is C, the result. C may be A and/or B (e.g., X=XrotX) */
2437	/* lhs is A */
2438	/* rhs is B, the number of digits to rotate (-ve to right) */
2439	/* set is the context */
2440	/* */
2441	/* The digits of the coefficient of A are rotated to the left (if B */
2442	/* is positive) or to the right (if B is negative) without adjusting */
2443	/* the exponent or the sign of A. If lhs->digits is less than */
2444	/* set->digits the coefficient is padded with zeros on the left */
2445	/* before the rotate. Any leading zeros in the result are removed */
2446	/* as usual. */
2447	/* */
2448	/* B must be an integer (q=0) and in the range -set->digits through */
2449	/* +set->digits. */
2450	/* C must have space for set->digits digits. */
2451	/* NaNs are propagated as usual. Infinities are unaffected (but */
2452	/* B must be valid). No status is set unless B is invalid or an */
2453	/* operand is an sNaN. */
2454	/* ------------------------------------------------------------------ */
2455	decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2456	const decNumber *rhs, decContext *set) {
2457	uInt status=0; /* accumulator */
2458	Int rotate; /* rhs as an Int */
2459
2460	#if DECCHECK
2461	if (decCheckOperands(res, lhs, rhs, set)) return res;
2462	#endif
2463
2464	/* NaNs propagate as normal */
2465	if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2466	decNaNs(res, lhs, rhs, set, &status);
2467	/* rhs must be an integer */
2468	else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2469	status=DEC_Invalid_operation;
2470	else { /* both numeric, rhs is an integer */
2471	rotate=decGetInt(rhs); /* [cannot fail] */
2472	if (rotate==BADINT /* something bad .. */
2473	|| rotate==BIGODD || rotate==BIGEVEN /* .. very big .. */
2474	|| abs(x: rotate)>set->digits) /* .. or out of range */
2475	status=DEC_Invalid_operation;
2476	else { /* rhs is OK */
2477	decNumberCopy(res, lhs);
2478	/* convert -ve rotate to equivalent positive rotation */
2479	if (rotate<0) rotate=set->digits+rotate;
2480	if (rotate!=0 && rotate!=set->digits /* zero or full rotation */
2481	&& !decNumberIsInfinite(res)) { /* lhs was infinite */
2482	/* left-rotate to do; 0 < rotate < set->digits */
2483	uInt units, shift; /* work */
2484	uInt msudigits; /* digits in result msu */
2485	Unit *msu=res->lsu+D2U(res->digits)-1; /* current msu */
2486	Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2487	for (msu++; msu<=msumax; msu++) *msu=0; /* ensure high units=0 */
2488	res->digits=set->digits; /* now full-length */
2489	msudigits=MSUDIGITS(res->digits); /* actual digits in msu */
2490
2491	/* rotation here is done in-place, in three steps */
2492	/* 1. shift all to least up to one unit to unit-align final */
2493	/* lsd [any digits shifted out are rotated to the left, */
2494	/* abutted to the original msd (which may require split)] */
2495	/* */
2496	/* [if there are no whole units left to rotate, the */
2497	/* rotation is now complete] */
2498	/* */
2499	/* 2. shift to least, from below the split point only, so that */
2500	/* the final msd is in the right place in its Unit [any */
2501	/* digits shifted out will fit exactly in the current msu, */
2502	/* left aligned, no split required] */
2503	/* */
2504	/* 3. rotate all the units by reversing left part, right */
2505	/* part, and then whole */
2506	/* */
2507	/* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2508	/* */
2509	/* start: 00a bcd efg hij klm npq */
2510	/* */
2511	/* 1a 000 0ab cde fgh|ijk lmn [pq saved] */
2512	/* 1b 00p qab cde fgh|ijk lmn */
2513	/* */
2514	/* 2a 00p qab cde fgh|00i jkl [mn saved] */
2515	/* 2b mnp qab cde fgh|00i jkl */
2516	/* */
2517	/* 3a fgh cde qab mnp|00i jkl */
2518	/* 3b fgh cde qab mnp|jkl 00i */
2519	/* 3c 00i jkl mnp qab cde fgh */
2520
2521	/* Step 1: amount to shift is the partial right-rotate count */
2522	rotate=set->digits-rotate; /* make it right-rotate */
2523	units=rotate/DECDPUN; /* whole units to rotate */
2524	shift=rotate%DECDPUN; /* left-over digits count */
2525	if (shift>0) { /* not an exact number of units */
2526	uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2527	decShiftToLeast(res->lsu, D2U(res->digits), shift);
2528	if (shift>msudigits) { /* msumax-1 needs >0 digits */
2529	uInt rem=save%powers[shift-msudigits];/* split save */
2530	*msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2531	*(msumax-1)=*(msumax-1)
2532	+(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2533	}
2534	else { /* all fits in msumax */
2535	*msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2536	}
2537	} /* digits shift needed */
2538
2539	/* If whole units to rotate... */
2540	if (units>0) { /* some to do */
2541	/* Step 2: the units to touch are the whole ones in rotate, */
2542	/* if any, and the shift is DECDPUN-msudigits (which may be */
2543	/* 0, again) */
2544	shift=DECDPUN-msudigits;
2545	if (shift>0) { /* not an exact number of units */
2546	uInt save=res->lsu[0]%powers[shift]; /* save low digit(s) */
2547	decShiftToLeast(res->lsu, units, shift);
2548	*msumax=*msumax+(Unit)(save*powers[msudigits]);
2549	} /* partial shift needed */
2550
2551	/* Step 3: rotate the units array using triple reverse */
2552	/* (reversing is easy and fast) */
2553	decReverse(res->lsu+units, msumax); /* left part */
2554	decReverse(res->lsu, res->lsu+units-1); /* right part */
2555	decReverse(res->lsu, msumax); /* whole */
2556	} /* whole units to rotate */
2557	/* the rotation may have left an undetermined number of zeros */
2558	/* on the left, so true length needs to be calculated */
2559	res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2560	} /* rotate needed */
2561	} /* rhs OK */
2562	} /* numerics */
2563	if (status!=0) decStatus(res, status, set);
2564	return res;
2565	} /* decNumberRotate */
2566
2567	/* ------------------------------------------------------------------ */
2568	/* decNumberSameQuantum -- test for equal exponents */
2569	/* */
2570	/* res is the result number, which will contain either 0 or 1 */
2571	/* lhs is a number to test */
2572	/* rhs is the second (usually a pattern) */
2573	/* */
2574	/* No errors are possible and no context is needed. */
2575	/* ------------------------------------------------------------------ */
2576	decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2577	const decNumber *rhs) {
2578	Unit ret=0; /* return value */
2579
2580	#if DECCHECK
2581	if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2582	#endif
2583
2584	if (SPECIALARGS) {
2585	if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2586	else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2587	/* [anything else with a special gives 0] */
2588	}
2589	else if (lhs->exponent==rhs->exponent) ret=1;
2590
2591	decNumberZero(res); /* OK to overwrite an operand now */
2592	*res->lsu=ret;
2593	return res;
2594	} /* decNumberSameQuantum */
2595
2596	/* ------------------------------------------------------------------ */
2597	/* decNumberScaleB -- multiply by a power of 10 */
2598	/* */
2599	/* This computes C = A x 10**B where B is an integer (q=0) with */
2600	/* maximum magnitude 2*(emax+digits) */
2601	/* */
2602	/* res is C, the result. C may be A or B */
2603	/* lhs is A, the number to adjust */
2604	/* rhs is B, the requested power of ten to use */
2605	/* set is the context */
2606	/* */
2607	/* C must have space for set->digits digits. */
2608	/* */
2609	/* The result may underflow or overflow. */
2610	/* ------------------------------------------------------------------ */
2611	decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2612	const decNumber *rhs, decContext *set) {
2613	Int reqexp; /* requested exponent change [B] */
2614	uInt status=0; /* accumulator */
2615	Int residue; /* work */
2616
2617	#if DECCHECK
2618	if (decCheckOperands(res, lhs, rhs, set)) return res;
2619	#endif
2620
2621	/* Handle special values except lhs infinite */
2622	if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2623	decNaNs(res, lhs, rhs, set, &status);
2624	/* rhs must be an integer */
2625	else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2626	status=DEC_Invalid_operation;
2627	else {
2628	/* lhs is a number; rhs is a finite with q==0 */
2629	reqexp=decGetInt(rhs); /* [cannot fail] */
2630	if (reqexp==BADINT /* something bad .. */
2631	|| reqexp==BIGODD || reqexp==BIGEVEN /* .. very big .. */
2632	|| abs(x: reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2633	status=DEC_Invalid_operation;
2634	else { /* rhs is OK */
2635	decNumberCopy(res, lhs); /* all done if infinite lhs */
2636	if (!decNumberIsInfinite(res)) { /* prepare to scale */
2637	res->exponent+=reqexp; /* adjust the exponent */
2638	residue=0;
2639	decFinalize(res, set, &residue, &status); /* .. and check */
2640	} /* finite LHS */
2641	} /* rhs OK */
2642	} /* rhs finite */
2643	if (status!=0) decStatus(res, status, set);
2644	return res;
2645	} /* decNumberScaleB */
2646
2647	/* ------------------------------------------------------------------ */
2648	/* decNumberShift -- shift the coefficient of a Number left or right */
2649	/* */
2650	/* This computes C = A << B or C = A >> -B (in base ten). */
2651	/* */
2652	/* res is C, the result. C may be A and/or B (e.g., X=X<<X) */
2653	/* lhs is A */
2654	/* rhs is B, the number of digits to shift (-ve to right) */
2655	/* set is the context */
2656	/* */
2657	/* The digits of the coefficient of A are shifted to the left (if B */
2658	/* is positive) or to the right (if B is negative) without adjusting */
2659	/* the exponent or the sign of A. */
2660	/* */
2661	/* B must be an integer (q=0) and in the range -set->digits through */
2662	/* +set->digits. */
2663	/* C must have space for set->digits digits. */
2664	/* NaNs are propagated as usual. Infinities are unaffected (but */
2665	/* B must be valid). No status is set unless B is invalid or an */
2666	/* operand is an sNaN. */
2667	/* ------------------------------------------------------------------ */
2668	decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2669	const decNumber *rhs, decContext *set) {
2670	uInt status=0; /* accumulator */
2671	Int shift; /* rhs as an Int */
2672
2673	#if DECCHECK
2674	if (decCheckOperands(res, lhs, rhs, set)) return res;
2675	#endif
2676
2677	/* NaNs propagate as normal */
2678	if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2679	decNaNs(res, lhs, rhs, set, &status);
2680	/* rhs must be an integer */
2681	else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2682	status=DEC_Invalid_operation;
2683	else { /* both numeric, rhs is an integer */
2684	shift=decGetInt(rhs); /* [cannot fail] */
2685	if (shift==BADINT /* something bad .. */
2686	|| shift==BIGODD || shift==BIGEVEN /* .. very big .. */
2687	|| abs(x: shift)>set->digits) /* .. or out of range */
2688	status=DEC_Invalid_operation;
2689	else { /* rhs is OK */
2690	decNumberCopy(res, lhs);
2691	if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2692	if (shift>0) { /* to left */
2693	if (shift==set->digits) { /* removing all */
2694	*res->lsu=0; /* so place 0 */
2695	res->digits=1; /* .. */
2696	}
2697	else { /* */
2698	/* first remove leading digits if necessary */
2699	if (res->digits+shift>set->digits) {
2700	decDecap(res, res->digits+shift-set->digits);
2701	/* that updated res->digits; may have gone to 1 (for a */
2702	/* single digit or for zero */
2703	}
2704	if (res->digits>1 || *res->lsu) /* if non-zero.. */
2705	res->digits=decShiftToMost(res->lsu, res->digits, shift);
2706	} /* partial left */
2707	} /* left */
2708	else { /* to right */
2709	if (-shift>=res->digits) { /* discarding all */
2710	*res->lsu=0; /* so place 0 */
2711	res->digits=1; /* .. */
2712	}
2713	else {
2714	decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2715	res->digits-=(-shift);
2716	}
2717	} /* to right */
2718	} /* non-0 non-Inf shift */
2719	} /* rhs OK */
2720	} /* numerics */
2721	if (status!=0) decStatus(res, status, set);
2722	return res;
2723	} /* decNumberShift */
2724
2725	/* ------------------------------------------------------------------ */
2726	/* decNumberSquareRoot -- square root operator */
2727	/* */
2728	/* This computes C = squareroot(A) */
2729	/* */
2730	/* res is C, the result. C may be A */
2731	/* rhs is A */
2732	/* set is the context; note that rounding mode has no effect */
2733	/* */
2734	/* C must have space for set->digits digits. */
2735	/* ------------------------------------------------------------------ */
2736	/* This uses the following varying-precision algorithm in: */
2737	/* */
2738	/* Properly Rounded Variable Precision Square Root, T. E. Hull and */
2739	/* A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2740	/* pp229-237, ACM, September 1985. */
2741	/* */
2742	/* The square-root is calculated using Newton's method, after which */
2743	/* a check is made to ensure the result is correctly rounded. */
2744	/* */
2745	/* % [Reformatted original Numerical Turing source code follows.] */
2746	/* function sqrt(x : real) : real */
2747	/* % sqrt(x) returns the properly rounded approximation to the square */
2748	/* % root of x, in the precision of the calling environment, or it */
2749	/* % fails if x < 0. */
2750	/* % t e hull and a abrham, august, 1984 */
2751	/* if x <= 0 then */
2752	/* if x < 0 then */
2753	/* assert false */
2754	/* else */
2755	/* result 0 */
2756	/* end if */
2757	/* end if */
2758	/* var f := setexp(x, 0) % fraction part of x [0.1 <= x < 1] */
2759	/* var e := getexp(x) % exponent part of x */
2760	/* var approx : real */
2761	/* if e mod 2 = 0 then */
2762	/* approx := .259 + .819 * f % approx to root of f */
2763	/* else */
2764	/* f := f/l0 % adjustments */
2765	/* e := e + 1 % for odd */
2766	/* approx := .0819 + 2.59 * f % exponent */
2767	/* end if */
2768	/* */
2769	/* var p:= 3 */
2770	/* const maxp := currentprecision + 2 */
2771	/* loop */
2772	/* p := min(2*p - 2, maxp) % p = 4,6,10, . . . , maxp */
2773	/* precision p */
2774	/* approx := .5 * (approx + f/approx) */
2775	/* exit when p = maxp */
2776	/* end loop */
2777	/* */
2778	/* % approx is now within 1 ulp of the properly rounded square root */
2779	/* % of f; to ensure proper rounding, compare squares of (approx - */
2780	/* % l/2 ulp) and (approx + l/2 ulp) with f. */
2781	/* p := currentprecision */
2782	/* begin */
2783	/* precision p + 2 */
2784	/* const approxsubhalf := approx - setexp(.5, -p) */
2785	/* if mulru(approxsubhalf, approxsubhalf) > f then */
2786	/* approx := approx - setexp(.l, -p + 1) */
2787	/* else */
2788	/* const approxaddhalf := approx + setexp(.5, -p) */
2789	/* if mulrd(approxaddhalf, approxaddhalf) < f then */
2790	/* approx := approx + setexp(.l, -p + 1) */
2791	/* end if */
2792	/* end if */
2793	/* end */
2794	/* result setexp(approx, e div 2) % fix exponent */
2795	/* end sqrt */
2796	/* ------------------------------------------------------------------ */
2797	decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2798	decContext *set) {
2799	decContext workset, approxset; /* work contexts */
2800	decNumber dzero; /* used for constant zero */
2801	Int maxp; /* largest working precision */
2802	Int workp; /* working precision */
2803	Int residue=0; /* rounding residue */
2804	uInt status=0, ignore=0; /* status accumulators */
2805	uInt rstatus; /* .. */
2806	Int exp; /* working exponent */
2807	Int ideal; /* ideal (preferred) exponent */
2808	Int needbytes; /* work */
2809	Int dropped; /* .. */
2810
2811	#if DECSUBSET
2812	decNumber *allocrhs=NULL; /* non-NULL if rounded rhs allocated */
2813	#endif
2814	/* buffer for f [needs +1 in case DECBUFFER 0] */
2815	decNumber buff[D2N(DECBUFFER+1)];
2816	/* buffer for a [needs +2 to match likely maxp] */
2817	decNumber bufa[D2N(DECBUFFER+2)];
2818	/* buffer for temporary, b [must be same size as a] */
2819	decNumber bufb[D2N(DECBUFFER+2)];
2820	decNumber *allocbuff=NULL; /* -> allocated buff, iff allocated */
2821	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
2822	decNumber *allocbufb=NULL; /* -> allocated bufb, iff allocated */
2823	decNumber *f=buff; /* reduced fraction */
2824	decNumber *a=bufa; /* approximation to result */
2825	decNumber *b=bufb; /* intermediate result */
2826	/* buffer for temporary variable, up to 3 digits */
2827	decNumber buft[D2N(3)];
2828	decNumber *t=buft; /* up-to-3-digit constant or work */
2829
2830	#if DECCHECK
2831	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2832	#endif
2833
2834	do { /* protect allocated storage */
2835	#if DECSUBSET
2836	if (!set->extended) {
2837	/* reduce operand and set lostDigits status, as needed */
2838	if (rhs->digits>set->digits) {
2839	allocrhs=decRoundOperand(rhs, set, &status);
2840	if (allocrhs==NULL) break;
2841	/* [Note: 'f' allocation below could reuse this buffer if */
2842	/* used, but as this is rare they are kept separate for clarity.] */
2843	rhs=allocrhs;
2844	}
2845	}
2846	#endif
2847	/* [following code does not require input rounding] */
2848
2849	/* handle infinities and NaNs */
2850	if (SPECIALARG) {
2851	if (decNumberIsInfinite(rhs)) { /* an infinity */
2852	if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
2853	else decNumberCopy(res, rhs); /* +Infinity */
2854	}
2855	else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
2856	break;
2857	}
2858
2859	/* calculate the ideal (preferred) exponent [floor(exp/2)] */
2860	/* [It would be nicer to write: ideal=rhs->exponent>>1, but this */
2861	/* generates a compiler warning. Generated code is the same.] */
2862	ideal=(rhs->exponent&~1)/2; /* target */
2863
2864	/* handle zeros */
2865	if (ISZERO(rhs)) {
2866	decNumberCopy(res, rhs); /* could be 0 or -0 */
2867	res->exponent=ideal; /* use the ideal [safe] */
2868	/* use decFinish to clamp any out-of-range exponent, etc. */
2869	decFinish(res, set, &residue, &status);
2870	break;
2871	}
2872
2873	/* any other -x is an oops */
2874	if (decNumberIsNegative(rhs)) {
2875	status|=DEC_Invalid_operation;
2876	break;
2877	}
2878
2879	/* space is needed for three working variables */
2880	/* f -- the same precision as the RHS, reduced to 0.01->0.99... */
2881	/* a -- Hull's approximation -- precision, when assigned, is */
2882	/* currentprecision+1 or the input argument precision, */
2883	/* whichever is larger (+2 for use as temporary) */
2884	/* b -- intermediate temporary result (same size as a) */
2885	/* if any is too long for local storage, then allocate */
2886	workp=MAXI(set->digits+1, rhs->digits); /* actual rounding precision */
2887	workp=MAXI(workp, 7); /* at least 7 for low cases */
2888	maxp=workp+2; /* largest working precision */
2889
2890	needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
2891	if (needbytes>(Int)sizeof(buff)) {
2892	allocbuff=(decNumber *)malloc(size: needbytes);
2893	if (allocbuff==NULL) { /* hopeless -- abandon */
2894	status|=DEC_Insufficient_storage;
2895	break;}
2896	f=allocbuff; /* use the allocated space */
2897	}
2898	/* a and b both need to be able to hold a maxp-length number */
2899	needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
2900	if (needbytes>(Int)sizeof(bufa)) { /* [same applies to b] */
2901	allocbufa=(decNumber *)malloc(size: needbytes);
2902	allocbufb=(decNumber *)malloc(size: needbytes);
2903	if (allocbufa==NULL || allocbufb==NULL) { /* hopeless */
2904	status|=DEC_Insufficient_storage;
2905	break;}
2906	a=allocbufa; /* use the allocated spaces */
2907	b=allocbufb; /* .. */
2908	}
2909
2910	/* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
2911	decNumberCopy(f, rhs);
2912	exp=f->exponent+f->digits; /* adjusted to Hull rules */
2913	f->exponent=-(f->digits); /* to range */
2914
2915	/* set up working context */
2916	decContextDefault(&workset, DEC_INIT_DECIMAL64);
2917	workset.emax=DEC_MAX_EMAX;
2918	workset.emin=DEC_MIN_EMIN;
2919
2920	/* [Until further notice, no error is possible and status bits */
2921	/* (Rounded, etc.) should be ignored, not accumulated.] */
2922
2923	/* Calculate initial approximation, and allow for odd exponent */
2924	workset.digits=workp; /* p for initial calculation */
2925	t->bits=0; t->digits=3;
2926	a->bits=0; a->digits=3;
2927	if ((exp & 1)==0) { /* even exponent */
2928	/* Set t=0.259, a=0.819 */
2929	t->exponent=-3;
2930	a->exponent=-3;
2931	#if DECDPUN>=3
2932	t->lsu[0]=259;
2933	a->lsu[0]=819;
2934	#elif DECDPUN==2
2935	t->lsu[0]=59; t->lsu[1]=2;
2936	a->lsu[0]=19; a->lsu[1]=8;
2937	#else
2938	t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
2939	a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
2940	#endif
2941	}
2942	else { /* odd exponent */
2943	/* Set t=0.0819, a=2.59 */
2944	f->exponent--; /* f=f/10 */
2945	exp++; /* e=e+1 */
2946	t->exponent=-4;
2947	a->exponent=-2;
2948	#if DECDPUN>=3
2949	t->lsu[0]=819;
2950	a->lsu[0]=259;
2951	#elif DECDPUN==2
2952	t->lsu[0]=19; t->lsu[1]=8;
2953	a->lsu[0]=59; a->lsu[1]=2;
2954	#else
2955	t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
2956	a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
2957	#endif
2958	}
2959
2960	decMultiplyOp(a, a, f, &workset, &ignore); /* a=a*f */
2961	decAddOp(a, a, t, &workset, 0, &ignore); /* ..+t */
2962	/* [a is now the initial approximation for sqrt(f), calculated with */
2963	/* currentprecision, which is also a's precision.] */
2964
2965	/* the main calculation loop */
2966	decNumberZero(&dzero); /* make 0 */
2967	decNumberZero(t); /* set t = 0.5 */
2968	t->lsu[0]=5; /* .. */
2969	t->exponent=-1; /* .. */
2970	workset.digits=3; /* initial p */
2971	for (; workset.digits<maxp;) {
2972	/* set p to min(2*p - 2, maxp) [hence 3; or: 4, 6, 10, ... , maxp] */
2973	workset.digits=MINI(workset.digits*2-2, maxp);
2974	/* a = 0.5 * (a + f/a) */
2975	/* [calculated at p then rounded to currentprecision] */
2976	decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
2977	decAddOp(b, b, a, &workset, 0, &ignore); /* b=b+a */
2978	decMultiplyOp(a, b, t, &workset, &ignore); /* a=b*0.5 */
2979	} /* loop */
2980
2981	/* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
2982	/* now reduce to length, etc.; this needs to be done with a */
2983	/* having the correct exponent so as to handle subnormals */
2984	/* correctly */
2985	approxset=*set; /* get emin, emax, etc. */
2986	approxset.round=DEC_ROUND_HALF_EVEN;
2987	a->exponent+=exp/2; /* set correct exponent */
2988	rstatus=0; /* clear status */
2989	residue=0; /* .. and accumulator */
2990	decCopyFit(a, a, &approxset, &residue, &rstatus); /* reduce (if needed) */
2991	decFinish(a, &approxset, &residue, &rstatus); /* clean and finalize */
2992
2993	/* Overflow was possible if the input exponent was out-of-range, */
2994	/* in which case quit */
2995	if (rstatus&DEC_Overflow) {
2996	status=rstatus; /* use the status as-is */
2997	decNumberCopy(res, a); /* copy to result */
2998	break;
2999	}
3000
3001	/* Preserve status except Inexact/Rounded */
3002	status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3003
3004	/* Carry out the Hull correction */
3005	a->exponent-=exp/2; /* back to 0.1->1 */
3006
3007	/* a is now at final precision and within 1 ulp of the properly */
3008	/* rounded square root of f; to ensure proper rounding, compare */
3009	/* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3010	/* Here workset.digits=maxp and t=0.5, and a->digits determines */
3011	/* the ulp */
3012	workset.digits--; /* maxp-1 is OK now */
3013	t->exponent=-a->digits-1; /* make 0.5 ulp */
3014	decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3015	workset.round=DEC_ROUND_UP;
3016	decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulru(b, b) */
3017	decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3018	if (decNumberIsNegative(b)) { /* f < b [i.e., b > f] */
3019	/* this is the more common adjustment, though both are rare */
3020	t->exponent++; /* make 1.0 ulp */
3021	t->lsu[0]=1; /* .. */
3022	decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3023	/* assign to approx [round to length] */
3024	approxset.emin-=exp/2; /* adjust to match a */
3025	approxset.emax-=exp/2;
3026	decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3027	}
3028	else {
3029	decAddOp(b, a, t, &workset, 0, &ignore); /* b = a + 0.5 ulp */
3030	workset.round=DEC_ROUND_DOWN;
3031	decMultiplyOp(b, b, b, &workset, &ignore); /* b = mulrd(b, b) */
3032	decCompareOp(b, b, f, &workset, COMPARE, &ignore); /* b ? f */
3033	if (decNumberIsNegative(b)) { /* b < f */
3034	t->exponent++; /* make 1.0 ulp */
3035	t->lsu[0]=1; /* .. */
3036	decAddOp(a, a, t, &workset, 0, &ignore); /* a = a + 1 ulp */
3037	/* assign to approx [round to length] */
3038	approxset.emin-=exp/2; /* adjust to match a */
3039	approxset.emax-=exp/2;
3040	decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3041	}
3042	}
3043	/* [no errors are possible in the above, and rounding/inexact during */
3044	/* estimation are irrelevant, so status was not accumulated] */
3045
3046	/* Here, 0.1 <= a < 1 (still), so adjust back */
3047	a->exponent+=exp/2; /* set correct exponent */
3048
3049	/* count droppable zeros [after any subnormal rounding] by */
3050	/* trimming a copy */
3051	decNumberCopy(b, a);
3052	decTrim(b, set, 1, 1, &dropped); /* [drops trailing zeros] */
3053
3054	/* Set Inexact and Rounded. The answer can only be exact if */
3055	/* it is short enough so that squaring it could fit in workp */
3056	/* digits, so this is the only (relatively rare) condition that */
3057	/* a careful check is needed */
3058	if (b->digits*2-1 > workp) { /* cannot fit */
3059	status|=DEC_Inexact|DEC_Rounded;
3060	}
3061	else { /* could be exact/unrounded */
3062	uInt mstatus=0; /* local status */
3063	decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3064	if (mstatus&DEC_Overflow) { /* result just won't fit */
3065	status|=DEC_Inexact|DEC_Rounded;
3066	}
3067	else { /* plausible */
3068	decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3069	if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3070	else { /* is Exact */
3071	/* here, dropped is the count of trailing zeros in 'a' */
3072	/* use closest exponent to ideal... */
3073	Int todrop=ideal-a->exponent; /* most that can be dropped */
3074	if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3075	else { /* unrounded */
3076	/* there are some to drop, but emax may not allow all */
3077	Int maxexp=set->emax-set->digits+1;
3078	Int maxdrop=maxexp-a->exponent;
3079	if (todrop>maxdrop && set->clamp) { /* apply clamping */
3080	todrop=maxdrop;
3081	status|=DEC_Clamped;
3082	}
3083	if (dropped<todrop) { /* clamp to those available */
3084	todrop=dropped;
3085	status|=DEC_Clamped;
3086	}
3087	if (todrop>0) { /* have some to drop */
3088	decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3089	a->exponent+=todrop; /* maintain numerical value */
3090	a->digits-=todrop; /* new length */
3091	}
3092	}
3093	}
3094	}
3095	}
3096
3097	/* double-check Underflow, as perhaps the result could not have */
3098	/* been subnormal (initial argument too big), or it is now Exact */
3099	if (status&DEC_Underflow) {
3100	Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
3101	/* check if truly subnormal */
3102	#if DECEXTFLAG /* DEC_Subnormal too */
3103	if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3104	#else
3105	if (ae>=set->emin*2) status&=~DEC_Underflow;
3106	#endif
3107	/* check if truly inexact */
3108	if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3109	}
3110
3111	decNumberCopy(res, a); /* a is now the result */
3112	} while(0); /* end protected */
3113
3114	free(ptr: allocbuff); /* drop any storage used */
3115	free(ptr: allocbufa); /* .. */
3116	free(ptr: allocbufb); /* .. */
3117	#if DECSUBSET
3118	free(allocrhs); /* .. */
3119	#endif
3120	if (status!=0) decStatus(res, status, set);/* then report status */
3121	#if DECCHECK
3122	decCheckInexact(res, set);
3123	#endif
3124	return res;
3125	} /* decNumberSquareRoot */
3126
3127	/* ------------------------------------------------------------------ */
3128	/* decNumberSubtract -- subtract two Numbers */
3129	/* */
3130	/* This computes C = A - B */
3131	/* */
3132	/* res is C, the result. C may be A and/or B (e.g., X=X-X) */
3133	/* lhs is A */
3134	/* rhs is B */
3135	/* set is the context */
3136	/* */
3137	/* C must have space for set->digits digits. */
3138	/* ------------------------------------------------------------------ */
3139	decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3140	const decNumber *rhs, decContext *set) {
3141	uInt status=0; /* accumulator */
3142
3143	decAddOp(res, lhs, rhs, set, DECNEG, &status);
3144	if (status!=0) decStatus(res, status, set);
3145	#if DECCHECK
3146	decCheckInexact(res, set);
3147	#endif
3148	return res;
3149	} /* decNumberSubtract */
3150
3151	/* ------------------------------------------------------------------ */
3152	/* decNumberToIntegralExact -- round-to-integral-value with InExact */
3153	/* decNumberToIntegralValue -- round-to-integral-value */
3154	/* */
3155	/* res is the result */
3156	/* rhs is input number */
3157	/* set is the context */
3158	/* */
3159	/* res must have space for any value of rhs. */
3160	/* */
3161	/* This implements the IEEE special operators and therefore treats */
3162	/* special values as valid. For finite numbers it returns */
3163	/* rescale(rhs, 0) if rhs->exponent is <0. */
3164	/* Otherwise the result is rhs (so no error is possible, except for */
3165	/* sNaN). */
3166	/* */
3167	/* The context is used for rounding mode and status after sNaN, but */
3168	/* the digits setting is ignored. The Exact version will signal */
3169	/* Inexact if the result differs numerically from rhs; the other */
3170	/* never signals Inexact. */
3171	/* ------------------------------------------------------------------ */
3172	decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3173	decContext *set) {
3174	decNumber dn;
3175	decContext workset; /* working context */
3176	uInt status=0; /* accumulator */
3177
3178	#if DECCHECK
3179	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3180	#endif
3181
3182	/* handle infinities and NaNs */
3183	if (SPECIALARG) {
3184	if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3185	else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3186	}
3187	else { /* finite */
3188	/* have a finite number; no error possible (res must be big enough) */
3189	if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3190	/* that was easy, but if negative exponent there is work to do... */
3191	workset=*set; /* clone rounding, etc. */
3192	workset.digits=rhs->digits; /* no length rounding */
3193	workset.traps=0; /* no traps */
3194	decNumberZero(&dn); /* make a number with exponent 0 */
3195	decNumberQuantize(res, lhs: rhs, rhs: &dn, set: &workset);
3196	status|=workset.status;
3197	}
3198	if (status!=0) decStatus(res, status, set);
3199	return res;
3200	} /* decNumberToIntegralExact */
3201
3202	decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3203	decContext *set) {
3204	decContext workset=*set; /* working context */
3205	workset.traps=0; /* no traps */
3206	decNumberToIntegralExact(res, rhs, set: &workset);
3207	/* this never affects set, except for sNaNs; NaN will have been set */
3208	/* or propagated already, so no need to call decStatus */
3209	set->status|=workset.status&DEC_Invalid_operation;
3210	return res;
3211	} /* decNumberToIntegralValue */
3212
3213	/* ------------------------------------------------------------------ */
3214	/* decNumberXor -- XOR two Numbers, digitwise */
3215	/* */
3216	/* This computes C = A ^ B */
3217	/* */
3218	/* res is C, the result. C may be A and/or B (e.g., X=X^X) */
3219	/* lhs is A */
3220	/* rhs is B */
3221	/* set is the context (used for result length and error report) */
3222	/* */
3223	/* C must have space for set->digits digits. */
3224	/* */
3225	/* Logical function restrictions apply (see above); a NaN is */
3226	/* returned with Invalid_operation if a restriction is violated. */
3227	/* ------------------------------------------------------------------ */
3228	decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3229	const decNumber *rhs, decContext *set) {
3230	const Unit *ua, *ub; /* -> operands */
3231	const Unit *msua, *msub; /* -> operand msus */
3232	Unit *uc, *msuc; /* -> result and its msu */
3233	Int msudigs; /* digits in res msu */
3234	#if DECCHECK
3235	if (decCheckOperands(res, lhs, rhs, set)) return res;
3236	#endif
3237
3238	if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3239	|| rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3240	decStatus(res, DEC_Invalid_operation, set);
3241	return res;
3242	}
3243	/* operands are valid */
3244	ua=lhs->lsu; /* bottom-up */
3245	ub=rhs->lsu; /* .. */
3246	uc=res->lsu; /* .. */
3247	msua=ua+D2U(lhs->digits)-1; /* -> msu of lhs */
3248	msub=ub+D2U(rhs->digits)-1; /* -> msu of rhs */
3249	msuc=uc+D2U(set->digits)-1; /* -> msu of result */
3250	msudigs=MSUDIGITS(set->digits); /* [faster than remainder] */
3251	for (; uc<=msuc; ua++, ub++, uc++) { /* Unit loop */
3252	Unit a, b; /* extract units */
3253	if (ua>msua) a=0;
3254	else a=*ua;
3255	if (ub>msub) b=0;
3256	else b=*ub;
3257	*uc=0; /* can now write back */
3258	if (a|b) { /* maybe 1 bits to examine */
3259	Int i, j;
3260	/* This loop could be unrolled and/or use BIN2BCD tables */
3261	for (i=0; i<DECDPUN; i++) {
3262	if ((a^b)&1) *uc=*uc+(Unit)powers[i]; /* effect XOR */
3263	j=a%10;
3264	a=a/10;
3265	j|=b%10;
3266	b=b/10;
3267	if (j>1) {
3268	decStatus(res, DEC_Invalid_operation, set);
3269	return res;
3270	}
3271	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
3272	} /* each digit */
3273	} /* non-zero */
3274	} /* each unit */
3275	/* [here uc-1 is the msu of the result] */
3276	res->digits=decGetDigits(res->lsu, uc-res->lsu);
3277	res->exponent=0; /* integer */
3278	res->bits=0; /* sign=0 */
3279	return res; /* [no status to set] */
3280	} /* decNumberXor */
3281
3282
3283	/* ================================================================== */
3284	/* Utility routines */
3285	/* ================================================================== */
3286
3287	/* ------------------------------------------------------------------ */
3288	/* decNumberClass -- return the decClass of a decNumber */
3289	/* dn -- the decNumber to test */
3290	/* set -- the context to use for Emin */
3291	/* returns the decClass enum */
3292	/* ------------------------------------------------------------------ */
3293	enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3294	if (decNumberIsSpecial(dn)) {
3295	if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3296	if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3297	/* must be an infinity */
3298	if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3299	return DEC_CLASS_POS_INF;
3300	}
3301	/* is finite */
3302	if (decNumberIsNormal(dn, set)) { /* most common */
3303	if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3304	return DEC_CLASS_POS_NORMAL;
3305	}
3306	/* is subnormal or zero */
3307	if (decNumberIsZero(dn)) { /* most common */
3308	if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3309	return DEC_CLASS_POS_ZERO;
3310	}
3311	if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3312	return DEC_CLASS_POS_SUBNORMAL;
3313	} /* decNumberClass */
3314
3315	/* ------------------------------------------------------------------ */
3316	/* decNumberClassToString -- convert decClass to a string */
3317	/* */
3318	/* eclass is a valid decClass */
3319	/* returns a constant string describing the class (max 13+1 chars) */
3320	/* ------------------------------------------------------------------ */
3321	const char *decNumberClassToString(enum decClass eclass) {
3322	if (eclass==DEC_CLASS_POS_NORMAL) return DEC_ClassString_PN;
3323	if (eclass==DEC_CLASS_NEG_NORMAL) return DEC_ClassString_NN;
3324	if (eclass==DEC_CLASS_POS_ZERO) return DEC_ClassString_PZ;
3325	if (eclass==DEC_CLASS_NEG_ZERO) return DEC_ClassString_NZ;
3326	if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3327	if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3328	if (eclass==DEC_CLASS_POS_INF) return DEC_ClassString_PI;
3329	if (eclass==DEC_CLASS_NEG_INF) return DEC_ClassString_NI;
3330	if (eclass==DEC_CLASS_QNAN) return DEC_ClassString_QN;
3331	if (eclass==DEC_CLASS_SNAN) return DEC_ClassString_SN;
3332	return DEC_ClassString_UN; /* Unknown */
3333	} /* decNumberClassToString */
3334
3335	/* ------------------------------------------------------------------ */
3336	/* decNumberCopy -- copy a number */
3337	/* */
3338	/* dest is the target decNumber */
3339	/* src is the source decNumber */
3340	/* returns dest */
3341	/* */
3342	/* (dest==src is allowed and is a no-op) */
3343	/* All fields are updated as required. This is a utility operation, */
3344	/* so special values are unchanged and no error is possible. */
3345	/* ------------------------------------------------------------------ */
3346	decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3347
3348	#if DECCHECK
3349	if (src==NULL) return decNumberZero(dest);
3350	#endif
3351
3352	if (dest==src) return dest; /* no copy required */
3353
3354	/* Use explicit assignments here as structure assignment could copy */
3355	/* more than just the lsu (for small DECDPUN). This would not affect */
3356	/* the value of the results, but could disturb test harness spill */
3357	/* checking. */
3358	dest->bits=src->bits;
3359	dest->exponent=src->exponent;
3360	dest->digits=src->digits;
3361	dest->lsu[0]=src->lsu[0];
3362	if (src->digits>DECDPUN) { /* more Units to come */
3363	const Unit *smsup, *s; /* work */
3364	Unit *d; /* .. */
3365	/* memcpy for the remaining Units would be safe as they cannot */
3366	/* overlap. However, this explicit loop is faster in short cases. */
3367	d=dest->lsu+1; /* -> first destination */
3368	smsup=src->lsu+D2U(src->digits); /* -> source msu+1 */
3369	for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3370	}
3371	return dest;
3372	} /* decNumberCopy */
3373
3374	/* ------------------------------------------------------------------ */
3375	/* decNumberCopyAbs -- quiet absolute value operator */
3376	/* */
3377	/* This sets C = abs(A) */
3378	/* */
3379	/* res is C, the result. C may be A */
3380	/* rhs is A */
3381	/* */
3382	/* C must have space for set->digits digits. */
3383	/* No exception or error can occur; this is a quiet bitwise operation.*/
3384	/* See also decNumberAbs for a checking version of this. */
3385	/* ------------------------------------------------------------------ */
3386	decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3387	#if DECCHECK
3388	if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3389	#endif
3390	decNumberCopy(dest: res, src: rhs);
3391	res->bits&=~DECNEG; /* turn off sign */
3392	return res;
3393	} /* decNumberCopyAbs */
3394
3395	/* ------------------------------------------------------------------ */
3396	/* decNumberCopyNegate -- quiet negate value operator */
3397	/* */
3398	/* This sets C = negate(A) */
3399	/* */
3400	/* res is C, the result. C may be A */
3401	/* rhs is A */
3402	/* */
3403	/* C must have space for set->digits digits. */
3404	/* No exception or error can occur; this is a quiet bitwise operation.*/
3405	/* See also decNumberMinus for a checking version of this. */
3406	/* ------------------------------------------------------------------ */
3407	decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3408	#if DECCHECK
3409	if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3410	#endif
3411	decNumberCopy(dest: res, src: rhs);
3412	res->bits^=DECNEG; /* invert the sign */
3413	return res;
3414	} /* decNumberCopyNegate */
3415
3416	/* ------------------------------------------------------------------ */
3417	/* decNumberCopySign -- quiet copy and set sign operator */
3418	/* */
3419	/* This sets C = A with the sign of B */
3420	/* */
3421	/* res is C, the result. C may be A */
3422	/* lhs is A */
3423	/* rhs is B */
3424	/* */
3425	/* C must have space for set->digits digits. */
3426	/* No exception or error can occur; this is a quiet bitwise operation.*/
3427	/* ------------------------------------------------------------------ */
3428	decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3429	const decNumber *rhs) {
3430	uByte sign; /* rhs sign */
3431	#if DECCHECK
3432	if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3433	#endif
3434	sign=rhs->bits & DECNEG; /* save sign bit */
3435	decNumberCopy(dest: res, src: lhs);
3436	res->bits&=~DECNEG; /* clear the sign */
3437	res->bits|=sign; /* set from rhs */
3438	return res;
3439	} /* decNumberCopySign */
3440
3441	/* ------------------------------------------------------------------ */
3442	/* decNumberGetBCD -- get the coefficient in BCD8 */
3443	/* dn is the source decNumber */
3444	/* bcd is the uInt array that will receive dn->digits BCD bytes, */
3445	/* most-significant at offset 0 */
3446	/* returns bcd */
3447	/* */
3448	/* bcd must have at least dn->digits bytes. No error is possible; if */
3449	/* dn is a NaN or Infinite, digits must be 1 and the coefficient 0. */
3450	/* ------------------------------------------------------------------ */
3451	uByte * decNumberGetBCD(const decNumber *dn, uByte *bcd) {
3452	uByte *ub=bcd+dn->digits-1; /* -> lsd */
3453	const Unit *up=dn->lsu; /* Unit pointer, -> lsu */
3454
3455	#if DECDPUN==1 /* trivial simple copy */
3456	for (; ub>=bcd; ub--, up++) *ub=*up;
3457	#else /* chopping needed */
3458	uInt u=*up; /* work */
3459	uInt cut=DECDPUN; /* downcounter through unit */
3460	for (; ub>=bcd; ub--) {
3461	*ub=(uByte)(u%10); /* [*6554 trick inhibits, here] */
3462	u=u/10;
3463	cut--;
3464	if (cut>0) continue; /* more in this unit */
3465	up++;
3466	u=*up;
3467	cut=DECDPUN;
3468	}
3469	#endif
3470	return bcd;
3471	} /* decNumberGetBCD */
3472
3473	/* ------------------------------------------------------------------ */
3474	/* decNumberSetBCD -- set (replace) the coefficient from BCD8 */
3475	/* dn is the target decNumber */
3476	/* bcd is the uInt array that will source n BCD bytes, most- */
3477	/* significant at offset 0 */
3478	/* n is the number of digits in the source BCD array (bcd) */
3479	/* returns dn */
3480	/* */
3481	/* dn must have space for at least n digits. No error is possible; */
3482	/* if dn is a NaN, or Infinite, or is to become a zero, n must be 1 */
3483	/* and bcd[0] zero. */
3484	/* ------------------------------------------------------------------ */
3485	decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3486	Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [target pointer] */
3487	const uByte *ub=bcd; /* -> source msd */
3488
3489	#if DECDPUN==1 /* trivial simple copy */
3490	for (; ub<bcd+n; ub++, up--) *up=*ub;
3491	#else /* some assembly needed */
3492	/* calculate how many digits in msu, and hence first cut */
3493	Int cut=MSUDIGITS(n); /* [faster than remainder] */
3494	for (;up>=dn->lsu; up--) { /* each Unit from msu */
3495	*up=0; /* will take <=DECDPUN digits */
3496	for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3497	cut=DECDPUN; /* next Unit has all digits */
3498	}
3499	#endif
3500	dn->digits=n; /* set digit count */
3501	return dn;
3502	} /* decNumberSetBCD */
3503
3504	/* ------------------------------------------------------------------ */
3505	/* decNumberIsNormal -- test normality of a decNumber */
3506	/* dn is the decNumber to test */
3507	/* set is the context to use for Emin */
3508	/* returns 1 if |dn| is finite and >=Nmin, 0 otherwise */
3509	/* ------------------------------------------------------------------ */
3510	Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3511	Int ae; /* adjusted exponent */
3512	#if DECCHECK
3513	if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3514	#endif
3515
3516	if (decNumberIsSpecial(dn)) return 0; /* not finite */
3517	if (decNumberIsZero(dn)) return 0; /* not non-zero */
3518
3519	ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3520	if (ae<set->emin) return 0; /* is subnormal */
3521	return 1;
3522	} /* decNumberIsNormal */
3523
3524	/* ------------------------------------------------------------------ */
3525	/* decNumberIsSubnormal -- test subnormality of a decNumber */
3526	/* dn is the decNumber to test */
3527	/* set is the context to use for Emin */
3528	/* returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise */
3529	/* ------------------------------------------------------------------ */
3530	Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3531	Int ae; /* adjusted exponent */
3532	#if DECCHECK
3533	if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3534	#endif
3535
3536	if (decNumberIsSpecial(dn)) return 0; /* not finite */
3537	if (decNumberIsZero(dn)) return 0; /* not non-zero */
3538
3539	ae=dn->exponent+dn->digits-1; /* adjusted exponent */
3540	if (ae<set->emin) return 1; /* is subnormal */
3541	return 0;
3542	} /* decNumberIsSubnormal */
3543
3544	/* ------------------------------------------------------------------ */
3545	/* decNumberTrim -- remove insignificant zeros */
3546	/* */
3547	/* dn is the number to trim */
3548	/* returns dn */
3549	/* */
3550	/* All fields are updated as required. This is a utility operation, */
3551	/* so special values are unchanged and no error is possible. The */
3552	/* zeros are removed unconditionally. */
3553	/* ------------------------------------------------------------------ */
3554	decNumber * decNumberTrim(decNumber *dn) {
3555	Int dropped; /* work */
3556	decContext set; /* .. */
3557	#if DECCHECK
3558	if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3559	#endif
3560	decContextDefault(&set, DEC_INIT_BASE); /* clamp=0 */
3561	return decTrim(dn, &set, 0, 1, &dropped);
3562	} /* decNumberTrim */
3563
3564	/* ------------------------------------------------------------------ */
3565	/* decNumberVersion -- return the name and version of this module */
3566	/* */
3567	/* No error is possible. */
3568	/* ------------------------------------------------------------------ */
3569	const char * decNumberVersion(void) {
3570	return DECVERSION;
3571	} /* decNumberVersion */
3572
3573	/* ------------------------------------------------------------------ */
3574	/* decNumberZero -- set a number to 0 */
3575	/* */
3576	/* dn is the number to set, with space for one digit */
3577	/* returns dn */
3578	/* */
3579	/* No error is possible. */
3580	/* ------------------------------------------------------------------ */
3581	/* Memset is not used as it is much slower in some environments. */
3582	decNumber * decNumberZero(decNumber *dn) {
3583
3584	#if DECCHECK
3585	if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3586	#endif
3587
3588	dn->bits=0;
3589	dn->exponent=0;
3590	dn->digits=1;
3591	dn->lsu[0]=0;
3592	return dn;
3593	} /* decNumberZero */
3594
3595	/* ================================================================== */
3596	/* Local routines */
3597	/* ================================================================== */
3598
3599	/* ------------------------------------------------------------------ */
3600	/* decToString -- lay out a number into a string */
3601	/* */
3602	/* dn is the number to lay out */
3603	/* string is where to lay out the number */
3604	/* eng is 1 if Engineering, 0 if Scientific */
3605	/* */
3606	/* string must be at least dn->digits+14 characters long */
3607	/* No error is possible. */
3608	/* */
3609	/* Note that this routine can generate a -0 or 0.000. These are */
3610	/* never generated in subset to-number or arithmetic, but can occur */
3611	/* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234). */
3612	/* ------------------------------------------------------------------ */
3613	/* If DECCHECK is enabled the string "?" is returned if a number is */
3614	/* invalid. */
3615	static void decToString(const decNumber *dn, char *string, Flag eng) {
3616	Int exp=dn->exponent; /* local copy */
3617	Int e; /* E-part value */
3618	Int pre; /* digits before the '.' */
3619	Int cut; /* for counting digits in a Unit */
3620	char *c=string; /* work [output pointer] */
3621	const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3622	uInt u, pow; /* work */
3623
3624	#if DECCHECK
3625	if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3626	strcpy(string, "?");
3627	return;}
3628	#endif
3629
3630	if (decNumberIsNegative(dn)) { /* Negatives get a minus */
3631	*c='-';
3632	c++;
3633	}
3634	if (dn->bits&DECSPECIAL) { /* Is a special value */
3635	if (decNumberIsInfinite(dn)) {
3636	strcpy(dest: c, src: "Inf");
3637	strcpy(dest: c+3, src: "inity");
3638	return;}
3639	/* a NaN */
3640	if (dn->bits&DECSNAN) { /* signalling NaN */
3641	*c='s';
3642	c++;
3643	}
3644	strcpy(dest: c, src: "NaN");
3645	c+=3; /* step past */
3646	/* if not a clean non-zero coefficient, that's all there is in a */
3647	/* NaN string */
3648	if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3649	/* [drop through to add integer] */
3650	}
3651
3652	/* calculate how many digits in msu, and hence first cut */
3653	cut=MSUDIGITS(dn->digits); /* [faster than remainder] */
3654	cut--; /* power of ten for digit */
3655
3656	if (exp==0) { /* simple integer [common fastpath] */
3657	for (;up>=dn->lsu; up--) { /* each Unit from msu */
3658	u=*up; /* contains DECDPUN digits to lay out */
3659	for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3660	cut=DECDPUN-1; /* next Unit has all digits */
3661	}
3662	*c='\0'; /* terminate the string */
3663	return;}
3664
3665	/* non-0 exponent -- assume plain form */
3666	pre=dn->digits+exp; /* digits before '.' */
3667	e=0; /* no E */
3668	if ((exp>0) || (pre<-5)) { /* need exponential form */
3669	e=exp+dn->digits-1; /* calculate E value */
3670	pre=1; /* assume one digit before '.' */
3671	if (eng && (e!=0)) { /* engineering: may need to adjust */
3672	Int adj; /* adjustment */
3673	/* The C remainder operator is undefined for negative numbers, so */
3674	/* a positive remainder calculation must be used here */
3675	if (e<0) {
3676	adj=(-e)%3;
3677	if (adj!=0) adj=3-adj;
3678	}
3679	else { /* e>0 */
3680	adj=e%3;
3681	}
3682	e=e-adj;
3683	/* if dealing with zero still produce an exponent which is a */
3684	/* multiple of three, as expected, but there will only be the */
3685	/* one zero before the E, still. Otherwise note the padding. */
3686	if (!ISZERO(dn)) pre+=adj;
3687	else { /* is zero */
3688	if (adj!=0) { /* 0.00Esnn needed */
3689	e=e+3;
3690	pre=-(2-adj);
3691	}
3692	} /* zero */
3693	} /* eng */
3694	} /* need exponent */
3695
3696	/* lay out the digits of the coefficient, adding 0s and . as needed */
3697	u=*up;
3698	if (pre>0) { /* xxx.xxx or xx00 (engineering) form */
3699	Int n=pre;
3700	for (; pre>0; pre--, c++, cut--) {
3701	if (cut<0) { /* need new Unit */
3702	if (up==dn->lsu) break; /* out of input digits (pre>digits) */
3703	up--;
3704	cut=DECDPUN-1;
3705	u=*up;
3706	}
3707	TODIGIT(u, cut, c, pow);
3708	}
3709	if (n<dn->digits) { /* more to come, after '.' */
3710	*c='.'; c++;
3711	for (;; c++, cut--) {
3712	if (cut<0) { /* need new Unit */
3713	if (up==dn->lsu) break; /* out of input digits */
3714	up--;
3715	cut=DECDPUN-1;
3716	u=*up;
3717	}
3718	TODIGIT(u, cut, c, pow);
3719	}
3720	}
3721	else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3722	}
3723	else { /* 0.xxx or 0.000xxx form */
3724	*c='0'; c++;
3725	*c='.'; c++;
3726	for (; pre<0; pre++, c++) *c='0'; /* add any 0's after '.' */
3727	for (; ; c++, cut--) {
3728	if (cut<0) { /* need new Unit */
3729	if (up==dn->lsu) break; /* out of input digits */
3730	up--;
3731	cut=DECDPUN-1;
3732	u=*up;
3733	}
3734	TODIGIT(u, cut, c, pow);
3735	}
3736	}
3737
3738	/* Finally add the E-part, if needed. It will never be 0, has a
3739	base maximum and minimum of +999999999 through -999999999, but
3740	could range down to -1999999998 for anormal numbers */
3741	if (e!=0) {
3742	Flag had=0; /* 1=had non-zero */
3743	*c='E'; c++;
3744	*c='+'; c++; /* assume positive */
3745	u=e; /* .. */
3746	if (e<0) {
3747	*(c-1)='-'; /* oops, need - */
3748	u=-e; /* uInt, please */
3749	}
3750	/* lay out the exponent [_itoa or equivalent is not ANSI C] */
3751	for (cut=9; cut>=0; cut--) {
3752	TODIGIT(u, cut, c, pow);
3753	if (*c=='0' && !had) continue; /* skip leading zeros */
3754	had=1; /* had non-0 */
3755	c++; /* step for next */
3756	} /* cut */
3757	}
3758	*c='\0'; /* terminate the string (all paths) */
3759	return;
3760	} /* decToString */
3761
3762	/* ------------------------------------------------------------------ */
3763	/* decAddOp -- add/subtract operation */
3764	/* */
3765	/* This computes C = A + B */
3766	/* */
3767	/* res is C, the result. C may be A and/or B (e.g., X=X+X) */
3768	/* lhs is A */
3769	/* rhs is B */
3770	/* set is the context */
3771	/* negate is DECNEG if rhs should be negated, or 0 otherwise */
3772	/* status accumulates status for the caller */
3773	/* */
3774	/* C must have space for set->digits digits. */
3775	/* Inexact in status must be 0 for correct Exact zero sign in result */
3776	/* ------------------------------------------------------------------ */
3777	/* If possible, the coefficient is calculated directly into C. */
3778	/* However, if: */
3779	/* -- a digits+1 calculation is needed because the numbers are */
3780	/* unaligned and span more than set->digits digits */
3781	/* -- a carry to digits+1 digits looks possible */
3782	/* -- C is the same as A or B, and the result would destructively */
3783	/* overlap the A or B coefficient */
3784	/* then the result must be calculated into a temporary buffer. In */
3785	/* this case a local (stack) buffer is used if possible, and only if */
3786	/* too long for that does malloc become the final resort. */
3787	/* */
3788	/* Misalignment is handled as follows: */
3789	/* Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp. */
3790	/* BPad: Apply the padding by a combination of shifting (whole */
3791	/* units) and multiplication (part units). */
3792	/* */
3793	/* Addition, especially x=x+1, is speed-critical. */
3794	/* The static buffer is larger than might be expected to allow for */
3795	/* calls from higher-level funtions (notable exp). */
3796	/* ------------------------------------------------------------------ */
3797	static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3798	const decNumber *rhs, decContext *set,
3799	uByte negate, uInt *status) {
3800	#if DECSUBSET
3801	decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
3802	decNumber *allocrhs=NULL; /* .., rhs */
3803	#endif
3804	Int rhsshift; /* working shift (in Units) */
3805	Int maxdigits; /* longest logical length */
3806	Int mult; /* multiplier */
3807	Int residue; /* rounding accumulator */
3808	uByte bits; /* result bits */
3809	Flag diffsign; /* non-0 if arguments have different sign */
3810	Unit *acc; /* accumulator for result */
3811	Unit accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3812	/* allocations when called from */
3813	/* other operations, notable exp] */
3814	Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
3815	Int reqdigits=set->digits; /* local copy; requested DIGITS */
3816	Int padding; /* work */
3817
3818	#if DECCHECK
3819	if (decCheckOperands(res, lhs, rhs, set)) return res;
3820	#endif
3821
3822	do { /* protect allocated storage */
3823	#if DECSUBSET
3824	if (!set->extended) {
3825	/* reduce operands and set lostDigits status, as needed */
3826	if (lhs->digits>reqdigits) {
3827	alloclhs=decRoundOperand(lhs, set, status);
3828	if (alloclhs==NULL) break;
3829	lhs=alloclhs;
3830	}
3831	if (rhs->digits>reqdigits) {
3832	allocrhs=decRoundOperand(rhs, set, status);
3833	if (allocrhs==NULL) break;
3834	rhs=allocrhs;
3835	}
3836	}
3837	#endif
3838	/* [following code does not require input rounding] */
3839
3840	/* note whether signs differ [used all paths] */
3841	diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3842
3843	/* handle infinities and NaNs */
3844	if (SPECIALARGS) { /* a special bit set */
3845	if (SPECIALARGS & (DECSNAN | DECNAN)) /* a NaN */
3846	decNaNs(res, lhs, rhs, set, status);
3847	else { /* one or two infinities */
3848	if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
3849	/* two infinities with different signs is invalid */
3850	if (decNumberIsInfinite(rhs) && diffsign) {
3851	*status|=DEC_Invalid_operation;
3852	break;
3853	}
3854	bits=lhs->bits & DECNEG; /* get sign from LHS */
3855	}
3856	else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3857	bits|=DECINF;
3858	decNumberZero(dn: res);
3859	res->bits=bits; /* set +/- infinity */
3860	} /* an infinity */
3861	break;
3862	}
3863
3864	/* Quick exit for add 0s; return the non-0, modified as need be */
3865	if (ISZERO(lhs)) {
3866	Int adjust; /* work */
3867	Int lexp=lhs->exponent; /* save in case LHS==RES */
3868	bits=lhs->bits; /* .. */
3869	residue=0; /* clear accumulator */
3870	decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
3871	res->bits^=negate; /* flip if rhs was negated */
3872	#if DECSUBSET
3873	if (set->extended) { /* exponents on zeros count */
3874	#endif
3875	/* exponent will be the lower of the two */
3876	adjust=lexp-res->exponent; /* adjustment needed [if -ve] */
3877	if (ISZERO(res)) { /* both 0: special IEEE 754 rules */
3878	if (adjust<0) res->exponent=lexp; /* set exponent */
3879	/* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
3880	if (diffsign) {
3881	if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3882	else res->bits=DECNEG; /* preserve 0 sign */
3883	}
3884	}
3885	else { /* non-0 res */
3886	if (adjust<0) { /* 0-padding needed */
3887	if ((res->digits-adjust)>set->digits) {
3888	adjust=res->digits-set->digits; /* to fit exactly */
3889	*status|=DEC_Rounded; /* [but exact] */
3890	}
3891	res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3892	res->exponent+=adjust; /* set the exponent. */
3893	}
3894	} /* non-0 res */
3895	#if DECSUBSET
3896	} /* extended */
3897	#endif
3898	decFinish(res, set, &residue, status); /* clean and finalize */
3899	break;}
3900
3901	if (ISZERO(rhs)) { /* [lhs is non-zero] */
3902	Int adjust; /* work */
3903	Int rexp=rhs->exponent; /* save in case RHS==RES */
3904	bits=rhs->bits; /* be clean */
3905	residue=0; /* clear accumulator */
3906	decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
3907	#if DECSUBSET
3908	if (set->extended) { /* exponents on zeros count */
3909	#endif
3910	/* exponent will be the lower of the two */
3911	/* [0-0 case handled above] */
3912	adjust=rexp-res->exponent; /* adjustment needed [if -ve] */
3913	if (adjust<0) { /* 0-padding needed */
3914	if ((res->digits-adjust)>set->digits) {
3915	adjust=res->digits-set->digits; /* to fit exactly */
3916	*status|=DEC_Rounded; /* [but exact] */
3917	}
3918	res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
3919	res->exponent+=adjust; /* set the exponent. */
3920	}
3921	#if DECSUBSET
3922	} /* extended */
3923	#endif
3924	decFinish(res, set, &residue, status); /* clean and finalize */
3925	break;}
3926
3927	/* [NB: both fastpath and mainpath code below assume these cases */
3928	/* (notably 0-0) have already been handled] */
3929
3930	/* calculate the padding needed to align the operands */
3931	padding=rhs->exponent-lhs->exponent;
3932
3933	/* Fastpath cases where the numbers are aligned and normal, the RHS */
3934	/* is all in one unit, no operand rounding is needed, and no carry, */
3935	/* lengthening, or borrow is needed */
3936	if (padding==0
3937	&& rhs->digits<=DECDPUN
3938	&& rhs->exponent>=set->emin /* [some normals drop through] */
3939	&& rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
3940	&& rhs->digits<=reqdigits
3941	&& lhs->digits<=reqdigits) {
3942	Int partial=*lhs->lsu;
3943	if (!diffsign) { /* adding */
3944	partial+=*rhs->lsu;
3945	if ((partial<=DECDPUNMAX) /* result fits in unit */
3946	&& (lhs->digits>=DECDPUN || /* .. and no digits-count change */
3947	partial<(Int)powers[lhs->digits])) { /* .. */
3948	if (res!=lhs) decNumberCopy(dest: res, src: lhs); /* not in place */
3949	*res->lsu=(Unit)partial; /* [copy could have overwritten RHS] */
3950	break;
3951	}
3952	/* else drop out for careful add */
3953	}
3954	else { /* signs differ */
3955	partial-=*rhs->lsu;
3956	if (partial>0) { /* no borrow needed, and non-0 result */
3957	if (res!=lhs) decNumberCopy(dest: res, src: lhs); /* not in place */
3958	*res->lsu=(Unit)partial;
3959	/* this could have reduced digits [but result>0] */
3960	res->digits=decGetDigits(res->lsu, D2U(res->digits));
3961	break;
3962	}
3963	/* else drop out for careful subtract */
3964	}
3965	}
3966
3967	/* Now align (pad) the lhs or rhs so they can be added or */
3968	/* subtracted, as necessary. If one number is much larger than */
3969	/* the other (that is, if in plain form there is a least one */
3970	/* digit between the lowest digit of one and the highest of the */
3971	/* other) padding with up to DIGITS-1 trailing zeros may be */
3972	/* needed; then apply rounding (as exotic rounding modes may be */
3973	/* affected by the residue). */
3974	rhsshift=0; /* rhs shift to left (padding) in Units */
3975	bits=lhs->bits; /* assume sign is that of LHS */
3976	mult=1; /* likely multiplier */
3977
3978	/* [if padding==0 the operands are aligned; no padding is needed] */
3979	if (padding!=0) {
3980	/* some padding needed; always pad the RHS, as any required */
3981	/* padding can then be effected by a simple combination of */
3982	/* shifts and a multiply */
3983	Flag swapped=0;
3984	if (padding<0) { /* LHS needs the padding */
3985	const decNumber *t;
3986	padding=-padding; /* will be +ve */
3987	bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
3988	t=lhs; lhs=rhs; rhs=t;
3989	swapped=1;
3990	}
3991
3992	/* If, after pad, rhs would be longer than lhs by digits+1 or */
3993	/* more then lhs cannot affect the answer, except as a residue, */
3994	/* so only need to pad up to a length of DIGITS+1. */
3995	if (rhs->digits+padding > lhs->digits+reqdigits+1) {
3996	/* The RHS is sufficient */
3997	/* for residue use the relative sign indication... */
3998	Int shift=reqdigits-rhs->digits; /* left shift needed */
3999	residue=1; /* residue for rounding */
4000	if (diffsign) residue=-residue; /* signs differ */
4001	/* copy, shortening if necessary */
4002	decCopyFit(res, rhs, set, &residue, status);
4003	/* if it was already shorter, then need to pad with zeros */
4004	if (shift>0) {
4005	res->digits=decShiftToMost(res->lsu, res->digits, shift);
4006	res->exponent-=shift; /* adjust the exponent. */
4007	}
4008	/* flip the result sign if unswapped and rhs was negated */
4009	if (!swapped) res->bits^=negate;
4010	decFinish(res, set, &residue, status); /* done */
4011	break;}
4012
4013	/* LHS digits may affect result */
4014	rhsshift=D2U(padding+1)-1; /* this much by Unit shift .. */
4015	mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4016	} /* padding needed */
4017
4018	if (diffsign) mult=-mult; /* signs differ */
4019
4020	/* determine the longer operand */
4021	maxdigits=rhs->digits+padding; /* virtual length of RHS */
4022	if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4023
4024	/* Decide on the result buffer to use; if possible place directly */
4025	/* into result. */
4026	acc=res->lsu; /* assume add direct to result */
4027	/* If destructive overlap, or the number is too long, or a carry or */
4028	/* borrow to DIGITS+1 might be possible, a buffer must be used. */
4029	/* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4030	if ((maxdigits>=reqdigits) /* is, or could be, too large */
4031	|| (res==rhs && rhsshift>0)) { /* destructive overlap */
4032	/* buffer needed, choose it; units for maxdigits digits will be */
4033	/* needed, +1 Unit for carry or borrow */
4034	Int need=D2U(maxdigits)+1;
4035	acc=accbuff; /* assume use local buffer */
4036	if (need*sizeof(Unit)>sizeof(accbuff)) {
4037	/* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4038	allocacc=(Unit *)malloc(size: need*sizeof(Unit));
4039	if (allocacc==NULL) { /* hopeless -- abandon */
4040	*status|=DEC_Insufficient_storage;
4041	break;}
4042	acc=allocacc;
4043	}
4044	}
4045
4046	res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */
4047	res->exponent=lhs->exponent; /* .. operands (even if aliased) */
4048
4049	#if DECTRACE
4050	decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4051	decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4052	printf(" :h: %ld %ld\n", rhsshift, mult);
4053	#endif
4054
4055	/* add [A+B*m] or subtract [A+B*(-m)] */
4056	res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4057	rhs->lsu, D2U(rhs->digits),
4058	rhsshift, acc, mult)
4059	*DECDPUN; /* [units -> digits] */
4060	if (res->digits<0) { /* borrowed... */
4061	res->digits=-res->digits;
4062	res->bits^=DECNEG; /* flip the sign */
4063	}
4064	#if DECTRACE
4065	decDumpAr('+', acc, D2U(res->digits));
4066	#endif
4067
4068	/* If a buffer was used the result must be copied back, possibly */
4069	/* shortening. (If no buffer was used then the result must have */
4070	/* fit, so can't need rounding and residue must be 0.) */
4071	residue=0; /* clear accumulator */
4072	if (acc!=res->lsu) {
4073	#if DECSUBSET
4074	if (set->extended) { /* round from first significant digit */
4075	#endif
4076	/* remove leading zeros that were added due to rounding up to */
4077	/* integral Units -- before the test for rounding. */
4078	if (res->digits>reqdigits)
4079	res->digits=decGetDigits(acc, D2U(res->digits));
4080	decSetCoeff(res, set, acc, res->digits, &residue, status);
4081	#if DECSUBSET
4082	}
4083	else { /* subset arithmetic rounds from original significant digit */
4084	/* May have an underestimate. This only occurs when both */
4085	/* numbers fit in DECDPUN digits and are padding with a */
4086	/* negative multiple (-10, -100...) and the top digit(s) become */
4087	/* 0. (This only matters when using X3.274 rules where the */
4088	/* leading zero could be included in the rounding.) */
4089	if (res->digits<maxdigits) {
4090	*(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4091	res->digits=maxdigits;
4092	}
4093	else {
4094	/* remove leading zeros that added due to rounding up to */
4095	/* integral Units (but only those in excess of the original */
4096	/* maxdigits length, unless extended) before test for rounding. */
4097	if (res->digits>reqdigits) {
4098	res->digits=decGetDigits(acc, D2U(res->digits));
4099	if (res->digits<maxdigits) res->digits=maxdigits;
4100	}
4101	}
4102	decSetCoeff(res, set, acc, res->digits, &residue, status);
4103	/* Now apply rounding if needed before removing leading zeros. */
4104	/* This is safe because subnormals are not a possibility */
4105	if (residue!=0) {
4106	decApplyRound(res, set, residue, status);
4107	residue=0; /* did what needed to be done */
4108	}
4109	} /* subset */
4110	#endif
4111	} /* used buffer */
4112
4113	/* strip leading zeros [these were left on in case of subset subtract] */
4114	res->digits=decGetDigits(res->lsu, D2U(res->digits));
4115
4116	/* apply checks and rounding */
4117	decFinish(res, set, &residue, status);
4118
4119	/* "When the sum of two operands with opposite signs is exactly */
4120	/* zero, the sign of that sum shall be '+' in all rounding modes */
4121	/* except round toward -Infinity, in which mode that sign shall be */
4122	/* '-'." [Subset zeros also never have '-', set by decFinish.] */
4123	if (ISZERO(res) && diffsign
4124	#if DECSUBSET
4125	&& set->extended
4126	#endif
4127	&& (*status&DEC_Inexact)==0) {
4128	if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */
4129	else res->bits&=~DECNEG; /* sign + */
4130	}
4131	} while(0); /* end protected */
4132
4133	free(ptr: allocacc); /* drop any storage used */
4134	#if DECSUBSET
4135	free(allocrhs); /* .. */
4136	free(alloclhs); /* .. */
4137	#endif
4138	return res;
4139	} /* decAddOp */
4140
4141	/* ------------------------------------------------------------------ */
4142	/* decDivideOp -- division operation */
4143	/* */
4144	/* This routine performs the calculations for all four division */
4145	/* operators (divide, divideInteger, remainder, remainderNear). */
4146	/* */
4147	/* C=A op B */
4148	/* */
4149	/* res is C, the result. C may be A and/or B (e.g., X=X/X) */
4150	/* lhs is A */
4151	/* rhs is B */
4152	/* set is the context */
4153	/* op is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively. */
4154	/* status is the usual accumulator */
4155	/* */
4156	/* C must have space for set->digits digits. */
4157	/* */
4158	/* ------------------------------------------------------------------ */
4159	/* The underlying algorithm of this routine is the same as in the */
4160	/* 1981 S/370 implementation, that is, non-restoring long division */
4161	/* with bi-unit (rather than bi-digit) estimation for each unit */
4162	/* multiplier. In this pseudocode overview, complications for the */
4163	/* Remainder operators and division residues for exact rounding are */
4164	/* omitted for clarity. */
4165	/* */
4166	/* Prepare operands and handle special values */
4167	/* Test for x/0 and then 0/x */
4168	/* Exp =Exp1 - Exp2 */
4169	/* Exp =Exp +len(var1) -len(var2) */
4170	/* Sign=Sign1 * Sign2 */
4171	/* Pad accumulator (Var1) to double-length with 0's (pad1) */
4172	/* Pad Var2 to same length as Var1 */
4173	/* msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round */
4174	/* have=0 */
4175	/* Do until (have=digits+1 OR residue=0) */
4176	/* if exp<0 then if integer divide/residue then leave */
4177	/* this_unit=0 */
4178	/* Do forever */
4179	/* compare numbers */
4180	/* if <0 then leave inner_loop */
4181	/* if =0 then (* quick exit without subtract *) do */
4182	/* this_unit=this_unit+1; output this_unit */
4183	/* leave outer_loop; end */
4184	/* Compare lengths of numbers (mantissae): */
4185	/* If same then tops2=msu2pair -- {units 1&2 of var2} */
4186	/* else tops2=msu2plus -- {0, unit 1 of var2} */
4187	/* tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4188	/* mult=tops1/tops2 -- Good and safe guess at divisor */
4189	/* if mult=0 then mult=1 */
4190	/* this_unit=this_unit+mult */
4191	/* subtract */
4192	/* end inner_loop */
4193	/* if have\=0 | this_unit\=0 then do */
4194	/* output this_unit */
4195	/* have=have+1; end */
4196	/* var2=var2/10 */
4197	/* exp=exp-1 */
4198	/* end outer_loop */
4199	/* exp=exp+1 -- set the proper exponent */
4200	/* if have=0 then generate answer=0 */
4201	/* Return (Result is defined by Var1) */
4202	/* */
4203	/* ------------------------------------------------------------------ */
4204	/* Two working buffers are needed during the division; one (digits+ */
4205	/* 1) to accumulate the result, and the other (up to 2*digits+1) for */
4206	/* long subtractions. These are acc and var1 respectively. */
4207	/* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4208	/* The static buffers may be larger than might be expected to allow */
4209	/* for calls from higher-level funtions (notable exp). */
4210	/* ------------------------------------------------------------------ */
4211	static decNumber * decDivideOp(decNumber *res,
4212	const decNumber *lhs, const decNumber *rhs,
4213	decContext *set, Flag op, uInt *status) {
4214	#if DECSUBSET
4215	decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
4216	decNumber *allocrhs=NULL; /* .., rhs */
4217	#endif
4218	Unit accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4219	Unit *acc=accbuff; /* -> accumulator array for result */
4220	Unit *allocacc=NULL; /* -> allocated buffer, iff allocated */
4221	Unit *accnext; /* -> where next digit will go */
4222	Int acclength; /* length of acc needed [Units] */
4223	Int accunits; /* count of units accumulated */
4224	Int accdigits; /* count of digits accumulated */
4225
4226	Unit varbuff[SD2U(DECBUFFER*2+DECDPUN)]; /* buffer for var1 */
4227	Unit *var1=varbuff; /* -> var1 array for long subtraction */
4228	Unit *varalloc=NULL; /* -> allocated buffer, iff used */
4229	Unit *msu1; /* -> msu of var1 */
4230
4231	const Unit *var2; /* -> var2 array */
4232	const Unit *msu2; /* -> msu of var2 */
4233	Int msu2plus; /* msu2 plus one [does not vary] */
4234	eInt msu2pair; /* msu2 pair plus one [does not vary] */
4235
4236	Int var1units, var2units; /* actual lengths */
4237	Int var2ulen; /* logical length (units) */
4238	Int var1initpad=0; /* var1 initial padding (digits) */
4239	Int maxdigits; /* longest LHS or required acc length */
4240	Int mult; /* multiplier for subtraction */
4241	Unit thisunit; /* current unit being accumulated */
4242	Int residue; /* for rounding */
4243	Int reqdigits=set->digits; /* requested DIGITS */
4244	Int exponent; /* working exponent */
4245	Int maxexponent=0; /* DIVIDE maximum exponent if unrounded */
4246	uByte bits; /* working sign */
4247	Unit *target; /* work */
4248	const Unit *source; /* .. */
4249	uInt const *pow; /* .. */
4250	Int shift, cut; /* .. */
4251	#if DECSUBSET
4252	Int dropped; /* work */
4253	#endif
4254
4255	#if DECCHECK
4256	if (decCheckOperands(res, lhs, rhs, set)) return res;
4257	#endif
4258
4259	do { /* protect allocated storage */
4260	#if DECSUBSET
4261	if (!set->extended) {
4262	/* reduce operands and set lostDigits status, as needed */
4263	if (lhs->digits>reqdigits) {
4264	alloclhs=decRoundOperand(lhs, set, status);
4265	if (alloclhs==NULL) break;
4266	lhs=alloclhs;
4267	}
4268	if (rhs->digits>reqdigits) {
4269	allocrhs=decRoundOperand(rhs, set, status);
4270	if (allocrhs==NULL) break;
4271	rhs=allocrhs;
4272	}
4273	}
4274	#endif
4275	/* [following code does not require input rounding] */
4276
4277	bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */
4278
4279	/* handle infinities and NaNs */
4280	if (SPECIALARGS) { /* a special bit set */
4281	if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4282	decNaNs(res, lhs, rhs, set, status);
4283	break;
4284	}
4285	/* one or two infinities */
4286	if (decNumberIsInfinite(lhs)) { /* LHS (dividend) is infinite */
4287	if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4288	op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4289	*status|=DEC_Invalid_operation;
4290	break;
4291	}
4292	/* [Note that infinity/0 raises no exceptions] */
4293	decNumberZero(dn: res);
4294	res->bits=bits|DECINF; /* set +/- infinity */
4295	break;
4296	}
4297	else { /* RHS (divisor) is infinite */
4298	residue=0;
4299	if (op&(REMAINDER|REMNEAR)) {
4300	/* result is [finished clone of] lhs */
4301	decCopyFit(res, lhs, set, &residue, status);
4302	}
4303	else { /* a division */
4304	decNumberZero(dn: res);
4305	res->bits=bits; /* set +/- zero */
4306	/* for DIVIDEINT the exponent is always 0. For DIVIDE, result */
4307	/* is a 0 with infinitely negative exponent, clamped to minimum */
4308	if (op&DIVIDE) {
4309	res->exponent=set->emin-set->digits+1;
4310	*status|=DEC_Clamped;
4311	}
4312	}
4313	decFinish(res, set, &residue, status);
4314	break;
4315	}
4316	}
4317
4318	/* handle 0 rhs (x/0) */
4319	if (ISZERO(rhs)) { /* x/0 is always exceptional */
4320	if (ISZERO(lhs)) {
4321	decNumberZero(dn: res); /* [after lhs test] */
4322	*status|=DEC_Division_undefined;/* 0/0 will become NaN */
4323	}
4324	else {
4325	decNumberZero(dn: res);
4326	if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4327	else {
4328	*status|=DEC_Division_by_zero; /* x/0 */
4329	res->bits=bits|DECINF; /* .. is +/- Infinity */
4330	}
4331	}
4332	break;}
4333
4334	/* handle 0 lhs (0/x) */
4335	if (ISZERO(lhs)) { /* 0/x [x!=0] */
4336	#if DECSUBSET
4337	if (!set->extended) decNumberZero(res);
4338	else {
4339	#endif
4340	if (op&DIVIDE) {
4341	residue=0;
4342	exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4343	decNumberCopy(dest: res, src: lhs); /* [zeros always fit] */
4344	res->bits=bits; /* sign as computed */
4345	res->exponent=exponent; /* exponent, too */
4346	decFinalize(res, set, &residue, status); /* check exponent */
4347	}
4348	else if (op&DIVIDEINT) {
4349	decNumberZero(dn: res); /* integer 0 */
4350	res->bits=bits; /* sign as computed */
4351	}
4352	else { /* a remainder */
4353	exponent=rhs->exponent; /* [save in case overwrite] */
4354	decNumberCopy(dest: res, src: lhs); /* [zeros always fit] */
4355	if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4356	}
4357	#if DECSUBSET
4358	}
4359	#endif
4360	break;}
4361
4362	/* Precalculate exponent. This starts off adjusted (and hence fits */
4363	/* in 31 bits) and becomes the usual unadjusted exponent as the */
4364	/* division proceeds. The order of evaluation is important, here, */
4365	/* to avoid wrap. */
4366	exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4367
4368	/* If the working exponent is -ve, then some quick exits are */
4369	/* possible because the quotient is known to be <1 */
4370	/* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4371	if (exponent<0 && !(op==DIVIDE)) {
4372	if (op&DIVIDEINT) {
4373	decNumberZero(dn: res); /* integer part is 0 */
4374	#if DECSUBSET
4375	if (set->extended)
4376	#endif
4377	res->bits=bits; /* set +/- zero */
4378	break;}
4379	/* fastpath remainders so long as the lhs has the smaller */
4380	/* (or equal) exponent */
4381	if (lhs->exponent<=rhs->exponent) {
4382	if (op&REMAINDER || exponent<-1) {
4383	/* It is REMAINDER or safe REMNEAR; result is [finished */
4384	/* clone of] lhs (r = x - 0*y) */
4385	residue=0;
4386	decCopyFit(res, lhs, set, &residue, status);
4387	decFinish(res, set, &residue, status);
4388	break;
4389	}
4390	/* [unsafe REMNEAR drops through] */
4391	}
4392	} /* fastpaths */
4393
4394	/* Long (slow) division is needed; roll up the sleeves... */
4395
4396	/* The accumulator will hold the quotient of the division. */
4397	/* If it needs to be too long for stack storage, then allocate. */
4398	acclength=D2U(reqdigits+DECDPUN); /* in Units */
4399	if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4400	/* printf("malloc dvacc %ld units\n", acclength); */
4401	allocacc=(Unit *)malloc(size: acclength*sizeof(Unit));
4402	if (allocacc==NULL) { /* hopeless -- abandon */
4403	*status|=DEC_Insufficient_storage;
4404	break;}
4405	acc=allocacc; /* use the allocated space */
4406	}
4407
4408	/* var1 is the padded LHS ready for subtractions. */
4409	/* If it needs to be too long for stack storage, then allocate. */
4410	/* The maximum units needed for var1 (long subtraction) is: */
4411	/* Enough for */
4412	/* (rhs->digits+reqdigits-1) -- to allow full slide to right */
4413	/* or (lhs->digits) -- to allow for long lhs */
4414	/* whichever is larger */
4415	/* +1 -- for rounding of slide to right */
4416	/* +1 -- for leading 0s */
4417	/* +1 -- for pre-adjust if a remainder or DIVIDEINT */
4418	/* [Note: unused units do not participate in decUnitAddSub data] */
4419	maxdigits=rhs->digits+reqdigits-1;
4420	if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4421	var1units=D2U(maxdigits)+2;
4422	/* allocate a guard unit above msu1 for REMAINDERNEAR */
4423	if (!(op&DIVIDE)) var1units++;
4424	if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4425	/* printf("malloc dvvar %ld units\n", var1units+1); */
4426	varalloc=(Unit *)malloc(size: (var1units+1)*sizeof(Unit));
4427	if (varalloc==NULL) { /* hopeless -- abandon */
4428	*status|=DEC_Insufficient_storage;
4429	break;}
4430	var1=varalloc; /* use the allocated space */
4431	}
4432
4433	/* Extend the lhs and rhs to full long subtraction length. The lhs */
4434	/* is truly extended into the var1 buffer, with 0 padding, so a */
4435	/* subtract in place is always possible. The rhs (var2) has */
4436	/* virtual padding (implemented by decUnitAddSub). */
4437	/* One guard unit was allocated above msu1 for rem=rem+rem in */
4438	/* REMAINDERNEAR. */
4439	msu1=var1+var1units-1; /* msu of var1 */
4440	source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4441	for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4442	for (; target>=var1; target--) *target=0;
4443
4444	/* rhs (var2) is left-aligned with var1 at the start */
4445	var2ulen=var1units; /* rhs logical length (units) */
4446	var2units=D2U(rhs->digits); /* rhs actual length (units) */
4447	var2=rhs->lsu; /* -> rhs array */
4448	msu2=var2+var2units-1; /* -> msu of var2 [never changes] */
4449	/* now set up the variables which will be used for estimating the */
4450	/* multiplication factor. If these variables are not exact, add */
4451	/* 1 to make sure that the multiplier is never overestimated. */
4452	msu2plus=*msu2; /* it's value .. */
4453	if (var2units>1) msu2plus++; /* .. +1 if any more */
4454	msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4455	if (var2units>1) { /* .. [else treat 2nd as 0] */
4456	msu2pair+=*(msu2-1); /* .. */
4457	if (var2units>2) msu2pair++; /* .. +1 if any more */
4458	}
4459
4460	/* The calculation is working in units, which may have leading zeros, */
4461	/* but the exponent was calculated on the assumption that they are */
4462	/* both left-aligned. Adjust the exponent to compensate: add the */
4463	/* number of leading zeros in var1 msu and subtract those in var2 msu. */
4464	/* [This is actually done by counting the digits and negating, as */
4465	/* lead1=DECDPUN-digits1, and similarly for lead2.] */
4466	for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4467	for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4468
4469	/* Now, if doing an integer divide or remainder, ensure that */
4470	/* the result will be Unit-aligned. To do this, shift the var1 */
4471	/* accumulator towards least if need be. (It's much easier to */
4472	/* do this now than to reassemble the residue afterwards, if */
4473	/* doing a remainder.) Also ensure the exponent is not negative. */
4474	if (!(op&DIVIDE)) {
4475	Unit *u; /* work */
4476	/* save the initial 'false' padding of var1, in digits */
4477	var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4478	/* Determine the shift to do. */
4479	if (exponent<0) cut=-exponent;
4480	else cut=DECDPUN-exponent%DECDPUN;
4481	decShiftToLeast(var1, var1units, cut);
4482	exponent+=cut; /* maintain numerical value */
4483	var1initpad-=cut; /* .. and reduce padding */
4484	/* clean any most-significant units which were just emptied */
4485	for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4486	} /* align */
4487	else { /* is DIVIDE */
4488	maxexponent=lhs->exponent-rhs->exponent; /* save */
4489	/* optimization: if the first iteration will just produce 0, */
4490	/* preadjust to skip it [valid for DIVIDE only] */
4491	if (*msu1<*msu2) {
4492	var2ulen--; /* shift down */
4493	exponent-=DECDPUN; /* update the exponent */
4494	}
4495	}
4496
4497	/* ---- start the long-division loops ------------------------------ */
4498	accunits=0; /* no units accumulated yet */
4499	accdigits=0; /* .. or digits */
4500	accnext=acc+acclength-1; /* -> msu of acc [NB: allows digits+1] */
4501	for (;;) { /* outer forever loop */
4502	thisunit=0; /* current unit assumed 0 */
4503	/* find the next unit */
4504	for (;;) { /* inner forever loop */
4505	/* strip leading zero units [from either pre-adjust or from */
4506	/* subtract last time around]. Leave at least one unit. */
4507	for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4508
4509	if (var1units<var2ulen) break; /* var1 too low for subtract */
4510	if (var1units==var2ulen) { /* unit-by-unit compare needed */
4511	/* compare the two numbers, from msu */
4512	const Unit *pv1, *pv2;
4513	Unit v2; /* units to compare */
4514	pv2=msu2; /* -> msu */
4515	for (pv1=msu1; ; pv1--, pv2--) {
4516	/* v1=*pv1 -- always OK */
4517	v2=0; /* assume in padding */
4518	if (pv2>=var2) v2=*pv2; /* in range */
4519	if (*pv1!=v2) break; /* no longer the same */
4520	if (pv1==var1) break; /* done; leave pv1 as is */
4521	}
4522	/* here when all inspected or a difference seen */
4523	if (*pv1<v2) break; /* var1 too low to subtract */
4524	if (*pv1==v2) { /* var1 == var2 */
4525	/* reach here if var1 and var2 are identical; subtraction */
4526	/* would increase digit by one, and the residue will be 0 so */
4527	/* the calculation is done; leave the loop with residue=0. */
4528	thisunit++; /* as though subtracted */
4529	*var1=0; /* set var1 to 0 */
4530	var1units=1; /* .. */
4531	break; /* from inner */
4532	} /* var1 == var2 */
4533	/* *pv1>v2. Prepare for real subtraction; the lengths are equal */
4534	/* Estimate the multiplier (there's always a msu1-1)... */
4535	/* Bring in two units of var2 to provide a good estimate. */
4536	mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4537	} /* lengths the same */
4538	else { /* var1units > var2ulen, so subtraction is safe */
4539	/* The var2 msu is one unit towards the lsu of the var1 msu, */
4540	/* so only one unit for var2 can be used. */
4541	mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4542	}
4543	if (mult==0) mult=1; /* must always be at least 1 */
4544	/* subtraction needed; var1 is > var2 */
4545	thisunit=(Unit)(thisunit+mult); /* accumulate */
4546	/* subtract var1-var2, into var1; only the overlap needs */
4547	/* processing, as this is an in-place calculation */
4548	shift=var2ulen-var2units;
4549	#if DECTRACE
4550	decDumpAr('1', &var1[shift], var1units-shift);
4551	decDumpAr('2', var2, var2units);
4552	printf("m=%ld\n", -mult);
4553	#endif
4554	decUnitAddSub(&var1[shift], var1units-shift,
4555	var2, var2units, 0,
4556	&var1[shift], -mult);
4557	#if DECTRACE
4558	decDumpAr('#', &var1[shift], var1units-shift);
4559	#endif
4560	/* var1 now probably has leading zeros; these are removed at the */
4561	/* top of the inner loop. */
4562	} /* inner loop */
4563
4564	/* The next unit has been calculated in full; unless it's a */
4565	/* leading zero, add to acc */
4566	if (accunits!=0 || thisunit!=0) { /* is first or non-zero */
4567	*accnext=thisunit; /* store in accumulator */
4568	/* account exactly for the new digits */
4569	if (accunits==0) {
4570	accdigits++; /* at least one */
4571	for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4572	}
4573	else accdigits+=DECDPUN;
4574	accunits++; /* update count */
4575	accnext--; /* ready for next */
4576	if (accdigits>reqdigits) break; /* have enough digits */
4577	}
4578
4579	/* if the residue is zero, the operation is done (unless divide */
4580	/* or divideInteger and still not enough digits yet) */
4581	if (*var1==0 && var1units==1) { /* residue is 0 */
4582	if (op&(REMAINDER|REMNEAR)) break;
4583	if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4584	/* [drop through if divideInteger] */
4585	}
4586	/* also done enough if calculating remainder or integer */
4587	/* divide and just did the last ('units') unit */
4588	if (exponent==0 && !(op&DIVIDE)) break;
4589
4590	/* to get here, var1 is less than var2, so divide var2 by the per- */
4591	/* Unit power of ten and go for the next digit */
4592	var2ulen--; /* shift down */
4593	exponent-=DECDPUN; /* update the exponent */
4594	} /* outer loop */
4595
4596	/* ---- division is complete --------------------------------------- */
4597	/* here: acc has at least reqdigits+1 of good results (or fewer */
4598	/* if early stop), starting at accnext+1 (its lsu) */
4599	/* var1 has any residue at the stopping point */
4600	/* accunits is the number of digits collected in acc */
4601	if (accunits==0) { /* acc is 0 */
4602	accunits=1; /* show have a unit .. */
4603	accdigits=1; /* .. */
4604	*accnext=0; /* .. whose value is 0 */
4605	}
4606	else accnext++; /* back to last placed */
4607	/* accnext now -> lowest unit of result */
4608
4609	residue=0; /* assume no residue */
4610	if (op&DIVIDE) {
4611	/* record the presence of any residue, for rounding */
4612	if (*var1!=0 || var1units>1) residue=1;
4613	else { /* no residue */
4614	/* Had an exact division; clean up spurious trailing 0s. */
4615	/* There will be at most DECDPUN-1, from the final multiply, */
4616	/* and then only if the result is non-0 (and even) and the */
4617	/* exponent is 'loose'. */
4618	#if DECDPUN>1
4619	Unit lsu=*accnext;
4620	if (!(lsu&0x01) && (lsu!=0)) {
4621	/* count the trailing zeros */
4622	Int drop=0;
4623	for (;; drop++) { /* [will terminate because lsu!=0] */
4624	if (exponent>=maxexponent) break; /* don't chop real 0s */
4625	#if DECDPUN<=4
4626	if ((lsu-QUOT10(lsu, drop+1)
4627	*powers[drop+1])!=0) break; /* found non-0 digit */
4628	#else
4629	if (lsu%powers[drop+1]!=0) break; /* found non-0 digit */
4630	#endif
4631	exponent++;
4632	}
4633	if (drop>0) {
4634	accunits=decShiftToLeast(accnext, accunits, drop);
4635	accdigits=decGetDigits(accnext, accunits);
4636	accunits=D2U(accdigits);
4637	/* [exponent was adjusted in the loop] */
4638	}
4639	} /* neither odd nor 0 */
4640	#endif
4641	} /* exact divide */
4642	} /* divide */
4643	else /* op!=DIVIDE */ {
4644	/* check for coefficient overflow */
4645	if (accdigits+exponent>reqdigits) {
4646	*status|=DEC_Division_impossible;
4647	break;
4648	}
4649	if (op & (REMAINDER|REMNEAR)) {
4650	/* [Here, the exponent will be 0, because var1 was adjusted */
4651	/* appropriately.] */
4652	Int postshift; /* work */
4653	Flag wasodd=0; /* integer was odd */
4654	Unit *quotlsu; /* for save */
4655	Int quotdigits; /* .. */
4656
4657	bits=lhs->bits; /* remainder sign is always as lhs */
4658
4659	/* Fastpath when residue is truly 0 is worthwhile [and */
4660	/* simplifies the code below] */
4661	if (*var1==0 && var1units==1) { /* residue is 0 */
4662	Int exp=lhs->exponent; /* save min(exponents) */
4663	if (rhs->exponent<exp) exp=rhs->exponent;
4664	decNumberZero(dn: res); /* 0 coefficient */
4665	#if DECSUBSET
4666	if (set->extended)
4667	#endif
4668	res->exponent=exp; /* .. with proper exponent */
4669	res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4670	decFinish(res, set, &residue, status); /* might clamp */
4671	break;
4672	}
4673	/* note if the quotient was odd */
4674	if (*accnext & 0x01) wasodd=1; /* acc is odd */
4675	quotlsu=accnext; /* save in case need to reinspect */
4676	quotdigits=accdigits; /* .. */
4677
4678	/* treat the residue, in var1, as the value to return, via acc */
4679	/* calculate the unused zero digits. This is the smaller of: */
4680	/* var1 initial padding (saved above) */
4681	/* var2 residual padding, which happens to be given by: */
4682	postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4683	/* [the 'exponent' term accounts for the shifts during divide] */
4684	if (var1initpad<postshift) postshift=var1initpad;
4685
4686	/* shift var1 the requested amount, and adjust its digits */
4687	var1units=decShiftToLeast(var1, var1units, postshift);
4688	accnext=var1;
4689	accdigits=decGetDigits(var1, var1units);
4690	accunits=D2U(accdigits);
4691
4692	exponent=lhs->exponent; /* exponent is smaller of lhs & rhs */
4693	if (rhs->exponent<exponent) exponent=rhs->exponent;
4694
4695	/* Now correct the result if doing remainderNear; if it */
4696	/* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4697	/* the integer was odd then the result should be rem-rhs. */
4698	if (op&REMNEAR) {
4699	Int compare, tarunits; /* work */
4700	Unit *up; /* .. */
4701	/* calculate remainder*2 into the var1 buffer (which has */
4702	/* 'headroom' of an extra unit and hence enough space) */
4703	/* [a dedicated 'double' loop would be faster, here] */
4704	tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4705	0, accnext, 1);
4706	/* decDumpAr('r', accnext, tarunits); */
4707
4708	/* Here, accnext (var1) holds tarunits Units with twice the */
4709	/* remainder's coefficient, which must now be compared to the */
4710	/* RHS. The remainder's exponent may be smaller than the RHS's. */
4711	compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4712	rhs->exponent-exponent);
4713	if (compare==BADINT) { /* deep trouble */
4714	*status|=DEC_Insufficient_storage;
4715	break;}
4716
4717	/* now restore the remainder by dividing by two; the lsu */
4718	/* is known to be even. */
4719	for (up=accnext; up<accnext+tarunits; up++) {
4720	Int half; /* half to add to lower unit */
4721	half=*up & 0x01;
4722	*up/=2; /* [shift] */
4723	if (!half) continue;
4724	*(up-1)+=(DECDPUNMAX+1)/2;
4725	}
4726	/* [accunits still describes the original remainder length] */
4727
4728	if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4729	Int exp, expunits, exprem; /* work */
4730	/* This is effectively causing round-up of the quotient, */
4731	/* so if it was the rare case where it was full and all */
4732	/* nines, it would overflow and hence division-impossible */
4733	/* should be raised */
4734	Flag allnines=0; /* 1 if quotient all nines */
4735	if (quotdigits==reqdigits) { /* could be borderline */
4736	for (up=quotlsu; ; up++) {
4737	if (quotdigits>DECDPUN) {
4738	if (*up!=DECDPUNMAX) break;/* non-nines */
4739	}
4740	else { /* this is the last Unit */
4741	if (*up==powers[quotdigits]-1) allnines=1;
4742	break;
4743	}
4744	quotdigits-=DECDPUN; /* checked those digits */
4745	} /* up */
4746	} /* borderline check */
4747	if (allnines) {
4748	*status|=DEC_Division_impossible;
4749	break;}
4750
4751	/* rem-rhs is needed; the sign will invert. Again, var1 */
4752	/* can safely be used for the working Units array. */
4753	exp=rhs->exponent-exponent; /* RHS padding needed */
4754	/* Calculate units and remainder from exponent. */
4755	expunits=exp/DECDPUN;
4756	exprem=exp%DECDPUN;
4757	/* subtract [A+B*(-m)]; the result will always be negative */
4758	accunits=-decUnitAddSub(accnext, accunits,
4759	rhs->lsu, D2U(rhs->digits),
4760	expunits, accnext, -(Int)powers[exprem]);
4761	accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4762	accunits=D2U(accdigits); /* and recalculate the units for copy */
4763	/* [exponent is as for original remainder] */
4764	bits^=DECNEG; /* flip the sign */
4765	}
4766	} /* REMNEAR */
4767	} /* REMAINDER or REMNEAR */
4768	} /* not DIVIDE */
4769
4770	/* Set exponent and bits */
4771	res->exponent=exponent;
4772	res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4773
4774	/* Now the coefficient. */
4775	decSetCoeff(res, set, accnext, accdigits, &residue, status);
4776
4777	decFinish(res, set, &residue, status); /* final cleanup */
4778
4779	#if DECSUBSET
4780	/* If a divide then strip trailing zeros if subset [after round] */
4781	if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, 1, &dropped);
4782	#endif
4783	} while(0); /* end protected */
4784
4785	free(ptr: varalloc); /* drop any storage used */
4786	free(ptr: allocacc); /* .. */
4787	#if DECSUBSET
4788	free(allocrhs); /* .. */
4789	free(alloclhs); /* .. */
4790	#endif
4791	return res;
4792	} /* decDivideOp */
4793
4794	/* ------------------------------------------------------------------ */
4795	/* decMultiplyOp -- multiplication operation */
4796	/* */
4797	/* This routine performs the multiplication C=A x B. */
4798	/* */
4799	/* res is C, the result. C may be A and/or B (e.g., X=X*X) */
4800	/* lhs is A */
4801	/* rhs is B */
4802	/* set is the context */
4803	/* status is the usual accumulator */
4804	/* */
4805	/* C must have space for set->digits digits. */
4806	/* */
4807	/* ------------------------------------------------------------------ */
4808	/* 'Classic' multiplication is used rather than Karatsuba, as the */
4809	/* latter would give only a minor improvement for the short numbers */
4810	/* expected to be handled most (and uses much more memory). */
4811	/* */
4812	/* There are two major paths here: the general-purpose ('old code') */
4813	/* path which handles all DECDPUN values, and a fastpath version */
4814	/* which is used if 64-bit ints are available, DECDPUN<=4, and more */
4815	/* than two calls to decUnitAddSub would be made. */
4816	/* */
4817	/* The fastpath version lumps units together into 8-digit or 9-digit */
4818	/* chunks, and also uses a lazy carry strategy to minimise expensive */
4819	/* 64-bit divisions. The chunks are then broken apart again into */
4820	/* units for continuing processing. Despite this overhead, the */
4821	/* fastpath can speed up some 16-digit operations by 10x (and much */
4822	/* more for higher-precision calculations). */
4823	/* */
4824	/* A buffer always has to be used for the accumulator; in the */
4825	/* fastpath, buffers are also always needed for the chunked copies of */
4826	/* of the operand coefficients. */
4827	/* Static buffers are larger than needed just for multiply, to allow */
4828	/* for calls from other operations (notably exp). */
4829	/* ------------------------------------------------------------------ */
4830	#define FASTMUL (DECUSE64 && DECDPUN<5)
4831	static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4832	const decNumber *rhs, decContext *set,
4833	uInt *status) {
4834	Int accunits; /* Units of accumulator in use */
4835	Int exponent; /* work */
4836	Int residue=0; /* rounding residue */
4837	uByte bits; /* result sign */
4838	Unit *acc; /* -> accumulator Unit array */
4839	Int needbytes; /* size calculator */
4840	void *allocacc=NULL; /* -> allocated accumulator, iff allocated */
4841	Unit accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4842	/* *4 for calls from other operations) */
4843	const Unit *mer, *mermsup; /* work */
4844	Int madlength; /* Units in multiplicand */
4845	Int shift; /* Units to shift multiplicand by */
4846
4847	#if FASTMUL
4848	/* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
4849	/* (DECDPUN is 2 or 4) then work in base 10**8 */
4850	#if DECDPUN & 1 /* odd */
4851	#define FASTBASE 1000000000 /* base */
4852	#define FASTDIGS 9 /* digits in base */
4853	#define FASTLAZY 18 /* carry resolution point [1->18] */
4854	#else
4855	#define FASTBASE 100000000
4856	#define FASTDIGS 8
4857	#define FASTLAZY 1844 /* carry resolution point [1->1844] */
4858	#endif
4859	/* three buffers are used, two for chunked copies of the operands */
4860	/* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
4861	/* lazy carry evaluation */
4862	uInt zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4863	uInt *zlhi=zlhibuff; /* -> lhs array */
4864	uInt *alloclhi=NULL; /* -> allocated buffer, iff allocated */
4865	uInt zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
4866	uInt *zrhi=zrhibuff; /* -> rhs array */
4867	uInt *allocrhi=NULL; /* -> allocated buffer, iff allocated */
4868	uLong zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
4869	/* [allocacc is shared for both paths, as only one will run] */
4870	uLong *zacc=zaccbuff; /* -> accumulator array for exact result */
4871	#if DECDPUN==1
4872	Int zoff; /* accumulator offset */
4873	#endif
4874	uInt *lip, *rip; /* item pointers */
4875	uInt *lmsi, *rmsi; /* most significant items */
4876	Int ilhs, irhs, iacc; /* item counts in the arrays */
4877	Int lazy; /* lazy carry counter */
4878	uLong lcarry; /* uLong carry */
4879	uInt carry; /* carry (NB not uLong) */
4880	Int count; /* work */
4881	const Unit *cup; /* .. */
4882	Unit *up; /* .. */
4883	uLong *lp; /* .. */
4884	Int p; /* .. */
4885	#endif
4886
4887	#if DECSUBSET
4888	decNumber *alloclhs=NULL; /* -> allocated buffer, iff allocated */
4889	decNumber *allocrhs=NULL; /* -> allocated buffer, iff allocated */
4890	#endif
4891
4892	#if DECCHECK
4893	if (decCheckOperands(res, lhs, rhs, set)) return res;
4894	#endif
4895
4896	/* precalculate result sign */
4897	bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4898
4899	/* handle infinities and NaNs */
4900	if (SPECIALARGS) { /* a special bit set */
4901	if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4902	decNaNs(res, lhs, rhs, set, status);
4903	return res;}
4904	/* one or two infinities; Infinity * 0 is invalid */
4905	if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4906	||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4907	*status|=DEC_Invalid_operation;
4908	return res;}
4909	decNumberZero(dn: res);
4910	res->bits=bits|DECINF; /* infinity */
4911	return res;}
4912
4913	/* For best speed, as in DMSRCN [the original Rexx numerics */
4914	/* module], use the shorter number as the multiplier (rhs) and */
4915	/* the longer as the multiplicand (lhs) to minimise the number of */
4916	/* adds (partial products) */
4917	if (lhs->digits<rhs->digits) { /* swap... */
4918	const decNumber *hold=lhs;
4919	lhs=rhs;
4920	rhs=hold;
4921	}
4922
4923	do { /* protect allocated storage */
4924	#if DECSUBSET
4925	if (!set->extended) {
4926	/* reduce operands and set lostDigits status, as needed */
4927	if (lhs->digits>set->digits) {
4928	alloclhs=decRoundOperand(lhs, set, status);
4929	if (alloclhs==NULL) break;
4930	lhs=alloclhs;
4931	}
4932	if (rhs->digits>set->digits) {
4933	allocrhs=decRoundOperand(rhs, set, status);
4934	if (allocrhs==NULL) break;
4935	rhs=allocrhs;
4936	}
4937	}
4938	#endif
4939	/* [following code does not require input rounding] */
4940
4941	#if FASTMUL /* fastpath can be used */
4942	/* use the fast path if there are enough digits in the shorter */
4943	/* operand to make the setup and takedown worthwhile */
4944	#define NEEDTWO (DECDPUN*2) /* within two decUnitAddSub calls */
4945	if (rhs->digits>NEEDTWO) { /* use fastpath... */
4946	/* calculate the number of elements in each array */
4947	ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
4948	irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
4949	iacc=ilhs+irhs;
4950
4951	/* allocate buffers if required, as usual */
4952	needbytes=ilhs*sizeof(uInt);
4953	if (needbytes>(Int)sizeof(zlhibuff)) {
4954	alloclhi=(uInt *)malloc(size: needbytes);
4955	zlhi=alloclhi;}
4956	needbytes=irhs*sizeof(uInt);
4957	if (needbytes>(Int)sizeof(zrhibuff)) {
4958	allocrhi=(uInt *)malloc(size: needbytes);
4959	zrhi=allocrhi;}
4960
4961	/* Allocating the accumulator space needs a special case when */
4962	/* DECDPUN=1 because when converting the accumulator to Units */
4963	/* after the multiplication each 8-byte item becomes 9 1-byte */
4964	/* units. Therefore iacc extra bytes are needed at the front */
4965	/* (rounded up to a multiple of 8 bytes), and the uLong */
4966	/* accumulator starts offset the appropriate number of units */
4967	/* to the right to avoid overwrite during the unchunking. */
4968	needbytes=iacc*sizeof(uLong);
4969	#if DECDPUN==1
4970	zoff=(iacc+7)/8; /* items to offset by */
4971	needbytes+=zoff*8;
4972	#endif
4973	if (needbytes>(Int)sizeof(zaccbuff)) {
4974	allocacc=(uLong *)malloc(size: needbytes);
4975	zacc=(uLong *)allocacc;}
4976	if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
4977	*status|=DEC_Insufficient_storage;
4978	break;}
4979
4980	acc=(Unit *)zacc; /* -> target Unit array */
4981	#if DECDPUN==1
4982	zacc+=zoff; /* start uLong accumulator to right */
4983	#endif
4984
4985	/* assemble the chunked copies of the left and right sides */
4986	for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
4987	for (p=0, *lip=0; p<FASTDIGS && count>0;
4988	p+=DECDPUN, cup++, count-=DECDPUN)
4989	*lip+=*cup*powers[p];
4990	lmsi=lip-1; /* save -> msi */
4991	for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
4992	for (p=0, *rip=0; p<FASTDIGS && count>0;
4993	p+=DECDPUN, cup++, count-=DECDPUN)
4994	*rip+=*cup*powers[p];
4995	rmsi=rip-1; /* save -> msi */
4996
4997	/* zero the accumulator */
4998	for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
4999
5000	/* Start the multiplication */
5001	/* Resolving carries can dominate the cost of accumulating the */
5002	/* partial products, so this is only done when necessary. */
5003	/* Each uLong item in the accumulator can hold values up to */
5004	/* 2**64-1, and each partial product can be as large as */
5005	/* (10**FASTDIGS-1)**2. When FASTDIGS=9, this can be added to */
5006	/* itself 18.4 times in a uLong without overflowing, so during */
5007	/* the main calculation resolution is carried out every 18th */
5008	/* add -- every 162 digits. Similarly, when FASTDIGS=8, the */
5009	/* partial products can be added to themselves 1844.6 times in */
5010	/* a uLong without overflowing, so intermediate carry */
5011	/* resolution occurs only every 14752 digits. Hence for common */
5012	/* short numbers usually only the one final carry resolution */
5013	/* occurs. */
5014	/* (The count is set via FASTLAZY to simplify experiments to */
5015	/* measure the value of this approach: a 35% improvement on a */
5016	/* [34x34] multiply.) */
5017	lazy=FASTLAZY; /* carry delay count */
5018	for (rip=zrhi; rip<=rmsi; rip++) { /* over each item in rhs */
5019	lp=zacc+(rip-zrhi); /* where to add the lhs */
5020	for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5021	*lp+=(uLong)(*lip)*(*rip); /* [this should in-line] */
5022	} /* lip loop */
5023	lazy--;
5024	if (lazy>0 && rip!=rmsi) continue;
5025	lazy=FASTLAZY; /* reset delay count */
5026	/* spin up the accumulator resolving overflows */
5027	for (lp=zacc; lp<zacc+iacc; lp++) {
5028	if (*lp<FASTBASE) continue; /* it fits */
5029	lcarry=*lp/FASTBASE; /* top part [slow divide] */
5030	/* lcarry can exceed 2**32-1, so check again; this check */
5031	/* and occasional extra divide (slow) is well worth it, as */
5032	/* it allows FASTLAZY to be increased to 18 rather than 4 */
5033	/* in the FASTDIGS=9 case */
5034	if (lcarry<FASTBASE) carry=(uInt)lcarry; /* [usual] */
5035	else { /* two-place carry [fairly rare] */
5036	uInt carry2=(uInt)(lcarry/FASTBASE); /* top top part */
5037	*(lp+2)+=carry2; /* add to item+2 */
5038	*lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5039	carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5040	}
5041	*(lp+1)+=carry; /* add to item above [inline] */
5042	*lp-=((uLong)FASTBASE*carry); /* [inline] */
5043	} /* carry resolution */
5044	} /* rip loop */
5045
5046	/* The multiplication is complete; time to convert back into */
5047	/* units. This can be done in-place in the accumulator and in */
5048	/* 32-bit operations, because carries were resolved after the */
5049	/* final add. This needs N-1 divides and multiplies for */
5050	/* each item in the accumulator (which will become up to N */
5051	/* units, where 2<=N<=9). */
5052	for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5053	uInt item=(uInt)*lp; /* decapitate to uInt */
5054	for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5055	uInt part=item/(DECDPUNMAX+1);
5056	*up=(Unit)(item-(part*(DECDPUNMAX+1)));
5057	item=part;
5058	} /* p */
5059	*up=(Unit)item; up++; /* [final needs no division] */
5060	} /* lp */
5061	accunits=up-acc; /* count of units */
5062	}
5063	else { /* here to use units directly, without chunking ['old code'] */
5064	#endif
5065
5066	/* if accumulator will be too long for local storage, then allocate */
5067	acc=accbuff; /* -> assume buffer for accumulator */
5068	needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5069	if (needbytes>(Int)sizeof(accbuff)) {
5070	allocacc=(Unit *)malloc(size: needbytes);
5071	if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5072	acc=(Unit *)allocacc; /* use the allocated space */
5073	}
5074
5075	/* Now the main long multiplication loop */
5076	/* Unlike the equivalent in the IBM Java implementation, there */
5077	/* is no advantage in calculating from msu to lsu. So, do it */
5078	/* by the book, as it were. */
5079	/* Each iteration calculates ACC=ACC+MULTAND*MULT */
5080	accunits=1; /* accumulator starts at '0' */
5081	*acc=0; /* .. (lsu=0) */
5082	shift=0; /* no multiplicand shift at first */
5083	madlength=D2U(lhs->digits); /* this won't change */
5084	mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5085
5086	for (mer=rhs->lsu; mer<mermsup; mer++) {
5087	/* Here, *mer is the next Unit in the multiplier to use */
5088	/* If non-zero [optimization] add it... */
5089	if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5090	lhs->lsu, madlength, 0,
5091	&acc[shift], *mer)
5092	+ shift;
5093	else { /* extend acc with a 0; it will be used shortly */
5094	*(acc+accunits)=0; /* [this avoids length of <=0 later] */
5095	accunits++;
5096	}
5097	/* multiply multiplicand by 10**DECDPUN for next Unit to left */
5098	shift++; /* add this for 'logical length' */
5099	} /* n */
5100	#if FASTMUL
5101	} /* unchunked units */
5102	#endif
5103	/* common end-path */
5104	#if DECTRACE
5105	decDumpAr('*', acc, accunits); /* Show exact result */
5106	#endif
5107
5108	/* acc now contains the exact result of the multiplication, */
5109	/* possibly with a leading zero unit; build the decNumber from */
5110	/* it, noting if any residue */
5111	res->bits=bits; /* set sign */
5112	res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5113
5114	/* There can be a 31-bit wrap in calculating the exponent. */
5115	/* This can only happen if both input exponents are negative and */
5116	/* both their magnitudes are large. If there was a wrap, set a */
5117	/* safe very negative exponent, from which decFinalize() will */
5118	/* raise a hard underflow shortly. */
5119	exponent=lhs->exponent+rhs->exponent; /* calculate exponent */
5120	if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5121	exponent=-2*DECNUMMAXE; /* force underflow */
5122	res->exponent=exponent; /* OK to overwrite now */
5123
5124
5125	/* Set the coefficient. If any rounding, residue records */
5126	decSetCoeff(res, set, acc, res->digits, &residue, status);
5127	decFinish(res, set, &residue, status); /* final cleanup */
5128	} while(0); /* end protected */
5129
5130	free(ptr: allocacc); /* drop any storage used */
5131	#if DECSUBSET
5132	free(allocrhs); /* .. */
5133	free(alloclhs); /* .. */
5134	#endif
5135	#if FASTMUL
5136	free(ptr: allocrhi); /* .. */
5137	free(ptr: alloclhi); /* .. */
5138	#endif
5139	return res;
5140	} /* decMultiplyOp */
5141
5142	/* ------------------------------------------------------------------ */
5143	/* decExpOp -- effect exponentiation */
5144	/* */
5145	/* This computes C = exp(A) */
5146	/* */
5147	/* res is C, the result. C may be A */
5148	/* rhs is A */
5149	/* set is the context; note that rounding mode has no effect */
5150	/* */
5151	/* C must have space for set->digits digits. status is updated but */
5152	/* not set. */
5153	/* */
5154	/* Restrictions: */
5155	/* */
5156	/* digits, emax, and -emin in the context must be less than */
5157	/* 2*DEC_MAX_MATH (1999998), and the rhs must be within these */
5158	/* bounds or a zero. This is an internal routine, so these */
5159	/* restrictions are contractual and not enforced. */
5160	/* */
5161	/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5162	/* almost always be correctly rounded, but may be up to 1 ulp in */
5163	/* error in rare cases. */
5164	/* */
5165	/* Finite results will always be full precision and Inexact, except */
5166	/* when A is a zero or -Infinity (giving 1 or 0 respectively). */
5167	/* ------------------------------------------------------------------ */
5168	/* This approach used here is similar to the algorithm described in */
5169	/* */
5170	/* Variable Precision Exponential Function, T. E. Hull and */
5171	/* A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5172	/* pp79-91, ACM, June 1986. */
5173	/* */
5174	/* with the main difference being that the iterations in the series */
5175	/* evaluation are terminated dynamically (which does not require the */
5176	/* extra variable-precision variables which are expensive in this */
5177	/* context). */
5178	/* */
5179	/* The error analysis in Hull & Abrham's paper applies except for the */
5180	/* round-off error accumulation during the series evaluation. This */
5181	/* code does not precalculate the number of iterations and so cannot */
5182	/* use Horner's scheme. Instead, the accumulation is done at double- */
5183	/* precision, which ensures that the additions of the terms are exact */
5184	/* and do not accumulate round-off (and any round-off errors in the */
5185	/* terms themselves move 'to the right' faster than they can */
5186	/* accumulate). This code also extends the calculation by allowing, */
5187	/* in the spirit of other decNumber operators, the input to be more */
5188	/* precise than the result (the precision used is based on the more */
5189	/* precise of the input or requested result). */
5190	/* */
5191	/* Implementation notes: */
5192	/* */
5193	/* 1. This is separated out as decExpOp so it can be called from */
5194	/* other Mathematical functions (notably Ln) with a wider range */
5195	/* than normal. In particular, it can handle the slightly wider */
5196	/* (double) range needed by Ln (which has to be able to calculate */
5197	/* exp(-x) where x can be the tiniest number (Ntiny). */
5198	/* */
5199	/* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop */
5200	/* iterations by approximately a third with additional (although */
5201	/* diminishing) returns as the range is reduced to even smaller */
5202	/* fractions. However, h (the power of 10 used to correct the */
5203	/* result at the end, see below) must be kept <=8 as otherwise */
5204	/* the final result cannot be computed. Hence the leverage is a */
5205	/* sliding value (8-h), where potentially the range is reduced */
5206	/* more for smaller values. */
5207	/* */
5208	/* The leverage that can be applied in this way is severely */
5209	/* limited by the cost of the raise-to-the power at the end, */
5210	/* which dominates when the number of iterations is small (less */
5211	/* than ten) or when rhs is short. As an example, the adjustment */
5212	/* x**10,000,000 needs 31 multiplications, all but one full-width. */
5213	/* */
5214	/* 3. The restrictions (especially precision) could be raised with */
5215	/* care, but the full decNumber range seems very hard within the */
5216	/* 32-bit limits. */
5217	/* */
5218	/* 4. The working precisions for the static buffers are twice the */
5219	/* obvious size to allow for calls from decNumberPower. */
5220	/* ------------------------------------------------------------------ */
5221	decNumber * decExpOp(decNumber *res, const decNumber *rhs,
5222	decContext *set, uInt *status) {
5223	uInt ignore=0; /* working status */
5224	Int h; /* adjusted exponent for 0.xxxx */
5225	Int p; /* working precision */
5226	Int residue; /* rounding residue */
5227	uInt needbytes; /* for space calculations */
5228	const decNumber *x=rhs; /* (may point to safe copy later) */
5229	decContext aset, tset, dset; /* working contexts */
5230	Int comp; /* work */
5231
5232	/* the argument is often copied to normalize it, so (unusually) it */
5233	/* is treated like other buffers, using DECBUFFER, +1 in case */
5234	/* DECBUFFER is 0 */
5235	decNumber bufr[D2N(DECBUFFER*2+1)];
5236	decNumber *allocrhs=NULL; /* non-NULL if rhs buffer allocated */
5237
5238	/* the working precision will be no more than set->digits+8+1 */
5239	/* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5240	/* is 0 (and twice that for the accumulator) */
5241
5242	/* buffer for t, term (working precision plus) */
5243	decNumber buft[D2N(DECBUFFER*2+9+1)];
5244	decNumber *allocbuft=NULL; /* -> allocated buft, iff allocated */
5245	decNumber *t=buft; /* term */
5246	/* buffer for a, accumulator (working precision * 2), at least 9 */
5247	decNumber bufa[D2N(DECBUFFER*4+18+1)];
5248	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5249	decNumber *a=bufa; /* accumulator */
5250	/* decNumber for the divisor term; this needs at most 9 digits */
5251	/* and so can be fixed size [16 so can use standard context] */
5252	decNumber bufd[D2N(16)];
5253	decNumber *d=bufd; /* divisor */
5254	decNumber numone; /* constant 1 */
5255
5256	#if DECCHECK
5257	Int iterations=0; /* for later sanity check */
5258	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5259	#endif
5260
5261	do { /* protect allocated storage */
5262	if (SPECIALARG) { /* handle infinities and NaNs */
5263	if (decNumberIsInfinite(rhs)) { /* an infinity */
5264	if (decNumberIsNegative(rhs)) /* -Infinity -> +0 */
5265	decNumberZero(dn: res);
5266	else decNumberCopy(dest: res, src: rhs); /* +Infinity -> self */
5267	}
5268	else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5269	break;}
5270
5271	if (ISZERO(rhs)) { /* zeros -> exact 1 */
5272	decNumberZero(dn: res); /* make clean 1 */
5273	*res->lsu=1; /* .. */
5274	break;} /* [no status to set] */
5275
5276	/* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5277	/* positive and negative tiny cases which will result in inexact */
5278	/* 1. This also allows the later add-accumulate to always be */
5279	/* exact (because its length will never be more than twice the */
5280	/* working precision). */
5281	/* The comparator (tiny) needs just one digit, so use the */
5282	/* decNumber d for it (reused as the divisor, etc., below); its */
5283	/* exponent is such that if x is positive it will have */
5284	/* set->digits-1 zeros between the decimal point and the digit, */
5285	/* which is 4, and if x is negative one more zero there as the */
5286	/* more precise result will be of the form 0.9999999 rather than */
5287	/* 1.0000001. Hence, tiny will be 0.0000004 if digits=7 and x>0 */
5288	/* or 0.00000004 if digits=7 and x<0. If RHS not larger than */
5289	/* this then the result will be 1.000000 */
5290	decNumberZero(dn: d); /* clean */
5291	*d->lsu=4; /* set 4 .. */
5292	d->exponent=-set->digits; /* * 10**(-d) */
5293	if (decNumberIsNegative(rhs)) d->exponent--; /* negative case */
5294	comp=decCompare(lhs: d, rhs, 1); /* signless compare */
5295	if (comp==BADINT) {
5296	*status|=DEC_Insufficient_storage;
5297	break;}
5298	if (comp>=0) { /* rhs < d */
5299	Int shift=set->digits-1;
5300	decNumberZero(dn: res); /* set 1 */
5301	*res->lsu=1; /* .. */
5302	res->digits=decShiftToMost(res->lsu, 1, shift);
5303	res->exponent=-shift; /* make 1.0000... */
5304	*status|=DEC_Inexact | DEC_Rounded; /* .. inexactly */
5305	break;} /* tiny */
5306
5307	/* set up the context to be used for calculating a, as this is */
5308	/* used on both paths below */
5309	decContextDefault(&aset, DEC_INIT_DECIMAL64);
5310	/* accumulator bounds are as requested (could underflow) */
5311	aset.emax=set->emax; /* usual bounds */
5312	aset.emin=set->emin; /* .. */
5313	aset.clamp=0; /* and no concrete format */
5314
5315	/* calculate the adjusted (Hull & Abrham) exponent (where the */
5316	/* decimal point is just to the left of the coefficient msd) */
5317	h=rhs->exponent+rhs->digits;
5318	/* if h>8 then 10**h cannot be calculated safely; however, when */
5319	/* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5320	/* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5321	/* overflow (or underflow to 0) is guaranteed -- so this case can */
5322	/* be handled by simply forcing the appropriate excess */
5323	if (h>8) { /* overflow/underflow */
5324	/* set up here so Power call below will over or underflow to */
5325	/* zero; set accumulator to either 2 or 0.02 */
5326	/* [stack buffer for a is always big enough for this] */
5327	decNumberZero(dn: a);
5328	*a->lsu=2; /* not 1 but < exp(1) */
5329	if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5330	h=8; /* clamp so 10**h computable */
5331	p=9; /* set a working precision */
5332	}
5333	else { /* h<=8 */
5334	Int maxlever=(rhs->digits>8?1:0);
5335	/* [could/should increase this for precisions >40 or so, too] */
5336
5337	/* if h is 8, cannot normalize to a lower upper limit because */
5338	/* the final result will not be computable (see notes above), */
5339	/* but leverage can be applied whenever h is less than 8. */
5340	/* Apply as much as possible, up to a MAXLEVER digits, which */
5341	/* sets the tradeoff against the cost of the later a**(10**h). */
5342	/* As h is increased, the working precision below also */
5343	/* increases to compensate for the "constant digits at the */
5344	/* front" effect. */
5345	Int lever=MINI(8-h, maxlever); /* leverage attainable */
5346	Int use=-rhs->digits-lever; /* exponent to use for RHS */
5347	h+=lever; /* apply leverage selected */
5348	if (h<0) { /* clamp */
5349	use+=h; /* [may end up subnormal] */
5350	h=0;
5351	}
5352	/* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5353	if (rhs->exponent!=use) {
5354	decNumber *newrhs=bufr; /* assume will fit on stack */
5355	needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5356	if (needbytes>sizeof(bufr)) { /* need malloc space */
5357	allocrhs=(decNumber *)malloc(size: needbytes);
5358	if (allocrhs==NULL) { /* hopeless -- abandon */
5359	*status|=DEC_Insufficient_storage;
5360	break;}
5361	newrhs=allocrhs; /* use the allocated space */
5362	}
5363	decNumberCopy(dest: newrhs, src: rhs); /* copy to safe space */
5364	newrhs->exponent=use; /* normalize; now <1 */
5365	x=newrhs; /* ready for use */
5366	/* decNumberShow(x); */
5367	}
5368
5369	/* Now use the usual power series to evaluate exp(x). The */
5370	/* series starts as 1 + x + x^2/2 ... so prime ready for the */
5371	/* third term by setting the term variable t=x, the accumulator */
5372	/* a=1, and the divisor d=2. */
5373
5374	/* First determine the working precision. From Hull & Abrham */
5375	/* this is set->digits+h+2. However, if x is 'over-precise' we */
5376	/* need to allow for all its digits to potentially participate */
5377	/* (consider an x where all the excess digits are 9s) so in */
5378	/* this case use x->digits+h+2 */
5379	p=MAXI(x->digits, set->digits)+h+2; /* [h<=8] */
5380
5381	/* a and t are variable precision, and depend on p, so space */
5382	/* must be allocated for them if necessary */
5383
5384	/* the accumulator needs to be able to hold 2p digits so that */
5385	/* the additions on the second and subsequent iterations are */
5386	/* sufficiently exact. */
5387	needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5388	if (needbytes>sizeof(bufa)) { /* need malloc space */
5389	allocbufa=(decNumber *)malloc(size: needbytes);
5390	if (allocbufa==NULL) { /* hopeless -- abandon */
5391	*status|=DEC_Insufficient_storage;
5392	break;}
5393	a=allocbufa; /* use the allocated space */
5394	}
5395	/* the term needs to be able to hold p digits (which is */
5396	/* guaranteed to be larger than x->digits, so the initial copy */
5397	/* is safe); it may also be used for the raise-to-power */
5398	/* calculation below, which needs an extra two digits */
5399	needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5400	if (needbytes>sizeof(buft)) { /* need malloc space */
5401	allocbuft=(decNumber *)malloc(size: needbytes);
5402	if (allocbuft==NULL) { /* hopeless -- abandon */
5403	*status|=DEC_Insufficient_storage;
5404	break;}
5405	t=allocbuft; /* use the allocated space */
5406	}
5407
5408	decNumberCopy(dest: t, src: x); /* term=x */
5409	decNumberZero(dn: a); *a->lsu=1; /* accumulator=1 */
5410	decNumberZero(dn: d); *d->lsu=2; /* divisor=2 */
5411	decNumberZero(dn: &numone); *numone.lsu=1; /* constant 1 for increment */
5412
5413	/* set up the contexts for calculating a, t, and d */
5414	decContextDefault(&tset, DEC_INIT_DECIMAL64);
5415	dset=tset;
5416	/* accumulator bounds are set above, set precision now */
5417	aset.digits=p*2; /* double */
5418	/* term bounds avoid any underflow or overflow */
5419	tset.digits=p;
5420	tset.emin=DEC_MIN_EMIN; /* [emax is plenty] */
5421	/* [dset.digits=16, etc., are sufficient] */
5422
5423	/* finally ready to roll */
5424	for (;;) {
5425	#if DECCHECK
5426	iterations++;
5427	#endif
5428	/* only the status from the accumulation is interesting */
5429	/* [but it should remain unchanged after first add] */
5430	decAddOp(res: a, lhs: a, rhs: t, set: &aset, negate: 0, status); /* a=a+t */
5431	decMultiplyOp(res: t, lhs: t, rhs: x, set: &tset, status: &ignore); /* t=t*x */
5432	decDivideOp(res: t, lhs: t, rhs: d, set: &tset, DIVIDE, status: &ignore); /* t=t/d */
5433	/* the iteration ends when the term cannot affect the result, */
5434	/* if rounded to p digits, which is when its value is smaller */
5435	/* than the accumulator by p+1 digits. There must also be */
5436	/* full precision in a. */
5437	if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5438	&& (a->digits>=p)) break;
5439	decAddOp(res: d, lhs: d, rhs: &numone, set: &dset, negate: 0, status: &ignore); /* d=d+1 */
5440	} /* iterate */
5441
5442	#if DECCHECK
5443	/* just a sanity check; comment out test to show always */
5444	if (iterations>p+3)
5445	printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5446	(LI)iterations, (LI)*status, (LI)p, (LI)x->digits);
5447	#endif
5448	} /* h<=8 */
5449
5450	/* apply postconditioning: a=a**(10**h) -- this is calculated */
5451	/* at a slightly higher precision than Hull & Abrham suggest */
5452	if (h>0) {
5453	Int seenbit=0; /* set once a 1-bit is seen */
5454	Int i; /* counter */
5455	Int n=powers[h]; /* always positive */
5456	aset.digits=p+2; /* sufficient precision */
5457	/* avoid the overhead and many extra digits of decNumberPower */
5458	/* as all that is needed is the short 'multipliers' loop; here */
5459	/* accumulate the answer into t */
5460	decNumberZero(dn: t); *t->lsu=1; /* acc=1 */
5461	for (i=1;;i++){ /* for each bit [top bit ignored] */
5462	/* abandon if have had overflow or terminal underflow */
5463	if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5464	if (*status&DEC_Overflow || ISZERO(t)) break;}
5465	n=n<<1; /* move next bit to testable position */
5466	if (n<0) { /* top bit is set */
5467	seenbit=1; /* OK, have a significant bit */
5468	decMultiplyOp(res: t, lhs: t, rhs: a, set: &aset, status); /* acc=acc*x */
5469	}
5470	if (i==31) break; /* that was the last bit */
5471	if (!seenbit) continue; /* no need to square 1 */
5472	decMultiplyOp(res: t, lhs: t, rhs: t, set: &aset, status); /* acc=acc*acc [square] */
5473	} /*i*/ /* 32 bits */
5474	/* decNumberShow(t); */
5475	a=t; /* and carry on using t instead of a */
5476	}
5477
5478	/* Copy and round the result to res */
5479	residue=1; /* indicate dirt to right .. */
5480	if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5481	aset.digits=set->digits; /* [use default rounding] */
5482	decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5483	decFinish(res, set, &residue, status); /* cleanup/set flags */
5484	} while(0); /* end protected */
5485
5486	free(ptr: allocrhs); /* drop any storage used */
5487	free(ptr: allocbufa); /* .. */
5488	free(ptr: allocbuft); /* .. */
5489	/* [status is handled by caller] */
5490	return res;
5491	} /* decExpOp */
5492
5493	/* ------------------------------------------------------------------ */
5494	/* Initial-estimate natural logarithm table */
5495	/* */
5496	/* LNnn -- 90-entry 16-bit table for values from .10 through .99. */
5497	/* The result is a 4-digit encode of the coefficient (c=the */
5498	/* top 14 bits encoding 0-9999) and a 2-digit encode of the */
5499	/* exponent (e=the bottom 2 bits encoding 0-3) */
5500	/* */
5501	/* The resulting value is given by: */
5502	/* */
5503	/* v = -c * 10**(-e-3) */
5504	/* */
5505	/* where e and c are extracted from entry k = LNnn[x-10] */
5506	/* where x is truncated (NB) into the range 10 through 99, */
5507	/* and then c = k>>2 and e = k&3. */
5508	/* ------------------------------------------------------------------ */
5509	const uShort LNnn[90]={9016, 8652, 8316, 8008, 7724, 7456, 7208,
5510	6972, 6748, 6540, 6340, 6148, 5968, 5792, 5628, 5464, 5312,
5511	5164, 5020, 4884, 4748, 4620, 4496, 4376, 4256, 4144, 4032,
5512	39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5513	29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5514	22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5515	15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5516	10197, 9685, 9177, 8677, 8185, 7697, 7213, 6737, 6269, 5801,
5517	5341, 4889, 4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5518	10130, 6046, 20055};
5519
5520	/* ------------------------------------------------------------------ */
5521	/* decLnOp -- effect natural logarithm */
5522	/* */
5523	/* This computes C = ln(A) */
5524	/* */
5525	/* res is C, the result. C may be A */
5526	/* rhs is A */
5527	/* set is the context; note that rounding mode has no effect */
5528	/* */
5529	/* C must have space for set->digits digits. */
5530	/* */
5531	/* Notable cases: */
5532	/* A<0 -> Invalid */
5533	/* A=0 -> -Infinity (Exact) */
5534	/* A=+Infinity -> +Infinity (Exact) */
5535	/* A=1 exactly -> 0 (Exact) */
5536	/* */
5537	/* Restrictions (as for Exp): */
5538	/* */
5539	/* digits, emax, and -emin in the context must be less than */
5540	/* DEC_MAX_MATH+11 (1000010), and the rhs must be within these */
5541	/* bounds or a zero. This is an internal routine, so these */
5542	/* restrictions are contractual and not enforced. */
5543	/* */
5544	/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will */
5545	/* almost always be correctly rounded, but may be up to 1 ulp in */
5546	/* error in rare cases. */
5547	/* ------------------------------------------------------------------ */
5548	/* The result is calculated using Newton's method, with each */
5549	/* iteration calculating a' = a + x * exp(-a) - 1. See, for example, */
5550	/* Epperson 1989. */
5551	/* */
5552	/* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5553	/* This has to be calculated at the sum of the precision of x and the */
5554	/* working precision. */
5555	/* */
5556	/* Implementation notes: */
5557	/* */
5558	/* 1. This is separated out as decLnOp so it can be called from */
5559	/* other Mathematical functions (e.g., Log 10) with a wider range */
5560	/* than normal. In particular, it can handle the slightly wider */
5561	/* (+9+2) range needed by a power function. */
5562	/* */
5563	/* 2. The speed of this function is about 10x slower than exp, as */
5564	/* it typically needs 4-6 iterations for short numbers, and the */
5565	/* extra precision needed adds a squaring effect, twice. */
5566	/* */
5567	/* 3. Fastpaths are included for ln(10) and ln(2), up to length 40, */
5568	/* as these are common requests. ln(10) is used by log10(x). */
5569	/* */
5570	/* 4. An iteration might be saved by widening the LNnn table, and */
5571	/* would certainly save at least one if it were made ten times */
5572	/* bigger, too (for truncated fractions 0.100 through 0.999). */
5573	/* However, for most practical evaluations, at least four or five */
5574	/* iterations will be neede -- so this would only speed up by */
5575	/* 20-25% and that probably does not justify increasing the table */
5576	/* size. */
5577	/* */
5578	/* 5. The static buffers are larger than might be expected to allow */
5579	/* for calls from decNumberPower. */
5580	/* ------------------------------------------------------------------ */
5581	decNumber * decLnOp(decNumber *res, const decNumber *rhs,
5582	decContext *set, uInt *status) {
5583	uInt ignore=0; /* working status accumulator */
5584	uInt needbytes; /* for space calculations */
5585	Int residue; /* rounding residue */
5586	Int r; /* rhs=f*10**r [see below] */
5587	Int p; /* working precision */
5588	Int pp; /* precision for iteration */
5589	Int t; /* work */
5590
5591	/* buffers for a (accumulator, typically precision+2) and b */
5592	/* (adjustment calculator, same size) */
5593	decNumber bufa[D2N(DECBUFFER+12)];
5594	decNumber *allocbufa=NULL; /* -> allocated bufa, iff allocated */
5595	decNumber *a=bufa; /* accumulator/work */
5596	decNumber bufb[D2N(DECBUFFER*2+2)];
5597	decNumber *allocbufb=NULL; /* -> allocated bufa, iff allocated */
5598	decNumber *b=bufb; /* adjustment/work */
5599
5600	decNumber numone; /* constant 1 */
5601	decNumber cmp; /* work */
5602	decContext aset, bset; /* working contexts */
5603
5604	#if DECCHECK
5605	Int iterations=0; /* for later sanity check */
5606	if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5607	#endif
5608
5609	do { /* protect allocated storage */
5610	if (SPECIALARG) { /* handle infinities and NaNs */
5611	if (decNumberIsInfinite(rhs)) { /* an infinity */
5612	if (decNumberIsNegative(rhs)) /* -Infinity -> error */
5613	*status|=DEC_Invalid_operation;
5614	else decNumberCopy(dest: res, src: rhs); /* +Infinity -> self */
5615	}
5616	else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5617	break;}
5618
5619	if (ISZERO(rhs)) { /* +/- zeros -> -Infinity */
5620	decNumberZero(dn: res); /* make clean */
5621	res->bits=DECINF|DECNEG; /* set - infinity */
5622	break;} /* [no status to set] */
5623
5624	/* Non-zero negatives are bad... */
5625	if (decNumberIsNegative(rhs)) { /* -x -> error */
5626	*status|=DEC_Invalid_operation;
5627	break;}
5628
5629	/* Here, rhs is positive, finite, and in range */
5630
5631	/* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5632	if (rhs->exponent==0 && set->digits<=40) {
5633	#if DECDPUN==1
5634	if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5635	#else
5636	if (rhs->lsu[0]==10 && rhs->digits==2) { /* ln(10) */
5637	#endif
5638	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5639	#define LN10 "2.302585092994045684017991454684364207601"
5640	decNumberFromString(dn: res, LN10, set: &aset);
5641	*status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5642	break;}
5643	if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5644	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5645	#define LN2 "0.6931471805599453094172321214581765680755"
5646	decNumberFromString(dn: res, LN2, set: &aset);
5647	*status|=(DEC_Inexact | DEC_Rounded);
5648	break;}
5649	} /* integer and short */
5650
5651	/* Determine the working precision. This is normally the */
5652	/* requested precision + 2, with a minimum of 9. However, if */
5653	/* the rhs is 'over-precise' then allow for all its digits to */
5654	/* potentially participate (consider an rhs where all the excess */
5655	/* digits are 9s) so in this case use rhs->digits+2. */
5656	p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5657
5658	/* Allocate space for the accumulator and the high-precision */
5659	/* adjustment calculator, if necessary. The accumulator must */
5660	/* be able to hold p digits, and the adjustment up to */
5661	/* rhs->digits+p digits. They are also made big enough for 16 */
5662	/* digits so that they can be used for calculating the initial */
5663	/* estimate. */
5664	needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5665	if (needbytes>sizeof(bufa)) { /* need malloc space */
5666	allocbufa=(decNumber *)malloc(size: needbytes);
5667	if (allocbufa==NULL) { /* hopeless -- abandon */
5668	*status|=DEC_Insufficient_storage;
5669	break;}
5670	a=allocbufa; /* use the allocated space */
5671	}
5672	pp=p+rhs->digits;
5673	needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5674	if (needbytes>sizeof(bufb)) { /* need malloc space */
5675	allocbufb=(decNumber *)malloc(size: needbytes);
5676	if (allocbufb==NULL) { /* hopeless -- abandon */
5677	*status|=DEC_Insufficient_storage;
5678	break;}
5679	b=allocbufb; /* use the allocated space */
5680	}
5681
5682	/* Prepare an initial estimate in acc. Calculate this by */
5683	/* considering the coefficient of x to be a normalized fraction, */
5684	/* f, with the decimal point at far left and multiplied by */
5685	/* 10**r. Then, rhs=f*10**r and 0.1<=f<1, and */
5686	/* ln(x) = ln(f) + ln(10)*r */
5687	/* Get the initial estimate for ln(f) from a small lookup */
5688	/* table (see above) indexed by the first two digits of f, */
5689	/* truncated. */
5690
5691	decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5692	r=rhs->exponent+rhs->digits; /* 'normalised' exponent */
5693	decNumberFromInt32(dn: a, in: r); /* a=r */
5694	decNumberFromInt32(dn: b, in: 2302585); /* b=ln(10) (2.302585) */
5695	b->exponent=-6; /* .. */
5696	decMultiplyOp(res: a, lhs: a, rhs: b, set: &aset, status: &ignore); /* a=a*b */
5697	/* now get top two digits of rhs into b by simple truncate and */
5698	/* force to integer */
5699	residue=0; /* (no residue) */
5700	aset.digits=2; aset.round=DEC_ROUND_DOWN;
5701	decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5702	b->exponent=0; /* make integer */
5703	t=decGetInt(b); /* [cannot fail] */
5704	if (t<10) t=X10(t); /* adjust single-digit b */
5705	t=LNnn[t-10]; /* look up ln(b) */
5706	decNumberFromInt32(dn: b, in: t>>2); /* b=ln(b) coefficient */
5707	b->exponent=-(t&3)-3; /* set exponent */
5708	b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */
5709	aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5710	decAddOp(res: a, lhs: a, rhs: b, set: &aset, negate: 0, status: &ignore); /* acc=a+b */
5711	/* the initial estimate is now in a, with up to 4 digits correct. */
5712	/* When rhs is at or near Nmax the estimate will be low, so we */
5713	/* will approach it from below, avoiding overflow when calling exp. */
5714
5715	decNumberZero(dn: &numone); *numone.lsu=1; /* constant 1 for adjustment */
5716
5717	/* accumulator bounds are as requested (could underflow, but */
5718	/* cannot overflow) */
5719	aset.emax=set->emax;
5720	aset.emin=set->emin;
5721	aset.clamp=0; /* no concrete format */
5722	/* set up a context to be used for the multiply and subtract */
5723	bset=aset;
5724	bset.emax=DEC_MAX_MATH*2; /* use double bounds for the */
5725	bset.emin=-DEC_MAX_MATH*2; /* adjustment calculation */
5726	/* [see decExpOp call below] */
5727	/* for each iteration double the number of digits to calculate, */
5728	/* up to a maximum of p */
5729	pp=9; /* initial precision */
5730	/* [initially 9 as then the sequence starts 7+2, 16+2, and */
5731	/* 34+2, which is ideal for standard-sized numbers] */
5732	aset.digits=pp; /* working context */
5733	bset.digits=pp+rhs->digits; /* wider context */
5734	for (;;) { /* iterate */
5735	#if DECCHECK
5736	iterations++;
5737	if (iterations>24) break; /* consider 9 * 2**24 */
5738	#endif
5739	/* calculate the adjustment (exp(-a)*x-1) into b. This is a */
5740	/* catastrophic subtraction but it really is the difference */
5741	/* from 1 that is of interest. */
5742	/* Use the internal entry point to Exp as it allows the double */
5743	/* range for calculating exp(-a) when a is the tiniest subnormal. */
5744	a->bits^=DECNEG; /* make -a */
5745	decExpOp(res: b, rhs: a, set: &bset, status: &ignore); /* b=exp(-a) */
5746	a->bits^=DECNEG; /* restore sign of a */
5747	/* now multiply by rhs and subtract 1, at the wider precision */
5748	decMultiplyOp(res: b, lhs: b, rhs, set: &bset, status: &ignore); /* b=b*rhs */
5749	decAddOp(res: b, lhs: b, rhs: &numone, set: &bset, DECNEG, status: &ignore); /* b=b-1 */
5750
5751	/* the iteration ends when the adjustment cannot affect the */
5752	/* result by >=0.5 ulp (at the requested digits), which */
5753	/* is when its value is smaller than the accumulator by */
5754	/* set->digits+1 digits (or it is zero) -- this is a looser */
5755	/* requirement than for Exp because all that happens to the */
5756	/* accumulator after this is the final rounding (but note that */
5757	/* there must also be full precision in a, or a=0). */
5758
5759	if (decNumberIsZero(b) ||
5760	(a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5761	if (a->digits==p) break;
5762	if (decNumberIsZero(a)) {
5763	decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5764	if (cmp.lsu[0]==0) a->exponent=0; /* yes, exact 0 */
5765	else *status|=(DEC_Inexact | DEC_Rounded); /* no, inexact */
5766	break;
5767	}
5768	/* force padding if adjustment has gone to 0 before full length */
5769	if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5770	}
5771
5772	/* not done yet ... */
5773	decAddOp(res: a, lhs: a, rhs: b, set: &aset, negate: 0, status: &ignore); /* a=a+b for next estimate */
5774	if (pp==p) continue; /* precision is at maximum */
5775	/* lengthen the next calculation */
5776	pp=pp*2; /* double precision */
5777	if (pp>p) pp=p; /* clamp to maximum */
5778	aset.digits=pp; /* working context */
5779	bset.digits=pp+rhs->digits; /* wider context */
5780	} /* Newton's iteration */
5781
5782	#if DECCHECK
5783	/* just a sanity check; remove the test to show always */
5784	if (iterations>24)
5785	printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5786	(LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
5787	#endif
5788
5789	/* Copy and round the result to res */
5790	residue=1; /* indicate dirt to right */
5791	if (ISZERO(a)) residue=0; /* .. unless underflowed to 0 */
5792	aset.digits=set->digits; /* [use default rounding] */
5793	decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5794	decFinish(res, set, &residue, status); /* cleanup/set flags */
5795	} while(0); /* end protected */
5796
5797	free(ptr: allocbufa); /* drop any storage used */
5798	free(ptr: allocbufb); /* .. */
5799	/* [status is handled by caller] */
5800	return res;
5801	} /* decLnOp */
5802
5803	/* ------------------------------------------------------------------ */
5804	/* decQuantizeOp -- force exponent to requested value */
5805	/* */
5806	/* This computes C = op(A, B), where op adjusts the coefficient */
5807	/* of C (by rounding or shifting) such that the exponent (-scale) */
5808	/* of C has the value B or matches the exponent of B. */
5809	/* The numerical value of C will equal A, except for the effects of */
5810	/* any rounding that occurred. */
5811	/* */
5812	/* res is C, the result. C may be A or B */
5813	/* lhs is A, the number to adjust */
5814	/* rhs is B, the requested exponent */
5815	/* set is the context */
5816	/* quant is 1 for quantize or 0 for rescale */
5817	/* status is the status accumulator (this can be called without */
5818	/* risk of control loss) */
5819	/* */
5820	/* C must have space for set->digits digits. */
5821	/* */
5822	/* Unless there is an error or the result is infinite, the exponent */
5823	/* after the operation is guaranteed to be that requested. */
5824	/* ------------------------------------------------------------------ */
5825	static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5826	const decNumber *rhs, decContext *set,
5827	Flag quant, uInt *status) {
5828	#if DECSUBSET
5829	decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
5830	decNumber *allocrhs=NULL; /* .., rhs */
5831	#endif
5832	const decNumber *inrhs=rhs; /* save original rhs */
5833	Int reqdigits=set->digits; /* requested DIGITS */
5834	Int reqexp; /* requested exponent [-scale] */
5835	Int residue=0; /* rounding residue */
5836	Int etiny=set->emin-(reqdigits-1);
5837
5838	#if DECCHECK
5839	if (decCheckOperands(res, lhs, rhs, set)) return res;
5840	#endif
5841
5842	do { /* protect allocated storage */
5843	#if DECSUBSET
5844	if (!set->extended) {
5845	/* reduce operands and set lostDigits status, as needed */
5846	if (lhs->digits>reqdigits) {
5847	alloclhs=decRoundOperand(lhs, set, status);
5848	if (alloclhs==NULL) break;
5849	lhs=alloclhs;
5850	}
5851	if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
5852	allocrhs=decRoundOperand(rhs, set, status);
5853	if (allocrhs==NULL) break;
5854	rhs=allocrhs;
5855	}
5856	}
5857	#endif
5858	/* [following code does not require input rounding] */
5859
5860	/* Handle special values */
5861	if (SPECIALARGS) {
5862	/* NaNs get usual processing */
5863	if (SPECIALARGS & (DECSNAN | DECNAN))
5864	decNaNs(res, lhs, rhs, set, status);
5865	/* one infinity but not both is bad */
5866	else if ((lhs->bits ^ rhs->bits) & DECINF)
5867	*status|=DEC_Invalid_operation;
5868	/* both infinity: return lhs */
5869	else decNumberCopy(dest: res, src: lhs); /* [nop if in place] */
5870	break;
5871	}
5872
5873	/* set requested exponent */
5874	if (quant) reqexp=inrhs->exponent; /* quantize -- match exponents */
5875	else { /* rescale -- use value of rhs */
5876	/* Original rhs must be an integer that fits and is in range, */
5877	/* which could be from -1999999997 to +999999999, thanks to */
5878	/* subnormals */
5879	reqexp=decGetInt(inrhs); /* [cannot fail] */
5880	}
5881
5882	#if DECSUBSET
5883	if (!set->extended) etiny=set->emin; /* no subnormals */
5884	#endif
5885
5886	if (reqexp==BADINT /* bad (rescale only) or .. */
5887	|| reqexp==BIGODD || reqexp==BIGEVEN /* very big (ditto) or .. */
5888	|| (reqexp<etiny) /* < lowest */
5889	|| (reqexp>set->emax)) { /* > emax */
5890	*status|=DEC_Invalid_operation;
5891	break;}
5892
5893	/* the RHS has been processed, so it can be overwritten now if necessary */
5894	if (ISZERO(lhs)) { /* zero coefficient unchanged */
5895	decNumberCopy(dest: res, src: lhs); /* [nop if in place] */
5896	res->exponent=reqexp; /* .. just set exponent */
5897	#if DECSUBSET
5898	if (!set->extended) res->bits=0; /* subset specification; no -0 */
5899	#endif
5900	}
5901	else { /* non-zero lhs */
5902	Int adjust=reqexp-lhs->exponent; /* digit adjustment needed */
5903	/* if adjusted coefficient will definitely not fit, give up now */
5904	if ((lhs->digits-adjust)>reqdigits) {
5905	*status|=DEC_Invalid_operation;
5906	break;
5907	}
5908
5909	if (adjust>0) { /* increasing exponent */
5910	/* this will decrease the length of the coefficient by adjust */
5911	/* digits, and must round as it does so */
5912	decContext workset; /* work */
5913	workset=*set; /* clone rounding, etc. */
5914	workset.digits=lhs->digits-adjust; /* set requested length */
5915	/* [note that the latter can be <1, here] */
5916	decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
5917	decApplyRound(res, &workset, residue, status); /* .. and round */
5918	residue=0; /* [used] */
5919	/* If just rounded a 999s case, exponent will be off by one; */
5920	/* adjust back (after checking space), if so. */
5921	if (res->exponent>reqexp) {
5922	/* re-check needed, e.g., for quantize(0.9999, 0.001) under */
5923	/* set->digits==3 */
5924	if (res->digits==reqdigits) { /* cannot shift by 1 */
5925	*status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
5926	*status|=DEC_Invalid_operation;
5927	break;
5928	}
5929	res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
5930	res->exponent--; /* (re)adjust the exponent. */
5931	}
5932	#if DECSUBSET
5933	if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
5934	#endif
5935	} /* increase */
5936	else /* adjust<=0 */ { /* decreasing or = exponent */
5937	/* this will increase the length of the coefficient by -adjust */
5938	/* digits, by adding zero or more trailing zeros; this is */
5939	/* already checked for fit, above */
5940	decNumberCopy(dest: res, src: lhs); /* [it will fit] */
5941	/* if padding needed (adjust<0), add it now... */
5942	if (adjust<0) {
5943	res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
5944	res->exponent+=adjust; /* adjust the exponent */
5945	}
5946	} /* decrease */
5947	} /* non-zero */
5948
5949	/* Check for overflow [do not use Finalize in this case, as an */
5950	/* overflow here is a "don't fit" situation] */
5951	if (res->exponent>set->emax-res->digits+1) { /* too big */
5952	*status|=DEC_Invalid_operation;
5953	break;
5954	}
5955	else {
5956	decFinalize(res, set, &residue, status); /* set subnormal flags */
5957	*status&=~DEC_Underflow; /* suppress Underflow [as per 754] */
5958	}
5959	} while(0); /* end protected */
5960
5961	#if DECSUBSET
5962	free(allocrhs); /* drop any storage used */
5963	free(alloclhs); /* .. */
5964	#endif
5965	return res;
5966	} /* decQuantizeOp */
5967
5968	/* ------------------------------------------------------------------ */
5969	/* decCompareOp -- compare, min, or max two Numbers */
5970	/* */
5971	/* This computes C = A ? B and carries out one of four operations: */
5972	/* COMPARE -- returns the signum (as a number) giving the */
5973	/* result of a comparison unless one or both */
5974	/* operands is a NaN (in which case a NaN results) */
5975	/* COMPSIG -- as COMPARE except that a quiet NaN raises */
5976	/* Invalid operation. */
5977	/* COMPMAX -- returns the larger of the operands, using the */
5978	/* 754 maxnum operation */
5979	/* COMPMAXMAG -- ditto, comparing absolute values */
5980	/* COMPMIN -- the 754 minnum operation */
5981	/* COMPMINMAG -- ditto, comparing absolute values */
5982	/* COMTOTAL -- returns the signum (as a number) giving the */
5983	/* result of a comparison using 754 total ordering */
5984	/* */
5985	/* res is C, the result. C may be A and/or B (e.g., X=X?X) */
5986	/* lhs is A */
5987	/* rhs is B */
5988	/* set is the context */
5989	/* op is the operation flag */
5990	/* status is the usual accumulator */
5991	/* */
5992	/* C must have space for one digit for COMPARE or set->digits for */
5993	/* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG. */
5994	/* ------------------------------------------------------------------ */
5995	/* The emphasis here is on speed for common cases, and avoiding */
5996	/* coefficient comparison if possible. */
5997	/* ------------------------------------------------------------------ */
5998	decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
5999	const decNumber *rhs, decContext *set,
6000	Flag op, uInt *status) {
6001	#if DECSUBSET
6002	decNumber *alloclhs=NULL; /* non-NULL if rounded lhs allocated */
6003	decNumber *allocrhs=NULL; /* .., rhs */
6004	#endif
6005	Int result=0; /* default result value */
6006	uByte merged; /* work */
6007
6008	#if DECCHECK
6009	if (decCheckOperands(res, lhs, rhs, set)) return res;
6010	#endif
6011
6012	do { /* protect allocated storage */
6013	#if DECSUBSET
6014	if (!set->extended) {
6015	/* reduce operands and set lostDigits status, as needed */
6016	if (lhs->digits>set->digits) {
6017	alloclhs=decRoundOperand(lhs, set, status);
6018	if (alloclhs==NULL) {result=BADINT; break;}
6019	lhs=alloclhs;
6020	}
6021	if (rhs->digits>set->digits) {
6022	allocrhs=decRoundOperand(rhs, set, status);
6023	if (allocrhs==NULL) {result=BADINT; break;}
6024	rhs=allocrhs;
6025	}
6026	}
6027	#endif
6028	/* [following code does not require input rounding] */
6029
6030	/* If total ordering then handle differing signs 'up front' */
6031	if (op==COMPTOTAL) { /* total ordering */
6032	if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6033	result=-1;
6034	break;
6035	}
6036	if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6037	result=+1;
6038	break;
6039	}
6040	}
6041
6042	/* handle NaNs specially; let infinities drop through */
6043	/* This assumes sNaN (even just one) leads to NaN. */
6044	merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6045	if (merged) { /* a NaN bit set */
6046	if (op==COMPARE); /* result will be NaN */
6047	else if (op==COMPSIG) /* treat qNaN as sNaN */
6048	*status|=DEC_Invalid_operation | DEC_sNaN;
6049	else if (op==COMPTOTAL) { /* total ordering, always finite */
6050	/* signs are known to be the same; compute the ordering here */
6051	/* as if the signs are both positive, then invert for negatives */
6052	if (!decNumberIsNaN(lhs)) result=-1;
6053	else if (!decNumberIsNaN(rhs)) result=+1;
6054	/* here if both NaNs */
6055	else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6056	else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6057	else { /* both NaN or both sNaN */
6058	/* now it just depends on the payload */
6059	result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6060	rhs->lsu, D2U(rhs->digits), 0);
6061	/* [Error not possible, as these are 'aligned'] */
6062	} /* both same NaNs */
6063	if (decNumberIsNegative(lhs)) result=-result;
6064	break;
6065	} /* total order */
6066
6067	else if (merged & DECSNAN); /* sNaN -> qNaN */
6068	else { /* here if MIN or MAX and one or two quiet NaNs */
6069	/* min or max -- 754 rules ignore single NaN */
6070	if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6071	/* just one NaN; force choice to be the non-NaN operand */
6072	op=COMPMAX;
6073	if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6074	else result=+1; /* pick lhs */
6075	break;
6076	}
6077	} /* max or min */
6078	op=COMPNAN; /* use special path */
6079	decNaNs(res, lhs, rhs, set, status); /* propagate NaN */
6080	break;
6081	}
6082	/* have numbers */
6083	if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6084	else result=decCompare(lhs, rhs, 0); /* sign matters */
6085	} while(0); /* end protected */
6086
6087	if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6088	else {
6089	if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6090	if (op==COMPTOTAL && result==0) {
6091	/* operands are numerically equal or same NaN (and same sign, */
6092	/* tested first); if identical, leave result 0 */
6093	if (lhs->exponent!=rhs->exponent) {
6094	if (lhs->exponent<rhs->exponent) result=-1;
6095	else result=+1;
6096	if (decNumberIsNegative(lhs)) result=-result;
6097	} /* lexp!=rexp */
6098	} /* total-order by exponent */
6099	decNumberZero(dn: res); /* [always a valid result] */
6100	if (result!=0) { /* must be -1 or +1 */
6101	*res->lsu=1;
6102	if (result<0) res->bits=DECNEG;
6103	}
6104	}
6105	else if (op==COMPNAN); /* special, drop through */
6106	else { /* MAX or MIN, non-NaN result */
6107	Int residue=0; /* rounding accumulator */
6108	/* choose the operand for the result */
6109	const decNumber *choice;
6110	if (result==0) { /* operands are numerically equal */
6111	/* choose according to sign then exponent (see 754) */
6112	uByte slhs=(lhs->bits & DECNEG);
6113	uByte srhs=(rhs->bits & DECNEG);
6114	#if DECSUBSET
6115	if (!set->extended) { /* subset: force left-hand */
6116	op=COMPMAX;
6117	result=+1;
6118	}
6119	else
6120	#endif
6121	if (slhs!=srhs) { /* signs differ */
6122	if (slhs) result=-1; /* rhs is max */
6123	else result=+1; /* lhs is max */
6124	}
6125	else if (slhs && srhs) { /* both negative */
6126	if (lhs->exponent<rhs->exponent) result=+1;
6127	else result=-1;
6128	/* [if equal, use lhs, technically identical] */
6129	}
6130	else { /* both positive */
6131	if (lhs->exponent>rhs->exponent) result=+1;
6132	else result=-1;
6133	/* [ditto] */
6134	}
6135	} /* numerically equal */
6136	/* here result will be non-0; reverse if looking for MIN */
6137	if (op==COMPMIN || op==COMPMINMAG) result=-result;
6138	choice=(result>0 ? lhs : rhs); /* choose */
6139	/* copy chosen to result, rounding if need be */
6140	decCopyFit(res, choice, set, &residue, status);
6141	decFinish(res, set, &residue, status);
6142	}
6143	}
6144	#if DECSUBSET
6145	free(allocrhs); /* free any storage used */
6146	free(alloclhs); /* .. */
6147	#endif
6148	return res;
6149	} /* decCompareOp */
6150
6151	/* ------------------------------------------------------------------ */
6152	/* decCompare -- compare two decNumbers by numerical value */
6153	/* */
6154	/* This routine compares A ? B without altering them. */
6155	/* */
6156	/* Arg1 is A, a decNumber which is not a NaN */
6157	/* Arg2 is B, a decNumber which is not a NaN */
6158	/* Arg3 is 1 for a sign-independent compare, 0 otherwise */
6159	/* */
6160	/* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6161	/* (the only possible failure is an allocation error) */
6162	/* ------------------------------------------------------------------ */
6163	static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6164	Flag abs) {
6165	Int result; /* result value */
6166	Int sigr; /* rhs signum */
6167	Int compare; /* work */
6168
6169	result=1; /* assume signum(lhs) */
6170	if (ISZERO(lhs)) result=0;
6171	if (abs) {
6172	if (ISZERO(rhs)) return result; /* LHS wins or both 0 */
6173	/* RHS is non-zero */
6174	if (result==0) return -1; /* LHS is 0; RHS wins */
6175	/* [here, both non-zero, result=1] */
6176	}
6177	else { /* signs matter */
6178	if (result && decNumberIsNegative(lhs)) result=-1;
6179	sigr=1; /* compute signum(rhs) */
6180	if (ISZERO(rhs)) sigr=0;
6181	else if (decNumberIsNegative(rhs)) sigr=-1;
6182	if (result > sigr) return +1; /* L > R, return 1 */
6183	if (result < sigr) return -1; /* L < R, return -1 */
6184	if (result==0) return 0; /* both 0 */
6185	}
6186
6187	/* signums are the same; both are non-zero */
6188	if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */
6189	if (decNumberIsInfinite(rhs)) {
6190	if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6191	else result=-result; /* only rhs infinite */
6192	}
6193	return result;
6194	}
6195	/* must compare the coefficients, allowing for exponents */
6196	if (lhs->exponent>rhs->exponent) { /* LHS exponent larger */
6197	/* swap sides, and sign */
6198	const decNumber *temp=lhs;
6199	lhs=rhs;
6200	rhs=temp;
6201	result=-result;
6202	}
6203	compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6204	rhs->lsu, D2U(rhs->digits),
6205	rhs->exponent-lhs->exponent);
6206	if (compare!=BADINT) compare*=result; /* comparison succeeded */
6207	return compare;
6208	} /* decCompare */
6209
6210	/* ------------------------------------------------------------------ */
6211	/* decUnitCompare -- compare two >=0 integers in Unit arrays */
6212	/* */
6213	/* This routine compares A ? B*10**E where A and B are unit arrays */
6214	/* A is a plain integer */
6215	/* B has an exponent of E (which must be non-negative) */
6216	/* */
6217	/* Arg1 is A first Unit (lsu) */
6218	/* Arg2 is A length in Units */
6219	/* Arg3 is B first Unit (lsu) */
6220	/* Arg4 is B length in Units */
6221	/* Arg5 is E (0 if the units are aligned) */
6222	/* */
6223	/* returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure */
6224	/* (the only possible failure is an allocation error, which can */
6225	/* only occur if E!=0) */
6226	/* ------------------------------------------------------------------ */
6227	static Int decUnitCompare(const Unit *a, Int alength,
6228	const Unit *b, Int blength, Int exp) {
6229	Unit *acc; /* accumulator for result */
6230	Unit accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6231	Unit *allocacc=NULL; /* -> allocated acc buffer, iff allocated */
6232	Int accunits, need; /* units in use or needed for acc */
6233	const Unit *l, *r, *u; /* work */
6234	Int expunits, exprem, result; /* .. */
6235
6236	if (exp==0) { /* aligned; fastpath */
6237	if (alength>blength) return 1;
6238	if (alength<blength) return -1;
6239	/* same number of units in both -- need unit-by-unit compare */
6240	l=a+alength-1;
6241	r=b+alength-1;
6242	for (;l>=a; l--, r--) {
6243	if (*l>*r) return 1;
6244	if (*l<*r) return -1;
6245	}
6246	return 0; /* all units match */
6247	} /* aligned */
6248
6249	/* Unaligned. If one is >1 unit longer than the other, padded */
6250	/* approximately, then can return easily */
6251	if (alength>blength+(Int)D2U(exp)) return 1;
6252	if (alength+1<blength+(Int)D2U(exp)) return -1;
6253
6254	/* Need to do a real subtract. For this, a result buffer is needed */
6255	/* even though only the sign is of interest. Its length needs */
6256	/* to be the larger of alength and padded blength, +2 */
6257	need=blength+D2U(exp); /* maximum real length of B */
6258	if (need<alength) need=alength;
6259	need+=2;
6260	acc=accbuff; /* assume use local buffer */
6261	if (need*sizeof(Unit)>sizeof(accbuff)) {
6262	allocacc=(Unit *)malloc(size: need*sizeof(Unit));
6263	if (allocacc==NULL) return BADINT; /* hopeless -- abandon */
6264	acc=allocacc;
6265	}
6266	/* Calculate units and remainder from exponent. */
6267	expunits=exp/DECDPUN;
6268	exprem=exp%DECDPUN;
6269	/* subtract [A+B*(-m)] */
6270	accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6271	-(Int)powers[exprem]);
6272	/* [UnitAddSub result may have leading zeros, even on zero] */
6273	if (accunits<0) result=-1; /* negative result */
6274	else { /* non-negative result */
6275	/* check units of the result before freeing any storage */
6276	for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6277	result=(*u==0 ? 0 : +1);
6278	}
6279	/* clean up and return the result */
6280	free(ptr: allocacc); /* drop any storage used */
6281	return result;
6282	} /* decUnitCompare */
6283
6284	/* ------------------------------------------------------------------ */
6285	/* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays */
6286	/* */
6287	/* This routine performs the calculation: */
6288	/* */
6289	/* C=A+(B*M) */
6290	/* */
6291	/* Where M is in the range -DECDPUNMAX through +DECDPUNMAX. */
6292	/* */
6293	/* A may be shorter or longer than B. */
6294	/* */
6295	/* Leading zeros are not removed after a calculation. The result is */
6296	/* either the same length as the longer of A and B (adding any */
6297	/* shift), or one Unit longer than that (if a Unit carry occurred). */
6298	/* */
6299	/* A and B content are not altered unless C is also A or B. */
6300	/* C may be the same array as A or B, but only if no zero padding is */
6301	/* requested (that is, C may be B only if bshift==0). */
6302	/* C is filled from the lsu; only those units necessary to complete */
6303	/* the calculation are referenced. */
6304	/* */
6305	/* Arg1 is A first Unit (lsu) */
6306	/* Arg2 is A length in Units */
6307	/* Arg3 is B first Unit (lsu) */
6308	/* Arg4 is B length in Units */
6309	/* Arg5 is B shift in Units (>=0; pads with 0 units if positive) */
6310	/* Arg6 is C first Unit (lsu) */
6311	/* Arg7 is M, the multiplier */
6312	/* */
6313	/* returns the count of Units written to C, which will be non-zero */
6314	/* and negated if the result is negative. That is, the sign of the */
6315	/* returned Int is the sign of the result (positive for zero) and */
6316	/* the absolute value of the Int is the count of Units. */
6317	/* */
6318	/* It is the caller's responsibility to make sure that C size is */
6319	/* safe, allowing space if necessary for a one-Unit carry. */
6320	/* */
6321	/* This routine is severely performance-critical; *any* change here */
6322	/* must be measured (timed) to assure no performance degradation. */
6323	/* In particular, trickery here tends to be counter-productive, as */
6324	/* increased complexity of code hurts register optimizations on */
6325	/* register-poor architectures. Avoiding divisions is nearly */
6326	/* always a Good Idea, however. */
6327	/* */
6328	/* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark */
6329	/* (IBM Warwick, UK) for some of the ideas used in this routine. */
6330	/* ------------------------------------------------------------------ */
6331	static Int decUnitAddSub(const Unit *a, Int alength,
6332	const Unit *b, Int blength, Int bshift,
6333	Unit *c, Int m) {
6334	const Unit *alsu=a; /* A lsu [need to remember it] */
6335	Unit *clsu=c; /* C ditto */
6336	Unit *minC; /* low water mark for C */
6337	Unit *maxC; /* high water mark for C */
6338	eInt carry=0; /* carry integer (could be Long) */
6339	Int add; /* work */
6340	#if DECDPUN<=4 /* myriadal, millenary, etc. */
6341	Int est; /* estimated quotient */
6342	#endif
6343
6344	#if DECTRACE
6345	if (alength<1 || blength<1)
6346	printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6347	#endif
6348
6349	maxC=c+alength; /* A is usually the longer */
6350	minC=c+blength; /* .. and B the shorter */
6351	if (bshift!=0) { /* B is shifted; low As copy across */
6352	minC+=bshift;
6353	/* if in place [common], skip copy unless there's a gap [rare] */
6354	if (a==c && bshift<=alength) {
6355	c+=bshift;
6356	a+=bshift;
6357	}
6358	else for (; c<clsu+bshift; a++, c++) { /* copy needed */
6359	if (a<alsu+alength) *c=*a;
6360	else *c=0;
6361	}
6362	}
6363	if (minC>maxC) { /* swap */
6364	Unit *hold=minC;
6365	minC=maxC;
6366	maxC=hold;
6367	}
6368
6369	/* For speed, do the addition as two loops; the first where both A */
6370	/* and B contribute, and the second (if necessary) where only one or */
6371	/* other of the numbers contribute. */
6372	/* Carry handling is the same (i.e., duplicated) in each case. */
6373	for (; c<minC; c++) {
6374	carry+=*a;
6375	a++;
6376	carry+=((eInt)*b)*m; /* [special-casing m=1/-1 */
6377	b++; /* here is not a win] */
6378	/* here carry is new Unit of digits; it could be +ve or -ve */
6379	if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6380	*c=(Unit)carry;
6381	carry=0;
6382	continue;
6383	}
6384	#if DECDPUN==4 /* use divide-by-multiply */
6385	if (carry>=0) {
6386	est=(((ueInt)carry>>11)*53687)>>18;
6387	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6388	carry=est; /* likely quotient [89%] */
6389	if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6390	carry++;
6391	*c-=DECDPUNMAX+1;
6392	continue;
6393	}
6394	/* negative case */
6395	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6396	est=(((ueInt)carry>>11)*53687)>>18;
6397	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6398	carry=est-(DECDPUNMAX+1); /* correctly negative */
6399	if (*c<DECDPUNMAX+1) continue; /* was OK */
6400	carry++;
6401	*c-=DECDPUNMAX+1;
6402	#elif DECDPUN==3
6403	if (carry>=0) {
6404	est=(((ueInt)carry>>3)*16777)>>21;
6405	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6406	carry=est; /* likely quotient [99%] */
6407	if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6408	carry++;
6409	*c-=DECDPUNMAX+1;
6410	continue;
6411	}
6412	/* negative case */
6413	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6414	est=(((ueInt)carry>>3)*16777)>>21;
6415	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6416	carry=est-(DECDPUNMAX+1); /* correctly negative */
6417	if (*c<DECDPUNMAX+1) continue; /* was OK */
6418	carry++;
6419	*c-=DECDPUNMAX+1;
6420	#elif DECDPUN<=2
6421	/* Can use QUOT10 as carry <= 4 digits */
6422	if (carry>=0) {
6423	est=QUOT10(carry, DECDPUN);
6424	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6425	carry=est; /* quotient */
6426	continue;
6427	}
6428	/* negative case */
6429	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6430	est=QUOT10(carry, DECDPUN);
6431	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6432	carry=est-(DECDPUNMAX+1); /* correctly negative */
6433	#else
6434	/* remainder operator is undefined if negative, so must test */
6435	if ((ueInt)carry<(DECDPUNMAX+1)*2) { /* fastpath carry +1 */
6436	*c=(Unit)(carry-(DECDPUNMAX+1)); /* [helps additions] */
6437	carry=1;
6438	continue;
6439	}
6440	if (carry>=0) {
6441	*c=(Unit)(carry%(DECDPUNMAX+1));
6442	carry=carry/(DECDPUNMAX+1);
6443	continue;
6444	}
6445	/* negative case */
6446	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6447	*c=(Unit)(carry%(DECDPUNMAX+1));
6448	carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6449	#endif
6450	} /* c */
6451
6452	/* now may have one or other to complete */
6453	/* [pretest to avoid loop setup/shutdown] */
6454	if (c<maxC) for (; c<maxC; c++) {
6455	if (a<alsu+alength) { /* still in A */
6456	carry+=*a;
6457	a++;
6458	}
6459	else { /* inside B */
6460	carry+=((eInt)*b)*m;
6461	b++;
6462	}
6463	/* here carry is new Unit of digits; it could be +ve or -ve and */
6464	/* magnitude up to DECDPUNMAX squared */
6465	if ((ueInt)carry<=DECDPUNMAX) { /* fastpath 0-DECDPUNMAX */
6466	*c=(Unit)carry;
6467	carry=0;
6468	continue;
6469	}
6470	/* result for this unit is negative or >DECDPUNMAX */
6471	#if DECDPUN==4 /* use divide-by-multiply */
6472	if (carry>=0) {
6473	est=(((ueInt)carry>>11)*53687)>>18;
6474	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6475	carry=est; /* likely quotient [79.7%] */
6476	if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6477	carry++;
6478	*c-=DECDPUNMAX+1;
6479	continue;
6480	}
6481	/* negative case */
6482	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6483	est=(((ueInt)carry>>11)*53687)>>18;
6484	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6485	carry=est-(DECDPUNMAX+1); /* correctly negative */
6486	if (*c<DECDPUNMAX+1) continue; /* was OK */
6487	carry++;
6488	*c-=DECDPUNMAX+1;
6489	#elif DECDPUN==3
6490	if (carry>=0) {
6491	est=(((ueInt)carry>>3)*16777)>>21;
6492	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6493	carry=est; /* likely quotient [99%] */
6494	if (*c<DECDPUNMAX+1) continue; /* estimate was correct */
6495	carry++;
6496	*c-=DECDPUNMAX+1;
6497	continue;
6498	}
6499	/* negative case */
6500	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6501	est=(((ueInt)carry>>3)*16777)>>21;
6502	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6503	carry=est-(DECDPUNMAX+1); /* correctly negative */
6504	if (*c<DECDPUNMAX+1) continue; /* was OK */
6505	carry++;
6506	*c-=DECDPUNMAX+1;
6507	#elif DECDPUN<=2
6508	if (carry>=0) {
6509	est=QUOT10(carry, DECDPUN);
6510	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6511	carry=est; /* quotient */
6512	continue;
6513	}
6514	/* negative case */
6515	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6516	est=QUOT10(carry, DECDPUN);
6517	*c=(Unit)(carry-est*(DECDPUNMAX+1));
6518	carry=est-(DECDPUNMAX+1); /* correctly negative */
6519	#else
6520	if ((ueInt)carry<(DECDPUNMAX+1)*2){ /* fastpath carry 1 */
6521	*c=(Unit)(carry-(DECDPUNMAX+1));
6522	carry=1;
6523	continue;
6524	}
6525	/* remainder operator is undefined if negative, so must test */
6526	if (carry>=0) {
6527	*c=(Unit)(carry%(DECDPUNMAX+1));
6528	carry=carry/(DECDPUNMAX+1);
6529	continue;
6530	}
6531	/* negative case */
6532	carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6533	*c=(Unit)(carry%(DECDPUNMAX+1));
6534	carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6535	#endif
6536	} /* c */
6537
6538	/* OK, all A and B processed; might still have carry or borrow */
6539	/* return number of Units in the result, negated if a borrow */
6540	if (carry==0) return c-clsu; /* no carry, so no more to do */
6541	if (carry>0) { /* positive carry */
6542	*c=(Unit)carry; /* place as new unit */
6543	c++; /* .. */
6544	return c-clsu;
6545	}
6546	/* -ve carry: it's a borrow; complement needed */
6547	add=1; /* temporary carry... */
6548	for (c=clsu; c<maxC; c++) {
6549	add=DECDPUNMAX+add-*c;
6550	if (add<=DECDPUNMAX) {
6551	*c=(Unit)add;
6552	add=0;
6553	}
6554	else {
6555	*c=0;
6556	add=1;
6557	}
6558	}
6559	/* add an extra unit iff it would be non-zero */
6560	#if DECTRACE
6561	printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6562	#endif
6563	if ((add-carry-1)!=0) {
6564	*c=(Unit)(add-carry-1);
6565	c++; /* interesting, include it */
6566	}
6567	return clsu-c; /* -ve result indicates borrowed */
6568	} /* decUnitAddSub */
6569
6570	/* ------------------------------------------------------------------ */
6571	/* decTrim -- trim trailing zeros or normalize */
6572	/* */
6573	/* dn is the number to trim or normalize */
6574	/* set is the context to use to check for clamp */
6575	/* all is 1 to remove all trailing zeros, 0 for just fraction ones */
6576	/* noclamp is 1 to unconditional (unclamped) trim */
6577	/* dropped returns the number of discarded trailing zeros */
6578	/* returns dn */
6579	/* */
6580	/* If clamp is set in the context then the number of zeros trimmed */
6581	/* may be limited if the exponent is high. */
6582	/* All fields are updated as required. This is a utility operation, */
6583	/* so special values are unchanged and no error is possible. */
6584	/* ------------------------------------------------------------------ */
6585	static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6586	Flag noclamp, Int *dropped) {
6587	Int d, exp; /* work */
6588	uInt cut; /* .. */
6589	Unit *up; /* -> current Unit */
6590
6591	#if DECCHECK
6592	if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6593	#endif
6594
6595	*dropped=0; /* assume no zeros dropped */
6596	if ((dn->bits & DECSPECIAL) /* fast exit if special .. */
6597	|| (*dn->lsu & 0x01)) return dn; /* .. or odd */
6598	if (ISZERO(dn)) { /* .. or 0 */
6599	dn->exponent=0; /* (sign is preserved) */
6600	return dn;
6601	}
6602
6603	/* have a finite number which is even */
6604	exp=dn->exponent;
6605	cut=1; /* digit (1-DECDPUN) in Unit */
6606	up=dn->lsu; /* -> current Unit */
6607	for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6608	/* slice by powers */
6609	#if DECDPUN<=4
6610	uInt quot=QUOT10(*up, cut);
6611	if ((*up-quot*powers[cut])!=0) break; /* found non-0 digit */
6612	#else
6613	if (*up%powers[cut]!=0) break; /* found non-0 digit */
6614	#endif
6615	/* have a trailing 0 */
6616	if (!all) { /* trimming */
6617	/* [if exp>0 then all trailing 0s are significant for trim] */
6618	if (exp<=0) { /* if digit might be significant */
6619	if (exp==0) break; /* then quit */
6620	exp++; /* next digit might be significant */
6621	}
6622	}
6623	cut++; /* next power */
6624	if (cut>DECDPUN) { /* need new Unit */
6625	up++;
6626	cut=1;
6627	}
6628	} /* d */
6629	if (d==0) return dn; /* none to drop */
6630
6631	/* may need to limit drop if clamping */
6632	if (set->clamp && !noclamp) {
6633	Int maxd=set->emax-set->digits+1-dn->exponent;
6634	if (maxd<=0) return dn; /* nothing possible */
6635	if (d>maxd) d=maxd;
6636	}
6637
6638	/* effect the drop */
6639	decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6640	dn->exponent+=d; /* maintain numerical value */
6641	dn->digits-=d; /* new length */
6642	*dropped=d; /* report the count */
6643	return dn;
6644	} /* decTrim */
6645
6646	/* ------------------------------------------------------------------ */
6647	/* decReverse -- reverse a Unit array in place */
6648	/* */
6649	/* ulo is the start of the array */
6650	/* uhi is the end of the array (highest Unit to include) */
6651	/* */
6652	/* The units ulo through uhi are reversed in place (if the number */
6653	/* of units is odd, the middle one is untouched). Note that the */
6654	/* digit(s) in each unit are unaffected. */
6655	/* ------------------------------------------------------------------ */
6656	static void decReverse(Unit *ulo, Unit *uhi) {
6657	Unit temp;
6658	for (; ulo<uhi; ulo++, uhi--) {
6659	temp=*ulo;
6660	*ulo=*uhi;
6661	*uhi=temp;
6662	}
6663	return;
6664	} /* decReverse */
6665
6666	/* ------------------------------------------------------------------ */
6667	/* decShiftToMost -- shift digits in array towards most significant */
6668	/* */
6669	/* uar is the array */
6670	/* digits is the count of digits in use in the array */
6671	/* shift is the number of zeros to pad with (least significant); */
6672	/* it must be zero or positive */
6673	/* */
6674	/* returns the new length of the integer in the array, in digits */
6675	/* */
6676	/* No overflow is permitted (that is, the uar array must be known to */
6677	/* be large enough to hold the result, after shifting). */
6678	/* ------------------------------------------------------------------ */
6679	static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6680	Unit *target, *source, *first; /* work */
6681	Int cut; /* odd 0's to add */
6682	uInt next; /* work */
6683
6684	if (shift==0) return digits; /* [fastpath] nothing to do */
6685	if ((digits+shift)<=DECDPUN) { /* [fastpath] single-unit case */
6686	*uar=(Unit)(*uar*powers[shift]);
6687	return digits+shift;
6688	}
6689
6690	next=0; /* all paths */
6691	source=uar+D2U(digits)-1; /* where msu comes from */
6692	target=source+D2U(shift); /* where upper part of first cut goes */
6693	cut=DECDPUN-MSUDIGITS(shift); /* where to slice */
6694	if (cut==0) { /* unit-boundary case */
6695	for (; source>=uar; source--, target--) *target=*source;
6696	}
6697	else {
6698	first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6699	for (; source>=uar; source--, target--) {
6700	/* split the source Unit and accumulate remainder for next */
6701	#if DECDPUN<=4
6702	uInt quot=QUOT10(*source, cut);
6703	uInt rem=*source-quot*powers[cut];
6704	next+=quot;
6705	#else
6706	uInt rem=*source%powers[cut];
6707	next+=*source/powers[cut];
6708	#endif
6709	if (target<=first) *target=(Unit)next; /* write to target iff valid */
6710	next=rem*powers[DECDPUN-cut]; /* save remainder for next Unit */
6711	}
6712	} /* shift-move */
6713
6714	/* propagate any partial unit to one below and clear the rest */
6715	for (; target>=uar; target--) {
6716	*target=(Unit)next;
6717	next=0;
6718	}
6719	return digits+shift;
6720	} /* decShiftToMost */
6721
6722	/* ------------------------------------------------------------------ */
6723	/* decShiftToLeast -- shift digits in array towards least significant */
6724	/* */
6725	/* uar is the array */
6726	/* units is length of the array, in units */
6727	/* shift is the number of digits to remove from the lsu end; it */
6728	/* must be zero or positive and <= than units*DECDPUN. */
6729	/* */
6730	/* returns the new length of the integer in the array, in units */
6731	/* */
6732	/* Removed digits are discarded (lost). Units not required to hold */
6733	/* the final result are unchanged. */
6734	/* ------------------------------------------------------------------ */
6735	static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6736	Unit *target, *up; /* work */
6737	Int cut, count; /* work */
6738	Int quot, rem; /* for division */
6739
6740	if (shift==0) return units; /* [fastpath] nothing to do */
6741	if (shift==units*DECDPUN) { /* [fastpath] little to do */
6742	*uar=0; /* all digits cleared gives zero */
6743	return 1; /* leaves just the one */
6744	}
6745
6746	target=uar; /* both paths */
6747	cut=MSUDIGITS(shift);
6748	if (cut==DECDPUN) { /* unit-boundary case; easy */
6749	up=uar+D2U(shift);
6750	for (; up<uar+units; target++, up++) *target=*up;
6751	return target-uar;
6752	}
6753
6754	/* messier */
6755	up=uar+D2U(shift-cut); /* source; correct to whole Units */
6756	count=units*DECDPUN-shift; /* the maximum new length */
6757	#if DECDPUN<=4
6758	quot=QUOT10(*up, cut);
6759	#else
6760	quot=*up/powers[cut];
6761	#endif
6762	for (; ; target++) {
6763	*target=(Unit)quot;
6764	count-=(DECDPUN-cut);
6765	if (count<=0) break;
6766	up++;
6767	quot=*up;
6768	#if DECDPUN<=4
6769	quot=QUOT10(quot, cut);
6770	rem=*up-quot*powers[cut];
6771	#else
6772	rem=quot%powers[cut];
6773	quot=quot/powers[cut];
6774	#endif
6775	*target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6776	count-=cut;
6777	if (count<=0) break;
6778	}
6779	return target-uar+1;
6780	} /* decShiftToLeast */
6781
6782	#if DECSUBSET
6783	/* ------------------------------------------------------------------ */
6784	/* decRoundOperand -- round an operand [used for subset only] */
6785	/* */
6786	/* dn is the number to round (dn->digits is > set->digits) */
6787	/* set is the relevant context */
6788	/* status is the status accumulator */
6789	/* */
6790	/* returns an allocated decNumber with the rounded result. */
6791	/* */
6792	/* lostDigits and other status may be set by this. */
6793	/* */
6794	/* Since the input is an operand, it must not be modified. */
6795	/* Instead, return an allocated decNumber, rounded as required. */
6796	/* It is the caller's responsibility to free the allocated storage. */
6797	/* */
6798	/* If no storage is available then the result cannot be used, so NULL */
6799	/* is returned. */
6800	/* ------------------------------------------------------------------ */
6801	static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6802	uInt *status) {
6803	decNumber *res; /* result structure */
6804	uInt newstatus=0; /* status from round */
6805	Int residue=0; /* rounding accumulator */
6806
6807	/* Allocate storage for the returned decNumber, big enough for the */
6808	/* length specified by the context */
6809	res=(decNumber *)malloc(sizeof(decNumber)
6810	+(D2U(set->digits)-1)*sizeof(Unit));
6811	if (res==NULL) {
6812	*status|=DEC_Insufficient_storage;
6813	return NULL;
6814	}
6815	decCopyFit(res, dn, set, &residue, &newstatus);
6816	decApplyRound(res, set, residue, &newstatus);
6817
6818	/* If that set Inexact then "lost digits" is raised... */
6819	if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6820	*status|=newstatus;
6821	return res;
6822	} /* decRoundOperand */
6823	#endif
6824
6825	/* ------------------------------------------------------------------ */
6826	/* decCopyFit -- copy a number, truncating the coefficient if needed */
6827	/* */
6828	/* dest is the target decNumber */
6829	/* src is the source decNumber */
6830	/* set is the context [used for length (digits) and rounding mode] */
6831	/* residue is the residue accumulator */
6832	/* status contains the current status to be updated */
6833	/* */
6834	/* (dest==src is allowed and will be a no-op if fits) */
6835	/* All fields are updated as required. */
6836	/* ------------------------------------------------------------------ */
6837	static void decCopyFit(decNumber *dest, const decNumber *src,
6838	decContext *set, Int *residue, uInt *status) {
6839	dest->bits=src->bits;
6840	dest->exponent=src->exponent;
6841	decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6842	} /* decCopyFit */
6843
6844	/* ------------------------------------------------------------------ */
6845	/* decSetCoeff -- set the coefficient of a number */
6846	/* */
6847	/* dn is the number whose coefficient array is to be set. */
6848	/* It must have space for set->digits digits */
6849	/* set is the context [for size] */
6850	/* lsu -> lsu of the source coefficient [may be dn->lsu] */
6851	/* len is digits in the source coefficient [may be dn->digits] */
6852	/* residue is the residue accumulator. This has values as in */
6853	/* decApplyRound, and will be unchanged unless the */
6854	/* target size is less than len. In this case, the */
6855	/* coefficient is truncated and the residue is updated to */
6856	/* reflect the previous residue and the dropped digits. */
6857	/* status is the status accumulator, as usual */
6858	/* */
6859	/* The coefficient may already be in the number, or it can be an */
6860	/* external intermediate array. If it is in the number, lsu must == */
6861	/* dn->lsu and len must == dn->digits. */
6862	/* */
6863	/* Note that the coefficient length (len) may be < set->digits, and */
6864	/* in this case this merely copies the coefficient (or is a no-op */
6865	/* if dn->lsu==lsu). */
6866	/* */
6867	/* Note also that (only internally, from decQuantizeOp and */
6868	/* decSetSubnormal) the value of set->digits may be less than one, */
6869	/* indicating a round to left. This routine handles that case */
6870	/* correctly; caller ensures space. */
6871	/* */
6872	/* dn->digits, dn->lsu (and as required), and dn->exponent are */
6873	/* updated as necessary. dn->bits (sign) is unchanged. */
6874	/* */
6875	/* DEC_Rounded status is set if any digits are discarded. */
6876	/* DEC_Inexact status is set if any non-zero digits are discarded, or */
6877	/* incoming residue was non-0 (implies rounded) */
6878	/* ------------------------------------------------------------------ */
6879	/* mapping array: maps 0-9 to canonical residues, so that a residue */
6880	/* can be adjusted in the range [-1, +1] and achieve correct rounding */
6881	/* 0 1 2 3 4 5 6 7 8 9 */
6882	static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
6883	static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
6884	Int len, Int *residue, uInt *status) {
6885	Int discard; /* number of digits to discard */
6886	uInt cut; /* cut point in Unit */
6887	const Unit *up; /* work */
6888	Unit *target; /* .. */
6889	Int count; /* .. */
6890	#if DECDPUN<=4
6891	uInt temp; /* .. */
6892	#endif
6893
6894	discard=len-set->digits; /* digits to discard */
6895	if (discard<=0) { /* no digits are being discarded */
6896	if (dn->lsu!=lsu) { /* copy needed */
6897	/* copy the coefficient array to the result number; no shift needed */
6898	count=len; /* avoids D2U */
6899	up=lsu;
6900	for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6901	*target=*up;
6902	dn->digits=len; /* set the new length */
6903	}
6904	/* dn->exponent and residue are unchanged, record any inexactitude */
6905	if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
6906	return;
6907	}
6908
6909	/* some digits must be discarded ... */
6910	dn->exponent+=discard; /* maintain numerical value */
6911	*status|=DEC_Rounded; /* accumulate Rounded status */
6912	if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
6913
6914	if (discard>len) { /* everything, +1, is being discarded */
6915	/* guard digit is 0 */
6916	/* residue is all the number [NB could be all 0s] */
6917	if (*residue<=0) { /* not already positive */
6918	count=len; /* avoids D2U */
6919	for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
6920	*residue=1;
6921	break; /* no need to check any others */
6922	}
6923	}
6924	if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
6925	*dn->lsu=0; /* coefficient will now be 0 */
6926	dn->digits=1; /* .. */
6927	return;
6928	} /* total discard */
6929
6930	/* partial discard [most common case] */
6931	/* here, at least the first (most significant) discarded digit exists */
6932
6933	/* spin up the number, noting residue during the spin, until get to */
6934	/* the Unit with the first discarded digit. When reach it, extract */
6935	/* it and remember its position */
6936	count=0;
6937	for (up=lsu;; up++) {
6938	count+=DECDPUN;
6939	if (count>=discard) break; /* full ones all checked */
6940	if (*up!=0) *residue=1;
6941	} /* up */
6942
6943	/* here up -> Unit with first discarded digit */
6944	cut=discard-(count-DECDPUN)-1;
6945	if (cut==DECDPUN-1) { /* unit-boundary case (fast) */
6946	Unit half=(Unit)powers[DECDPUN]>>1;
6947	/* set residue directly */
6948	if (*up>=half) {
6949	if (*up>half) *residue=7;
6950	else *residue+=5; /* add sticky bit */
6951	}
6952	else { /* <half */
6953	if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
6954	}
6955	if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
6956	*dn->lsu=0; /* .. result is 0 */
6957	dn->digits=1; /* .. */
6958	}
6959	else { /* shift to least */
6960	count=set->digits; /* now digits to end up with */
6961	dn->digits=count; /* set the new length */
6962	up++; /* move to next */
6963	/* on unit boundary, so shift-down copy loop is simple */
6964	for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
6965	*target=*up;
6966	}
6967	} /* unit-boundary case */
6968
6969	else { /* discard digit is in low digit(s), and not top digit */
6970	uInt discard1; /* first discarded digit */
6971	uInt quot, rem; /* for divisions */
6972	if (cut==0) quot=*up; /* is at bottom of unit */
6973	else /* cut>0 */ { /* it's not at bottom of unit */
6974	#if DECDPUN<=4
6975	quot=QUOT10(*up, cut);
6976	rem=*up-quot*powers[cut];
6977	#else
6978	rem=*up%powers[cut];
6979	quot=*up/powers[cut];
6980	#endif
6981	if (rem!=0) *residue=1;
6982	}
6983	/* discard digit is now at bottom of quot */
6984	#if DECDPUN<=4
6985	temp=(quot*6554)>>16; /* fast /10 */
6986	/* Vowels algorithm here not a win (9 instructions) */
6987	discard1=quot-X10(temp);
6988	quot=temp;
6989	#else
6990	discard1=quot%10;
6991	quot=quot/10;
6992	#endif
6993	/* here, discard1 is the guard digit, and residue is everything */
6994	/* else [use mapping array to accumulate residue safely] */
6995	*residue+=resmap[discard1];
6996	cut++; /* update cut */
6997	/* here: up -> Unit of the array with bottom digit */
6998	/* cut is the division point for each Unit */
6999	/* quot holds the uncut high-order digits for the current unit */
7000	if (set->digits<=0) { /* special for Quantize/Subnormal :-( */
7001	*dn->lsu=0; /* .. result is 0 */
7002	dn->digits=1; /* .. */
7003	}
7004	else { /* shift to least needed */
7005	count=set->digits; /* now digits to end up with */
7006	dn->digits=count; /* set the new length */
7007	/* shift-copy the coefficient array to the result number */
7008	for (target=dn->lsu; ; target++) {
7009	*target=(Unit)quot;
7010	count-=(DECDPUN-cut);
7011	if (count<=0) break;
7012	up++;
7013	quot=*up;
7014	#if DECDPUN<=4
7015	quot=QUOT10(quot, cut);
7016	rem=*up-quot*powers[cut];
7017	#else
7018	rem=quot%powers[cut];
7019	quot=quot/powers[cut];
7020	#endif
7021	*target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7022	count-=cut;
7023	if (count<=0) break;
7024	} /* shift-copy loop */
7025	} /* shift to least */
7026	} /* not unit boundary */
7027
7028	if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7029	return;
7030	} /* decSetCoeff */
7031
7032	/* ------------------------------------------------------------------ */
7033	/* decApplyRound -- apply pending rounding to a number */
7034	/* */
7035	/* dn is the number, with space for set->digits digits */
7036	/* set is the context [for size and rounding mode] */
7037	/* residue indicates pending rounding, being any accumulated */
7038	/* guard and sticky information. It may be: */
7039	/* 6-9: rounding digit is >5 */
7040	/* 5: rounding digit is exactly half-way */
7041	/* 1-4: rounding digit is <5 and >0 */
7042	/* 0: the coefficient is exact */
7043	/* -1: as 1, but the hidden digits are subtractive, that */
7044	/* is, of the opposite sign to dn. In this case the */
7045	/* coefficient must be non-0. This case occurs when */
7046	/* subtracting a small number (which can be reduced to */
7047	/* a sticky bit); see decAddOp. */
7048	/* status is the status accumulator, as usual */
7049	/* */
7050	/* This routine applies rounding while keeping the length of the */
7051	/* coefficient constant. The exponent and status are unchanged */
7052	/* except if: */
7053	/* */
7054	/* -- the coefficient was increased and is all nines (in which */
7055	/* case Overflow could occur, and is handled directly here so */
7056	/* the caller does not need to re-test for overflow) */
7057	/* */
7058	/* -- the coefficient was decreased and becomes all nines (in which */
7059	/* case Underflow could occur, and is also handled directly). */
7060	/* */
7061	/* All fields in dn are updated as required. */
7062	/* */
7063	/* ------------------------------------------------------------------ */
7064	static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7065	uInt *status) {
7066	Int bump; /* 1 if coefficient needs to be incremented */
7067	/* -1 if coefficient needs to be decremented */
7068
7069	if (residue==0) return; /* nothing to apply */
7070
7071	bump=0; /* assume a smooth ride */
7072
7073	/* now decide whether, and how, to round, depending on mode */
7074	switch (set->round) {
7075	case DEC_ROUND_05UP: { /* round zero or five up (for reround) */
7076	/* This is the same as DEC_ROUND_DOWN unless there is a */
7077	/* positive residue and the lsd of dn is 0 or 5, in which case */
7078	/* it is bumped; when residue is <0, the number is therefore */
7079	/* bumped down unless the final digit was 1 or 6 (in which */
7080	/* case it is bumped down and then up -- a no-op) */
7081	Int lsd5=*dn->lsu%5; /* get lsd and quintate */
7082	if (residue<0 && lsd5!=1) bump=-1;
7083	else if (residue>0 && lsd5==0) bump=1;
7084	/* [bump==1 could be applied directly; use common path for clarity] */
7085	break;} /* r-05 */
7086
7087	case DEC_ROUND_DOWN: {
7088	/* no change, except if negative residue */
7089	if (residue<0) bump=-1;
7090	break;} /* r-d */
7091
7092	case DEC_ROUND_HALF_DOWN: {
7093	if (residue>5) bump=1;
7094	break;} /* r-h-d */
7095
7096	case DEC_ROUND_HALF_EVEN: {
7097	if (residue>5) bump=1; /* >0.5 goes up */
7098	else if (residue==5) { /* exactly 0.5000... */
7099	/* 0.5 goes up iff [new] lsd is odd */
7100	if (*dn->lsu & 0x01) bump=1;
7101	}
7102	break;} /* r-h-e */
7103
7104	case DEC_ROUND_HALF_UP: {
7105	if (residue>=5) bump=1;
7106	break;} /* r-h-u */
7107
7108	case DEC_ROUND_UP: {
7109	if (residue>0) bump=1;
7110	break;} /* r-u */
7111
7112	case DEC_ROUND_CEILING: {
7113	/* same as _UP for positive numbers, and as _DOWN for negatives */
7114	/* [negative residue cannot occur on 0] */
7115	if (decNumberIsNegative(dn)) {
7116	if (residue<0) bump=-1;
7117	}
7118	else {
7119	if (residue>0) bump=1;
7120	}
7121	break;} /* r-c */
7122
7123	case DEC_ROUND_FLOOR: {
7124	/* same as _UP for negative numbers, and as _DOWN for positive */
7125	/* [negative residue cannot occur on 0] */
7126	if (!decNumberIsNegative(dn)) {
7127	if (residue<0) bump=-1;
7128	}
7129	else {
7130	if (residue>0) bump=1;
7131	}
7132	break;} /* r-f */
7133
7134	default: { /* e.g., DEC_ROUND_MAX */
7135	*status|=DEC_Invalid_context;
7136	#if DECTRACE || (DECCHECK && DECVERB)
7137	printf("Unknown rounding mode: %d\n", set->round);
7138	#endif
7139	break;}
7140	} /* switch */
7141
7142	/* now bump the number, up or down, if need be */
7143	if (bump==0) return; /* no action required */
7144
7145	/* Simply use decUnitAddSub unless bumping up and the number is */
7146	/* all nines. In this special case set to 100... explicitly */
7147	/* and adjust the exponent by one (as otherwise could overflow */
7148	/* the array) */
7149	/* Similarly handle all-nines result if bumping down. */
7150	if (bump>0) {
7151	Unit *up; /* work */
7152	uInt count=dn->digits; /* digits to be checked */
7153	for (up=dn->lsu; ; up++) {
7154	if (count<=DECDPUN) {
7155	/* this is the last Unit (the msu) */
7156	if (*up!=powers[count]-1) break; /* not still 9s */
7157	/* here if it, too, is all nines */
7158	*up=(Unit)powers[count-1]; /* here 999 -> 100 etc. */
7159	for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7160	dn->exponent++; /* and bump exponent */
7161	/* [which, very rarely, could cause Overflow...] */
7162	if ((dn->exponent+dn->digits)>set->emax+1) {
7163	decSetOverflow(dn, set, status);
7164	}
7165	return; /* done */
7166	}
7167	/* a full unit to check, with more to come */
7168	if (*up!=DECDPUNMAX) break; /* not still 9s */
7169	count-=DECDPUN;
7170	} /* up */
7171	} /* bump>0 */
7172	else { /* -1 */
7173	/* here checking for a pre-bump of 1000... (leading 1, all */
7174	/* other digits zero) */
7175	Unit *up, *sup; /* work */
7176	uInt count=dn->digits; /* digits to be checked */
7177	for (up=dn->lsu; ; up++) {
7178	if (count<=DECDPUN) {
7179	/* this is the last Unit (the msu) */
7180	if (*up!=powers[count-1]) break; /* not 100.. */
7181	/* here if have the 1000... case */
7182	sup=up; /* save msu pointer */
7183	*up=(Unit)powers[count]-1; /* here 100 in msu -> 999 */
7184	/* others all to all-nines, too */
7185	for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7186	dn->exponent--; /* and bump exponent */
7187
7188	/* iff the number was at the subnormal boundary (exponent=etiny) */
7189	/* then the exponent is now out of range, so it will in fact get */
7190	/* clamped to etiny and the final 9 dropped. */
7191	/* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7192	/* dn->exponent, set->digits); */
7193	if (dn->exponent+1==set->emin-set->digits+1) {
7194	if (count==1 && dn->digits==1) *sup=0; /* here 9 -> 0[.9] */
7195	else {
7196	*sup=(Unit)powers[count-1]-1; /* here 999.. in msu -> 99.. */
7197	dn->digits--;
7198	}
7199	dn->exponent++;
7200	*status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7201	}
7202	return; /* done */
7203	}
7204
7205	/* a full unit to check, with more to come */
7206	if (*up!=0) break; /* not still 0s */
7207	count-=DECDPUN;
7208	} /* up */
7209
7210	} /* bump<0 */
7211
7212	/* Actual bump needed. Do it. */
7213	decUnitAddSub(a: dn->lsu, D2U(dn->digits), b: uarrone, blength: 1, bshift: 0, c: dn->lsu, m: bump);
7214	} /* decApplyRound */
7215
7216	#if DECSUBSET
7217	/* ------------------------------------------------------------------ */
7218	/* decFinish -- finish processing a number */
7219	/* */
7220	/* dn is the number */
7221	/* set is the context */
7222	/* residue is the rounding accumulator (as in decApplyRound) */
7223	/* status is the accumulator */
7224	/* */
7225	/* This finishes off the current number by: */
7226	/* 1. If not extended: */
7227	/* a. Converting a zero result to clean '0' */
7228	/* b. Reducing positive exponents to 0, if would fit in digits */
7229	/* 2. Checking for overflow and subnormals (always) */
7230	/* Note this is just Finalize when no subset arithmetic. */
7231	/* All fields are updated as required. */
7232	/* ------------------------------------------------------------------ */
7233	static void decFinish(decNumber *dn, decContext *set, Int *residue,
7234	uInt *status) {
7235	if (!set->extended) {
7236	if ISZERO(dn) { /* value is zero */
7237	dn->exponent=0; /* clean exponent .. */
7238	dn->bits=0; /* .. and sign */
7239	return; /* no error possible */
7240	}
7241	if (dn->exponent>=0) { /* non-negative exponent */
7242	/* >0; reduce to integer if possible */
7243	if (set->digits >= (dn->exponent+dn->digits)) {
7244	dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7245	dn->exponent=0;
7246	}
7247	}
7248	} /* !extended */
7249
7250	decFinalize(dn, set, residue, status);
7251	} /* decFinish */
7252	#endif
7253
7254	/* ------------------------------------------------------------------ */
7255	/* decFinalize -- final check, clamp, and round of a number */
7256	/* */
7257	/* dn is the number */
7258	/* set is the context */
7259	/* residue is the rounding accumulator (as in decApplyRound) */
7260	/* status is the status accumulator */
7261	/* */
7262	/* This finishes off the current number by checking for subnormal */
7263	/* results, applying any pending rounding, checking for overflow, */
7264	/* and applying any clamping. */
7265	/* Underflow and overflow conditions are raised as appropriate. */
7266	/* All fields are updated as required. */
7267	/* ------------------------------------------------------------------ */
7268	static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7269	uInt *status) {
7270	Int shift; /* shift needed if clamping */
7271	Int tinyexp=set->emin-dn->digits+1; /* precalculate subnormal boundary */
7272
7273	/* Must be careful, here, when checking the exponent as the */
7274	/* adjusted exponent could overflow 31 bits [because it may already */
7275	/* be up to twice the expected]. */
7276
7277	/* First test for subnormal. This must be done before any final */
7278	/* round as the result could be rounded to Nmin or 0. */
7279	if (dn->exponent<=tinyexp) { /* prefilter */
7280	Int comp;
7281	decNumber nmin;
7282	/* A very nasty case here is dn == Nmin and residue<0 */
7283	if (dn->exponent<tinyexp) {
7284	/* Go handle subnormals; this will apply round if needed. */
7285	decSetSubnormal(dn, set, residue, status);
7286	return;
7287	}
7288	/* Equals case: only subnormal if dn=Nmin and negative residue */
7289	decNumberZero(dn: &nmin);
7290	nmin.lsu[0]=1;
7291	nmin.exponent=set->emin;
7292	comp=decCompare(lhs: dn, rhs: &nmin, abs: 1); /* (signless compare) */
7293	if (comp==BADINT) { /* oops */
7294	*status|=DEC_Insufficient_storage; /* abandon... */
7295	return;
7296	}
7297	if (*residue<0 && comp==0) { /* neg residue and dn==Nmin */
7298	decApplyRound(dn, set, residue: *residue, status); /* might force down */
7299	decSetSubnormal(dn, set, residue, status);
7300	return;
7301	}
7302	}
7303
7304	/* now apply any pending round (this could raise overflow). */
7305	if (*residue!=0) decApplyRound(dn, set, residue: *residue, status);
7306
7307	/* Check for overflow [redundant in the 'rare' case] or clamp */
7308	if (dn->exponent<=set->emax-set->digits+1) return; /* neither needed */
7309
7310
7311	/* here when might have an overflow or clamp to do */
7312	if (dn->exponent>set->emax-dn->digits+1) { /* too big */
7313	decSetOverflow(dn, set, status);
7314	return;
7315	}
7316	/* here when the result is normal but in clamp range */
7317	if (!set->clamp) return;
7318
7319	/* here when need to apply the IEEE exponent clamp (fold-down) */
7320	shift=dn->exponent-(set->emax-set->digits+1);
7321
7322	/* shift coefficient (if non-zero) */
7323	if (!ISZERO(dn)) {
7324	dn->digits=decShiftToMost(uar: dn->lsu, digits: dn->digits, shift);
7325	}
7326	dn->exponent-=shift; /* adjust the exponent to match */
7327	*status|=DEC_Clamped; /* and record the dirty deed */
7328	return;
7329	} /* decFinalize */
7330
7331	/* ------------------------------------------------------------------ */
7332	/* decSetOverflow -- set number to proper overflow value */
7333	/* */
7334	/* dn is the number (used for sign [only] and result) */
7335	/* set is the context [used for the rounding mode, etc.] */
7336	/* status contains the current status to be updated */
7337	/* */
7338	/* This sets the sign of a number and sets its value to either */
7339	/* Infinity or the maximum finite value, depending on the sign of */
7340	/* dn and the rounding mode, following IEEE 754 rules. */
7341	/* ------------------------------------------------------------------ */
7342	static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7343	Flag needmax=0; /* result is maximum finite value */
7344	uByte sign=dn->bits&DECNEG; /* clean and save sign bit */
7345
7346	if (ISZERO(dn)) { /* zero does not overflow magnitude */
7347	Int emax=set->emax; /* limit value */
7348	if (set->clamp) emax-=set->digits-1; /* lower if clamping */
7349	if (dn->exponent>emax) { /* clamp required */
7350	dn->exponent=emax;
7351	*status|=DEC_Clamped;
7352	}
7353	return;
7354	}
7355
7356	decNumberZero(dn);
7357	switch (set->round) {
7358	case DEC_ROUND_DOWN: {
7359	needmax=1; /* never Infinity */
7360	break;} /* r-d */
7361	case DEC_ROUND_05UP: {
7362	needmax=1; /* never Infinity */
7363	break;} /* r-05 */
7364	case DEC_ROUND_CEILING: {
7365	if (sign) needmax=1; /* Infinity if non-negative */
7366	break;} /* r-c */
7367	case DEC_ROUND_FLOOR: {
7368	if (!sign) needmax=1; /* Infinity if negative */
7369	break;} /* r-f */
7370	default: break; /* Infinity in all other cases */
7371	}
7372	if (needmax) {
7373	decSetMaxValue(dn, set);
7374	dn->bits=sign; /* set sign */
7375	}
7376	else dn->bits=sign|DECINF; /* Value is +/-Infinity */
7377	*status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7378	} /* decSetOverflow */
7379
7380	/* ------------------------------------------------------------------ */
7381	/* decSetMaxValue -- set number to +Nmax (maximum normal value) */
7382	/* */
7383	/* dn is the number to set */
7384	/* set is the context [used for digits and emax] */
7385	/* */
7386	/* This sets the number to the maximum positive value. */
7387	/* ------------------------------------------------------------------ */
7388	static void decSetMaxValue(decNumber *dn, decContext *set) {
7389	Unit *up; /* work */
7390	Int count=set->digits; /* nines to add */
7391	dn->digits=count;
7392	/* fill in all nines to set maximum value */
7393	for (up=dn->lsu; ; up++) {
7394	if (count>DECDPUN) *up=DECDPUNMAX; /* unit full o'nines */
7395	else { /* this is the msu */
7396	*up=(Unit)(powers[count]-1);
7397	break;
7398	}
7399	count-=DECDPUN; /* filled those digits */
7400	} /* up */
7401	dn->bits=0; /* + sign */
7402	dn->exponent=set->emax-set->digits+1;
7403	} /* decSetMaxValue */
7404
7405	/* ------------------------------------------------------------------ */
7406	/* decSetSubnormal -- process value whose exponent is <Emin */
7407	/* */
7408	/* dn is the number (used as input as well as output; it may have */
7409	/* an allowed subnormal value, which may need to be rounded) */
7410	/* set is the context [used for the rounding mode] */
7411	/* residue is any pending residue */
7412	/* status contains the current status to be updated */
7413	/* */
7414	/* If subset mode, set result to zero and set Underflow flags. */
7415	/* */
7416	/* Value may be zero with a low exponent; this does not set Subnormal */
7417	/* but the exponent will be clamped to Etiny. */
7418	/* */
7419	/* Otherwise ensure exponent is not out of range, and round as */
7420	/* necessary. Underflow is set if the result is Inexact. */
7421	/* ------------------------------------------------------------------ */
7422	static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7423	uInt *status) {
7424	decContext workset; /* work */
7425	Int etiny, adjust; /* .. */
7426
7427	#if DECSUBSET
7428	/* simple set to zero and 'hard underflow' for subset */
7429	if (!set->extended) {
7430	decNumberZero(dn);
7431	/* always full overflow */
7432	*status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7433	return;
7434	}
7435	#endif
7436
7437	/* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7438	/* (Etiny) if needed */
7439	etiny=set->emin-(set->digits-1); /* smallest allowed exponent */
7440
7441	if ISZERO(dn) { /* value is zero */
7442	/* residue can never be non-zero here */
7443	#if DECCHECK
7444	if (*residue!=0) {
7445	printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7446	*status|=DEC_Invalid_operation;
7447	}
7448	#endif
7449	if (dn->exponent<etiny) { /* clamp required */
7450	dn->exponent=etiny;
7451	*status|=DEC_Clamped;
7452	}
7453	return;
7454	}
7455
7456	*status|=DEC_Subnormal; /* have a non-zero subnormal */
7457	adjust=etiny-dn->exponent; /* calculate digits to remove */
7458	if (adjust<=0) { /* not out of range; unrounded */
7459	/* residue can never be non-zero here, except in the Nmin-residue */
7460	/* case (which is a subnormal result), so can take fast-path here */
7461	/* it may already be inexact (from setting the coefficient) */
7462	if (*status&DEC_Inexact) *status|=DEC_Underflow;
7463	return;
7464	}
7465
7466	/* adjust>0, so need to rescale the result so exponent becomes Etiny */
7467	/* [this code is similar to that in rescale] */
7468	workset=*set; /* clone rounding, etc. */
7469	workset.digits=dn->digits-adjust; /* set requested length */
7470	workset.emin-=adjust; /* and adjust emin to match */
7471	/* [note that the latter can be <1, here, similar to Rescale case] */
7472	decSetCoeff(dn, set: &workset, lsu: dn->lsu, len: dn->digits, residue, status);
7473	decApplyRound(dn, set: &workset, residue: *residue, status);
7474
7475	/* Use 754 default rule: Underflow is set iff Inexact */
7476	/* [independent of whether trapped] */
7477	if (*status&DEC_Inexact) *status|=DEC_Underflow;
7478
7479	/* if rounded up a 999s case, exponent will be off by one; adjust */
7480	/* back if so [it will fit, because it was shortened earlier] */
7481	if (dn->exponent>etiny) {
7482	dn->digits=decShiftToMost(uar: dn->lsu, digits: dn->digits, shift: 1);
7483	dn->exponent--; /* (re)adjust the exponent. */
7484	}
7485
7486	/* if rounded to zero, it is by definition clamped... */
7487	if (ISZERO(dn)) *status|=DEC_Clamped;
7488	} /* decSetSubnormal */
7489
7490	/* ------------------------------------------------------------------ */
7491	/* decCheckMath - check entry conditions for a math function */
7492	/* */
7493	/* This checks the context and the operand */
7494	/* */
7495	/* rhs is the operand to check */
7496	/* set is the context to check */
7497	/* status is unchanged if both are good */
7498	/* */
7499	/* returns non-zero if status is changed, 0 otherwise */
7500	/* */
7501	/* Restrictions enforced: */
7502	/* */
7503	/* digits, emax, and -emin in the context must be less than */
7504	/* DEC_MAX_MATH (999999), and A must be within these bounds if */
7505	/* non-zero. Invalid_operation is set in the status if a */
7506	/* restriction is violated. */
7507	/* ------------------------------------------------------------------ */
7508	static uInt decCheckMath(const decNumber *rhs, decContext *set,
7509	uInt *status) {
7510	uInt save=*status; /* record */
7511	if (set->digits>DEC_MAX_MATH
7512	|| set->emax>DEC_MAX_MATH
7513	|| -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7514	else if ((rhs->digits>DEC_MAX_MATH
7515	|| rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7516	|| rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7517	&& !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7518	return (*status!=save);
7519	} /* decCheckMath */
7520
7521	/* ------------------------------------------------------------------ */
7522	/* decGetInt -- get integer from a number */
7523	/* */
7524	/* dn is the number [which will not be altered] */
7525	/* */
7526	/* returns one of: */
7527	/* BADINT if there is a non-zero fraction */
7528	/* the converted integer */
7529	/* BIGEVEN if the integer is even and magnitude > 2*10**9 */
7530	/* BIGODD if the integer is odd and magnitude > 2*10**9 */
7531	/* */
7532	/* This checks and gets a whole number from the input decNumber. */
7533	/* The sign can be determined from dn by the caller when BIGEVEN or */
7534	/* BIGODD is returned. */
7535	/* ------------------------------------------------------------------ */
7536	static Int decGetInt(const decNumber *dn) {
7537	Int theInt; /* result accumulator */
7538	const Unit *up; /* work */
7539	Int got; /* digits (real or not) processed */
7540	Int ilength=dn->digits+dn->exponent; /* integral length */
7541	Flag neg=decNumberIsNegative(dn); /* 1 if -ve */
7542
7543	/* The number must be an integer that fits in 10 digits */
7544	/* Assert, here, that 10 is enough for any rescale Etiny */
7545	#if DEC_MAX_EMAX > 999999999
7546	#error GetInt may need updating [for Emax]
7547	#endif
7548	#if DEC_MIN_EMIN < -999999999
7549	#error GetInt may need updating [for Emin]
7550	#endif
7551	if (ISZERO(dn)) return 0; /* zeros are OK, with any exponent */
7552
7553	up=dn->lsu; /* ready for lsu */
7554	theInt=0; /* ready to accumulate */
7555	if (dn->exponent>=0) { /* relatively easy */
7556	/* no fractional part [usual]; allow for positive exponent */
7557	got=dn->exponent;
7558	}
7559	else { /* -ve exponent; some fractional part to check and discard */
7560	Int count=-dn->exponent; /* digits to discard */
7561	/* spin up whole units until reach the Unit with the unit digit */
7562	for (; count>=DECDPUN; up++) {
7563	if (*up!=0) return BADINT; /* non-zero Unit to discard */
7564	count-=DECDPUN;
7565	}
7566	if (count==0) got=0; /* [a multiple of DECDPUN] */
7567	else { /* [not multiple of DECDPUN] */
7568	Int rem; /* work */
7569	/* slice off fraction digits and check for non-zero */
7570	#if DECDPUN<=4
7571	theInt=QUOT10(*up, count);
7572	rem=*up-theInt*powers[count];
7573	#else
7574	rem=*up%powers[count]; /* slice off discards */
7575	theInt=*up/powers[count];
7576	#endif
7577	if (rem!=0) return BADINT; /* non-zero fraction */
7578	/* it looks good */
7579	got=DECDPUN-count; /* number of digits so far */
7580	up++; /* ready for next */
7581	}
7582	}
7583	/* now it's known there's no fractional part */
7584
7585	/* tricky code now, to accumulate up to 9.3 digits */
7586	if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7587
7588	if (ilength<11) {
7589	Int save=theInt;
7590	/* collect any remaining unit(s) */
7591	for (; got<ilength; up++) {
7592	theInt+=*up*powers[got];
7593	got+=DECDPUN;
7594	}
7595	if (ilength==10) { /* need to check for wrap */
7596	if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7597	/* [that test also disallows the BADINT result case] */
7598	else if (neg && theInt>1999999997) ilength=11;
7599	else if (!neg && theInt>999999999) ilength=11;
7600	if (ilength==11) theInt=save; /* restore correct low bit */
7601	}
7602	}
7603
7604	if (ilength>10) { /* too big */
7605	if (theInt&1) return BIGODD; /* bottom bit 1 */
7606	return BIGEVEN; /* bottom bit 0 */
7607	}
7608
7609	if (neg) theInt=-theInt; /* apply sign */
7610	return theInt;
7611	} /* decGetInt */
7612
7613	/* ------------------------------------------------------------------ */
7614	/* decDecap -- decapitate the coefficient of a number */
7615	/* */
7616	/* dn is the number to be decapitated */
7617	/* drop is the number of digits to be removed from the left of dn; */
7618	/* this must be <= dn->digits (if equal, the coefficient is */
7619	/* set to 0) */
7620	/* */
7621	/* Returns dn; dn->digits will be <= the initial digits less drop */
7622	/* (after removing drop digits there may be leading zero digits */
7623	/* which will also be removed). Only dn->lsu and dn->digits change. */
7624	/* ------------------------------------------------------------------ */
7625	static decNumber *decDecap(decNumber *dn, Int drop) {
7626	Unit *msu; /* -> target cut point */
7627	Int cut; /* work */
7628	if (drop>=dn->digits) { /* losing the whole thing */
7629	#if DECCHECK
7630	if (drop>dn->digits)
7631	printf("decDecap called with drop>digits [%ld>%ld]\n",
7632	(LI)drop, (LI)dn->digits);
7633	#endif
7634	dn->lsu[0]=0;
7635	dn->digits=1;
7636	return dn;
7637	}
7638	msu=dn->lsu+D2U(dn->digits-drop)-1; /* -> likely msu */
7639	cut=MSUDIGITS(dn->digits-drop); /* digits to be in use in msu */
7640	if (cut!=DECDPUN) *msu%=powers[cut]; /* clear left digits */
7641	/* that may have left leading zero digits, so do a proper count... */
7642	dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7643	return dn;
7644	} /* decDecap */
7645
7646	/* ------------------------------------------------------------------ */
7647	/* decBiStr -- compare string with pairwise options */
7648	/* */
7649	/* targ is the string to compare */
7650	/* str1 is one of the strings to compare against (length may be 0) */
7651	/* str2 is the other; it must be the same length as str1 */
7652	/* */
7653	/* returns 1 if strings compare equal, (that is, it is the same */
7654	/* length as str1 and str2, and each character of targ is in either */
7655	/* str1 or str2 in the corresponding position), or 0 otherwise */
7656	/* */
7657	/* This is used for generic caseless compare, including the awkward */
7658	/* case of the Turkish dotted and dotless Is. Use as (for example): */
7659	/* if (decBiStr(test, "mike", "MIKE")) ... */
7660	/* ------------------------------------------------------------------ */
7661	static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7662	for (;;targ++, str1++, str2++) {
7663	if (*targ!=*str1 && *targ!=*str2) return 0;
7664	/* *targ has a match in one (or both, if terminator) */
7665	if (*targ=='\0') break;
7666	} /* forever */
7667	return 1;
7668	} /* decBiStr */
7669
7670	/* ------------------------------------------------------------------ */
7671	/* decNaNs -- handle NaN operand or operands */
7672	/* */
7673	/* res is the result number */
7674	/* lhs is the first operand */
7675	/* rhs is the second operand, or NULL if none */
7676	/* context is used to limit payload length */
7677	/* status contains the current status */
7678	/* returns res in case convenient */
7679	/* */
7680	/* Called when one or both operands is a NaN, and propagates the */
7681	/* appropriate result to res. When an sNaN is found, it is changed */
7682	/* to a qNaN and Invalid operation is set. */
7683	/* ------------------------------------------------------------------ */
7684	static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7685	const decNumber *rhs, decContext *set,
7686	uInt *status) {
7687	/* This decision tree ends up with LHS being the source pointer, */
7688	/* and status updated if need be */
7689	if (lhs->bits & DECSNAN)
7690	*status|=DEC_Invalid_operation | DEC_sNaN;
7691	else if (rhs==NULL);
7692	else if (rhs->bits & DECSNAN) {
7693	lhs=rhs;
7694	*status|=DEC_Invalid_operation | DEC_sNaN;
7695	}
7696	else if (lhs->bits & DECNAN);
7697	else lhs=rhs;
7698
7699	/* propagate the payload */
7700	if (lhs->digits<=set->digits) decNumberCopy(dest: res, src: lhs); /* easy */
7701	else { /* too long */
7702	const Unit *ul;
7703	Unit *ur, *uresp1;
7704	/* copy safe number of units, then decapitate */
7705	res->bits=lhs->bits; /* need sign etc. */
7706	uresp1=res->lsu+D2U(set->digits);
7707	for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7708	res->digits=D2U(set->digits)*DECDPUN;
7709	/* maybe still too long */
7710	if (res->digits>set->digits) decDecap(dn: res, drop: res->digits-set->digits);
7711	}
7712
7713	res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */
7714	res->bits|=DECNAN; /* .. preserving sign */
7715	res->exponent=0; /* clean exponent */
7716	/* [coefficient was copied/decapitated] */
7717	return res;
7718	} /* decNaNs */
7719
7720	/* ------------------------------------------------------------------ */
7721	/* decStatus -- apply non-zero status */
7722	/* */
7723	/* dn is the number to set if error */
7724	/* status contains the current status (not yet in context) */
7725	/* set is the context */
7726	/* */
7727	/* If the status is an error status, the number is set to a NaN, */
7728	/* unless the error was an overflow, divide-by-zero, or underflow, */
7729	/* in which case the number will have already been set. */
7730	/* */
7731	/* The context status is then updated with the new status. Note that */
7732	/* this may raise a signal, so control may never return from this */
7733	/* routine (hence resources must be recovered before it is called). */
7734	/* ------------------------------------------------------------------ */
7735	static void decStatus(decNumber *dn, uInt status, decContext *set) {
7736	if (status & DEC_NaNs) { /* error status -> NaN */
7737	/* if cause was an sNaN, clear and propagate [NaN is already set up] */
7738	if (status & DEC_sNaN) status&=~DEC_sNaN;
7739	else {
7740	decNumberZero(dn); /* other error: clean throughout */
7741	dn->bits=DECNAN; /* and make a quiet NaN */
7742	}
7743	}
7744	decContextSetStatus(set, status); /* [may not return] */
7745	return;
7746	} /* decStatus */
7747
7748	/* ------------------------------------------------------------------ */
7749	/* decGetDigits -- count digits in a Units array */
7750	/* */
7751	/* uar is the Unit array holding the number (this is often an */
7752	/* accumulator of some sort) */
7753	/* len is the length of the array in units [>=1] */
7754	/* */
7755	/* returns the number of (significant) digits in the array */
7756	/* */
7757	/* All leading zeros are excluded, except the last if the array has */
7758	/* only zero Units. */
7759	/* ------------------------------------------------------------------ */
7760	/* This may be called twice during some operations. */
7761	static Int decGetDigits(Unit *uar, Int len) {
7762	Unit *up=uar+(len-1); /* -> msu */
7763	Int digits=(len-1)*DECDPUN+1; /* possible digits excluding msu */
7764	#if DECDPUN>4
7765	uInt const *pow; /* work */
7766	#endif
7767	/* (at least 1 in final msu) */
7768	#if DECCHECK
7769	if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7770	#endif
7771
7772	for (; up>=uar; up--) {
7773	if (*up==0) { /* unit is all 0s */
7774	if (digits==1) break; /* a zero has one digit */
7775	digits-=DECDPUN; /* adjust for 0 unit */
7776	continue;}
7777	/* found the first (most significant) non-zero Unit */
7778	#if DECDPUN>1 /* not done yet */
7779	if (*up<10) break; /* is 1-9 */
7780	digits++;
7781	#if DECDPUN>2 /* not done yet */
7782	if (*up<100) break; /* is 10-99 */
7783	digits++;
7784	#if DECDPUN>3 /* not done yet */
7785	if (*up<1000) break; /* is 100-999 */
7786	digits++;
7787	#if DECDPUN>4 /* count the rest ... */
7788	for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7789	#endif
7790	#endif
7791	#endif
7792	#endif
7793	break;
7794	} /* up */
7795	return digits;
7796	} /* decGetDigits */
7797
7798	#if DECTRACE | DECCHECK
7799	/* ------------------------------------------------------------------ */
7800	/* decNumberShow -- display a number [debug aid] */
7801	/* dn is the number to show */
7802	/* */
7803	/* Shows: sign, exponent, coefficient (msu first), digits */
7804	/* or: sign, special-value */
7805	/* ------------------------------------------------------------------ */
7806	/* this is public so other modules can use it */
7807	void decNumberShow(const decNumber *dn) {
7808	const Unit *up; /* work */
7809	uInt u, d; /* .. */
7810	Int cut; /* .. */
7811	char isign='+'; /* main sign */
7812	if (dn==NULL) {
7813	printf("NULL\n");
7814	return;}
7815	if (decNumberIsNegative(dn)) isign='-';
7816	printf(" >> %c ", isign);
7817	if (dn->bits&DECSPECIAL) { /* Is a special value */
7818	if (decNumberIsInfinite(dn)) printf("Infinity");
7819	else { /* a NaN */
7820	if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */
7821	else printf("NaN");
7822	}
7823	/* if coefficient and exponent are 0, no more to do */
7824	if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
7825	printf("\n");
7826	return;}
7827	/* drop through to report other information */
7828	printf(" ");
7829	}
7830
7831	/* now carefully display the coefficient */
7832	up=dn->lsu+D2U(dn->digits)-1; /* msu */
7833	printf("%ld", (LI)*up);
7834	for (up=up-1; up>=dn->lsu; up--) {
7835	u=*up;
7836	printf(":");
7837	for (cut=DECDPUN-1; cut>=0; cut--) {
7838	d=u/powers[cut];
7839	u-=d*powers[cut];
7840	printf("%ld", (LI)d);
7841	} /* cut */
7842	} /* up */
7843	if (dn->exponent!=0) {
7844	char esign='+';
7845	if (dn->exponent<0) esign='-';
7846	printf(" E%c%ld", esign, (LI)abs(dn->exponent));
7847	}
7848	printf(" [%ld]\n", (LI)dn->digits);
7849	} /* decNumberShow */
7850	#endif
7851
7852	#if DECTRACE || DECCHECK
7853	/* ------------------------------------------------------------------ */
7854	/* decDumpAr -- display a unit array [debug/check aid] */
7855	/* name is a single-character tag name */
7856	/* ar is the array to display */
7857	/* len is the length of the array in Units */
7858	/* ------------------------------------------------------------------ */
7859	static void decDumpAr(char name, const Unit *ar, Int len) {
7860	Int i;
7861	const char *spec;
7862	#if DECDPUN==9
7863	spec="%09d ";
7864	#elif DECDPUN==8
7865	spec="%08d ";
7866	#elif DECDPUN==7
7867	spec="%07d ";
7868	#elif DECDPUN==6
7869	spec="%06d ";
7870	#elif DECDPUN==5
7871	spec="%05d ";
7872	#elif DECDPUN==4
7873	spec="%04d ";
7874	#elif DECDPUN==3
7875	spec="%03d ";
7876	#elif DECDPUN==2
7877	spec="%02d ";
7878	#else
7879	spec="%d ";
7880	#endif
7881	printf(" :%c: ", name);
7882	for (i=len-1; i>=0; i--) {
7883	if (i==len-1) printf("%ld ", (LI)ar[i]);
7884	else printf(spec, ar[i]);
7885	}
7886	printf("\n");
7887	return;}
7888	#endif
7889
7890	#if DECCHECK
7891	/* ------------------------------------------------------------------ */
7892	/* decCheckOperands -- check operand(s) to a routine */
7893	/* res is the result structure (not checked; it will be set to */
7894	/* quiet NaN if error found (and it is not NULL)) */
7895	/* lhs is the first operand (may be DECUNRESU) */
7896	/* rhs is the second (may be DECUNUSED) */
7897	/* set is the context (may be DECUNCONT) */
7898	/* returns 0 if both operands, and the context are clean, or 1 */
7899	/* otherwise (in which case the context will show an error, */
7900	/* unless NULL). Note that res is not cleaned; caller should */
7901	/* handle this so res=NULL case is safe. */
7902	/* The caller is expected to abandon immediately if 1 is returned. */
7903	/* ------------------------------------------------------------------ */
7904	static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
7905	const decNumber *rhs, decContext *set) {
7906	Flag bad=0;
7907	if (set==NULL) { /* oops; hopeless */
7908	#if DECTRACE || DECVERB
7909	printf("Reference to context is NULL.\n");
7910	#endif
7911	bad=1;
7912	return 1;}
7913	else if (set!=DECUNCONT
7914	&& (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
7915	bad=1;
7916	#if DECTRACE || DECVERB
7917	printf("Bad context [digits=%ld round=%ld].\n",
7918	(LI)set->digits, (LI)set->round);
7919	#endif
7920	}
7921	else {
7922	if (res==NULL) {
7923	bad=1;
7924	#if DECTRACE
7925	/* this one not DECVERB as standard tests include NULL */
7926	printf("Reference to result is NULL.\n");
7927	#endif
7928	}
7929	if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
7930	if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
7931	}
7932	if (bad) {
7933	if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
7934	if (res!=DECUNRESU && res!=NULL) {
7935	decNumberZero(res);
7936	res->bits=DECNAN; /* qNaN */
7937	}
7938	}
7939	return bad;
7940	} /* decCheckOperands */
7941
7942	/* ------------------------------------------------------------------ */
7943	/* decCheckNumber -- check a number */
7944	/* dn is the number to check */
7945	/* returns 0 if the number is clean, or 1 otherwise */
7946	/* */
7947	/* The number is considered valid if it could be a result from some */
7948	/* operation in some valid context. */
7949	/* ------------------------------------------------------------------ */
7950	static Flag decCheckNumber(const decNumber *dn) {
7951	const Unit *up; /* work */
7952	uInt maxuint; /* .. */
7953	Int ae, d, digits; /* .. */
7954	Int emin, emax; /* .. */
7955
7956	if (dn==NULL) { /* hopeless */
7957	#if DECTRACE
7958	/* this one not DECVERB as standard tests include NULL */
7959	printf("Reference to decNumber is NULL.\n");
7960	#endif
7961	return 1;}
7962
7963	/* check special values */
7964	if (dn->bits & DECSPECIAL) {
7965	if (dn->exponent!=0) {
7966	#if DECTRACE || DECVERB
7967	printf("Exponent %ld (not 0) for a special value [%02x].\n",
7968	(LI)dn->exponent, dn->bits);
7969	#endif
7970	return 1;}
7971
7972	/* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
7973	if (decNumberIsInfinite(dn)) {
7974	if (dn->digits!=1) {
7975	#if DECTRACE || DECVERB
7976	printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
7977	#endif
7978	return 1;}
7979	if (*dn->lsu!=0) {
7980	#if DECTRACE || DECVERB
7981	printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
7982	#endif
7983	decDumpAr('I', dn->lsu, D2U(dn->digits));
7984	return 1;}
7985	} /* Inf */
7986	/* 2002.12.26: negative NaNs can now appear through proposed IEEE */
7987	/* concrete formats (decimal64, etc.). */
7988	return 0;
7989	}
7990
7991	/* check the coefficient */
7992	if (dn->digits<1 || dn->digits>DECNUMMAXP) {
7993	#if DECTRACE || DECVERB
7994	printf("Digits %ld in number.\n", (LI)dn->digits);
7995	#endif
7996	return 1;}
7997
7998	d=dn->digits;
7999
8000	for (up=dn->lsu; d>0; up++) {
8001	if (d>DECDPUN) maxuint=DECDPUNMAX;
8002	else { /* reached the msu */
8003	maxuint=powers[d]-1;
8004	if (dn->digits>1 && *up<powers[d-1]) {
8005	#if DECTRACE || DECVERB
8006	printf("Leading 0 in number.\n");
8007	decNumberShow(dn);
8008	#endif
8009	return 1;}
8010	}
8011	if (*up>maxuint) {
8012	#if DECTRACE || DECVERB
8013	printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8014	(LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8015	#endif
8016	return 1;}
8017	d-=DECDPUN;
8018	}
8019
8020	/* check the exponent. Note that input operands can have exponents */
8021	/* which are out of the set->emin/set->emax and set->digits range */
8022	/* (just as they can have more digits than set->digits). */
8023	ae=dn->exponent+dn->digits-1; /* adjusted exponent */
8024	emax=DECNUMMAXE;
8025	emin=DECNUMMINE;
8026	digits=DECNUMMAXP;
8027	if (ae<emin-(digits-1)) {
8028	#if DECTRACE || DECVERB
8029	printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8030	decNumberShow(dn);
8031	#endif
8032	return 1;}
8033	if (ae>+emax) {
8034	#if DECTRACE || DECVERB
8035	printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8036	decNumberShow(dn);
8037	#endif
8038	return 1;}
8039
8040	return 0; /* it's OK */
8041	} /* decCheckNumber */
8042
8043	/* ------------------------------------------------------------------ */
8044	/* decCheckInexact -- check a normal finite inexact result has digits */
8045	/* dn is the number to check */
8046	/* set is the context (for status and precision) */
8047	/* sets Invalid operation, etc., if some digits are missing */
8048	/* [this check is not made for DECSUBSET compilation or when */
8049	/* subnormal is not set] */
8050	/* ------------------------------------------------------------------ */
8051	static void decCheckInexact(const decNumber *dn, decContext *set) {
8052	#if !DECSUBSET && DECEXTFLAG
8053	if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8054	&& (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8055	#if DECTRACE || DECVERB
8056	printf("Insufficient digits [%ld] on normal Inexact result.\n",
8057	(LI)dn->digits);
8058	decNumberShow(dn);
8059	#endif
8060	decContextSetStatus(set, DEC_Invalid_operation);
8061	}
8062	#else
8063	/* next is a noop for quiet compiler */
8064	if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8065	#endif
8066	return;
8067	} /* decCheckInexact */
8068	#endif
8069
8070	#if DECALLOC
8071	#undef malloc
8072	#undef free
8073	/* ------------------------------------------------------------------ */
8074	/* decMalloc -- accountable allocation routine */
8075	/* n is the number of bytes to allocate */
8076	/* */
8077	/* Semantics is the same as the stdlib malloc routine, but bytes */
8078	/* allocated are accounted for globally, and corruption fences are */
8079	/* added before and after the 'actual' storage. */
8080	/* ------------------------------------------------------------------ */
8081	/* This routine allocates storage with an extra twelve bytes; 8 are */
8082	/* at the start and hold: */
8083	/* 0-3 the original length requested */
8084	/* 4-7 buffer corruption detection fence (DECFENCE, x4) */
8085	/* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8086	/* ------------------------------------------------------------------ */
8087	static void *decMalloc(size_t n) {
8088	uInt size=n+12; /* true size */
8089	void *alloc; /* -> allocated storage */
8090	uByte *b, *b0; /* work */
8091	uInt uiwork; /* for macros */
8092
8093	alloc=malloc(size); /* -> allocated storage */
8094	if (alloc==NULL) return NULL; /* out of strorage */
8095	b0=(uByte *)alloc; /* as bytes */
8096	decAllocBytes+=n; /* account for storage */
8097	UBFROMUI(alloc, n); /* save n */
8098	/* printf(" alloc ++ dAB: %ld (%ld)\n", (LI)decAllocBytes, (LI)n); */
8099	for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8100	for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8101	return b0+8; /* -> play area */
8102	} /* decMalloc */
8103
8104	/* ------------------------------------------------------------------ */
8105	/* decFree -- accountable free routine */
8106	/* alloc is the storage to free */
8107	/* */
8108	/* Semantics is the same as the stdlib malloc routine, except that */
8109	/* the global storage accounting is updated and the fences are */
8110	/* checked to ensure that no routine has written 'out of bounds'. */
8111	/* ------------------------------------------------------------------ */
8112	/* This routine first checks that the fences have not been corrupted. */
8113	/* It then frees the storage using the 'truw' storage address (that */
8114	/* is, offset by 8). */
8115	/* ------------------------------------------------------------------ */
8116	static void decFree(void *alloc) {
8117	uInt n; /* original length */
8118	uByte *b, *b0; /* work */
8119	uInt uiwork; /* for macros */
8120
8121	if (alloc==NULL) return; /* allowed; it's a nop */
8122	b0=(uByte *)alloc; /* as bytes */
8123	b0-=8; /* -> true start of storage */
8124	n=UBTOUI(b0); /* lift length */
8125	for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8126	printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8127	b-b0-8, (LI)b0);
8128	for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8129	printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8130	b-b0-8, (LI)b0, (LI)n);
8131	free(b0); /* drop the storage */
8132	decAllocBytes-=n; /* account for storage */
8133	/* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8134	} /* decFree */
8135	#define malloc(a) decMalloc(a)
8136	#define free(a) decFree(a)
8137	#endif
8138