qemu

1
/* Decimal number arithmetic module for the decNumber C Library.
2
   Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3
   Contributed by IBM Corporation.  Author Mike Cowlishaw.
4

5
   This file is part of GCC.
6

7
   GCC is free software; you can redistribute it and/or modify it under
8
   the terms of the GNU General Public License as published by the Free
9
   Software Foundation; either version 2, or (at your option) any later
10
   version.
11

12
   In addition to the permissions in the GNU General Public License,
13
   the Free Software Foundation gives you unlimited permission to link
14
   the compiled version of this file into combinations with other
15
   programs, and to distribute those combinations without any
16
   restriction coming from the use of this file.  (The General Public
17
   License restrictions do apply in other respects; for example, they
18
   cover modification of the file, and distribution when not linked
19
   into a combine executable.)
20

21
   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
22
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
23
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
24
   for more details.
25

26
   You should have received a copy of the GNU General Public License
27
   along with GCC; see the file COPYING.  If not, write to the Free
28
   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
29
   02110-1301, USA.  */
30

31
/* ------------------------------------------------------------------ */
32
/* Decimal Number arithmetic module				      */
33
/* ------------------------------------------------------------------ */
34
/* This module comprises the routines for General Decimal Arithmetic  */
35
/* as defined in the specification which may be found on the	      */
36
/* http://www2.hursley.ibm.com/decimal web pages.  It implements both */
37
/* the full ('extended') arithmetic and the simpler ('subset')	      */
38
/* arithmetic.							      */
39
/*								      */
40
/* Usage notes:							      */
41
/*								      */
42
/* 1. This code is ANSI C89 except:				      */
43
/*								      */
44
/*       If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and	      */
45
/*	 uint64_t types may be used.  To avoid these, set DECUSE64=0  */
46
/*	 and DECDPUN<=4 (see documentation).			      */
47
/*								      */
48
/* 2. The decNumber format which this library uses is optimized for   */
49
/*    efficient processing of relatively short numbers; in particular */
50
/*    it allows the use of fixed sized structures and minimizes copy  */
51
/*    and move operations.  It does, however, support arbitrary	      */
52
/*    precision (up to 999,999,999 digits) and arbitrary exponent     */
53
/*    range (Emax in the range 0 through 999,999,999 and Emin in the  */
54
/*    range -999,999,999 through 0).  Mathematical functions (for     */
55
/*    example decNumberExp) as identified below are restricted more   */
56
/*    tightly: digits, emax, and -emin in the context must be <=      */
57
/*    DEC_MAX_MATH (999999), and their operand(s) must be within      */
58
/*    these bounds.						      */
59
/*								      */
60
/* 3. Logical functions are further restricted; their operands must   */
61
/*    be finite, positive, have an exponent of zero, and all digits   */
62
/*    must be either 0 or 1.  The result will only contain digits     */
63
/*    which are 0 or 1 (and will have exponent=0 and a sign of 0).    */
64
/*								      */
65
/* 4. Operands to operator functions are never modified unless they   */
66
/*    are also specified to be the result number (which is always     */
67
/*    permitted).  Other than that case, operands must not overlap.   */
68
/*								      */
69
/* 5. Error handling: the type of the error is ORed into the status   */
70
/*    flags in the current context (decContext structure).  The	      */
71
/*    SIGFPE signal is then raised if the corresponding trap-enabler  */
72
/*    flag in the decContext is set (is 1).			      */
73
/*								      */
74
/*    It is the responsibility of the caller to clear the status      */
75
/*    flags as required.					      */
76
/*								      */
77
/*    The result of any routine which returns a number will always    */
78
/*    be a valid number (which may be a special value, such as an     */
79
/*    Infinity or NaN).						      */
80
/*								      */
81
/* 6. The decNumber format is not an exchangeable concrete	      */
82
/*    representation as it comprises fields which may be machine-     */
83
/*    dependent (packed or unpacked, or special length, for example). */
84
/*    Canonical conversions to and from strings are provided; other   */
85
/*    conversions are available in separate modules.		      */
86
/*								      */
87
/* 7. Normally, input operands are assumed to be valid.	 Set DECCHECK */
88
/*    to 1 for extended operand checking (including NULL operands).   */
89
/*    Results are undefined if a badly-formed structure (or a NULL    */
90
/*    pointer to a structure) is provided, though with DECCHECK	      */
91
/*    enabled the operator routines are protected against exceptions. */
92
/*    (Except if the result pointer is NULL, which is unrecoverable.) */
93
/*								      */
94
/*    However, the routines will never cause exceptions if they are   */
95
/*    given well-formed operands, even if the value of the operands   */
96
/*    is inappropriate for the operation and DECCHECK is not set.     */
97
/*    (Except for SIGFPE, as and where documented.)		      */
98
/*								      */
99
/* 8. Subset arithmetic is available only if DECSUBSET is set to 1.   */
100
/* ------------------------------------------------------------------ */
101
/* Implementation notes for maintenance of this module:		      */
102
/*								      */
103
/* 1. Storage leak protection:	Routines which use malloc are not     */
104
/*    permitted to use return for fastpath or error exits (i.e.,      */
105
/*    they follow strict structured programming conventions).	      */
106
/*    Instead they have a do{}while(0); construct surrounding the     */
107
/*    code which is protected -- break may be used to exit this.      */
108
/*    Other routines can safely use the return statement inline.      */
109
/*								      */
110
/*    Storage leak accounting can be enabled using DECALLOC.	      */
111
/*								      */
112
/* 2. All loops use the for(;;) construct.  Any do construct does     */
113
/*    not loop; it is for allocation protection as just described.    */
114
/*								      */
115
/* 3. Setting status in the context must always be the very last      */
116
/*    action in a routine, as non-0 status may raise a trap and hence */
117
/*    the call to set status may not return (if the handler uses long */
118
/*    jump).  Therefore all cleanup must be done first.	 In general,  */
119
/*    to achieve this status is accumulated and is only applied just  */
120
/*    before return by calling decContextSetStatus (via decStatus).   */
121
/*								      */
122
/*    Routines which allocate storage cannot, in general, use the     */
123
/*    'top level' routines which could cause a non-returning	      */
124
/*    transfer of control.  The decXxxxOp routines are safe (do not   */
125
/*    call decStatus even if traps are set in the context) and should */
126
/*    be used instead (they are also a little faster).		      */
127
/*								      */
128
/* 4. Exponent checking is minimized by allowing the exponent to      */
129
/*    grow outside its limits during calculations, provided that      */
130
/*    the decFinalize function is called later.	 Multiplication and   */
131
/*    division, and intermediate calculations in exponentiation,      */
132
/*    require more careful checks because of the risk of 31-bit	      */
133
/*    overflow (the most negative valid exponent is -1999999997, for  */
134
/*    a 999999999-digit number with adjusted exponent of -999999999). */
135
/*								      */
136
/* 5. Rounding is deferred until finalization of results, with any    */
137
/*    'off to the right' data being represented as a single digit     */
138
/*    residue (in the range -1 through 9).  This avoids any double-   */
139
/*    rounding when more than one shortening takes place (for	      */
140
/*    example, when a result is subnormal).			      */
141
/*								      */
142
/* 6. The digits count is allowed to rise to a multiple of DECDPUN    */
143
/*    during many operations, so whole Units are handled and exact    */
144
/*    accounting of digits is not needed.  The correct digits value   */
145
/*    is found by decGetDigits, which accounts for leading zeros.     */
146
/*    This must be called before any rounding if the number of digits */
147
/*    is not known exactly.					      */
148
/*								      */
149
/* 7. The multiply-by-reciprocal 'trick' is used for partitioning     */
150
/*    numbers up to four digits, using appropriate constants.  This   */
151
/*    is not useful for longer numbers because overflow of 32 bits    */
152
/*    would lead to 4 multiplies, which is almost as expensive as     */
153
/*    a divide (unless a floating-point or 64-bit multiply is	      */
154
/*    assumed to be available).					      */
155
/*								      */
156
/* 8. Unusual abbreviations that may be used in the commentary:	      */
157
/*	lhs -- left hand side (operand, of an operation)	      */
158
/*	lsd -- least significant digit (of coefficient)		      */
159
/*	lsu -- least significant Unit (of coefficient)		      */
160
/*	msd -- most significant digit (of coefficient)		      */
161
/*	msi -- most significant item (in an array)		      */
162
/*	msu -- most significant Unit (of coefficient)		      */
163
/*	rhs -- right hand side (operand, of an operation)	      */
164
/*	+ve -- positive						      */
165
/*	-ve -- negative						      */
166
/*	**  -- raise to the power				      */
167
/* ------------------------------------------------------------------ */
168

169
#include "qemu/osdep.h"
170
#include "qemu/host-utils.h"
171
#include "libdecnumber/dconfig.h"
172
#include "libdecnumber/decNumber.h"
173
#include "libdecnumber/decNumberLocal.h"
174

175
/* Constants */
176
/* Public lookup table used by the D2U macro */
177
const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
178

179
#define DECVERB	    1		   /* set to 1 for verbose DECCHECK */
180
#define powers	    DECPOWERS	   /* old internal name */
181

182
/* Local constants */
183
#define DIVIDE	    0x80	   /* Divide operators */
184
#define REMAINDER   0x40	   /* .. */
185
#define DIVIDEINT   0x20	   /* .. */
186
#define REMNEAR	    0x10	   /* .. */
187
#define COMPARE	    0x01	   /* Compare operators */
188
#define COMPMAX	    0x02	   /* .. */
189
#define COMPMIN	    0x03	   /* .. */
190
#define COMPTOTAL   0x04	   /* .. */
191
#define COMPNAN	    0x05	   /* .. [NaN processing] */
192
#define COMPSIG	    0x06	   /* .. [signaling COMPARE] */
193
#define COMPMAXMAG  0x07	   /* .. */
194
#define COMPMINMAG  0x08	   /* .. */
195

196
#define DEC_sNaN     0x40000000	   /* local status: sNaN signal */
197
#define BADINT	(Int)0x80000000	   /* most-negative Int; error indicator */
198
/* Next two indicate an integer >= 10**6, and its parity (bottom bit) */
199
#define BIGEVEN (Int)0x80000002
200
#define BIGODD	(Int)0x80000003
201

202
static Unit uarrone[1]={1};   /* Unit array of 1, used for incrementing */
203

204
/* Granularity-dependent code */
205
#if DECDPUN<=4
206
  #define eInt	Int	      /* extended integer */
207
  #define ueInt uInt	      /* unsigned extended integer */
208
  /* Constant multipliers for divide-by-power-of five using reciprocal */
209
  /* multiply, after removing powers of 2 by shifting, and final shift */
210
  /* of 17 [we only need up to **4] */
211
  static const uInt multies[]={131073, 26215, 5243, 1049, 210};
212
  /* QUOT10 -- macro to return the quotient of unit u divided by 10**n */
213
  #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
214
#else
215
  /* For DECDPUN>4 non-ANSI-89 64-bit types are needed. */
216
  #if !DECUSE64
217
    #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
218
  #endif
219
  #define eInt	Long	      /* extended integer */
220
  #define ueInt uLong	      /* unsigned extended integer */
221
#endif
222

223
/* Local routines */
224
static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
225
			      decContext *, uByte, uInt *);
226
static Flag	   decBiStr(const char *, const char *, const char *);
227
static uInt	   decCheckMath(const decNumber *, decContext *, uInt *);
228
static void	   decApplyRound(decNumber *, decContext *, Int, uInt *);
229
static Int	   decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
230
static decNumber * decCompareOp(decNumber *, const decNumber *,
231
			      const decNumber *, decContext *,
232
			      Flag, uInt *);
233
static void	   decCopyFit(decNumber *, const decNumber *, decContext *,
234
			      Int *, uInt *);
235
static decNumber * decDecap(decNumber *, Int);
236
static decNumber * decDivideOp(decNumber *, const decNumber *,
237
			      const decNumber *, decContext *, Flag, uInt *);
238
static decNumber * decExpOp(decNumber *, const decNumber *,
239
			      decContext *, uInt *);
240
static void	   decFinalize(decNumber *, decContext *, Int *, uInt *);
241
static Int	   decGetDigits(Unit *, Int);
242
static Int	   decGetInt(const decNumber *);
243
static decNumber * decLnOp(decNumber *, const decNumber *,
244
			      decContext *, uInt *);
245
static decNumber * decMultiplyOp(decNumber *, const decNumber *,
246
			      const decNumber *, decContext *,
247
			      uInt *);
248
static decNumber * decNaNs(decNumber *, const decNumber *,
249
			      const decNumber *, decContext *, uInt *);
250
static decNumber * decQuantizeOp(decNumber *, const decNumber *,
251
			      const decNumber *, decContext *, Flag,
252
			      uInt *);
253
static void	   decReverse(Unit *, Unit *);
254
static void	   decSetCoeff(decNumber *, decContext *, const Unit *,
255
			      Int, Int *, uInt *);
256
static void	   decSetMaxValue(decNumber *, decContext *);
257
static void	   decSetOverflow(decNumber *, decContext *, uInt *);
258
static void	   decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
259
static Int	   decShiftToLeast(Unit *, Int, Int);
260
static Int	   decShiftToMost(Unit *, Int, Int);
261
static void	   decStatus(decNumber *, uInt, decContext *);
262
static void	   decToString(const decNumber *, char[], Flag);
263
static decNumber * decTrim(decNumber *, decContext *, Flag, Int *);
264
static Int	   decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
265
			      Unit *, Int);
266
static Int	   decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
267
static bool        mulUInt128ByPowOf10(uLong *, uLong *, uInt);
268

269
#if !DECSUBSET
270
/* decFinish == decFinalize when no subset arithmetic needed */
271
#define decFinish(a,b,c,d) decFinalize(a,b,c,d)
272
#else
273
static void	   decFinish(decNumber *, decContext *, Int *, uInt *);
274
static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
275
#endif
276

277
/* Local macros */
278
/* masked special-values bits */
279
#define SPECIALARG  (rhs->bits & DECSPECIAL)
280
#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
281

282
/* Diagnostic macros, etc. */
283
#if DECALLOC
284
/* Handle malloc/free accounting.  If enabled, our accountable routines */
285
/* are used; otherwise the code just goes straight to the system malloc */
286
/* and free routines. */
287
#define malloc(a) decMalloc(a)
288
#define free(a) decFree(a)
289
#define DECFENCE 0x5a		   /* corruption detector */
290
/* 'Our' malloc and free: */
291
static void *decMalloc(size_t);
292
static void  decFree(void *);
293
uInt decAllocBytes=0;		   /* count of bytes allocated */
294
/* Note that DECALLOC code only checks for storage buffer overflow. */
295
/* To check for memory leaks, the decAllocBytes variable must be */
296
/* checked to be 0 at appropriate times (e.g., after the test */
297
/* harness completes a set of tests).  This checking may be unreliable */
298
/* if the testing is done in a multi-thread environment. */
299
#endif
300

301
#if DECCHECK
302
/* Optional checking routines.	Enabling these means that decNumber */
303
/* and decContext operands to operator routines are checked for */
304
/* correctness.	 This roughly doubles the execution time of the */
305
/* fastest routines (and adds 600+ bytes), so should not normally be */
306
/* used in 'production'. */
307
/* decCheckInexact is used to check that inexact results have a full */
308
/* complement of digits (where appropriate -- this is not the case */
309
/* for Quantize, for example) */
310
#define DECUNRESU ((decNumber *)(void *)0xffffffff)
311
#define DECUNUSED ((const decNumber *)(void *)0xffffffff)
312
#define DECUNCONT ((decContext *)(void *)(0xffffffff))
313
static Flag decCheckOperands(decNumber *, const decNumber *,
314
			     const decNumber *, decContext *);
315
static Flag decCheckNumber(const decNumber *);
316
static void decCheckInexact(const decNumber *, decContext *);
317
#endif
318

319
#if DECTRACE || DECCHECK
320
/* Optional trace/debugging routines (may or may not be used) */
321
void decNumberShow(const decNumber *);	/* displays the components of a number */
322
static void decDumpAr(char, const Unit *, Int);
323
#endif
324

325
/* ================================================================== */
326
/* Conversions							      */
327
/* ================================================================== */
328

329
/* ------------------------------------------------------------------ */
330
/* from-int32 -- conversion from Int or uInt			      */
331
/*								      */
332
/*  dn is the decNumber to receive the integer			      */
333
/*  in or uin is the integer to be converted			      */
334
/*  returns dn							      */
335
/*								      */
336
/* No error is possible.					      */
337
/* ------------------------------------------------------------------ */
338
decNumber * decNumberFromInt32(decNumber *dn, Int in) {
339
  uInt unsig;
340
  if (in>=0) unsig=in;
341
   else {				/* negative (possibly BADINT) */
342
    if (in==BADINT) unsig=(uInt)1073741824*2; /* special case */
343
     else unsig=-in;			/* invert */
344
    }
345
  /* in is now positive */
346
  decNumberFromUInt32(dn, unsig);
347
  if (in<0) dn->bits=DECNEG;		/* sign needed */
348
  return dn;
349
  } /* decNumberFromInt32 */
350

351
decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
352
  Unit *up;				/* work pointer */
353
  decNumberZero(dn);			/* clean */
354
  if (uin==0) return dn;		/* [or decGetDigits bad call] */
355
  for (up=dn->lsu; uin>0; up++) {
356
    *up=(Unit)(uin%(DECDPUNMAX+1));
357
    uin=uin/(DECDPUNMAX+1);
358
    }
359
  dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
360
  return dn;
361
  } /* decNumberFromUInt32 */
362

363
/* ------------------------------------------------------------------ */
364
/* to-int32 -- conversion to Int or uInt			      */
365
/*								      */
366
/*  dn is the decNumber to convert				      */
367
/*  set is the context for reporting errors			      */
368
/*  returns the converted decNumber, or 0 if Invalid is set	      */
369
/*								      */
370
/* Invalid is set if the decNumber does not have exponent==0 or if    */
371
/* it is a NaN, Infinite, or out-of-range.			      */
372
/* ------------------------------------------------------------------ */
373
Int decNumberToInt32(const decNumber *dn, decContext *set) {
374
  #if DECCHECK
375
  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
376
  #endif
377

378
  /* special or too many digits, or bad exponent */
379
  if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
380
   else { /* is a finite integer with 10 or fewer digits */
381
    Int d;			   /* work */
382
    const Unit *up;		   /* .. */
383
    uInt hi=0, lo;		   /* .. */
384
    up=dn->lsu;			   /* -> lsu */
385
    lo=*up;			   /* get 1 to 9 digits */
386
    #if DECDPUN>1		   /* split to higher */
387
      hi=lo/10;
388
      lo=lo%10;
389
    #endif
390
    up++;
391
    /* collect remaining Units, if any, into hi */
392
    for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
393
    /* now low has the lsd, hi the remainder */
394
    if (hi>214748364 || (hi==214748364 && lo>7)) { /* out of range? */
395
      /* most-negative is a reprieve */
396
      if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
397
      /* bad -- drop through */
398
      }
399
     else { /* in-range always */
400
      Int i=X10(hi)+lo;
401
      if (dn->bits&DECNEG) return -i;
402
      return i;
403
      }
404
    } /* integer */
405
  decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
406
  return 0;
407
  } /* decNumberToInt32 */
408

409
uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
410
  #if DECCHECK
411
  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
412
  #endif
413
  /* special or too many digits, or bad exponent, or negative (<0) */
414
  if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
415
    || (dn->bits&DECNEG && !ISZERO(dn)));		    /* bad */
416
   else { /* is a finite integer with 10 or fewer digits */
417
    Int d;			   /* work */
418
    const Unit *up;		   /* .. */
419
    uInt hi=0, lo;		   /* .. */
420
    up=dn->lsu;			   /* -> lsu */
421
    lo=*up;			   /* get 1 to 9 digits */
422
    #if DECDPUN>1		   /* split to higher */
423
      hi=lo/10;
424
      lo=lo%10;
425
    #endif
426
    up++;
427
    /* collect remaining Units, if any, into hi */
428
    for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
429

430
    /* now low has the lsd, hi the remainder */
431
    if (hi>429496729 || (hi==429496729 && lo>5)) ; /* no reprieve possible */
432
     else return X10(hi)+lo;
433
    } /* integer */
434
  decContextSetStatus(set, DEC_Invalid_operation); /* [may not return] */
435
  return 0;
436
  } /* decNumberToUInt32 */
437

438
decNumber *decNumberFromInt64(decNumber *dn, int64_t in)
439
{
440
    uint64_t unsig = in;
441
    if (in < 0) {
442
        unsig = -unsig;
443
    }
444

445
    decNumberFromUInt64(dn, unsig);
446
    if (in < 0) {
447
        dn->bits = DECNEG;        /* sign needed */
448
    }
449
    return dn;
450
} /* decNumberFromInt64 */
451

452
decNumber *decNumberFromUInt64(decNumber *dn, uint64_t uin)
453
{
454
    Unit *up;                             /* work pointer */
455
    decNumberZero(dn);                    /* clean */
456
    if (uin == 0) {
457
        return dn;                /* [or decGetDigits bad call] */
458
    }
459
    for (up = dn->lsu; uin > 0; up++) {
460
        *up = (Unit)(uin % (DECDPUNMAX + 1));
461
        uin = uin / (DECDPUNMAX + 1);
462
    }
463
    dn->digits = decGetDigits(dn->lsu, up-dn->lsu);
464
    return dn;
465
} /* decNumberFromUInt64 */
466

467
decNumber *decNumberFromInt128(decNumber *dn, uint64_t lo, int64_t hi)
468
{
469
    uint64_t unsig_hi = hi;
470
    if (hi < 0) {
471
        if (lo == 0) {
472
            unsig_hi = -unsig_hi;
473
        } else {
474
            unsig_hi = ~unsig_hi;
475
            lo = -lo;
476
        }
477
    }
478

479
    decNumberFromUInt128(dn, lo, unsig_hi);
480
    if (hi < 0) {
481
        dn->bits = DECNEG;        /* sign needed */
482
    }
483
    return dn;
484
} /* decNumberFromInt128 */
485

486
decNumber *decNumberFromUInt128(decNumber *dn, uint64_t lo, uint64_t hi)
487
{
488
    uint64_t rem;
489
    Unit *up;                             /* work pointer */
490
    decNumberZero(dn);                    /* clean */
491
    if (lo == 0 && hi == 0) {
492
        return dn;                /* [or decGetDigits bad call] */
493
    }
494
    for (up = dn->lsu; hi > 0 || lo > 0; up++) {
495
        rem = divu128(&lo, &hi, DECDPUNMAX + 1);
496
        *up = (Unit)rem;
497
    }
498
    dn->digits = decGetDigits(dn->lsu, up - dn->lsu);
499
    return dn;
500
} /* decNumberFromUInt128 */
501

502
/* ------------------------------------------------------------------ */
503
/* to-int64 -- conversion to int64                                    */
504
/*                                                                    */
505
/*  dn is the decNumber to convert.  dn is assumed to have been       */
506
/*    rounded to a floating point integer value.                      */
507
/*  set is the context for reporting errors                           */
508
/*  returns the converted decNumber, or 0 if Invalid is set           */
509
/*                                                                    */
510
/* Invalid is set if the decNumber is a NaN, Infinite or is out of    */
511
/* range for a signed 64 bit integer.                                 */
512
/* ------------------------------------------------------------------ */
513

514
int64_t decNumberIntegralToInt64(const decNumber *dn, decContext *set)
515
{
516
    if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
517
       (dn->digits + dn->exponent > 19)) {
518
        goto Invalid;
519
    } else {
520
        int64_t d;        /* work */
521
        const Unit *up;   /* .. */
522
        uint64_t hi = 0;
523
        up = dn->lsu;     /* -> lsu */
524

525
        for (d = 1; d <= dn->digits; up++, d += DECDPUN) {
526
            uint64_t prev = hi;
527
            hi += *up * powers[d-1];
528
            if ((hi < prev) || (hi > INT64_MAX)) {
529
                goto Invalid;
530
            }
531
        }
532

533
        uint64_t prev = hi;
534
        hi *= (uint64_t)powers[dn->exponent];
535
        if ((hi < prev) || (hi > INT64_MAX)) {
536
            goto Invalid;
537
        }
538
        return (decNumberIsNegative(dn)) ? -((int64_t)hi) : (int64_t)hi;
539
    }
540

541
Invalid:
542
    decContextSetStatus(set, DEC_Invalid_operation);
543
    return 0;
544
} /* decNumberIntegralToInt64 */
545

546
/* ------------------------------------------------------------------ */
547
/* decNumberIntegralToInt128 -- conversion to int128                  */
548
/*                                                                    */
549
/*  dn is the decNumber to convert.  dn is assumed to have been       */
550
/*    rounded to a floating point integer value.                      */
551
/*  set is the context for reporting errors                           */
552
/*  returns the converted decNumber via plow and phigh                */
553
/*                                                                    */
554
/* Invalid is set if the decNumber is a NaN, Infinite or is out of    */
555
/* range for a signed 128 bit integer.                                */
556
/* ------------------------------------------------------------------ */
557

558
void decNumberIntegralToInt128(const decNumber *dn, decContext *set,
559
        uint64_t *plow, uint64_t *phigh)
560
{
561
    int d;        /* work */
562
    const Unit *up;   /* .. */
563
    uint64_t lo = 0, hi = 0;
564

565
    if (decNumberIsSpecial(dn) || (dn->exponent < 0) ||
566
       (dn->digits + dn->exponent > 39)) {
567
        goto Invalid;
568
    }
569

570
    up = dn->lsu;     /* -> lsu */
571

572
    for (d = (dn->digits - 1) / DECDPUN; d >= 0; d--) {
573
        if (mulu128(&lo, &hi, DECDPUNMAX + 1)) {
574
            /* overflow */
575
            goto Invalid;
576
        }
577
        if (uadd64_overflow(lo, up[d], &lo)) {
578
            if (uadd64_overflow(hi, 1, &hi)) {
579
                /* overflow */
580
                goto Invalid;
581
            }
582
        }
583
    }
584

585
    if (mulUInt128ByPowOf10(&lo, &hi, dn->exponent)) {
586
        /* overflow */
587
        goto Invalid;
588
    }
589

590
    if (decNumberIsNegative(dn)) {
591
        if (lo == 0) {
592
            *phigh = -hi;
593
            *plow = 0;
594
        } else {
595
            *phigh = ~hi;
596
            *plow = -lo;
597
        }
598
    } else {
599
        *plow = lo;
600
        *phigh = hi;
601
    }
602

603
    return;
604

605
Invalid:
606
    decContextSetStatus(set, DEC_Invalid_operation);
607
} /* decNumberIntegralToInt128 */
608

609
/* ------------------------------------------------------------------ */
610
/* to-scientific-string -- conversion to numeric string		      */
611
/* to-engineering-string -- conversion to numeric string	      */
612
/*								      */
613
/*   decNumberToString(dn, string);				      */
614
/*   decNumberToEngString(dn, string);				      */
615
/*								      */
616
/*  dn is the decNumber to convert				      */
617
/*  string is the string where the result will be laid out	      */
618
/*								      */
619
/*  string must be at least dn->digits+14 characters long	      */
620
/*								      */
621
/*  No error is possible, and no status can be set.		      */
622
/* ------------------------------------------------------------------ */
623
char * decNumberToString(const decNumber *dn, char *string){
624
  decToString(dn, string, 0);
625
  return string;
626
  } /* DecNumberToString */
627

628
char * decNumberToEngString(const decNumber *dn, char *string){
629
  decToString(dn, string, 1);
630
  return string;
631
  } /* DecNumberToEngString */
632

633
/* ------------------------------------------------------------------ */
634
/* to-number -- conversion from numeric string			      */
635
/*								      */
636
/* decNumberFromString -- convert string to decNumber		      */
637
/*   dn	       -- the number structure to fill			      */
638
/*   chars[]   -- the string to convert ('\0' terminated)	      */
639
/*   set       -- the context used for processing any error,	      */
640
/*		  determining the maximum precision available	      */
641
/*		  (set.digits), determining the maximum and minimum   */
642
/*		  exponent (set.emax and set.emin), determining if    */
643
/*		  extended values are allowed, and checking the	      */
644
/*		  rounding mode if overflow occurs or rounding is     */
645
/*		  needed.					      */
646
/*								      */
647
/* The length of the coefficient and the size of the exponent are     */
648
/* checked by this routine, so the correct error (Underflow or	      */
649
/* Overflow) can be reported or rounding applied, as necessary.	      */
650
/*								      */
651
/* If bad syntax is detected, the result will be a quiet NaN.	      */
652
/* ------------------------------------------------------------------ */
653
decNumber * decNumberFromString(decNumber *dn, const char chars[],
654
				decContext *set) {
655
  Int	exponent=0;		   /* working exponent [assume 0] */
656
  uByte bits=0;			   /* working flags [assume +ve] */
657
  Unit	*res;			   /* where result will be built */
658
  Unit	resbuff[SD2U(DECBUFFER+9)];/* local buffer in case need temporary */
659
				   /* [+9 allows for ln() constants] */
660
  Unit	*allocres=NULL;		   /* -> allocated result, iff allocated */
661
  Int	d=0;			   /* count of digits found in decimal part */
662
  const char *dotchar=NULL;	   /* where dot was found */
663
  const char *cfirst=chars;	   /* -> first character of decimal part */
664
  const char *last=NULL;	   /* -> last digit of decimal part */
665
  const char *c;		   /* work */
666
  Unit	*up;			   /* .. */
667
  #if DECDPUN>1
668
  Int	cut, out;		   /* .. */
669
  #endif
670
  Int	residue;		   /* rounding residue */
671
  uInt	status=0;		   /* error code */
672

673
  #if DECCHECK
674
  if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
675
    return decNumberZero(dn);
676
  #endif
677

678
  do {				   /* status & malloc protection */
679
    for (c=chars;; c++) {	   /* -> input character */
680
      if (*c>='0' && *c<='9') {	   /* test for Arabic digit */
681
	last=c;
682
	d++;			   /* count of real digits */
683
	continue;		   /* still in decimal part */
684
	}
685
      if (*c=='.' && dotchar==NULL) { /* first '.' */
686
	dotchar=c;		   /* record offset into decimal part */
687
	if (c==cfirst) cfirst++;   /* first digit must follow */
688
	continue;}
689
      if (c==chars) {		   /* first in string... */
690
	if (*c=='-') {		   /* valid - sign */
691
	  cfirst++;
692
	  bits=DECNEG;
693
	  continue;}
694
	if (*c=='+') {		   /* valid + sign */
695
	  cfirst++;
696
	  continue;}
697
	}
698
      /* *c is not a digit, or a valid +, -, or '.' */
699
      break;
700
      } /* c */
701

702
    if (last==NULL) {		   /* no digits yet */
703
      status=DEC_Conversion_syntax;/* assume the worst */
704
      if (*c=='\0') break;	   /* and no more to come... */
705
      #if DECSUBSET
706
      /* if subset then infinities and NaNs are not allowed */
707
      if (!set->extended) break;   /* hopeless */
708
      #endif
709
      /* Infinities and NaNs are possible, here */
710
      if (dotchar!=NULL) break;	   /* .. unless had a dot */
711
      decNumberZero(dn);	   /* be optimistic */
712
      if (decBiStr(c, "infinity", "INFINITY")
713
       || decBiStr(c, "inf", "INF")) {
714
	dn->bits=bits | DECINF;
715
	status=0;		   /* is OK */
716
	break; /* all done */
717
	}
718
      /* a NaN expected */
719
      /* 2003.09.10 NaNs are now permitted to have a sign */
720
      dn->bits=bits | DECNAN;	   /* assume simple NaN */
721
      if (*c=='s' || *c=='S') {	   /* looks like an sNaN */
722
	c++;
723
	dn->bits=bits | DECSNAN;
724
	}
725
      if (*c!='n' && *c!='N') break;	/* check caseless "NaN" */
726
      c++;
727
      if (*c!='a' && *c!='A') break;	/* .. */
728
      c++;
729
      if (*c!='n' && *c!='N') break;	/* .. */
730
      c++;
731
      /* now either nothing, or nnnn payload, expected */
732
      /* -> start of integer and skip leading 0s [including plain 0] */
733
      for (cfirst=c; *cfirst=='0';) cfirst++;
734
      if (*cfirst=='\0') {	   /* "NaN" or "sNaN", maybe with all 0s */
735
	status=0;		   /* it's good */
736
	break;			   /* .. */
737
	}
738
      /* something other than 0s; setup last and d as usual [no dots] */
739
      for (c=cfirst;; c++, d++) {
740
	if (*c<'0' || *c>'9') break; /* test for Arabic digit */
741
	last=c;
742
	}
743
      if (*c!='\0') break;	   /* not all digits */
744
      if (d>set->digits-1) {
745
	/* [NB: payload in a decNumber can be full length unless */
746
	/* clamped, in which case can only be digits-1] */
747
	if (set->clamp) break;
748
	if (d>set->digits) break;
749
	} /* too many digits? */
750
      /* good; drop through to convert the integer to coefficient */
751
      status=0;			   /* syntax is OK */
752
      bits=dn->bits;		   /* for copy-back */
753
      } /* last==NULL */
754

755
     else if (*c!='\0') {	   /* more to process... */
756
      /* had some digits; exponent is only valid sequence now */
757
      Flag nege;		   /* 1=negative exponent */
758
      const char *firstexp;	   /* -> first significant exponent digit */
759
      status=DEC_Conversion_syntax;/* assume the worst */
760
      if (*c!='e' && *c!='E') break;
761
      /* Found 'e' or 'E' -- now process explicit exponent */
762
      /* 1998.07.11: sign no longer required */
763
      nege=0;
764
      c++;			   /* to (possible) sign */
765
      if (*c=='-') {nege=1; c++;}
766
       else if (*c=='+') c++;
767
      if (*c=='\0') break;
768

769
      for (; *c=='0' && *(c+1)!='\0';) c++;  /* strip insignificant zeros */
770
      firstexp=c;			     /* save exponent digit place */
771
      for (; ;c++) {
772
	if (*c<'0' || *c>'9') break;	     /* not a digit */
773
	exponent=X10(exponent)+(Int)*c-(Int)'0';
774
	} /* c */
775
      /* if not now on a '\0', *c must not be a digit */
776
      if (*c!='\0') break;
777

778
      /* (this next test must be after the syntax checks) */
779
      /* if it was too long the exponent may have wrapped, so check */
780
      /* carefully and set it to a certain overflow if wrap possible */
781
      if (c>=firstexp+9+1) {
782
	if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
783
	/* [up to 1999999999 is OK, for example 1E-1000000998] */
784
	}
785
      if (nege) exponent=-exponent;	/* was negative */
786
      status=0;				/* is OK */
787
      } /* stuff after digits */
788

789
    /* Here when whole string has been inspected; syntax is good */
790
    /* cfirst->first digit (never dot), last->last digit (ditto) */
791

792
    /* strip leading zeros/dot [leave final 0 if all 0's] */
793
    if (*cfirst=='0') {			/* [cfirst has stepped over .] */
794
      for (c=cfirst; c<last; c++, cfirst++) {
795
	if (*c=='.') continue;		/* ignore dots */
796
	if (*c!='0') break;		/* non-zero found */
797
	d--;				/* 0 stripped */
798
	} /* c */
799
      #if DECSUBSET
800
      /* make a rapid exit for easy zeros if !extended */
801
      if (*cfirst=='0' && !set->extended) {
802
	decNumberZero(dn);		/* clean result */
803
	break;				/* [could be return] */
804
	}
805
      #endif
806
      } /* at least one leading 0 */
807

808
    /* Handle decimal point... */
809
    if (dotchar!=NULL && dotchar<last)	/* non-trailing '.' found? */
810
      exponent-=(last-dotchar);		/* adjust exponent */
811
    /* [we can now ignore the .] */
812

813
    /* OK, the digits string is good.  Assemble in the decNumber, or in */
814
    /* a temporary units array if rounding is needed */
815
    if (d<=set->digits) res=dn->lsu;	/* fits into supplied decNumber */
816
     else {				/* rounding needed */
817
      Int needbytes=D2U(d)*sizeof(Unit);/* bytes needed */
818
      res=resbuff;			/* assume use local buffer */
819
      if (needbytes>(Int)sizeof(resbuff)) { /* too big for local */
820
	allocres=(Unit *)malloc(needbytes);
821
	if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
822
	res=allocres;
823
	}
824
      }
825
    /* res now -> number lsu, buffer, or allocated storage for Unit array */
826

827
    /* Place the coefficient into the selected Unit array */
828
    /* [this is often 70% of the cost of this function when DECDPUN>1] */
829
    #if DECDPUN>1
830
    out=0;			   /* accumulator */
831
    up=res+D2U(d)-1;		   /* -> msu */
832
    cut=d-(up-res)*DECDPUN;	   /* digits in top unit */
833
    for (c=cfirst;; c++) {	   /* along the digits */
834
      if (*c=='.') continue;	   /* ignore '.' [don't decrement cut] */
835
      out=X10(out)+(Int)*c-(Int)'0';
836
      if (c==last) break;	   /* done [never get to trailing '.'] */
837
      cut--;
838
      if (cut>0) continue;	   /* more for this unit */
839
      *up=(Unit)out;		   /* write unit */
840
      up--;			   /* prepare for unit below.. */
841
      cut=DECDPUN;		   /* .. */
842
      out=0;			   /* .. */
843
      } /* c */
844
    *up=(Unit)out;		   /* write lsu */
845

846
    #else
847
    /* DECDPUN==1 */
848
    up=res;			   /* -> lsu */
849
    for (c=last; c>=cfirst; c--) { /* over each character, from least */
850
      if (*c=='.') continue;	   /* ignore . [don't step up] */
851
      *up=(Unit)((Int)*c-(Int)'0');
852
      up++;
853
      } /* c */
854
    #endif
855

856
    dn->bits=bits;
857
    dn->exponent=exponent;
858
    dn->digits=d;
859

860
    /* if not in number (too long) shorten into the number */
861
    if (d>set->digits) {
862
      residue=0;
863
      decSetCoeff(dn, set, res, d, &residue, &status);
864
      /* always check for overflow or subnormal and round as needed */
865
      decFinalize(dn, set, &residue, &status);
866
      }
867
     else { /* no rounding, but may still have overflow or subnormal */
868
      /* [these tests are just for performance; finalize repeats them] */
869
      if ((dn->exponent-1<set->emin-dn->digits)
870
       || (dn->exponent-1>set->emax-set->digits)) {
871
	residue=0;
872
	decFinalize(dn, set, &residue, &status);
873
	}
874
      }
875
    /* decNumberShow(dn); */
876
    } while(0);				/* [for break] */
877

878
  if (allocres!=NULL) free(allocres);	/* drop any storage used */
879
  if (status!=0) decStatus(dn, status, set);
880
  return dn;
881
  } /* decNumberFromString */
882

883
/* ================================================================== */
884
/* Operators							      */
885
/* ================================================================== */
886

887
/* ------------------------------------------------------------------ */
888
/* decNumberAbs -- absolute value operator			      */
889
/*								      */
890
/*   This computes C = abs(A)					      */
891
/*								      */
892
/*   res is C, the result.  C may be A				      */
893
/*   rhs is A							      */
894
/*   set is the context						      */
895
/*								      */
896
/* See also decNumberCopyAbs for a quiet bitwise version of this.     */
897
/* C must have space for set->digits digits.			      */
898
/* ------------------------------------------------------------------ */
899
/* This has the same effect as decNumberPlus unless A is negative,    */
900
/* in which case it has the same effect as decNumberMinus.	      */
901
/* ------------------------------------------------------------------ */
902
decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
903
			 decContext *set) {
904
  decNumber dzero;			/* for 0 */
905
  uInt status=0;			/* accumulator */
906

907
  #if DECCHECK
908
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
909
  #endif
910

911
  decNumberZero(&dzero);		/* set 0 */
912
  dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
913
  decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
914
  if (status!=0) decStatus(res, status, set);
915
  #if DECCHECK
916
  decCheckInexact(res, set);
917
  #endif
918
  return res;
919
  } /* decNumberAbs */
920

921
/* ------------------------------------------------------------------ */
922
/* decNumberAdd -- add two Numbers				      */
923
/*								      */
924
/*   This computes C = A + B					      */
925
/*								      */
926
/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
927
/*   lhs is A							      */
928
/*   rhs is B							      */
929
/*   set is the context						      */
930
/*								      */
931
/* C must have space for set->digits digits.			      */
932
/* ------------------------------------------------------------------ */
933
/* This just calls the routine shared with Subtract		      */
934
decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
935
			 const decNumber *rhs, decContext *set) {
936
  uInt status=0;			/* accumulator */
937
  decAddOp(res, lhs, rhs, set, 0, &status);
938
  if (status!=0) decStatus(res, status, set);
939
  #if DECCHECK
940
  decCheckInexact(res, set);
941
  #endif
942
  return res;
943
  } /* decNumberAdd */
944

945
/* ------------------------------------------------------------------ */
946
/* decNumberAnd -- AND two Numbers, digitwise			      */
947
/*								      */
948
/*   This computes C = A & B					      */
949
/*								      */
950
/*   res is C, the result.  C may be A and/or B (e.g., X=X&X)	      */
951
/*   lhs is A							      */
952
/*   rhs is B							      */
953
/*   set is the context (used for result length and error report)     */
954
/*								      */
955
/* C must have space for set->digits digits.			      */
956
/*								      */
957
/* Logical function restrictions apply (see above); a NaN is	      */
958
/* returned with Invalid_operation if a restriction is violated.      */
959
/* ------------------------------------------------------------------ */
960
decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
961
			 const decNumber *rhs, decContext *set) {
962
  const Unit *ua, *ub;			/* -> operands */
963
  const Unit *msua, *msub;		/* -> operand msus */
964
  Unit *uc,  *msuc;			/* -> result and its msu */
965
  Int	msudigs;			/* digits in res msu */
966
  #if DECCHECK
967
  if (decCheckOperands(res, lhs, rhs, set)) return res;
968
  #endif
969

970
  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
971
   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
972
    decStatus(res, DEC_Invalid_operation, set);
973
    return res;
974
    }
975

976
  /* operands are valid */
977
  ua=lhs->lsu;				/* bottom-up */
978
  ub=rhs->lsu;				/* .. */
979
  uc=res->lsu;				/* .. */
980
  msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
981
  msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
982
  msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
983
  msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
984
  for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
985
    Unit a, b;				/* extract units */
986
    if (ua>msua) a=0;
987
     else a=*ua;
988
    if (ub>msub) b=0;
989
     else b=*ub;
990
    *uc=0;				/* can now write back */
991
    if (a|b) {				/* maybe 1 bits to examine */
992
      Int i, j;
993
      *uc=0;				/* can now write back */
994
      /* This loop could be unrolled and/or use BIN2BCD tables */
995
      for (i=0; i<DECDPUN; i++) {
996
	if (a&b&1) *uc=*uc+(Unit)powers[i];  /* effect AND */
997
	j=a%10;
998
	a=a/10;
999
	j|=b%10;
1000
	b=b/10;
1001
	if (j>1) {
1002
	  decStatus(res, DEC_Invalid_operation, set);
1003
	  return res;
1004
	  }
1005
	if (uc==msuc && i==msudigs-1) break; /* just did final digit */
1006
	} /* each digit */
1007
      } /* both OK */
1008
    } /* each unit */
1009
  /* [here uc-1 is the msu of the result] */
1010
  res->digits=decGetDigits(res->lsu, uc-res->lsu);
1011
  res->exponent=0;			/* integer */
1012
  res->bits=0;				/* sign=0 */
1013
  return res;  /* [no status to set] */
1014
  } /* decNumberAnd */
1015

1016
/* ------------------------------------------------------------------ */
1017
/* decNumberCompare -- compare two Numbers			      */
1018
/*								      */
1019
/*   This computes C = A ? B					      */
1020
/*								      */
1021
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1022
/*   lhs is A							      */
1023
/*   rhs is B							      */
1024
/*   set is the context						      */
1025
/*								      */
1026
/* C must have space for one digit (or NaN).			      */
1027
/* ------------------------------------------------------------------ */
1028
decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
1029
			     const decNumber *rhs, decContext *set) {
1030
  uInt status=0;			/* accumulator */
1031
  decCompareOp(res, lhs, rhs, set, COMPARE, &status);
1032
  if (status!=0) decStatus(res, status, set);
1033
  return res;
1034
  } /* decNumberCompare */
1035

1036
/* ------------------------------------------------------------------ */
1037
/* decNumberCompareSignal -- compare, signalling on all NaNs	      */
1038
/*								      */
1039
/*   This computes C = A ? B					      */
1040
/*								      */
1041
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1042
/*   lhs is A							      */
1043
/*   rhs is B							      */
1044
/*   set is the context						      */
1045
/*								      */
1046
/* C must have space for one digit (or NaN).			      */
1047
/* ------------------------------------------------------------------ */
1048
decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
1049
				   const decNumber *rhs, decContext *set) {
1050
  uInt status=0;			/* accumulator */
1051
  decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
1052
  if (status!=0) decStatus(res, status, set);
1053
  return res;
1054
  } /* decNumberCompareSignal */
1055

1056
/* ------------------------------------------------------------------ */
1057
/* decNumberCompareTotal -- compare two Numbers, using total ordering */
1058
/*								      */
1059
/*   This computes C = A ? B, under total ordering		      */
1060
/*								      */
1061
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1062
/*   lhs is A							      */
1063
/*   rhs is B							      */
1064
/*   set is the context						      */
1065
/*								      */
1066
/* C must have space for one digit; the result will always be one of  */
1067
/* -1, 0, or 1.							      */
1068
/* ------------------------------------------------------------------ */
1069
decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
1070
				  const decNumber *rhs, decContext *set) {
1071
  uInt status=0;			/* accumulator */
1072
  decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
1073
  if (status!=0) decStatus(res, status, set);
1074
  return res;
1075
  } /* decNumberCompareTotal */
1076

1077
/* ------------------------------------------------------------------ */
1078
/* decNumberCompareTotalMag -- compare, total ordering of magnitudes  */
1079
/*								      */
1080
/*   This computes C = |A| ? |B|, under total ordering		      */
1081
/*								      */
1082
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1083
/*   lhs is A							      */
1084
/*   rhs is B							      */
1085
/*   set is the context						      */
1086
/*								      */
1087
/* C must have space for one digit; the result will always be one of  */
1088
/* -1, 0, or 1.							      */
1089
/* ------------------------------------------------------------------ */
1090
decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
1091
				     const decNumber *rhs, decContext *set) {
1092
  uInt status=0;		   /* accumulator */
1093
  uInt needbytes;		   /* for space calculations */
1094
  decNumber bufa[D2N(DECBUFFER+1)];/* +1 in case DECBUFFER=0 */
1095
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1096
  decNumber bufb[D2N(DECBUFFER+1)];
1097
  decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
1098
  decNumber *a, *b;		   /* temporary pointers */
1099

1100
  #if DECCHECK
1101
  if (decCheckOperands(res, lhs, rhs, set)) return res;
1102
  #endif
1103

1104
  do {					/* protect allocated storage */
1105
    /* if either is negative, take a copy and absolute */
1106
    if (decNumberIsNegative(lhs)) {	/* lhs<0 */
1107
      a=bufa;
1108
      needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
1109
      if (needbytes>sizeof(bufa)) {	/* need malloc space */
1110
	allocbufa=(decNumber *)malloc(needbytes);
1111
	if (allocbufa==NULL) {		/* hopeless -- abandon */
1112
	  status|=DEC_Insufficient_storage;
1113
	  break;}
1114
	a=allocbufa;			/* use the allocated space */
1115
	}
1116
      decNumberCopy(a, lhs);		/* copy content */
1117
      a->bits&=~DECNEG;			/* .. and clear the sign */
1118
      lhs=a;				/* use copy from here on */
1119
      }
1120
    if (decNumberIsNegative(rhs)) {	/* rhs<0 */
1121
      b=bufb;
1122
      needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
1123
      if (needbytes>sizeof(bufb)) {	/* need malloc space */
1124
	allocbufb=(decNumber *)malloc(needbytes);
1125
	if (allocbufb==NULL) {		/* hopeless -- abandon */
1126
	  status|=DEC_Insufficient_storage;
1127
	  break;}
1128
	b=allocbufb;			/* use the allocated space */
1129
	}
1130
      decNumberCopy(b, rhs);		/* copy content */
1131
      b->bits&=~DECNEG;			/* .. and clear the sign */
1132
      rhs=b;				/* use copy from here on */
1133
      }
1134
    decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
1135
    } while(0);				/* end protected */
1136

1137
  if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1138
  if (allocbufb!=NULL) free(allocbufb); /* .. */
1139
  if (status!=0) decStatus(res, status, set);
1140
  return res;
1141
  } /* decNumberCompareTotalMag */
1142

1143
/* ------------------------------------------------------------------ */
1144
/* decNumberDivide -- divide one number by another		      */
1145
/*								      */
1146
/*   This computes C = A / B					      */
1147
/*								      */
1148
/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)	      */
1149
/*   lhs is A							      */
1150
/*   rhs is B							      */
1151
/*   set is the context						      */
1152
/*								      */
1153
/* C must have space for set->digits digits.			      */
1154
/* ------------------------------------------------------------------ */
1155
decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
1156
			    const decNumber *rhs, decContext *set) {
1157
  uInt status=0;			/* accumulator */
1158
  decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
1159
  if (status!=0) decStatus(res, status, set);
1160
  #if DECCHECK
1161
  decCheckInexact(res, set);
1162
  #endif
1163
  return res;
1164
  } /* decNumberDivide */
1165

1166
/* ------------------------------------------------------------------ */
1167
/* decNumberDivideInteger -- divide and return integer quotient	      */
1168
/*								      */
1169
/*   This computes C = A # B, where # is the integer divide operator  */
1170
/*								      */
1171
/*   res is C, the result.  C may be A and/or B (e.g., X=X#X)	      */
1172
/*   lhs is A							      */
1173
/*   rhs is B							      */
1174
/*   set is the context						      */
1175
/*								      */
1176
/* C must have space for set->digits digits.			      */
1177
/* ------------------------------------------------------------------ */
1178
decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
1179
				   const decNumber *rhs, decContext *set) {
1180
  uInt status=0;			/* accumulator */
1181
  decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
1182
  if (status!=0) decStatus(res, status, set);
1183
  return res;
1184
  } /* decNumberDivideInteger */
1185

1186
/* ------------------------------------------------------------------ */
1187
/* decNumberExp -- exponentiation				      */
1188
/*								      */
1189
/*   This computes C = exp(A)					      */
1190
/*								      */
1191
/*   res is C, the result.  C may be A				      */
1192
/*   rhs is A							      */
1193
/*   set is the context; note that rounding mode has no effect	      */
1194
/*								      */
1195
/* C must have space for set->digits digits.			      */
1196
/*								      */
1197
/* Mathematical function restrictions apply (see above); a NaN is     */
1198
/* returned with Invalid_operation if a restriction is violated.      */
1199
/*								      */
1200
/* Finite results will always be full precision and Inexact, except   */
1201
/* when A is a zero or -Infinity (giving 1 or 0 respectively).	      */
1202
/*								      */
1203
/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1204
/* almost always be correctly rounded, but may be up to 1 ulp in      */
1205
/* error in rare cases.						      */
1206
/* ------------------------------------------------------------------ */
1207
/* This is a wrapper for decExpOp which can handle the slightly wider */
1208
/* (double) range needed by Ln (which has to be able to calculate     */
1209
/* exp(-a) where a can be the tiniest number (Ntiny).		      */
1210
/* ------------------------------------------------------------------ */
1211
decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
1212
			 decContext *set) {
1213
  uInt status=0;			/* accumulator */
1214
  #if DECSUBSET
1215
  decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1216
  #endif
1217

1218
  #if DECCHECK
1219
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1220
  #endif
1221

1222
  /* Check restrictions; these restrictions ensure that if h=8 (see */
1223
  /* decExpOp) then the result will either overflow or underflow to 0. */
1224
  /* Other math functions restrict the input range, too, for inverses. */
1225
  /* If not violated then carry out the operation. */
1226
  if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1227
    #if DECSUBSET
1228
    if (!set->extended) {
1229
      /* reduce operand and set lostDigits status, as needed */
1230
      if (rhs->digits>set->digits) {
1231
	allocrhs=decRoundOperand(rhs, set, &status);
1232
	if (allocrhs==NULL) break;
1233
	rhs=allocrhs;
1234
	}
1235
      }
1236
    #endif
1237
    decExpOp(res, rhs, set, &status);
1238
    } while(0);				/* end protected */
1239

1240
  #if DECSUBSET
1241
  if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
1242
  #endif
1243
  /* apply significant status */
1244
  if (status!=0) decStatus(res, status, set);
1245
  #if DECCHECK
1246
  decCheckInexact(res, set);
1247
  #endif
1248
  return res;
1249
  } /* decNumberExp */
1250

1251
/* ------------------------------------------------------------------ */
1252
/* decNumberFMA -- fused multiply add				      */
1253
/*								      */
1254
/*   This computes D = (A * B) + C with only one rounding	      */
1255
/*								      */
1256
/*   res is D, the result.  D may be A or B or C (e.g., X=FMA(X,X,X)) */
1257
/*   lhs is A							      */
1258
/*   rhs is B							      */
1259
/*   fhs is C [far hand side]					      */
1260
/*   set is the context						      */
1261
/*								      */
1262
/* Mathematical function restrictions apply (see above); a NaN is     */
1263
/* returned with Invalid_operation if a restriction is violated.      */
1264
/*								      */
1265
/* C must have space for set->digits digits.			      */
1266
/* ------------------------------------------------------------------ */
1267
decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
1268
			 const decNumber *rhs, const decNumber *fhs,
1269
			 decContext *set) {
1270
  uInt status=0;		   /* accumulator */
1271
  decContext dcmul;		   /* context for the multiplication */
1272
  uInt needbytes;		   /* for space calculations */
1273
  decNumber bufa[D2N(DECBUFFER*2+1)];
1274
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1275
  decNumber *acc;		   /* accumulator pointer */
1276
  decNumber dzero;		   /* work */
1277

1278
  #if DECCHECK
1279
  if (decCheckOperands(res, lhs, rhs, set)) return res;
1280
  if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
1281
  #endif
1282

1283
  do {					/* protect allocated storage */
1284
    #if DECSUBSET
1285
    if (!set->extended) {		/* [undefined if subset] */
1286
      status|=DEC_Invalid_operation;
1287
      break;}
1288
    #endif
1289
    /* Check math restrictions [these ensure no overflow or underflow] */
1290
    if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
1291
     || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
1292
     || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
1293
    /* set up context for multiply */
1294
    dcmul=*set;
1295
    dcmul.digits=lhs->digits+rhs->digits; /* just enough */
1296
    /* [The above may be an over-estimate for subset arithmetic, but that's OK] */
1297
    dcmul.emax=DEC_MAX_EMAX;		/* effectively unbounded .. */
1298
    dcmul.emin=DEC_MIN_EMIN;		/* [thanks to Math restrictions] */
1299
    /* set up decNumber space to receive the result of the multiply */
1300
    acc=bufa;				/* may fit */
1301
    needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
1302
    if (needbytes>sizeof(bufa)) {	/* need malloc space */
1303
      allocbufa=(decNumber *)malloc(needbytes);
1304
      if (allocbufa==NULL) {		/* hopeless -- abandon */
1305
	status|=DEC_Insufficient_storage;
1306
	break;}
1307
      acc=allocbufa;			/* use the allocated space */
1308
      }
1309
    /* multiply with extended range and necessary precision */
1310
    /*printf("emin=%ld\n", dcmul.emin); */
1311
    decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
1312
    /* Only Invalid operation (from sNaN or Inf * 0) is possible in */
1313
    /* status; if either is seen than ignore fhs (in case it is */
1314
    /* another sNaN) and set acc to NaN unless we had an sNaN */
1315
    /* [decMultiplyOp leaves that to caller] */
1316
    /* Note sNaN has to go through addOp to shorten payload if */
1317
    /* necessary */
1318
    if ((status&DEC_Invalid_operation)!=0) {
1319
      if (!(status&DEC_sNaN)) {		/* but be true invalid */
1320
	decNumberZero(res);		/* acc not yet set */
1321
	res->bits=DECNAN;
1322
	break;
1323
	}
1324
      decNumberZero(&dzero);		/* make 0 (any non-NaN would do) */
1325
      fhs=&dzero;			/* use that */
1326
      }
1327
    #if DECCHECK
1328
     else { /* multiply was OK */
1329
      if (status!=0) printf("Status=%08lx after FMA multiply\n", status);
1330
      }
1331
    #endif
1332
    /* add the third operand and result -> res, and all is done */
1333
    decAddOp(res, acc, fhs, set, 0, &status);
1334
    } while(0);				/* end protected */
1335

1336
  if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1337
  if (status!=0) decStatus(res, status, set);
1338
  #if DECCHECK
1339
  decCheckInexact(res, set);
1340
  #endif
1341
  return res;
1342
  } /* decNumberFMA */
1343

1344
/* ------------------------------------------------------------------ */
1345
/* decNumberInvert -- invert a Number, digitwise		      */
1346
/*								      */
1347
/*   This computes C = ~A					      */
1348
/*								      */
1349
/*   res is C, the result.  C may be A (e.g., X=~X)		      */
1350
/*   rhs is A							      */
1351
/*   set is the context (used for result length and error report)     */
1352
/*								      */
1353
/* C must have space for set->digits digits.			      */
1354
/*								      */
1355
/* Logical function restrictions apply (see above); a NaN is	      */
1356
/* returned with Invalid_operation if a restriction is violated.      */
1357
/* ------------------------------------------------------------------ */
1358
decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
1359
			    decContext *set) {
1360
  const Unit *ua, *msua;		/* -> operand and its msu */
1361
  Unit	*uc, *msuc;			/* -> result and its msu */
1362
  Int	msudigs;			/* digits in res msu */
1363
  #if DECCHECK
1364
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1365
  #endif
1366

1367
  if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1368
    decStatus(res, DEC_Invalid_operation, set);
1369
    return res;
1370
    }
1371
  /* operand is valid */
1372
  ua=rhs->lsu;				/* bottom-up */
1373
  uc=res->lsu;				/* .. */
1374
  msua=ua+D2U(rhs->digits)-1;		/* -> msu of rhs */
1375
  msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
1376
  msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
1377
  for (; uc<=msuc; ua++, uc++) {	/* Unit loop */
1378
    Unit a;				/* extract unit */
1379
    Int	 i, j;				/* work */
1380
    if (ua>msua) a=0;
1381
     else a=*ua;
1382
    *uc=0;				/* can now write back */
1383
    /* always need to examine all bits in rhs */
1384
    /* This loop could be unrolled and/or use BIN2BCD tables */
1385
    for (i=0; i<DECDPUN; i++) {
1386
      if ((~a)&1) *uc=*uc+(Unit)powers[i];   /* effect INVERT */
1387
      j=a%10;
1388
      a=a/10;
1389
      if (j>1) {
1390
	decStatus(res, DEC_Invalid_operation, set);
1391
	return res;
1392
	}
1393
      if (uc==msuc && i==msudigs-1) break;   /* just did final digit */
1394
      } /* each digit */
1395
    } /* each unit */
1396
  /* [here uc-1 is the msu of the result] */
1397
  res->digits=decGetDigits(res->lsu, uc-res->lsu);
1398
  res->exponent=0;			/* integer */
1399
  res->bits=0;				/* sign=0 */
1400
  return res;  /* [no status to set] */
1401
  } /* decNumberInvert */
1402

1403
/* ------------------------------------------------------------------ */
1404
/* decNumberLn -- natural logarithm				      */
1405
/*								      */
1406
/*   This computes C = ln(A)					      */
1407
/*								      */
1408
/*   res is C, the result.  C may be A				      */
1409
/*   rhs is A							      */
1410
/*   set is the context; note that rounding mode has no effect	      */
1411
/*								      */
1412
/* C must have space for set->digits digits.			      */
1413
/*								      */
1414
/* Notable cases:						      */
1415
/*   A<0 -> Invalid						      */
1416
/*   A=0 -> -Infinity (Exact)					      */
1417
/*   A=+Infinity -> +Infinity (Exact)				      */
1418
/*   A=1 exactly -> 0 (Exact)					      */
1419
/*								      */
1420
/* Mathematical function restrictions apply (see above); a NaN is     */
1421
/* returned with Invalid_operation if a restriction is violated.      */
1422
/*								      */
1423
/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1424
/* almost always be correctly rounded, but may be up to 1 ulp in      */
1425
/* error in rare cases.						      */
1426
/* ------------------------------------------------------------------ */
1427
/* This is a wrapper for decLnOp which can handle the slightly wider  */
1428
/* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
1429
/* to calculate at p+e+2).					      */
1430
/* ------------------------------------------------------------------ */
1431
decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
1432
			decContext *set) {
1433
  uInt status=0;		   /* accumulator */
1434
  #if DECSUBSET
1435
  decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1436
  #endif
1437

1438
  #if DECCHECK
1439
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1440
  #endif
1441

1442
  /* Check restrictions; this is a math function; if not violated */
1443
  /* then carry out the operation. */
1444
  if (!decCheckMath(rhs, set, &status)) do { /* protect allocation */
1445
    #if DECSUBSET
1446
    if (!set->extended) {
1447
      /* reduce operand and set lostDigits status, as needed */
1448
      if (rhs->digits>set->digits) {
1449
	allocrhs=decRoundOperand(rhs, set, &status);
1450
	if (allocrhs==NULL) break;
1451
	rhs=allocrhs;
1452
	}
1453
      /* special check in subset for rhs=0 */
1454
      if (ISZERO(rhs)) {		/* +/- zeros -> error */
1455
	status|=DEC_Invalid_operation;
1456
	break;}
1457
      } /* extended=0 */
1458
    #endif
1459
    decLnOp(res, rhs, set, &status);
1460
    } while(0);				/* end protected */
1461

1462
  #if DECSUBSET
1463
  if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
1464
  #endif
1465
  /* apply significant status */
1466
  if (status!=0) decStatus(res, status, set);
1467
  #if DECCHECK
1468
  decCheckInexact(res, set);
1469
  #endif
1470
  return res;
1471
  } /* decNumberLn */
1472

1473
/* ------------------------------------------------------------------ */
1474
/* decNumberLogB - get adjusted exponent, by 754r rules		      */
1475
/*								      */
1476
/*   This computes C = adjustedexponent(A)			      */
1477
/*								      */
1478
/*   res is C, the result.  C may be A				      */
1479
/*   rhs is A							      */
1480
/*   set is the context, used only for digits and status	      */
1481
/*								      */
1482
/* C must have space for 10 digits (A might have 10**9 digits and     */
1483
/* an exponent of +999999999, or one digit and an exponent of	      */
1484
/* -1999999999).						      */
1485
/*								      */
1486
/* This returns the adjusted exponent of A after (in theory) padding  */
1487
/* with zeros on the right to set->digits digits while keeping the    */
1488
/* same value.	The exponent is not limited by emin/emax.	      */
1489
/*								      */
1490
/* Notable cases:						      */
1491
/*   A<0 -> Use |A|						      */
1492
/*   A=0 -> -Infinity (Division by zero)			      */
1493
/*   A=Infinite -> +Infinity (Exact)				      */
1494
/*   A=1 exactly -> 0 (Exact)					      */
1495
/*   NaNs are propagated as usual				      */
1496
/* ------------------------------------------------------------------ */
1497
decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
1498
			  decContext *set) {
1499
  uInt status=0;		   /* accumulator */
1500

1501
  #if DECCHECK
1502
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1503
  #endif
1504

1505
  /* NaNs as usual; Infinities return +Infinity; 0->oops */
1506
  if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
1507
   else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
1508
   else if (decNumberIsZero(rhs)) {
1509
    decNumberZero(res);			/* prepare for Infinity */
1510
    res->bits=DECNEG|DECINF;		/* -Infinity */
1511
    status|=DEC_Division_by_zero;	/* as per 754r */
1512
    }
1513
   else { /* finite non-zero */
1514
    Int ae=rhs->exponent+rhs->digits-1; /* adjusted exponent */
1515
    decNumberFromInt32(res, ae);	/* lay it out */
1516
    }
1517

1518
  if (status!=0) decStatus(res, status, set);
1519
  return res;
1520
  } /* decNumberLogB */
1521

1522
/* ------------------------------------------------------------------ */
1523
/* decNumberLog10 -- logarithm in base 10			      */
1524
/*								      */
1525
/*   This computes C = log10(A)					      */
1526
/*								      */
1527
/*   res is C, the result.  C may be A				      */
1528
/*   rhs is A							      */
1529
/*   set is the context; note that rounding mode has no effect	      */
1530
/*								      */
1531
/* C must have space for set->digits digits.			      */
1532
/*								      */
1533
/* Notable cases:						      */
1534
/*   A<0 -> Invalid						      */
1535
/*   A=0 -> -Infinity (Exact)					      */
1536
/*   A=+Infinity -> +Infinity (Exact)				      */
1537
/*   A=10**n (if n is an integer) -> n (Exact)			      */
1538
/*								      */
1539
/* Mathematical function restrictions apply (see above); a NaN is     */
1540
/* returned with Invalid_operation if a restriction is violated.      */
1541
/*								      */
1542
/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
1543
/* almost always be correctly rounded, but may be up to 1 ulp in      */
1544
/* error in rare cases.						      */
1545
/* ------------------------------------------------------------------ */
1546
/* This calculates ln(A)/ln(10) using appropriate precision.  For     */
1547
/* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
1548
/* requested digits and t is the number of digits in the exponent     */
1549
/* (maximum 6).	 For ln(10) it is p + 3; this is often handled by the */
1550
/* fastpath in decLnOp.	 The final division is done to the requested  */
1551
/* precision.							      */
1552
/* ------------------------------------------------------------------ */
1553
decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
1554
			  decContext *set) {
1555
  uInt status=0, ignore=0;	   /* status accumulators */
1556
  uInt needbytes;		   /* for space calculations */
1557
  Int p;			   /* working precision */
1558
  Int t;			   /* digits in exponent of A */
1559

1560
  /* buffers for a and b working decimals */
1561
  /* (adjustment calculator, same size) */
1562
  decNumber bufa[D2N(DECBUFFER+2)];
1563
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
1564
  decNumber *a=bufa;		   /* temporary a */
1565
  decNumber bufb[D2N(DECBUFFER+2)];
1566
  decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
1567
  decNumber *b=bufb;		   /* temporary b */
1568
  decNumber bufw[D2N(10)];	   /* working 2-10 digit number */
1569
  decNumber *w=bufw;		   /* .. */
1570
  #if DECSUBSET
1571
  decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
1572
  #endif
1573

1574
  decContext aset;		   /* working context */
1575

1576
  #if DECCHECK
1577
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1578
  #endif
1579

1580
  /* Check restrictions; this is a math function; if not violated */
1581
  /* then carry out the operation. */
1582
  if (!decCheckMath(rhs, set, &status)) do { /* protect malloc */
1583
    #if DECSUBSET
1584
    if (!set->extended) {
1585
      /* reduce operand and set lostDigits status, as needed */
1586
      if (rhs->digits>set->digits) {
1587
	allocrhs=decRoundOperand(rhs, set, &status);
1588
	if (allocrhs==NULL) break;
1589
	rhs=allocrhs;
1590
	}
1591
      /* special check in subset for rhs=0 */
1592
      if (ISZERO(rhs)) {		/* +/- zeros -> error */
1593
	status|=DEC_Invalid_operation;
1594
	break;}
1595
      } /* extended=0 */
1596
    #endif
1597

1598
    decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
1599

1600
    /* handle exact powers of 10; only check if +ve finite */
1601
    if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1602
      Int residue=0;		   /* (no residue) */
1603
      uInt copystat=0;		   /* clean status */
1604

1605
      /* round to a single digit... */
1606
      aset.digits=1;
1607
      decCopyFit(w, rhs, &aset, &residue, &copystat); /* copy & shorten */
1608
      /* if exact and the digit is 1, rhs is a power of 10 */
1609
      if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
1610
	/* the exponent, conveniently, is the power of 10; making */
1611
	/* this the result needs a little care as it might not fit, */
1612
	/* so first convert it into the working number, and then move */
1613
	/* to res */
1614
	decNumberFromInt32(w, w->exponent);
1615
	residue=0;
1616
	decCopyFit(res, w, set, &residue, &status); /* copy & round */
1617
	decFinish(res, set, &residue, &status);	    /* cleanup/set flags */
1618
	break;
1619
	} /* not a power of 10 */
1620
      } /* not a candidate for exact */
1621

1622
    /* simplify the information-content calculation to use 'total */
1623
    /* number of digits in a, including exponent' as compared to the */
1624
    /* requested digits, as increasing this will only rarely cost an */
1625
    /* iteration in ln(a) anyway */
1626
    t=6;				/* it can never be >6 */
1627

1628
    /* allocate space when needed... */
1629
    p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
1630
    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1631
    if (needbytes>sizeof(bufa)) {	/* need malloc space */
1632
      allocbufa=(decNumber *)malloc(needbytes);
1633
      if (allocbufa==NULL) {		/* hopeless -- abandon */
1634
	status|=DEC_Insufficient_storage;
1635
	break;}
1636
      a=allocbufa;			/* use the allocated space */
1637
      }
1638
    aset.digits=p;			/* as calculated */
1639
    aset.emax=DEC_MAX_MATH;		/* usual bounds */
1640
    aset.emin=-DEC_MAX_MATH;		/* .. */
1641
    aset.clamp=0;			/* and no concrete format */
1642
    decLnOp(a, rhs, &aset, &status);	/* a=ln(rhs) */
1643

1644
    /* skip the division if the result so far is infinite, NaN, or */
1645
    /* zero, or there was an error; note NaN from sNaN needs copy */
1646
    if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
1647
    if (a->bits&DECSPECIAL || ISZERO(a)) {
1648
      decNumberCopy(res, a);		/* [will fit] */
1649
      break;}
1650

1651
    /* for ln(10) an extra 3 digits of precision are needed */
1652
    p=set->digits+3;
1653
    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
1654
    if (needbytes>sizeof(bufb)) {	/* need malloc space */
1655
      allocbufb=(decNumber *)malloc(needbytes);
1656
      if (allocbufb==NULL) {		/* hopeless -- abandon */
1657
	status|=DEC_Insufficient_storage;
1658
	break;}
1659
      b=allocbufb;			/* use the allocated space */
1660
      }
1661
    decNumberZero(w);			/* set up 10... */
1662
    #if DECDPUN==1
1663
    w->lsu[1]=1; w->lsu[0]=0;		/* .. */
1664
    #else
1665
    w->lsu[0]=10;			/* .. */
1666
    #endif
1667
    w->digits=2;			/* .. */
1668

1669
    aset.digits=p;
1670
    decLnOp(b, w, &aset, &ignore);	/* b=ln(10) */
1671

1672
    aset.digits=set->digits;		/* for final divide */
1673
    decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result */
1674
    } while(0);				/* [for break] */
1675

1676
  if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
1677
  if (allocbufb!=NULL) free(allocbufb); /* .. */
1678
  #if DECSUBSET
1679
  if (allocrhs !=NULL) free(allocrhs);	/* .. */
1680
  #endif
1681
  /* apply significant status */
1682
  if (status!=0) decStatus(res, status, set);
1683
  #if DECCHECK
1684
  decCheckInexact(res, set);
1685
  #endif
1686
  return res;
1687
  } /* decNumberLog10 */
1688

1689
/* ------------------------------------------------------------------ */
1690
/* decNumberMax -- compare two Numbers and return the maximum	      */
1691
/*								      */
1692
/*   This computes C = A ? B, returning the maximum by 754R rules     */
1693
/*								      */
1694
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1695
/*   lhs is A							      */
1696
/*   rhs is B							      */
1697
/*   set is the context						      */
1698
/*								      */
1699
/* C must have space for set->digits digits.			      */
1700
/* ------------------------------------------------------------------ */
1701
decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
1702
			 const decNumber *rhs, decContext *set) {
1703
  uInt status=0;			/* accumulator */
1704
  decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
1705
  if (status!=0) decStatus(res, status, set);
1706
  #if DECCHECK
1707
  decCheckInexact(res, set);
1708
  #endif
1709
  return res;
1710
  } /* decNumberMax */
1711

1712
/* ------------------------------------------------------------------ */
1713
/* decNumberMaxMag -- compare and return the maximum by magnitude     */
1714
/*								      */
1715
/*   This computes C = A ? B, returning the maximum by 754R rules     */
1716
/*								      */
1717
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1718
/*   lhs is A							      */
1719
/*   rhs is B							      */
1720
/*   set is the context						      */
1721
/*								      */
1722
/* C must have space for set->digits digits.			      */
1723
/* ------------------------------------------------------------------ */
1724
decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
1725
			 const decNumber *rhs, decContext *set) {
1726
  uInt status=0;			/* accumulator */
1727
  decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
1728
  if (status!=0) decStatus(res, status, set);
1729
  #if DECCHECK
1730
  decCheckInexact(res, set);
1731
  #endif
1732
  return res;
1733
  } /* decNumberMaxMag */
1734

1735
/* ------------------------------------------------------------------ */
1736
/* decNumberMin -- compare two Numbers and return the minimum	      */
1737
/*								      */
1738
/*   This computes C = A ? B, returning the minimum by 754R rules     */
1739
/*								      */
1740
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1741
/*   lhs is A							      */
1742
/*   rhs is B							      */
1743
/*   set is the context						      */
1744
/*								      */
1745
/* C must have space for set->digits digits.			      */
1746
/* ------------------------------------------------------------------ */
1747
decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
1748
			 const decNumber *rhs, decContext *set) {
1749
  uInt status=0;			/* accumulator */
1750
  decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
1751
  if (status!=0) decStatus(res, status, set);
1752
  #if DECCHECK
1753
  decCheckInexact(res, set);
1754
  #endif
1755
  return res;
1756
  } /* decNumberMin */
1757

1758
/* ------------------------------------------------------------------ */
1759
/* decNumberMinMag -- compare and return the minimum by magnitude     */
1760
/*								      */
1761
/*   This computes C = A ? B, returning the minimum by 754R rules     */
1762
/*								      */
1763
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
1764
/*   lhs is A							      */
1765
/*   rhs is B							      */
1766
/*   set is the context						      */
1767
/*								      */
1768
/* C must have space for set->digits digits.			      */
1769
/* ------------------------------------------------------------------ */
1770
decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
1771
			 const decNumber *rhs, decContext *set) {
1772
  uInt status=0;			/* accumulator */
1773
  decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
1774
  if (status!=0) decStatus(res, status, set);
1775
  #if DECCHECK
1776
  decCheckInexact(res, set);
1777
  #endif
1778
  return res;
1779
  } /* decNumberMinMag */
1780

1781
/* ------------------------------------------------------------------ */
1782
/* decNumberMinus -- prefix minus operator			      */
1783
/*								      */
1784
/*   This computes C = 0 - A					      */
1785
/*								      */
1786
/*   res is C, the result.  C may be A				      */
1787
/*   rhs is A							      */
1788
/*   set is the context						      */
1789
/*								      */
1790
/* See also decNumberCopyNegate for a quiet bitwise version of this.  */
1791
/* C must have space for set->digits digits.			      */
1792
/* ------------------------------------------------------------------ */
1793
/* Simply use AddOp for the subtract, which will do the necessary.    */
1794
/* ------------------------------------------------------------------ */
1795
decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
1796
			   decContext *set) {
1797
  decNumber dzero;
1798
  uInt status=0;			/* accumulator */
1799

1800
  #if DECCHECK
1801
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1802
  #endif
1803

1804
  decNumberZero(&dzero);		/* make 0 */
1805
  dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
1806
  decAddOp(res, &dzero, rhs, set, DECNEG, &status);
1807
  if (status!=0) decStatus(res, status, set);
1808
  #if DECCHECK
1809
  decCheckInexact(res, set);
1810
  #endif
1811
  return res;
1812
  } /* decNumberMinus */
1813

1814
/* ------------------------------------------------------------------ */
1815
/* decNumberNextMinus -- next towards -Infinity			      */
1816
/*								      */
1817
/*   This computes C = A - infinitesimal, rounded towards -Infinity   */
1818
/*								      */
1819
/*   res is C, the result.  C may be A				      */
1820
/*   rhs is A							      */
1821
/*   set is the context						      */
1822
/*								      */
1823
/* This is a generalization of 754r NextDown.			      */
1824
/* ------------------------------------------------------------------ */
1825
decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
1826
			       decContext *set) {
1827
  decNumber dtiny;			     /* constant */
1828
  decContext workset=*set;		     /* work */
1829
  uInt status=0;			     /* accumulator */
1830
  #if DECCHECK
1831
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1832
  #endif
1833

1834
  /* +Infinity is the special case */
1835
  if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1836
    decSetMaxValue(res, set);		     /* is +ve */
1837
    /* there is no status to set */
1838
    return res;
1839
    }
1840
  decNumberZero(&dtiny);		     /* start with 0 */
1841
  dtiny.lsu[0]=1;			     /* make number that is .. */
1842
  dtiny.exponent=DEC_MIN_EMIN-1;	     /* .. smaller than tiniest */
1843
  workset.round=DEC_ROUND_FLOOR;
1844
  decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
1845
  status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1846
  if (status!=0) decStatus(res, status, set);
1847
  return res;
1848
  } /* decNumberNextMinus */
1849

1850
/* ------------------------------------------------------------------ */
1851
/* decNumberNextPlus -- next towards +Infinity			      */
1852
/*								      */
1853
/*   This computes C = A + infinitesimal, rounded towards +Infinity   */
1854
/*								      */
1855
/*   res is C, the result.  C may be A				      */
1856
/*   rhs is A							      */
1857
/*   set is the context						      */
1858
/*								      */
1859
/* This is a generalization of 754r NextUp.			      */
1860
/* ------------------------------------------------------------------ */
1861
decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
1862
			      decContext *set) {
1863
  decNumber dtiny;			     /* constant */
1864
  decContext workset=*set;		     /* work */
1865
  uInt status=0;			     /* accumulator */
1866
  #if DECCHECK
1867
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
1868
  #endif
1869

1870
  /* -Infinity is the special case */
1871
  if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1872
    decSetMaxValue(res, set);
1873
    res->bits=DECNEG;			     /* negative */
1874
    /* there is no status to set */
1875
    return res;
1876
    }
1877
  decNumberZero(&dtiny);		     /* start with 0 */
1878
  dtiny.lsu[0]=1;			     /* make number that is .. */
1879
  dtiny.exponent=DEC_MIN_EMIN-1;	     /* .. smaller than tiniest */
1880
  workset.round=DEC_ROUND_CEILING;
1881
  decAddOp(res, rhs, &dtiny, &workset, 0, &status);
1882
  status&=DEC_Invalid_operation|DEC_sNaN;    /* only sNaN Invalid please */
1883
  if (status!=0) decStatus(res, status, set);
1884
  return res;
1885
  } /* decNumberNextPlus */
1886

1887
/* ------------------------------------------------------------------ */
1888
/* decNumberNextToward -- next towards rhs			      */
1889
/*								      */
1890
/*   This computes C = A +/- infinitesimal, rounded towards	      */
1891
/*   +/-Infinity in the direction of B, as per 754r nextafter rules   */
1892
/*								      */
1893
/*   res is C, the result.  C may be A or B.			      */
1894
/*   lhs is A							      */
1895
/*   rhs is B							      */
1896
/*   set is the context						      */
1897
/*								      */
1898
/* This is a generalization of 754r NextAfter.			      */
1899
/* ------------------------------------------------------------------ */
1900
decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
1901
				const decNumber *rhs, decContext *set) {
1902
  decNumber dtiny;			     /* constant */
1903
  decContext workset=*set;		     /* work */
1904
  Int result;				     /* .. */
1905
  uInt status=0;			     /* accumulator */
1906
  #if DECCHECK
1907
  if (decCheckOperands(res, lhs, rhs, set)) return res;
1908
  #endif
1909

1910
  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
1911
    decNaNs(res, lhs, rhs, set, &status);
1912
    }
1913
   else { /* Is numeric, so no chance of sNaN Invalid, etc. */
1914
    result=decCompare(lhs, rhs, 0);	/* sign matters */
1915
    if (result==BADINT) status|=DEC_Insufficient_storage; /* rare */
1916
     else { /* valid compare */
1917
      if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */
1918
       else { /* differ: need NextPlus or NextMinus */
1919
	uByte sub;			/* add or subtract */
1920
	if (result<0) {			/* lhs<rhs, do nextplus */
1921
	  /* -Infinity is the special case */
1922
	  if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1923
	    decSetMaxValue(res, set);
1924
	    res->bits=DECNEG;		/* negative */
1925
	    return res;			/* there is no status to set */
1926
	    }
1927
	  workset.round=DEC_ROUND_CEILING;
1928
	  sub=0;			/* add, please */
1929
	  } /* plus */
1930
	 else {				/* lhs>rhs, do nextminus */
1931
	  /* +Infinity is the special case */
1932
	  if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1933
	    decSetMaxValue(res, set);
1934
	    return res;			/* there is no status to set */
1935
	    }
1936
	  workset.round=DEC_ROUND_FLOOR;
1937
	  sub=DECNEG;			/* subtract, please */
1938
	  } /* minus */
1939
	decNumberZero(&dtiny);		/* start with 0 */
1940
	dtiny.lsu[0]=1;			/* make number that is .. */
1941
	dtiny.exponent=DEC_MIN_EMIN-1;	/* .. smaller than tiniest */
1942
	decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */
1943
	/* turn off exceptions if the result is a normal number */
1944
	/* (including Nmin), otherwise let all status through */
1945
	if (decNumberIsNormal(res, set)) status=0;
1946
	} /* unequal */
1947
      } /* compare OK */
1948
    } /* numeric */
1949
  if (status!=0) decStatus(res, status, set);
1950
  return res;
1951
  } /* decNumberNextToward */
1952

1953
/* ------------------------------------------------------------------ */
1954
/* decNumberOr -- OR two Numbers, digitwise			      */
1955
/*								      */
1956
/*   This computes C = A | B					      */
1957
/*								      */
1958
/*   res is C, the result.  C may be A and/or B (e.g., X=X|X)	      */
1959
/*   lhs is A							      */
1960
/*   rhs is B							      */
1961
/*   set is the context (used for result length and error report)     */
1962
/*								      */
1963
/* C must have space for set->digits digits.			      */
1964
/*								      */
1965
/* Logical function restrictions apply (see above); a NaN is	      */
1966
/* returned with Invalid_operation if a restriction is violated.      */
1967
/* ------------------------------------------------------------------ */
1968
decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
1969
			const decNumber *rhs, decContext *set) {
1970
  const Unit *ua, *ub;			/* -> operands */
1971
  const Unit *msua, *msub;		/* -> operand msus */
1972
  Unit	*uc, *msuc;			/* -> result and its msu */
1973
  Int	msudigs;			/* digits in res msu */
1974
  #if DECCHECK
1975
  if (decCheckOperands(res, lhs, rhs, set)) return res;
1976
  #endif
1977

1978
  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
1979
   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
1980
    decStatus(res, DEC_Invalid_operation, set);
1981
    return res;
1982
    }
1983
  /* operands are valid */
1984
  ua=lhs->lsu;				/* bottom-up */
1985
  ub=rhs->lsu;				/* .. */
1986
  uc=res->lsu;				/* .. */
1987
  msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
1988
  msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
1989
  msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
1990
  msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
1991
  for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
1992
    Unit a, b;				/* extract units */
1993
    if (ua>msua) a=0;
1994
     else a=*ua;
1995
    if (ub>msub) b=0;
1996
     else b=*ub;
1997
    *uc=0;				/* can now write back */
1998
    if (a|b) {				/* maybe 1 bits to examine */
1999
      Int i, j;
2000
      /* This loop could be unrolled and/or use BIN2BCD tables */
2001
      for (i=0; i<DECDPUN; i++) {
2002
	if ((a|b)&1) *uc=*uc+(Unit)powers[i];	  /* effect OR */
2003
	j=a%10;
2004
	a=a/10;
2005
	j|=b%10;
2006
	b=b/10;
2007
	if (j>1) {
2008
	  decStatus(res, DEC_Invalid_operation, set);
2009
	  return res;
2010
	  }
2011
	if (uc==msuc && i==msudigs-1) break;	  /* just did final digit */
2012
	} /* each digit */
2013
      } /* non-zero */
2014
    } /* each unit */
2015
  /* [here uc-1 is the msu of the result] */
2016
  res->digits=decGetDigits(res->lsu, uc-res->lsu);
2017
  res->exponent=0;			/* integer */
2018
  res->bits=0;				/* sign=0 */
2019
  return res;  /* [no status to set] */
2020
  } /* decNumberOr */
2021

2022
/* ------------------------------------------------------------------ */
2023
/* decNumberPlus -- prefix plus operator			      */
2024
/*								      */
2025
/*   This computes C = 0 + A					      */
2026
/*								      */
2027
/*   res is C, the result.  C may be A				      */
2028
/*   rhs is A							      */
2029
/*   set is the context						      */
2030
/*								      */
2031
/* See also decNumberCopy for a quiet bitwise version of this.	      */
2032
/* C must have space for set->digits digits.			      */
2033
/* ------------------------------------------------------------------ */
2034
/* This simply uses AddOp; Add will take fast path after preparing A. */
2035
/* Performance is a concern here, as this routine is often used to    */
2036
/* check operands and apply rounding and overflow/underflow testing.  */
2037
/* ------------------------------------------------------------------ */
2038
decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
2039
			  decContext *set) {
2040
  decNumber dzero;
2041
  uInt status=0;			/* accumulator */
2042
  #if DECCHECK
2043
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2044
  #endif
2045

2046
  decNumberZero(&dzero);		/* make 0 */
2047
  dzero.exponent=rhs->exponent;		/* [no coefficient expansion] */
2048
  decAddOp(res, &dzero, rhs, set, 0, &status);
2049
  if (status!=0) decStatus(res, status, set);
2050
  #if DECCHECK
2051
  decCheckInexact(res, set);
2052
  #endif
2053
  return res;
2054
  } /* decNumberPlus */
2055

2056
/* ------------------------------------------------------------------ */
2057
/* decNumberMultiply -- multiply two Numbers			      */
2058
/*								      */
2059
/*   This computes C = A x B					      */
2060
/*								      */
2061
/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
2062
/*   lhs is A							      */
2063
/*   rhs is B							      */
2064
/*   set is the context						      */
2065
/*								      */
2066
/* C must have space for set->digits digits.			      */
2067
/* ------------------------------------------------------------------ */
2068
decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
2069
			      const decNumber *rhs, decContext *set) {
2070
  uInt status=0;		   /* accumulator */
2071
  decMultiplyOp(res, lhs, rhs, set, &status);
2072
  if (status!=0) decStatus(res, status, set);
2073
  #if DECCHECK
2074
  decCheckInexact(res, set);
2075
  #endif
2076
  return res;
2077
  } /* decNumberMultiply */
2078

2079
/* ------------------------------------------------------------------ */
2080
/* decNumberPower -- raise a number to a power			      */
2081
/*								      */
2082
/*   This computes C = A ** B					      */
2083
/*								      */
2084
/*   res is C, the result.  C may be A and/or B (e.g., X=X**X)	      */
2085
/*   lhs is A							      */
2086
/*   rhs is B							      */
2087
/*   set is the context						      */
2088
/*								      */
2089
/* C must have space for set->digits digits.			      */
2090
/*								      */
2091
/* Mathematical function restrictions apply (see above); a NaN is     */
2092
/* returned with Invalid_operation if a restriction is violated.      */
2093
/*								      */
2094
/* However, if 1999999997<=B<=999999999 and B is an integer then the  */
2095
/* restrictions on A and the context are relaxed to the usual bounds, */
2096
/* for compatibility with the earlier (integer power only) version    */
2097
/* of this function.						      */
2098
/*								      */
2099
/* When B is an integer, the result may be exact, even if rounded.    */
2100
/*								      */
2101
/* The final result is rounded according to the context; it will      */
2102
/* almost always be correctly rounded, but may be up to 1 ulp in      */
2103
/* error in rare cases.						      */
2104
/* ------------------------------------------------------------------ */
2105
decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
2106
			   const decNumber *rhs, decContext *set) {
2107
  #if DECSUBSET
2108
  decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
2109
  decNumber *allocrhs=NULL;	   /* .., rhs */
2110
  #endif
2111
  decNumber *allocdac=NULL;	   /* -> allocated acc buffer, iff used */
2112
  decNumber *allocinv=NULL;	   /* -> allocated 1/x buffer, iff used */
2113
  Int	reqdigits=set->digits;	   /* requested DIGITS */
2114
  Int	n;			   /* rhs in binary */
2115
  Flag	rhsint=0;		   /* 1 if rhs is an integer */
2116
  Flag	useint=0;		   /* 1 if can use integer calculation */
2117
  Flag	isoddint=0;		   /* 1 if rhs is an integer and odd */
2118
  Int	i;			   /* work */
2119
  #if DECSUBSET
2120
  Int	dropped;		   /* .. */
2121
  #endif
2122
  uInt	needbytes;		   /* buffer size needed */
2123
  Flag	seenbit;		   /* seen a bit while powering */
2124
  Int	residue=0;		   /* rounding residue */
2125
  uInt	status=0;		   /* accumulators */
2126
  uByte bits=0;			   /* result sign if errors */
2127
  decContext aset;		   /* working context */
2128
  decNumber dnOne;		   /* work value 1... */
2129
  /* local accumulator buffer [a decNumber, with digits+elength+1 digits] */
2130
  decNumber dacbuff[D2N(DECBUFFER+9)];
2131
  decNumber *dac=dacbuff;	   /* -> result accumulator */
2132
  /* same again for possible 1/lhs calculation */
2133
  decNumber invbuff[D2N(DECBUFFER+9)];
2134

2135
  #if DECCHECK
2136
  if (decCheckOperands(res, lhs, rhs, set)) return res;
2137
  #endif
2138

2139
  do {				   /* protect allocated storage */
2140
    #if DECSUBSET
2141
    if (!set->extended) { /* reduce operands and set status, as needed */
2142
      if (lhs->digits>reqdigits) {
2143
	alloclhs=decRoundOperand(lhs, set, &status);
2144
	if (alloclhs==NULL) break;
2145
	lhs=alloclhs;
2146
	}
2147
      if (rhs->digits>reqdigits) {
2148
	allocrhs=decRoundOperand(rhs, set, &status);
2149
	if (allocrhs==NULL) break;
2150
	rhs=allocrhs;
2151
	}
2152
      }
2153
    #endif
2154
    /* [following code does not require input rounding] */
2155

2156
    /* handle NaNs and rhs Infinity (lhs infinity is harder) */
2157
    if (SPECIALARGS) {
2158
      if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */
2159
	decNaNs(res, lhs, rhs, set, &status);
2160
	break;}
2161
      if (decNumberIsInfinite(rhs)) {	/* rhs Infinity */
2162
	Flag rhsneg=rhs->bits&DECNEG;	/* save rhs sign */
2163
	if (decNumberIsNegative(lhs)	/* lhs<0 */
2164
	 && !decNumberIsZero(lhs))	/* .. */
2165
	  status|=DEC_Invalid_operation;
2166
	 else {				/* lhs >=0 */
2167
	  decNumberZero(&dnOne);	/* set up 1 */
2168
	  dnOne.lsu[0]=1;
2169
	  decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */
2170
	  decNumberZero(res);		/* prepare for 0/1/Infinity */
2171
	  if (decNumberIsNegative(dac)) {    /* lhs<1 */
2172
	    if (rhsneg) res->bits|=DECINF;   /* +Infinity [else is +0] */
2173
	    }
2174
	   else if (dac->lsu[0]==0) {	     /* lhs=1 */
2175
	    /* 1**Infinity is inexact, so return fully-padded 1.0000 */
2176
	    Int shift=set->digits-1;
2177
	    *res->lsu=1;		     /* was 0, make int 1 */
2178
	    res->digits=decShiftToMost(res->lsu, 1, shift);
2179
	    res->exponent=-shift;	     /* make 1.0000... */
2180
	    status|=DEC_Inexact|DEC_Rounded; /* deemed inexact */
2181
	    }
2182
	   else {			     /* lhs>1 */
2183
	    if (!rhsneg) res->bits|=DECINF;  /* +Infinity [else is +0] */
2184
	    }
2185
	  } /* lhs>=0 */
2186
	break;}
2187
      /* [lhs infinity drops through] */
2188
      } /* specials */
2189

2190
    /* Original rhs may be an integer that fits and is in range */
2191
    n=decGetInt(rhs);
2192
    if (n!=BADINT) {			/* it is an integer */
2193
      rhsint=1;				/* record the fact for 1**n */
2194
      isoddint=(Flag)n&1;		/* [works even if big] */
2195
      if (n!=BIGEVEN && n!=BIGODD)	/* can use integer path? */
2196
	useint=1;			/* looks good */
2197
      }
2198

2199
    if (decNumberIsNegative(lhs)	/* -x .. */
2200
      && isoddint) bits=DECNEG;		/* .. to an odd power */
2201

2202
    /* handle LHS infinity */
2203
    if (decNumberIsInfinite(lhs)) {	/* [NaNs already handled] */
2204
      uByte rbits=rhs->bits;		/* save */
2205
      decNumberZero(res);		/* prepare */
2206
      if (n==0) *res->lsu=1;		/* [-]Inf**0 => 1 */
2207
       else {
2208
	/* -Inf**nonint -> error */
2209
	if (!rhsint && decNumberIsNegative(lhs)) {
2210
	  status|=DEC_Invalid_operation;     /* -Inf**nonint is error */
2211
	  break;}
2212
	if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2213
	/* [otherwise will be 0 or -0] */
2214
	res->bits=bits;
2215
	}
2216
      break;}
2217

2218
    /* similarly handle LHS zero */
2219
    if (decNumberIsZero(lhs)) {
2220
      if (n==0) {			     /* 0**0 => Error */
2221
	#if DECSUBSET
2222
	if (!set->extended) {		     /* [unless subset] */
2223
	  decNumberZero(res);
2224
	  *res->lsu=1;			     /* return 1 */
2225
	  break;}
2226
	#endif
2227
	status|=DEC_Invalid_operation;
2228
	}
2229
       else {				     /* 0**x */
2230
	uByte rbits=rhs->bits;		     /* save */
2231
	if (rbits & DECNEG) {		     /* was a 0**(-n) */
2232
	  #if DECSUBSET
2233
	  if (!set->extended) {		     /* [bad if subset] */
2234
	    status|=DEC_Invalid_operation;
2235
	    break;}
2236
	  #endif
2237
	  bits|=DECINF;
2238
	  }
2239
	decNumberZero(res);		     /* prepare */
2240
	/* [otherwise will be 0 or -0] */
2241
	res->bits=bits;
2242
	}
2243
      break;}
2244

2245
    /* here both lhs and rhs are finite; rhs==0 is handled in the */
2246
    /* integer path.  Next handle the non-integer cases */
2247
    if (!useint) {			/* non-integral rhs */
2248
      /* any -ve lhs is bad, as is either operand or context out of */
2249
      /* bounds */
2250
      if (decNumberIsNegative(lhs)) {
2251
	status|=DEC_Invalid_operation;
2252
	break;}
2253
      if (decCheckMath(lhs, set, &status)
2254
       || decCheckMath(rhs, set, &status)) break; /* variable status */
2255

2256
      decContextDefault(&aset, DEC_INIT_DECIMAL64); /* clean context */
2257
      aset.emax=DEC_MAX_MATH;		/* usual bounds */
2258
      aset.emin=-DEC_MAX_MATH;		/* .. */
2259
      aset.clamp=0;			/* and no concrete format */
2260

2261
      /* calculate the result using exp(ln(lhs)*rhs), which can */
2262
      /* all be done into the accumulator, dac.	 The precision needed */
2263
      /* is enough to contain the full information in the lhs (which */
2264
      /* is the total digits, including exponent), or the requested */
2265
      /* precision, if larger, + 4; 6 is used for the exponent */
2266
      /* maximum length, and this is also used when it is shorter */
2267
      /* than the requested digits as it greatly reduces the >0.5 ulp */
2268
      /* cases at little cost (because Ln doubles digits each */
2269
      /* iteration so a few extra digits rarely causes an extra */
2270
      /* iteration) */
2271
      aset.digits=MAXI(lhs->digits, set->digits)+6+4;
2272
      } /* non-integer rhs */
2273

2274
     else { /* rhs is in-range integer */
2275
      if (n==0) {			/* x**0 = 1 */
2276
	/* (0**0 was handled above) */
2277
	decNumberZero(res);		/* result=1 */
2278
	*res->lsu=1;			/* .. */
2279
	break;}
2280
      /* rhs is a non-zero integer */
2281
      if (n<0) n=-n;			/* use abs(n) */
2282

2283
      aset=*set;			/* clone the context */
2284
      aset.round=DEC_ROUND_HALF_EVEN;	/* internally use balanced */
2285
      /* calculate the working DIGITS */
2286
      aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
2287
      #if DECSUBSET
2288
      if (!set->extended) aset.digits--;     /* use classic precision */
2289
      #endif
2290
      /* it's an error if this is more than can be handled */
2291
      if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
2292
      } /* integer path */
2293

2294
    /* aset.digits is the count of digits for the accumulator needed */
2295
    /* if accumulator is too long for local storage, then allocate */
2296
    needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
2297
    /* [needbytes also used below if 1/lhs needed] */
2298
    if (needbytes>sizeof(dacbuff)) {
2299
      allocdac=(decNumber *)malloc(needbytes);
2300
      if (allocdac==NULL) {   /* hopeless -- abandon */
2301
	status|=DEC_Insufficient_storage;
2302
	break;}
2303
      dac=allocdac;	      /* use the allocated space */
2304
      }
2305
    /* here, aset is set up and accumulator is ready for use */
2306

2307
    if (!useint) {			     /* non-integral rhs */
2308
      /* x ** y; special-case x=1 here as it will otherwise always */
2309
      /* reduce to integer 1; decLnOp has a fastpath which detects */
2310
      /* the case of x=1 */
2311
      decLnOp(dac, lhs, &aset, &status);     /* dac=ln(lhs) */
2312
      /* [no error possible, as lhs 0 already handled] */
2313
      if (ISZERO(dac)) {		     /* x==1, 1.0, etc. */
2314
	/* need to return fully-padded 1.0000 etc., but rhsint->1 */
2315
	*dac->lsu=1;			     /* was 0, make int 1 */
2316
	if (!rhsint) {			     /* add padding */
2317
	  Int shift=set->digits-1;
2318
	  dac->digits=decShiftToMost(dac->lsu, 1, shift);
2319
	  dac->exponent=-shift;		     /* make 1.0000... */
2320
	  status|=DEC_Inexact|DEC_Rounded;   /* deemed inexact */
2321
	  }
2322
	}
2323
       else {
2324
	decMultiplyOp(dac, dac, rhs, &aset, &status);  /* dac=dac*rhs */
2325
	decExpOp(dac, dac, &aset, &status);	       /* dac=exp(dac) */
2326
	}
2327
      /* and drop through for final rounding */
2328
      } /* non-integer rhs */
2329

2330
     else {				/* carry on with integer */
2331
      decNumberZero(dac);		/* acc=1 */
2332
      *dac->lsu=1;			/* .. */
2333

2334
      /* if a negative power the constant 1 is needed, and if not subset */
2335
      /* invert the lhs now rather than inverting the result later */
2336
      if (decNumberIsNegative(rhs)) {	/* was a **-n [hence digits>0] */
2337
	decNumber *inv=invbuff;		/* assume use fixed buffer */
2338
	decNumberCopy(&dnOne, dac);	/* dnOne=1;  [needed now or later] */
2339
	#if DECSUBSET
2340
	if (set->extended) {		/* need to calculate 1/lhs */
2341
	#endif
2342
	  /* divide lhs into 1, putting result in dac [dac=1/dac] */
2343
	  decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
2344
	  /* now locate or allocate space for the inverted lhs */
2345
	  if (needbytes>sizeof(invbuff)) {
2346
	    allocinv=(decNumber *)malloc(needbytes);
2347
	    if (allocinv==NULL) {	/* hopeless -- abandon */
2348
	      status|=DEC_Insufficient_storage;
2349
	      break;}
2350
	    inv=allocinv;		/* use the allocated space */
2351
	    }
2352
	  /* [inv now points to big-enough buffer or allocated storage] */
2353
	  decNumberCopy(inv, dac);	/* copy the 1/lhs */
2354
	  decNumberCopy(dac, &dnOne);	/* restore acc=1 */
2355
	  lhs=inv;			/* .. and go forward with new lhs */
2356
	#if DECSUBSET
2357
	  }
2358
	#endif
2359
	}
2360

2361
      /* Raise-to-the-power loop... */
2362
      seenbit=0;		   /* set once a 1-bit is encountered */
2363
      for (i=1;;i++){		   /* for each bit [top bit ignored] */
2364
	/* abandon if had overflow or terminal underflow */
2365
	if (status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
2366
	  if (status&DEC_Overflow || ISZERO(dac)) break;
2367
	  }
2368
	/* [the following two lines revealed an optimizer bug in a C++ */
2369
	/* compiler, with symptom: 5**3 -> 25, when n=n+n was used] */
2370
	n=n<<1;			   /* move next bit to testable position */
2371
	if (n<0) {		   /* top bit is set */
2372
	  seenbit=1;		   /* OK, significant bit seen */
2373
	  decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */
2374
	  }
2375
	if (i==31) break;	   /* that was the last bit */
2376
	if (!seenbit) continue;	   /* no need to square 1 */
2377
	decMultiplyOp(dac, dac, dac, &aset, &status); /* dac=dac*dac [square] */
2378
	} /*i*/ /* 32 bits */
2379

2380
      /* complete internal overflow or underflow processing */
2381
      if (status & (DEC_Overflow|DEC_Underflow)) {
2382
	#if DECSUBSET
2383
	/* If subset, and power was negative, reverse the kind of -erflow */
2384
	/* [1/x not yet done] */
2385
	if (!set->extended && decNumberIsNegative(rhs)) {
2386
	  if (status & DEC_Overflow)
2387
	    status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
2388
	   else { /* trickier -- Underflow may or may not be set */
2389
	    status&=~(DEC_Underflow | DEC_Subnormal); /* [one or both] */
2390
	    status|=DEC_Overflow;
2391
	    }
2392
	  }
2393
	#endif
2394
	dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2395
	/* round subnormals [to set.digits rather than aset.digits] */
2396
	/* or set overflow result similarly as required */
2397
	decFinalize(dac, set, &residue, &status);
2398
	decNumberCopy(res, dac);   /* copy to result (is now OK length) */
2399
	break;
2400
	}
2401

2402
      #if DECSUBSET
2403
      if (!set->extended &&		     /* subset math */
2404
	  decNumberIsNegative(rhs)) {	     /* was a **-n [hence digits>0] */
2405
	/* so divide result into 1 [dac=1/dac] */
2406
	decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
2407
	}
2408
      #endif
2409
      } /* rhs integer path */
2410

2411
    /* reduce result to the requested length and copy to result */
2412
    decCopyFit(res, dac, set, &residue, &status);
2413
    decFinish(res, set, &residue, &status);  /* final cleanup */
2414
    #if DECSUBSET
2415
    if (!set->extended) decTrim(res, set, 0, &dropped); /* trailing zeros */
2416
    #endif
2417
    } while(0);				/* end protected */
2418

2419
  if (allocdac!=NULL) free(allocdac);	/* drop any storage used */
2420
  if (allocinv!=NULL) free(allocinv);	/* .. */
2421
  #if DECSUBSET
2422
  if (alloclhs!=NULL) free(alloclhs);	/* .. */
2423
  if (allocrhs!=NULL) free(allocrhs);	/* .. */
2424
  #endif
2425
  if (status!=0) decStatus(res, status, set);
2426
  #if DECCHECK
2427
  decCheckInexact(res, set);
2428
  #endif
2429
  return res;
2430
  } /* decNumberPower */
2431

2432
/* ------------------------------------------------------------------ */
2433
/* decNumberQuantize -- force exponent to requested value	      */
2434
/*								      */
2435
/*   This computes C = op(A, B), where op adjusts the coefficient     */
2436
/*   of C (by rounding or shifting) such that the exponent (-scale)   */
2437
/*   of C has exponent of B.  The numerical value of C will equal A,  */
2438
/*   except for the effects of any rounding that occurred.	      */
2439
/*								      */
2440
/*   res is C, the result.  C may be A or B			      */
2441
/*   lhs is A, the number to adjust				      */
2442
/*   rhs is B, the number with exponent to match		      */
2443
/*   set is the context						      */
2444
/*								      */
2445
/* C must have space for set->digits digits.			      */
2446
/*								      */
2447
/* Unless there is an error or the result is infinite, the exponent   */
2448
/* after the operation is guaranteed to be equal to that of B.	      */
2449
/* ------------------------------------------------------------------ */
2450
decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
2451
			      const decNumber *rhs, decContext *set) {
2452
  uInt status=0;			/* accumulator */
2453
  decQuantizeOp(res, lhs, rhs, set, 1, &status);
2454
  if (status!=0) decStatus(res, status, set);
2455
  return res;
2456
  } /* decNumberQuantize */
2457

2458
/* ------------------------------------------------------------------ */
2459
/* decNumberReduce -- remove trailing zeros			      */
2460
/*								      */
2461
/*   This computes C = 0 + A, and normalizes the result		      */
2462
/*								      */
2463
/*   res is C, the result.  C may be A				      */
2464
/*   rhs is A							      */
2465
/*   set is the context						      */
2466
/*								      */
2467
/* C must have space for set->digits digits.			      */
2468
/* ------------------------------------------------------------------ */
2469
/* Previously known as Normalize */
2470
decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
2471
			       decContext *set) {
2472
  return decNumberReduce(res, rhs, set);
2473
  } /* decNumberNormalize */
2474

2475
decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
2476
			    decContext *set) {
2477
  #if DECSUBSET
2478
  decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
2479
  #endif
2480
  uInt status=0;		   /* as usual */
2481
  Int  residue=0;		   /* as usual */
2482
  Int  dropped;			   /* work */
2483

2484
  #if DECCHECK
2485
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2486
  #endif
2487

2488
  do {				   /* protect allocated storage */
2489
    #if DECSUBSET
2490
    if (!set->extended) {
2491
      /* reduce operand and set lostDigits status, as needed */
2492
      if (rhs->digits>set->digits) {
2493
	allocrhs=decRoundOperand(rhs, set, &status);
2494
	if (allocrhs==NULL) break;
2495
	rhs=allocrhs;
2496
	}
2497
      }
2498
    #endif
2499
    /* [following code does not require input rounding] */
2500

2501
    /* Infinities copy through; NaNs need usual treatment */
2502
    if (decNumberIsNaN(rhs)) {
2503
      decNaNs(res, rhs, NULL, set, &status);
2504
      break;
2505
      }
2506

2507
    /* reduce result to the requested length and copy to result */
2508
    decCopyFit(res, rhs, set, &residue, &status); /* copy & round */
2509
    decFinish(res, set, &residue, &status);	  /* cleanup/set flags */
2510
    decTrim(res, set, 1, &dropped);		  /* normalize in place */
2511
    } while(0);				     /* end protected */
2512

2513
  #if DECSUBSET
2514
  if (allocrhs !=NULL) free(allocrhs);	     /* .. */
2515
  #endif
2516
  if (status!=0) decStatus(res, status, set);/* then report status */
2517
  return res;
2518
  } /* decNumberReduce */
2519

2520
/* ------------------------------------------------------------------ */
2521
/* decNumberRescale -- force exponent to requested value	      */
2522
/*								      */
2523
/*   This computes C = op(A, B), where op adjusts the coefficient     */
2524
/*   of C (by rounding or shifting) such that the exponent (-scale)   */
2525
/*   of C has the value B.  The numerical value of C will equal A,    */
2526
/*   except for the effects of any rounding that occurred.	      */
2527
/*								      */
2528
/*   res is C, the result.  C may be A or B			      */
2529
/*   lhs is A, the number to adjust				      */
2530
/*   rhs is B, the requested exponent				      */
2531
/*   set is the context						      */
2532
/*								      */
2533
/* C must have space for set->digits digits.			      */
2534
/*								      */
2535
/* Unless there is an error or the result is infinite, the exponent   */
2536
/* after the operation is guaranteed to be equal to B.		      */
2537
/* ------------------------------------------------------------------ */
2538
decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
2539
			     const decNumber *rhs, decContext *set) {
2540
  uInt status=0;			/* accumulator */
2541
  decQuantizeOp(res, lhs, rhs, set, 0, &status);
2542
  if (status!=0) decStatus(res, status, set);
2543
  return res;
2544
  } /* decNumberRescale */
2545

2546
/* ------------------------------------------------------------------ */
2547
/* decNumberRemainder -- divide and return remainder		      */
2548
/*								      */
2549
/*   This computes C = A % B					      */
2550
/*								      */
2551
/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)	      */
2552
/*   lhs is A							      */
2553
/*   rhs is B							      */
2554
/*   set is the context						      */
2555
/*								      */
2556
/* C must have space for set->digits digits.			      */
2557
/* ------------------------------------------------------------------ */
2558
decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
2559
			       const decNumber *rhs, decContext *set) {
2560
  uInt status=0;			/* accumulator */
2561
  decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
2562
  if (status!=0) decStatus(res, status, set);
2563
  #if DECCHECK
2564
  decCheckInexact(res, set);
2565
  #endif
2566
  return res;
2567
  } /* decNumberRemainder */
2568

2569
/* ------------------------------------------------------------------ */
2570
/* decNumberRemainderNear -- divide and return remainder from nearest */
2571
/*								      */
2572
/*   This computes C = A % B, where % is the IEEE remainder operator  */
2573
/*								      */
2574
/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)	      */
2575
/*   lhs is A							      */
2576
/*   rhs is B							      */
2577
/*   set is the context						      */
2578
/*								      */
2579
/* C must have space for set->digits digits.			      */
2580
/* ------------------------------------------------------------------ */
2581
decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
2582
				   const decNumber *rhs, decContext *set) {
2583
  uInt status=0;			/* accumulator */
2584
  decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
2585
  if (status!=0) decStatus(res, status, set);
2586
  #if DECCHECK
2587
  decCheckInexact(res, set);
2588
  #endif
2589
  return res;
2590
  } /* decNumberRemainderNear */
2591

2592
/* ------------------------------------------------------------------ */
2593
/* decNumberRotate -- rotate the coefficient of a Number left/right   */
2594
/*								      */
2595
/*   This computes C = A rot B	(in base ten and rotating set->digits */
2596
/*   digits).							      */
2597
/*								      */
2598
/*   res is C, the result.  C may be A and/or B (e.g., X=XrotX)	      */
2599
/*   lhs is A							      */
2600
/*   rhs is B, the number of digits to rotate (-ve to right)	      */
2601
/*   set is the context						      */
2602
/*								      */
2603
/* The digits of the coefficient of A are rotated to the left (if B   */
2604
/* is positive) or to the right (if B is negative) without adjusting  */
2605
/* the exponent or the sign of A.  If lhs->digits is less than	      */
2606
/* set->digits the coefficient is padded with zeros on the left	      */
2607
/* before the rotate.  Any leading zeros in the result are removed    */
2608
/* as usual.							      */
2609
/*								      */
2610
/* B must be an integer (q=0) and in the range -set->digits through   */
2611
/* +set->digits.						      */
2612
/* C must have space for set->digits digits.			      */
2613
/* NaNs are propagated as usual.  Infinities are unaffected (but      */
2614
/* B must be valid).  No status is set unless B is invalid or an      */
2615
/* operand is an sNaN.						      */
2616
/* ------------------------------------------------------------------ */
2617
decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
2618
			   const decNumber *rhs, decContext *set) {
2619
  uInt status=0;	      /* accumulator */
2620
  Int  rotate;		      /* rhs as an Int */
2621

2622
  #if DECCHECK
2623
  if (decCheckOperands(res, lhs, rhs, set)) return res;
2624
  #endif
2625

2626
  /* NaNs propagate as normal */
2627
  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2628
    decNaNs(res, lhs, rhs, set, &status);
2629
   /* rhs must be an integer */
2630
   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2631
    status=DEC_Invalid_operation;
2632
   else { /* both numeric, rhs is an integer */
2633
    rotate=decGetInt(rhs);		     /* [cannot fail] */
2634
    if (rotate==BADINT			     /* something bad .. */
2635
     || rotate==BIGODD || rotate==BIGEVEN    /* .. very big .. */
2636
     || abs(rotate)>set->digits)	     /* .. or out of range */
2637
      status=DEC_Invalid_operation;
2638
     else {				     /* rhs is OK */
2639
      decNumberCopy(res, lhs);
2640
      /* convert -ve rotate to equivalent positive rotation */
2641
      if (rotate<0) rotate=set->digits+rotate;
2642
      if (rotate!=0 && rotate!=set->digits   /* zero or full rotation */
2643
       && !decNumberIsInfinite(res)) {	     /* lhs was infinite */
2644
	/* left-rotate to do; 0 < rotate < set->digits */
2645
	uInt units, shift;		     /* work */
2646
	uInt msudigits;			     /* digits in result msu */
2647
	Unit *msu=res->lsu+D2U(res->digits)-1;	  /* current msu */
2648
	Unit *msumax=res->lsu+D2U(set->digits)-1; /* rotation msu */
2649
	for (msu++; msu<=msumax; msu++) *msu=0;	  /* ensure high units=0 */
2650
	res->digits=set->digits;		  /* now full-length */
2651
	msudigits=MSUDIGITS(res->digits);	  /* actual digits in msu */
2652

2653
	/* rotation here is done in-place, in three steps */
2654
	/* 1. shift all to least up to one unit to unit-align final */
2655
	/*    lsd [any digits shifted out are rotated to the left, */
2656
	/*    abutted to the original msd (which may require split)] */
2657
	/* */
2658
	/*    [if there are no whole units left to rotate, the */
2659
	/*    rotation is now complete] */
2660
	/* */
2661
	/* 2. shift to least, from below the split point only, so that */
2662
	/*    the final msd is in the right place in its Unit [any */
2663
	/*    digits shifted out will fit exactly in the current msu, */
2664
	/*    left aligned, no split required] */
2665
	/* */
2666
	/* 3. rotate all the units by reversing left part, right */
2667
	/*    part, and then whole */
2668
	/* */
2669
	/* example: rotate right 8 digits (2 units + 2), DECDPUN=3. */
2670
	/* */
2671
	/*   start: 00a bcd efg hij klm npq */
2672
	/* */
2673
	/*	1a  000 0ab cde fgh|ijk lmn [pq saved] */
2674
	/*	1b  00p qab cde fgh|ijk lmn */
2675
	/* */
2676
	/*	2a  00p qab cde fgh|00i jkl [mn saved] */
2677
	/*	2b  mnp qab cde fgh|00i jkl */
2678
	/* */
2679
	/*	3a  fgh cde qab mnp|00i jkl */
2680
	/*	3b  fgh cde qab mnp|jkl 00i */
2681
	/*	3c  00i jkl mnp qab cde fgh */
2682

2683
	/* Step 1: amount to shift is the partial right-rotate count */
2684
	rotate=set->digits-rotate;	/* make it right-rotate */
2685
	units=rotate/DECDPUN;		/* whole units to rotate */
2686
	shift=rotate%DECDPUN;		/* left-over digits count */
2687
	if (shift>0) {			/* not an exact number of units */
2688
	  uInt save=res->lsu[0]%powers[shift];	  /* save low digit(s) */
2689
	  decShiftToLeast(res->lsu, D2U(res->digits), shift);
2690
	  if (shift>msudigits) {	/* msumax-1 needs >0 digits */
2691
	    uInt rem=save%powers[shift-msudigits];/* split save */
2692
	    *msumax=(Unit)(save/powers[shift-msudigits]); /* and insert */
2693
	    *(msumax-1)=*(msumax-1)
2694
		       +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); /* .. */
2695
	    }
2696
	   else { /* all fits in msumax */
2697
	    *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); /* [maybe *1] */
2698
	    }
2699
	  } /* digits shift needed */
2700

2701
	/* If whole units to rotate... */
2702
	if (units>0) {			/* some to do */
2703
	  /* Step 2: the units to touch are the whole ones in rotate, */
2704
	  /*   if any, and the shift is DECDPUN-msudigits (which may be */
2705
	  /*   0, again) */
2706
	  shift=DECDPUN-msudigits;
2707
	  if (shift>0) {		/* not an exact number of units */
2708
	    uInt save=res->lsu[0]%powers[shift];  /* save low digit(s) */
2709
	    decShiftToLeast(res->lsu, units, shift);
2710
	    *msumax=*msumax+(Unit)(save*powers[msudigits]);
2711
	    } /* partial shift needed */
2712

2713
	  /* Step 3: rotate the units array using triple reverse */
2714
	  /* (reversing is easy and fast) */
2715
	  decReverse(res->lsu+units, msumax);	  /* left part */
2716
	  decReverse(res->lsu, res->lsu+units-1); /* right part */
2717
	  decReverse(res->lsu, msumax);		  /* whole */
2718
	  } /* whole units to rotate */
2719
	/* the rotation may have left an undetermined number of zeros */
2720
	/* on the left, so true length needs to be calculated */
2721
	res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
2722
	} /* rotate needed */
2723
      } /* rhs OK */
2724
    } /* numerics */
2725
  if (status!=0) decStatus(res, status, set);
2726
  return res;
2727
  } /* decNumberRotate */
2728

2729
/* ------------------------------------------------------------------ */
2730
/* decNumberSameQuantum -- test for equal exponents		      */
2731
/*								      */
2732
/*   res is the result number, which will contain either 0 or 1	      */
2733
/*   lhs is a number to test					      */
2734
/*   rhs is the second (usually a pattern)			      */
2735
/*								      */
2736
/* No errors are possible and no context is needed.		      */
2737
/* ------------------------------------------------------------------ */
2738
decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
2739
				 const decNumber *rhs) {
2740
  Unit ret=0;			   /* return value */
2741

2742
  #if DECCHECK
2743
  if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
2744
  #endif
2745

2746
  if (SPECIALARGS) {
2747
    if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
2748
     else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
2749
     /* [anything else with a special gives 0] */
2750
    }
2751
   else if (lhs->exponent==rhs->exponent) ret=1;
2752

2753
  decNumberZero(res);		   /* OK to overwrite an operand now */
2754
  *res->lsu=ret;
2755
  return res;
2756
  } /* decNumberSameQuantum */
2757

2758
/* ------------------------------------------------------------------ */
2759
/* decNumberScaleB -- multiply by a power of 10			      */
2760
/*								      */
2761
/* This computes C = A x 10**B where B is an integer (q=0) with	      */
2762
/* maximum magnitude 2*(emax+digits)				      */
2763
/*								      */
2764
/*   res is C, the result.  C may be A or B			      */
2765
/*   lhs is A, the number to adjust				      */
2766
/*   rhs is B, the requested power of ten to use		      */
2767
/*   set is the context						      */
2768
/*								      */
2769
/* C must have space for set->digits digits.			      */
2770
/*								      */
2771
/* The result may underflow or overflow.			      */
2772
/* ------------------------------------------------------------------ */
2773
decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
2774
			    const decNumber *rhs, decContext *set) {
2775
  Int  reqexp;		      /* requested exponent change [B] */
2776
  uInt status=0;	      /* accumulator */
2777
  Int  residue;		      /* work */
2778

2779
  #if DECCHECK
2780
  if (decCheckOperands(res, lhs, rhs, set)) return res;
2781
  #endif
2782

2783
  /* Handle special values except lhs infinite */
2784
  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2785
    decNaNs(res, lhs, rhs, set, &status);
2786
    /* rhs must be an integer */
2787
   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2788
    status=DEC_Invalid_operation;
2789
   else {
2790
    /* lhs is a number; rhs is a finite with q==0 */
2791
    reqexp=decGetInt(rhs);		     /* [cannot fail] */
2792
    if (reqexp==BADINT			     /* something bad .. */
2793
     || reqexp==BIGODD || reqexp==BIGEVEN    /* .. very big .. */
2794
     || abs(reqexp)>(2*(set->digits+set->emax))) /* .. or out of range */
2795
      status=DEC_Invalid_operation;
2796
     else {				     /* rhs is OK */
2797
      decNumberCopy(res, lhs);		     /* all done if infinite lhs */
2798
      if (!decNumberIsInfinite(res)) {	     /* prepare to scale */
2799
	res->exponent+=reqexp;		     /* adjust the exponent */
2800
	residue=0;
2801
	decFinalize(res, set, &residue, &status); /* .. and check */
2802
	} /* finite LHS */
2803
      } /* rhs OK */
2804
    } /* rhs finite */
2805
  if (status!=0) decStatus(res, status, set);
2806
  return res;
2807
  } /* decNumberScaleB */
2808

2809
/* ------------------------------------------------------------------ */
2810
/* decNumberShift -- shift the coefficient of a Number left or right  */
2811
/*								      */
2812
/*   This computes C = A << B or C = A >> -B  (in base ten).	      */
2813
/*								      */
2814
/*   res is C, the result.  C may be A and/or B (e.g., X=X<<X)	      */
2815
/*   lhs is A							      */
2816
/*   rhs is B, the number of digits to shift (-ve to right)	      */
2817
/*   set is the context						      */
2818
/*								      */
2819
/* The digits of the coefficient of A are shifted to the left (if B   */
2820
/* is positive) or to the right (if B is negative) without adjusting  */
2821
/* the exponent or the sign of A.				      */
2822
/*								      */
2823
/* B must be an integer (q=0) and in the range -set->digits through   */
2824
/* +set->digits.						      */
2825
/* C must have space for set->digits digits.			      */
2826
/* NaNs are propagated as usual.  Infinities are unaffected (but      */
2827
/* B must be valid).  No status is set unless B is invalid or an      */
2828
/* operand is an sNaN.						      */
2829
/* ------------------------------------------------------------------ */
2830
decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
2831
			   const decNumber *rhs, decContext *set) {
2832
  uInt status=0;	      /* accumulator */
2833
  Int  shift;		      /* rhs as an Int */
2834

2835
  #if DECCHECK
2836
  if (decCheckOperands(res, lhs, rhs, set)) return res;
2837
  #endif
2838

2839
  /* NaNs propagate as normal */
2840
  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
2841
    decNaNs(res, lhs, rhs, set, &status);
2842
   /* rhs must be an integer */
2843
   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
2844
    status=DEC_Invalid_operation;
2845
   else { /* both numeric, rhs is an integer */
2846
    shift=decGetInt(rhs);		     /* [cannot fail] */
2847
    if (shift==BADINT			     /* something bad .. */
2848
     || shift==BIGODD || shift==BIGEVEN	     /* .. very big .. */
2849
     || abs(shift)>set->digits)		     /* .. or out of range */
2850
      status=DEC_Invalid_operation;
2851
     else {				     /* rhs is OK */
2852
      decNumberCopy(res, lhs);
2853
      if (shift!=0 && !decNumberIsInfinite(res)) { /* something to do */
2854
	if (shift>0) {			     /* to left */
2855
	  if (shift==set->digits) {	     /* removing all */
2856
	    *res->lsu=0;		     /* so place 0 */
2857
	    res->digits=1;		     /* .. */
2858
	    }
2859
	   else {			     /* */
2860
	    /* first remove leading digits if necessary */
2861
	    if (res->digits+shift>set->digits) {
2862
	      decDecap(res, res->digits+shift-set->digits);
2863
	      /* that updated res->digits; may have gone to 1 (for a */
2864
	      /* single digit or for zero */
2865
	      }
2866
	    if (res->digits>1 || *res->lsu)  /* if non-zero.. */
2867
	      res->digits=decShiftToMost(res->lsu, res->digits, shift);
2868
	    } /* partial left */
2869
	  } /* left */
2870
	 else { /* to right */
2871
	  if (-shift>=res->digits) {	     /* discarding all */
2872
	    *res->lsu=0;		     /* so place 0 */
2873
	    res->digits=1;		     /* .. */
2874
	    }
2875
	   else {
2876
	    decShiftToLeast(res->lsu, D2U(res->digits), -shift);
2877
	    res->digits-=(-shift);
2878
	    }
2879
	  } /* to right */
2880
	} /* non-0 non-Inf shift */
2881
      } /* rhs OK */
2882
    } /* numerics */
2883
  if (status!=0) decStatus(res, status, set);
2884
  return res;
2885
  } /* decNumberShift */
2886

2887
/* ------------------------------------------------------------------ */
2888
/* decNumberSquareRoot -- square root operator			      */
2889
/*								      */
2890
/*   This computes C = squareroot(A)				      */
2891
/*								      */
2892
/*   res is C, the result.  C may be A				      */
2893
/*   rhs is A							      */
2894
/*   set is the context; note that rounding mode has no effect	      */
2895
/*								      */
2896
/* C must have space for set->digits digits.			      */
2897
/* ------------------------------------------------------------------ */
2898
/* This uses the following varying-precision algorithm in:	      */
2899
/*								      */
2900
/*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
2901
/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
2902
/*   pp229-237, ACM, September 1985.				      */
2903
/*								      */
2904
/* The square-root is calculated using Newton's method, after which   */
2905
/* a check is made to ensure the result is correctly rounded.	      */
2906
/*								      */
2907
/* % [Reformatted original Numerical Turing source code follows.]     */
2908
/* function sqrt(x : real) : real				      */
2909
/* % sqrt(x) returns the properly rounded approximation to the square */
2910
/* % root of x, in the precision of the calling environment, or it    */
2911
/* % fails if x < 0.						      */
2912
/* % t e hull and a abrham, august, 1984			      */
2913
/* if x <= 0 then						      */
2914
/*   if x < 0 then						      */
2915
/*     assert false						      */
2916
/*   else							      */
2917
/*     result 0							      */
2918
/*   end if							      */
2919
/* end if							      */
2920
/* var f := setexp(x, 0)  % fraction part of x	 [0.1 <= x < 1]	      */
2921
/* var e := getexp(x)	  % exponent part of x			      */
2922
/* var approx : real						      */
2923
/* if e mod 2 = 0  then						      */
2924
/*   approx := .259 + .819 * f	 % approx to root of f		      */
2925
/* else								      */
2926
/*   f := f/l0			 % adjustments			      */
2927
/*   e := e + 1			 %   for odd			      */
2928
/*   approx := .0819 + 2.59 * f	 %   exponent			      */
2929
/* end if							      */
2930
/*								      */
2931
/* var p:= 3							      */
2932
/* const maxp := currentprecision + 2				      */
2933
/* loop								      */
2934
/*   p := min(2*p - 2, maxp)	 % p = 4,6,10, . . . , maxp	      */
2935
/*   precision p						      */
2936
/*   approx := .5 * (approx + f/approx)				      */
2937
/*   exit when p = maxp						      */
2938
/* end loop							      */
2939
/*								      */
2940
/* % approx is now within 1 ulp of the properly rounded square root   */
2941
/* % of f; to ensure proper rounding, compare squares of (approx -    */
2942
/* % l/2 ulp) and (approx + l/2 ulp) with f.			      */
2943
/* p := currentprecision					      */
2944
/* begin							      */
2945
/*   precision p + 2						      */
2946
/*   const approxsubhalf := approx - setexp(.5, -p)		      */
2947
/*   if mulru(approxsubhalf, approxsubhalf) > f then		      */
2948
/*     approx := approx - setexp(.l, -p + 1)			      */
2949
/*   else							      */
2950
/*     const approxaddhalf := approx + setexp(.5, -p)		      */
2951
/*     if mulrd(approxaddhalf, approxaddhalf) < f then		      */
2952
/*	 approx := approx + setexp(.l, -p + 1)			      */
2953
/*     end if							      */
2954
/*   end if							      */
2955
/* end								      */
2956
/* result setexp(approx, e div 2)  % fix exponent		      */
2957
/* end sqrt							      */
2958
/* ------------------------------------------------------------------ */
2959
decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
2960
				decContext *set) {
2961
  decContext workset, approxset;   /* work contexts */
2962
  decNumber dzero;		   /* used for constant zero */
2963
  Int  maxp;			   /* largest working precision */
2964
  Int  workp;			   /* working precision */
2965
  Int  residue=0;		   /* rounding residue */
2966
  uInt status=0, ignore=0;	   /* status accumulators */
2967
  uInt rstatus;			   /* .. */
2968
  Int  exp;			   /* working exponent */
2969
  Int  ideal;			   /* ideal (preferred) exponent */
2970
  Int  needbytes;		   /* work */
2971
  Int  dropped;			   /* .. */
2972

2973
  #if DECSUBSET
2974
  decNumber *allocrhs=NULL;	   /* non-NULL if rounded rhs allocated */
2975
  #endif
2976
  /* buffer for f [needs +1 in case DECBUFFER 0] */
2977
  decNumber buff[D2N(DECBUFFER+1)];
2978
  /* buffer for a [needs +2 to match likely maxp] */
2979
  decNumber bufa[D2N(DECBUFFER+2)];
2980
  /* buffer for temporary, b [must be same size as a] */
2981
  decNumber bufb[D2N(DECBUFFER+2)];
2982
  decNumber *allocbuff=NULL;	   /* -> allocated buff, iff allocated */
2983
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
2984
  decNumber *allocbufb=NULL;	   /* -> allocated bufb, iff allocated */
2985
  decNumber *f=buff;		   /* reduced fraction */
2986
  decNumber *a=bufa;		   /* approximation to result */
2987
  decNumber *b=bufb;		   /* intermediate result */
2988
  /* buffer for temporary variable, up to 3 digits */
2989
  decNumber buft[D2N(3)];
2990
  decNumber *t=buft;		   /* up-to-3-digit constant or work */
2991

2992
  #if DECCHECK
2993
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
2994
  #endif
2995

2996
  do {				   /* protect allocated storage */
2997
    #if DECSUBSET
2998
    if (!set->extended) {
2999
      /* reduce operand and set lostDigits status, as needed */
3000
      if (rhs->digits>set->digits) {
3001
	allocrhs=decRoundOperand(rhs, set, &status);
3002
	if (allocrhs==NULL) break;
3003
	/* [Note: 'f' allocation below could reuse this buffer if */
3004
	/* used, but as this is rare they are kept separate for clarity.] */
3005
	rhs=allocrhs;
3006
	}
3007
      }
3008
    #endif
3009
    /* [following code does not require input rounding] */
3010

3011
    /* handle infinities and NaNs */
3012
    if (SPECIALARG) {
3013
      if (decNumberIsInfinite(rhs)) {	      /* an infinity */
3014
	if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
3015
	 else decNumberCopy(res, rhs);	      /* +Infinity */
3016
	}
3017
       else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3018
      break;
3019
      }
3020

3021
    /* calculate the ideal (preferred) exponent [floor(exp/2)] */
3022
    /* [We would like to write: ideal=rhs->exponent>>1, but this */
3023
    /* generates a compiler warning.  Generated code is the same.] */
3024
    ideal=(rhs->exponent&~1)/2;		/* target */
3025

3026
    /* handle zeros */
3027
    if (ISZERO(rhs)) {
3028
      decNumberCopy(res, rhs);		/* could be 0 or -0 */
3029
      res->exponent=ideal;		/* use the ideal [safe] */
3030
      /* use decFinish to clamp any out-of-range exponent, etc. */
3031
      decFinish(res, set, &residue, &status);
3032
      break;
3033
      }
3034

3035
    /* any other -x is an oops */
3036
    if (decNumberIsNegative(rhs)) {
3037
      status|=DEC_Invalid_operation;
3038
      break;
3039
      }
3040

3041
    /* space is needed for three working variables */
3042
    /*	 f -- the same precision as the RHS, reduced to 0.01->0.99... */
3043
    /*	 a -- Hull's approximation -- precision, when assigned, is */
3044
    /*	      currentprecision+1 or the input argument precision, */
3045
    /*	      whichever is larger (+2 for use as temporary) */
3046
    /*	 b -- intermediate temporary result (same size as a) */
3047
    /* if any is too long for local storage, then allocate */
3048
    workp=MAXI(set->digits+1, rhs->digits);  /* actual rounding precision */
3049
    maxp=workp+2;			     /* largest working precision */
3050

3051
    needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
3052
    if (needbytes>(Int)sizeof(buff)) {
3053
      allocbuff=(decNumber *)malloc(needbytes);
3054
      if (allocbuff==NULL) {  /* hopeless -- abandon */
3055
	status|=DEC_Insufficient_storage;
3056
	break;}
3057
      f=allocbuff;	      /* use the allocated space */
3058
      }
3059
    /* a and b both need to be able to hold a maxp-length number */
3060
    needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
3061
    if (needbytes>(Int)sizeof(bufa)) {		  /* [same applies to b] */
3062
      allocbufa=(decNumber *)malloc(needbytes);
3063
      allocbufb=(decNumber *)malloc(needbytes);
3064
      if (allocbufa==NULL || allocbufb==NULL) {	  /* hopeless */
3065
	status|=DEC_Insufficient_storage;
3066
	break;}
3067
      a=allocbufa;	      /* use the allocated spaces */
3068
      b=allocbufb;	      /* .. */
3069
      }
3070

3071
    /* copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1 */
3072
    decNumberCopy(f, rhs);
3073
    exp=f->exponent+f->digits;		     /* adjusted to Hull rules */
3074
    f->exponent=-(f->digits);		     /* to range */
3075

3076
    /* set up working context */
3077
    decContextDefault(&workset, DEC_INIT_DECIMAL64);
3078

3079
    /* [Until further notice, no error is possible and status bits */
3080
    /* (Rounded, etc.) should be ignored, not accumulated.] */
3081

3082
    /* Calculate initial approximation, and allow for odd exponent */
3083
    workset.digits=workp;		     /* p for initial calculation */
3084
    t->bits=0; t->digits=3;
3085
    a->bits=0; a->digits=3;
3086
    if ((exp & 1)==0) {			     /* even exponent */
3087
      /* Set t=0.259, a=0.819 */
3088
      t->exponent=-3;
3089
      a->exponent=-3;
3090
      #if DECDPUN>=3
3091
	t->lsu[0]=259;
3092
	a->lsu[0]=819;
3093
      #elif DECDPUN==2
3094
	t->lsu[0]=59; t->lsu[1]=2;
3095
	a->lsu[0]=19; a->lsu[1]=8;
3096
      #else
3097
	t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
3098
	a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
3099
      #endif
3100
      }
3101
     else {				     /* odd exponent */
3102
      /* Set t=0.0819, a=2.59 */
3103
      f->exponent--;			     /* f=f/10 */
3104
      exp++;				     /* e=e+1 */
3105
      t->exponent=-4;
3106
      a->exponent=-2;
3107
      #if DECDPUN>=3
3108
	t->lsu[0]=819;
3109
	a->lsu[0]=259;
3110
      #elif DECDPUN==2
3111
	t->lsu[0]=19; t->lsu[1]=8;
3112
	a->lsu[0]=59; a->lsu[1]=2;
3113
      #else
3114
	t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
3115
	a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
3116
      #endif
3117
      }
3118
    decMultiplyOp(a, a, f, &workset, &ignore);	  /* a=a*f */
3119
    decAddOp(a, a, t, &workset, 0, &ignore);	  /* ..+t */
3120
    /* [a is now the initial approximation for sqrt(f), calculated with */
3121
    /* currentprecision, which is also a's precision.] */
3122

3123
    /* the main calculation loop */
3124
    decNumberZero(&dzero);		     /* make 0 */
3125
    decNumberZero(t);			     /* set t = 0.5 */
3126
    t->lsu[0]=5;			     /* .. */
3127
    t->exponent=-1;			     /* .. */
3128
    workset.digits=3;			     /* initial p */
3129
    for (;;) {
3130
      /* set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp] */
3131
      workset.digits=workset.digits*2-2;
3132
      if (workset.digits>maxp) workset.digits=maxp;
3133
      /* a = 0.5 * (a + f/a) */
3134
      /* [calculated at p then rounded to currentprecision] */
3135
      decDivideOp(b, f, a, &workset, DIVIDE, &ignore); /* b=f/a */
3136
      decAddOp(b, b, a, &workset, 0, &ignore);	  /* b=b+a */
3137
      decMultiplyOp(a, b, t, &workset, &ignore);  /* a=b*0.5 */
3138
      if (a->digits==maxp) break;	     /* have required digits */
3139
      } /* loop */
3140

3141
    /* Here, 0.1 <= a < 1 [Hull], and a has maxp digits */
3142
    /* now reduce to length, etc.; this needs to be done with a */
3143
    /* having the correct exponent so as to handle subnormals */
3144
    /* correctly */
3145
    approxset=*set;			     /* get emin, emax, etc. */
3146
    approxset.round=DEC_ROUND_HALF_EVEN;
3147
    a->exponent+=exp/2;			     /* set correct exponent */
3148

3149
    rstatus=0;				     /* clear status */
3150
    residue=0;				     /* .. and accumulator */
3151
    decCopyFit(a, a, &approxset, &residue, &rstatus);  /* reduce (if needed) */
3152
    decFinish(a, &approxset, &residue, &rstatus);      /* clean and finalize */
3153

3154
    /* Overflow was possible if the input exponent was out-of-range, */
3155
    /* in which case quit */
3156
    if (rstatus&DEC_Overflow) {
3157
      status=rstatus;			     /* use the status as-is */
3158
      decNumberCopy(res, a);		     /* copy to result */
3159
      break;
3160
      }
3161

3162
    /* Preserve status except Inexact/Rounded */
3163
    status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
3164

3165
    /* Carry out the Hull correction */
3166
    a->exponent-=exp/2;			     /* back to 0.1->1 */
3167

3168
    /* a is now at final precision and within 1 ulp of the properly */
3169
    /* rounded square root of f; to ensure proper rounding, compare */
3170
    /* squares of (a - l/2 ulp) and (a + l/2 ulp) with f. */
3171
    /* Here workset.digits=maxp and t=0.5, and a->digits determines */
3172
    /* the ulp */
3173
    workset.digits--;				  /* maxp-1 is OK now */
3174
    t->exponent=-a->digits-1;			  /* make 0.5 ulp */
3175
    decAddOp(b, a, t, &workset, DECNEG, &ignore); /* b = a - 0.5 ulp */
3176
    workset.round=DEC_ROUND_UP;
3177
    decMultiplyOp(b, b, b, &workset, &ignore);	  /* b = mulru(b, b) */
3178
    decCompareOp(b, f, b, &workset, COMPARE, &ignore); /* b ? f, reversed */
3179
    if (decNumberIsNegative(b)) {		  /* f < b [i.e., b > f] */
3180
      /* this is the more common adjustment, though both are rare */
3181
      t->exponent++;				  /* make 1.0 ulp */
3182
      t->lsu[0]=1;				  /* .. */
3183
      decAddOp(a, a, t, &workset, DECNEG, &ignore); /* a = a - 1 ulp */
3184
      /* assign to approx [round to length] */
3185
      approxset.emin-=exp/2;			  /* adjust to match a */
3186
      approxset.emax-=exp/2;
3187
      decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3188
      }
3189
     else {
3190
      decAddOp(b, a, t, &workset, 0, &ignore);	  /* b = a + 0.5 ulp */
3191
      workset.round=DEC_ROUND_DOWN;
3192
      decMultiplyOp(b, b, b, &workset, &ignore);  /* b = mulrd(b, b) */
3193
      decCompareOp(b, b, f, &workset, COMPARE, &ignore);   /* b ? f */
3194
      if (decNumberIsNegative(b)) {		  /* b < f */
3195
	t->exponent++;				  /* make 1.0 ulp */
3196
	t->lsu[0]=1;				  /* .. */
3197
	decAddOp(a, a, t, &workset, 0, &ignore);  /* a = a + 1 ulp */
3198
	/* assign to approx [round to length] */
3199
	approxset.emin-=exp/2;			  /* adjust to match a */
3200
	approxset.emax-=exp/2;
3201
	decAddOp(a, &dzero, a, &approxset, 0, &ignore);
3202
	}
3203
      }
3204
    /* [no errors are possible in the above, and rounding/inexact during */
3205
    /* estimation are irrelevant, so status was not accumulated] */
3206

3207
    /* Here, 0.1 <= a < 1  (still), so adjust back */
3208
    a->exponent+=exp/2;			     /* set correct exponent */
3209

3210
    /* count droppable zeros [after any subnormal rounding] by */
3211
    /* trimming a copy */
3212
    decNumberCopy(b, a);
3213
    decTrim(b, set, 1, &dropped);	     /* [drops trailing zeros] */
3214

3215
    /* Set Inexact and Rounded.	 The answer can only be exact if */
3216
    /* it is short enough so that squaring it could fit in workp digits, */
3217
    /* and it cannot have trailing zeros due to clamping, so these are */
3218
    /* the only (relatively rare) conditions a careful check is needed */
3219
    if (b->digits*2-1 > workp && !set->clamp) { /* cannot fit */
3220
      status|=DEC_Inexact|DEC_Rounded;
3221
      }
3222
     else {				     /* could be exact/unrounded */
3223
      uInt mstatus=0;			     /* local status */
3224
      decMultiplyOp(b, b, b, &workset, &mstatus); /* try the multiply */
3225
      if (mstatus&DEC_Overflow) {	     /* result just won't fit */
3226
	status|=DEC_Inexact|DEC_Rounded;
3227
	}
3228
       else {				     /* plausible */
3229
	decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); /* b ? rhs */
3230
	if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; /* not equal */
3231
	 else {				     /* is Exact */
3232
	  /* here, dropped is the count of trailing zeros in 'a' */
3233
	  /* use closest exponent to ideal... */
3234
	  Int todrop=ideal-a->exponent;	     /* most that can be dropped */
3235
	  if (todrop<0) status|=DEC_Rounded; /* ideally would add 0s */
3236
	   else {			     /* unrounded */
3237
	    if (dropped<todrop) {	     /* clamp to those available */
3238
	      todrop=dropped;
3239
	      status|=DEC_Clamped;
3240
	      }
3241
	    if (todrop>0) {		     /* have some to drop */
3242
	      decShiftToLeast(a->lsu, D2U(a->digits), todrop);
3243
	      a->exponent+=todrop;	     /* maintain numerical value */
3244
	      a->digits-=todrop;	     /* new length */
3245
	      }
3246
	    }
3247
	  }
3248
	}
3249
      }
3250

3251
    /* double-check Underflow, as perhaps the result could not have */
3252
    /* been subnormal (initial argument too big), or it is now Exact */
3253
    if (status&DEC_Underflow) {
3254
      Int ae=rhs->exponent+rhs->digits-1;    /* adjusted exponent */
3255
      /* check if truly subnormal */
3256
      #if DECEXTFLAG			     /* DEC_Subnormal too */
3257
	if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
3258
      #else
3259
	if (ae>=set->emin*2) status&=~DEC_Underflow;
3260
      #endif
3261
      /* check if truly inexact */
3262
      if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
3263
      }
3264

3265
    decNumberCopy(res, a);		     /* a is now the result */
3266
    } while(0);				     /* end protected */
3267

3268
  if (allocbuff!=NULL) free(allocbuff);	     /* drop any storage used */
3269
  if (allocbufa!=NULL) free(allocbufa);	     /* .. */
3270
  if (allocbufb!=NULL) free(allocbufb);	     /* .. */
3271
  #if DECSUBSET
3272
  if (allocrhs !=NULL) free(allocrhs);	     /* .. */
3273
  #endif
3274
  if (status!=0) decStatus(res, status, set);/* then report status */
3275
  #if DECCHECK
3276
  decCheckInexact(res, set);
3277
  #endif
3278
  return res;
3279
  } /* decNumberSquareRoot */
3280

3281
/* ------------------------------------------------------------------ */
3282
/* decNumberSubtract -- subtract two Numbers			      */
3283
/*								      */
3284
/*   This computes C = A - B					      */
3285
/*								      */
3286
/*   res is C, the result.  C may be A and/or B (e.g., X=X-X)	      */
3287
/*   lhs is A							      */
3288
/*   rhs is B							      */
3289
/*   set is the context						      */
3290
/*								      */
3291
/* C must have space for set->digits digits.			      */
3292
/* ------------------------------------------------------------------ */
3293
decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
3294
			      const decNumber *rhs, decContext *set) {
3295
  uInt status=0;			/* accumulator */
3296

3297
  decAddOp(res, lhs, rhs, set, DECNEG, &status);
3298
  if (status!=0) decStatus(res, status, set);
3299
  #if DECCHECK
3300
  decCheckInexact(res, set);
3301
  #endif
3302
  return res;
3303
  } /* decNumberSubtract */
3304

3305
/* ------------------------------------------------------------------ */
3306
/* decNumberToIntegralExact -- round-to-integral-value with InExact   */
3307
/* decNumberToIntegralValue -- round-to-integral-value		      */
3308
/*								      */
3309
/*   res is the result						      */
3310
/*   rhs is input number					      */
3311
/*   set is the context						      */
3312
/*								      */
3313
/* res must have space for any value of rhs.			      */
3314
/*								      */
3315
/* This implements the IEEE special operators and therefore treats    */
3316
/* special values as valid.  For finite numbers it returns	      */
3317
/* rescale(rhs, 0) if rhs->exponent is <0.			      */
3318
/* Otherwise the result is rhs (so no error is possible, except for   */
3319
/* sNaN).							      */
3320
/*								      */
3321
/* The context is used for rounding mode and status after sNaN, but   */
3322
/* the digits setting is ignored.  The Exact version will signal      */
3323
/* Inexact if the result differs numerically from rhs; the other      */
3324
/* never signals Inexact.					      */
3325
/* ------------------------------------------------------------------ */
3326
decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
3327
				     decContext *set) {
3328
  decNumber dn;
3329
  decContext workset;		   /* working context */
3330
  uInt status=0;		   /* accumulator */
3331

3332
  #if DECCHECK
3333
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
3334
  #endif
3335

3336
  /* handle infinities and NaNs */
3337
  if (SPECIALARG) {
3338
    if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); /* an Infinity */
3339
     else decNaNs(res, rhs, NULL, set, &status); /* a NaN */
3340
    }
3341
   else { /* finite */
3342
    /* have a finite number; no error possible (res must be big enough) */
3343
    if (rhs->exponent>=0) return decNumberCopy(res, rhs);
3344
    /* that was easy, but if negative exponent there is work to do... */
3345
    workset=*set;		   /* clone rounding, etc. */
3346
    workset.digits=rhs->digits;	   /* no length rounding */
3347
    workset.traps=0;		   /* no traps */
3348
    decNumberZero(&dn);		   /* make a number with exponent 0 */
3349
    decNumberQuantize(res, rhs, &dn, &workset);
3350
    status|=workset.status;
3351
    }
3352
  if (status!=0) decStatus(res, status, set);
3353
  return res;
3354
  } /* decNumberToIntegralExact */
3355

3356
decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
3357
				     decContext *set) {
3358
  decContext workset=*set;	   /* working context */
3359
  workset.traps=0;		   /* no traps */
3360
  decNumberToIntegralExact(res, rhs, &workset);
3361
  /* this never affects set, except for sNaNs; NaN will have been set */
3362
  /* or propagated already, so no need to call decStatus */
3363
  set->status|=workset.status&DEC_Invalid_operation;
3364
  return res;
3365
  } /* decNumberToIntegralValue */
3366

3367
/* ------------------------------------------------------------------ */
3368
/* decNumberXor -- XOR two Numbers, digitwise			      */
3369
/*								      */
3370
/*   This computes C = A ^ B					      */
3371
/*								      */
3372
/*   res is C, the result.  C may be A and/or B (e.g., X=X^X)	      */
3373
/*   lhs is A							      */
3374
/*   rhs is B							      */
3375
/*   set is the context (used for result length and error report)     */
3376
/*								      */
3377
/* C must have space for set->digits digits.			      */
3378
/*								      */
3379
/* Logical function restrictions apply (see above); a NaN is	      */
3380
/* returned with Invalid_operation if a restriction is violated.      */
3381
/* ------------------------------------------------------------------ */
3382
decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
3383
			 const decNumber *rhs, decContext *set) {
3384
  const Unit *ua, *ub;			/* -> operands */
3385
  const Unit *msua, *msub;		/* -> operand msus */
3386
  Unit	*uc, *msuc;			/* -> result and its msu */
3387
  Int	msudigs;			/* digits in res msu */
3388
  #if DECCHECK
3389
  if (decCheckOperands(res, lhs, rhs, set)) return res;
3390
  #endif
3391

3392
  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
3393
   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
3394
    decStatus(res, DEC_Invalid_operation, set);
3395
    return res;
3396
    }
3397
  /* operands are valid */
3398
  ua=lhs->lsu;				/* bottom-up */
3399
  ub=rhs->lsu;				/* .. */
3400
  uc=res->lsu;				/* .. */
3401
  msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */
3402
  msub=ub+D2U(rhs->digits)-1;		/* -> msu of rhs */
3403
  msuc=uc+D2U(set->digits)-1;		/* -> msu of result */
3404
  msudigs=MSUDIGITS(set->digits);	/* [faster than remainder] */
3405
  for (; uc<=msuc; ua++, ub++, uc++) {	/* Unit loop */
3406
    Unit a, b;				/* extract units */
3407
    if (ua>msua) a=0;
3408
     else a=*ua;
3409
    if (ub>msub) b=0;
3410
     else b=*ub;
3411
    *uc=0;				/* can now write back */
3412
    if (a|b) {				/* maybe 1 bits to examine */
3413
      Int i, j;
3414
      /* This loop could be unrolled and/or use BIN2BCD tables */
3415
      for (i=0; i<DECDPUN; i++) {
3416
	if ((a^b)&1) *uc=*uc+(Unit)powers[i];	  /* effect XOR */
3417
	j=a%10;
3418
	a=a/10;
3419
	j|=b%10;
3420
	b=b/10;
3421
	if (j>1) {
3422
	  decStatus(res, DEC_Invalid_operation, set);
3423
	  return res;
3424
	  }
3425
	if (uc==msuc && i==msudigs-1) break;	  /* just did final digit */
3426
	} /* each digit */
3427
      } /* non-zero */
3428
    } /* each unit */
3429
  /* [here uc-1 is the msu of the result] */
3430
  res->digits=decGetDigits(res->lsu, uc-res->lsu);
3431
  res->exponent=0;			/* integer */
3432
  res->bits=0;				/* sign=0 */
3433
  return res;  /* [no status to set] */
3434
  } /* decNumberXor */
3435

3436

3437
/* ================================================================== */
3438
/* Utility routines						      */
3439
/* ================================================================== */
3440

3441
/* ------------------------------------------------------------------ */
3442
/* decNumberClass -- return the decClass of a decNumber		      */
3443
/*   dn -- the decNumber to test				      */
3444
/*   set -- the context to use for Emin				      */
3445
/*   returns the decClass enum					      */
3446
/* ------------------------------------------------------------------ */
3447
enum decClass decNumberClass(const decNumber *dn, decContext *set) {
3448
  if (decNumberIsSpecial(dn)) {
3449
    if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
3450
    if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
3451
    /* must be an infinity */
3452
    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
3453
    return DEC_CLASS_POS_INF;
3454
    }
3455
  /* is finite */
3456
  if (decNumberIsNormal(dn, set)) { /* most common */
3457
    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
3458
    return DEC_CLASS_POS_NORMAL;
3459
    }
3460
  /* is subnormal or zero */
3461
  if (decNumberIsZero(dn)) {	/* most common */
3462
    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
3463
    return DEC_CLASS_POS_ZERO;
3464
    }
3465
  if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
3466
  return DEC_CLASS_POS_SUBNORMAL;
3467
  } /* decNumberClass */
3468

3469
/* ------------------------------------------------------------------ */
3470
/* decNumberClassToString -- convert decClass to a string	      */
3471
/*								      */
3472
/*  eclass is a valid decClass					      */
3473
/*  returns a constant string describing the class (max 13+1 chars)   */
3474
/* ------------------------------------------------------------------ */
3475
const char *decNumberClassToString(enum decClass eclass) {
3476
  if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
3477
  if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
3478
  if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
3479
  if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
3480
  if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
3481
  if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
3482
  if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
3483
  if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
3484
  if (eclass==DEC_CLASS_QNAN)	       return DEC_ClassString_QN;
3485
  if (eclass==DEC_CLASS_SNAN)	       return DEC_ClassString_SN;
3486
  return DEC_ClassString_UN;	       /* Unknown */
3487
  } /* decNumberClassToString */
3488

3489
/* ------------------------------------------------------------------ */
3490
/* decNumberCopy -- copy a number				      */
3491
/*								      */
3492
/*   dest is the target decNumber				      */
3493
/*   src  is the source decNumber				      */
3494
/*   returns dest						      */
3495
/*								      */
3496
/* (dest==src is allowed and is a no-op)			      */
3497
/* All fields are updated as required.	This is a utility operation,  */
3498
/* so special values are unchanged and no error is possible.	      */
3499
/* ------------------------------------------------------------------ */
3500
decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
3501

3502
  #if DECCHECK
3503
  if (src==NULL) return decNumberZero(dest);
3504
  #endif
3505

3506
  if (dest==src) return dest;		     /* no copy required */
3507

3508
  /* Use explicit assignments here as structure assignment could copy */
3509
  /* more than just the lsu (for small DECDPUN).  This would not affect */
3510
  /* the value of the results, but could disturb test harness spill */
3511
  /* checking. */
3512
  dest->bits=src->bits;
3513
  dest->exponent=src->exponent;
3514
  dest->digits=src->digits;
3515
  dest->lsu[0]=src->lsu[0];
3516
  if (src->digits>DECDPUN) {		     /* more Units to come */
3517
    const Unit *smsup, *s;		     /* work */
3518
    Unit  *d;				     /* .. */
3519
    /* memcpy for the remaining Units would be safe as they cannot */
3520
    /* overlap.	 However, this explicit loop is faster in short cases. */
3521
    d=dest->lsu+1;			     /* -> first destination */
3522
    smsup=src->lsu+D2U(src->digits);	     /* -> source msu+1 */
3523
    for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
3524
    }
3525
  return dest;
3526
  } /* decNumberCopy */
3527

3528
/* ------------------------------------------------------------------ */
3529
/* decNumberCopyAbs -- quiet absolute value operator		      */
3530
/*								      */
3531
/*   This sets C = abs(A)					      */
3532
/*								      */
3533
/*   res is C, the result.  C may be A				      */
3534
/*   rhs is A							      */
3535
/*								      */
3536
/* C must have space for set->digits digits.			      */
3537
/* No exception or error can occur; this is a quiet bitwise operation.*/
3538
/* See also decNumberAbs for a checking version of this.	      */
3539
/* ------------------------------------------------------------------ */
3540
decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
3541
  #if DECCHECK
3542
  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3543
  #endif
3544
  decNumberCopy(res, rhs);
3545
  res->bits&=~DECNEG;			/* turn off sign */
3546
  return res;
3547
  } /* decNumberCopyAbs */
3548

3549
/* ------------------------------------------------------------------ */
3550
/* decNumberCopyNegate -- quiet negate value operator		      */
3551
/*								      */
3552
/*   This sets C = negate(A)					      */
3553
/*								      */
3554
/*   res is C, the result.  C may be A				      */
3555
/*   rhs is A							      */
3556
/*								      */
3557
/* C must have space for set->digits digits.			      */
3558
/* No exception or error can occur; this is a quiet bitwise operation.*/
3559
/* See also decNumberMinus for a checking version of this.	      */
3560
/* ------------------------------------------------------------------ */
3561
decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
3562
  #if DECCHECK
3563
  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3564
  #endif
3565
  decNumberCopy(res, rhs);
3566
  res->bits^=DECNEG;			/* invert the sign */
3567
  return res;
3568
  } /* decNumberCopyNegate */
3569

3570
/* ------------------------------------------------------------------ */
3571
/* decNumberCopySign -- quiet copy and set sign operator	      */
3572
/*								      */
3573
/*   This sets C = A with the sign of B				      */
3574
/*								      */
3575
/*   res is C, the result.  C may be A				      */
3576
/*   lhs is A							      */
3577
/*   rhs is B							      */
3578
/*								      */
3579
/* C must have space for set->digits digits.			      */
3580
/* No exception or error can occur; this is a quiet bitwise operation.*/
3581
/* ------------------------------------------------------------------ */
3582
decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
3583
			      const decNumber *rhs) {
3584
  uByte sign;				/* rhs sign */
3585
  #if DECCHECK
3586
  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
3587
  #endif
3588
  sign=rhs->bits & DECNEG;		/* save sign bit */
3589
  decNumberCopy(res, lhs);
3590
  res->bits&=~DECNEG;			/* clear the sign */
3591
  res->bits|=sign;			/* set from rhs */
3592
  return res;
3593
  } /* decNumberCopySign */
3594

3595
/* ------------------------------------------------------------------ */
3596
/* decNumberGetBCD -- get the coefficient in BCD8		      */
3597
/*   dn is the source decNumber					      */
3598
/*   bcd is the uInt array that will receive dn->digits BCD bytes,    */
3599
/*     most-significant at offset 0				      */
3600
/*   returns bcd						      */
3601
/*								      */
3602
/* bcd must have at least dn->digits bytes.  No error is possible; if */
3603
/* dn is a NaN or Infinite, digits must be 1 and the coefficient 0.   */
3604
/* ------------------------------------------------------------------ */
3605
uByte * decNumberGetBCD(const decNumber *dn, uint8_t *bcd) {
3606
  uByte *ub=bcd+dn->digits-1;	   /* -> lsd */
3607
  const Unit *up=dn->lsu;	   /* Unit pointer, -> lsu */
3608

3609
  #if DECDPUN==1		   /* trivial simple copy */
3610
    for (; ub>=bcd; ub--, up++) *ub=*up;
3611
  #else				   /* chopping needed */
3612
    uInt u=*up;			   /* work */
3613
    uInt cut=DECDPUN;		   /* downcounter through unit */
3614
    for (; ub>=bcd; ub--) {
3615
      *ub=(uByte)(u%10);	   /* [*6554 trick inhibits, here] */
3616
      u=u/10;
3617
      cut--;
3618
      if (cut>0) continue;	   /* more in this unit */
3619
      up++;
3620
      u=*up;
3621
      cut=DECDPUN;
3622
      }
3623
  #endif
3624
  return bcd;
3625
  } /* decNumberGetBCD */
3626

3627
/* ------------------------------------------------------------------ */
3628
/* decNumberSetBCD -- set (replace) the coefficient from BCD8	      */
3629
/*   dn is the target decNumber					      */
3630
/*   bcd is the uInt array that will source n BCD bytes, most-	      */
3631
/*     significant at offset 0					      */
3632
/*   n is the number of digits in the source BCD array (bcd)	      */
3633
/*   returns dn							      */
3634
/*								      */
3635
/* dn must have space for at least n digits.  No error is possible;   */
3636
/* if dn is a NaN, or Infinite, or is to become a zero, n must be 1   */
3637
/* and bcd[0] zero.						      */
3638
/* ------------------------------------------------------------------ */
3639
decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
3640
  Unit *up = dn->lsu + D2U(n) - 1;      /* -> msu [target pointer] */
3641
  const uByte *ub=bcd;			/* -> source msd */
3642

3643
  #if DECDPUN==1			/* trivial simple copy */
3644
    for (; ub<bcd+n; ub++, up--) *up=*ub;
3645
  #else					/* some assembly needed */
3646
    /* calculate how many digits in msu, and hence first cut */
3647
    Int cut=MSUDIGITS(n);		/* [faster than remainder] */
3648
    for (;up>=dn->lsu; up--) {		/* each Unit from msu */
3649
      *up=0;				/* will take <=DECDPUN digits */
3650
      for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
3651
      cut=DECDPUN;			/* next Unit has all digits */
3652
      }
3653
  #endif
3654
  dn->digits=n;				/* set digit count */
3655
  return dn;
3656
  } /* decNumberSetBCD */
3657

3658
/* ------------------------------------------------------------------ */
3659
/* decNumberIsNormal -- test normality of a decNumber		      */
3660
/*   dn is the decNumber to test				      */
3661
/*   set is the context to use for Emin				      */
3662
/*   returns 1 if |dn| is finite and >=Nmin, 0 otherwise	      */
3663
/* ------------------------------------------------------------------ */
3664
Int decNumberIsNormal(const decNumber *dn, decContext *set) {
3665
  Int ae;				/* adjusted exponent */
3666
  #if DECCHECK
3667
  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3668
  #endif
3669

3670
  if (decNumberIsSpecial(dn)) return 0; /* not finite */
3671
  if (decNumberIsZero(dn)) return 0;	/* not non-zero */
3672

3673
  ae=dn->exponent+dn->digits-1;		/* adjusted exponent */
3674
  if (ae<set->emin) return 0;		/* is subnormal */
3675
  return 1;
3676
  } /* decNumberIsNormal */
3677

3678
/* ------------------------------------------------------------------ */
3679
/* decNumberIsSubnormal -- test subnormality of a decNumber	      */
3680
/*   dn is the decNumber to test				      */
3681
/*   set is the context to use for Emin				      */
3682
/*   returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise    */
3683
/* ------------------------------------------------------------------ */
3684
Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
3685
  Int ae;				/* adjusted exponent */
3686
  #if DECCHECK
3687
  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
3688
  #endif
3689

3690
  if (decNumberIsSpecial(dn)) return 0; /* not finite */
3691
  if (decNumberIsZero(dn)) return 0;	/* not non-zero */
3692

3693
  ae=dn->exponent+dn->digits-1;		/* adjusted exponent */
3694
  if (ae<set->emin) return 1;		/* is subnormal */
3695
  return 0;
3696
  } /* decNumberIsSubnormal */
3697

3698
/* ------------------------------------------------------------------ */
3699
/* decNumberTrim -- remove insignificant zeros			      */
3700
/*								      */
3701
/*   dn is the number to trim					      */
3702
/*   returns dn							      */
3703
/*								      */
3704
/* All fields are updated as required.	This is a utility operation,  */
3705
/* so special values are unchanged and no error is possible.	      */
3706
/* ------------------------------------------------------------------ */
3707
decNumber * decNumberTrim(decNumber *dn) {
3708
  Int  dropped;			   /* work */
3709
  decContext set;		   /* .. */
3710
  #if DECCHECK
3711
  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
3712
  #endif
3713
  decContextDefault(&set, DEC_INIT_BASE);    /* clamp=0 */
3714
  return decTrim(dn, &set, 0, &dropped);
3715
  } /* decNumberTrim */
3716

3717
/* ------------------------------------------------------------------ */
3718
/* decNumberVersion -- return the name and version of this module     */
3719
/*								      */
3720
/* No error is possible.					      */
3721
/* ------------------------------------------------------------------ */
3722
const char * decNumberVersion(void) {
3723
  return DECVERSION;
3724
  } /* decNumberVersion */
3725

3726
/* ------------------------------------------------------------------ */
3727
/* decNumberZero -- set a number to 0				      */
3728
/*								      */
3729
/*   dn is the number to set, with space for one digit		      */
3730
/*   returns dn							      */
3731
/*								      */
3732
/* No error is possible.					      */
3733
/* ------------------------------------------------------------------ */
3734
/* Memset is not used as it is much slower in some environments. */
3735
decNumber * decNumberZero(decNumber *dn) {
3736

3737
  #if DECCHECK
3738
  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
3739
  #endif
3740

3741
  dn->bits=0;
3742
  dn->exponent=0;
3743
  dn->digits=1;
3744
  dn->lsu[0]=0;
3745
  return dn;
3746
  } /* decNumberZero */
3747

3748
/* ================================================================== */
3749
/* Local routines						      */
3750
/* ================================================================== */
3751

3752
/* ------------------------------------------------------------------ */
3753
/* decToString -- lay out a number into a string		      */
3754
/*								      */
3755
/*   dn	    is the number to lay out				      */
3756
/*   string is where to lay out the number			      */
3757
/*   eng    is 1 if Engineering, 0 if Scientific		      */
3758
/*								      */
3759
/* string must be at least dn->digits+14 characters long	      */
3760
/* No error is possible.					      */
3761
/*								      */
3762
/* Note that this routine can generate a -0 or 0.000.  These are      */
3763
/* never generated in subset to-number or arithmetic, but can occur   */
3764
/* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).	      */
3765
/* ------------------------------------------------------------------ */
3766
/* If DECCHECK is enabled the string "?" is returned if a number is */
3767
/* invalid. */
3768
static void decToString(const decNumber *dn, char *string, Flag eng) {
3769
  Int exp=dn->exponent;	      /* local copy */
3770
  Int e;		      /* E-part value */
3771
  Int pre;		      /* digits before the '.' */
3772
  Int cut;		      /* for counting digits in a Unit */
3773
  char *c=string;	      /* work [output pointer] */
3774
  const Unit *up=dn->lsu+D2U(dn->digits)-1; /* -> msu [input pointer] */
3775
  uInt u, pow;		      /* work */
3776

3777
  #if DECCHECK
3778
  if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
3779
    strcpy(string, "?");
3780
    return;}
3781
  #endif
3782

3783
  if (decNumberIsNegative(dn)) {   /* Negatives get a minus */
3784
    *c='-';
3785
    c++;
3786
    }
3787
  if (dn->bits&DECSPECIAL) {	   /* Is a special value */
3788
    if (decNumberIsInfinite(dn)) {
3789
      strcpy(c,	  "Inf");
3790
      strcpy(c+3, "inity");
3791
      return;}
3792
    /* a NaN */
3793
    if (dn->bits&DECSNAN) {	   /* signalling NaN */
3794
      *c='s';
3795
      c++;
3796
      }
3797
    strcpy(c, "NaN");
3798
    c+=3;			   /* step past */
3799
    /* if not a clean non-zero coefficient, that's all there is in a */
3800
    /* NaN string */
3801
    if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
3802
    /* [drop through to add integer] */
3803
    }
3804

3805
  /* calculate how many digits in msu, and hence first cut */
3806
  cut=MSUDIGITS(dn->digits);	   /* [faster than remainder] */
3807
  cut--;			   /* power of ten for digit */
3808

3809
  if (exp==0) {			   /* simple integer [common fastpath] */
3810
    for (;up>=dn->lsu; up--) {	   /* each Unit from msu */
3811
      u=*up;			   /* contains DECDPUN digits to lay out */
3812
      for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
3813
      cut=DECDPUN-1;		   /* next Unit has all digits */
3814
      }
3815
    *c='\0';			   /* terminate the string */
3816
    return;}
3817

3818
  /* non-0 exponent -- assume plain form */
3819
  pre=dn->digits+exp;		   /* digits before '.' */
3820
  e=0;				   /* no E */
3821
  if ((exp>0) || (pre<-5)) {	   /* need exponential form */
3822
    e=exp+dn->digits-1;		   /* calculate E value */
3823
    pre=1;			   /* assume one digit before '.' */
3824
    if (eng && (e!=0)) {	   /* engineering: may need to adjust */
3825
      Int adj;			   /* adjustment */
3826
      /* The C remainder operator is undefined for negative numbers, so */
3827
      /* a positive remainder calculation must be used here */
3828
      if (e<0) {
3829
	adj=(-e)%3;
3830
	if (adj!=0) adj=3-adj;
3831
	}
3832
       else { /* e>0 */
3833
	adj=e%3;
3834
	}
3835
      e=e-adj;
3836
      /* if dealing with zero still produce an exponent which is a */
3837
      /* multiple of three, as expected, but there will only be the */
3838
      /* one zero before the E, still.	Otherwise note the padding. */
3839
      if (!ISZERO(dn)) pre+=adj;
3840
       else {  /* is zero */
3841
	if (adj!=0) {		   /* 0.00Esnn needed */
3842
	  e=e+3;
3843
	  pre=-(2-adj);
3844
	  }
3845
	} /* zero */
3846
      } /* eng */
3847
    } /* need exponent */
3848

3849
  /* lay out the digits of the coefficient, adding 0s and . as needed */
3850
  u=*up;
3851
  if (pre>0) {			   /* xxx.xxx or xx00 (engineering) form */
3852
    Int n=pre;
3853
    for (; pre>0; pre--, c++, cut--) {
3854
      if (cut<0) {		   /* need new Unit */
3855
	if (up==dn->lsu) break;	   /* out of input digits (pre>digits) */
3856
	up--;
3857
	cut=DECDPUN-1;
3858
	u=*up;
3859
	}
3860
      TODIGIT(u, cut, c, pow);
3861
      }
3862
    if (n<dn->digits) {		   /* more to come, after '.' */
3863
      *c='.'; c++;
3864
      for (;; c++, cut--) {
3865
	if (cut<0) {		   /* need new Unit */
3866
	  if (up==dn->lsu) break;  /* out of input digits */
3867
	  up--;
3868
	  cut=DECDPUN-1;
3869
	  u=*up;
3870
	  }
3871
	TODIGIT(u, cut, c, pow);
3872
	}
3873
      }
3874
     else for (; pre>0; pre--, c++) *c='0'; /* 0 padding (for engineering) needed */
3875
    }
3876
   else {			   /* 0.xxx or 0.000xxx form */
3877
    *c='0'; c++;
3878
    *c='.'; c++;
3879
    for (; pre<0; pre++, c++) *c='0';	/* add any 0's after '.' */
3880
    for (; ; c++, cut--) {
3881
      if (cut<0) {		   /* need new Unit */
3882
	if (up==dn->lsu) break;	   /* out of input digits */
3883
	up--;
3884
	cut=DECDPUN-1;
3885
	u=*up;
3886
	}
3887
      TODIGIT(u, cut, c, pow);
3888
      }
3889
    }
3890

3891
  /* Finally add the E-part, if needed.	 It will never be 0, has a
3892
     base maximum and minimum of +999999999 through -999999999, but
3893
     could range down to -1999999998 for anormal numbers */
3894
  if (e!=0) {
3895
    Flag had=0;		      /* 1=had non-zero */
3896
    *c='E'; c++;
3897
    *c='+'; c++;	      /* assume positive */
3898
    u=e;		      /* .. */
3899
    if (e<0) {
3900
      *(c-1)='-';	      /* oops, need - */
3901
      u=-e;		      /* uInt, please */
3902
      }
3903
    /* lay out the exponent [_itoa or equivalent is not ANSI C] */
3904
    for (cut=9; cut>=0; cut--) {
3905
      TODIGIT(u, cut, c, pow);
3906
      if (*c=='0' && !had) continue;	/* skip leading zeros */
3907
      had=1;				/* had non-0 */
3908
      c++;				/* step for next */
3909
      } /* cut */
3910
    }
3911
  *c='\0';	    /* terminate the string (all paths) */
3912
  return;
3913
  } /* decToString */
3914

3915
/* ------------------------------------------------------------------ */
3916
/* decAddOp -- add/subtract operation				      */
3917
/*								      */
3918
/*   This computes C = A + B					      */
3919
/*								      */
3920
/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)	      */
3921
/*   lhs is A							      */
3922
/*   rhs is B							      */
3923
/*   set is the context						      */
3924
/*   negate is DECNEG if rhs should be negated, or 0 otherwise	      */
3925
/*   status accumulates status for the caller			      */
3926
/*								      */
3927
/* C must have space for set->digits digits.			      */
3928
/* Inexact in status must be 0 for correct Exact zero sign in result  */
3929
/* ------------------------------------------------------------------ */
3930
/* If possible, the coefficient is calculated directly into C.	      */
3931
/* However, if:							      */
3932
/*   -- a digits+1 calculation is needed because the numbers are      */
3933
/*	unaligned and span more than set->digits digits		      */
3934
/*   -- a carry to digits+1 digits looks possible		      */
3935
/*   -- C is the same as A or B, and the result would destructively   */
3936
/*	overlap the A or B coefficient				      */
3937
/* then the result must be calculated into a temporary buffer.	In    */
3938
/* this case a local (stack) buffer is used if possible, and only if  */
3939
/* too long for that does malloc become the final resort.	      */
3940
/*								      */
3941
/* Misalignment is handled as follows:				      */
3942
/*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
3943
/*   BPad: Apply the padding by a combination of shifting (whole      */
3944
/*	   units) and multiplication (part units).		      */
3945
/*								      */
3946
/* Addition, especially x=x+1, is speed-critical.		      */
3947
/* The static buffer is larger than might be expected to allow for    */
3948
/* calls from higher-level functions (notably exp).		      */
3949
/* ------------------------------------------------------------------ */
3950
static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
3951
			    const decNumber *rhs, decContext *set,
3952
			    uByte negate, uInt *status) {
3953
  #if DECSUBSET
3954
  decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
3955
  decNumber *allocrhs=NULL;	   /* .., rhs */
3956
  #endif
3957
  Int	rhsshift;		   /* working shift (in Units) */
3958
  Int	maxdigits;		   /* longest logical length */
3959
  Int	mult;			   /* multiplier */
3960
  Int	residue;		   /* rounding accumulator */
3961
  uByte bits;			   /* result bits */
3962
  Flag	diffsign;		   /* non-0 if arguments have different sign */
3963
  Unit	*acc;			   /* accumulator for result */
3964
  Unit	accbuff[SD2U(DECBUFFER*2+20)]; /* local buffer [*2+20 reduces many */
3965
				   /* allocations when called from */
3966
				   /* other operations, notable exp] */
3967
  Unit	*allocacc=NULL;		   /* -> allocated acc buffer, iff allocated */
3968
  Int	reqdigits=set->digits;	   /* local copy; requested DIGITS */
3969
  Int	padding;		   /* work */
3970

3971
  #if DECCHECK
3972
  if (decCheckOperands(res, lhs, rhs, set)) return res;
3973
  #endif
3974

3975
  do {				   /* protect allocated storage */
3976
    #if DECSUBSET
3977
    if (!set->extended) {
3978
      /* reduce operands and set lostDigits status, as needed */
3979
      if (lhs->digits>reqdigits) {
3980
	alloclhs=decRoundOperand(lhs, set, status);
3981
	if (alloclhs==NULL) break;
3982
	lhs=alloclhs;
3983
	}
3984
      if (rhs->digits>reqdigits) {
3985
	allocrhs=decRoundOperand(rhs, set, status);
3986
	if (allocrhs==NULL) break;
3987
	rhs=allocrhs;
3988
	}
3989
      }
3990
    #endif
3991
    /* [following code does not require input rounding] */
3992

3993
    /* note whether signs differ [used all paths] */
3994
    diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3995

3996
    /* handle infinities and NaNs */
3997
    if (SPECIALARGS) {			/* a special bit set */
3998
      if (SPECIALARGS & (DECSNAN | DECNAN))  /* a NaN */
3999
	decNaNs(res, lhs, rhs, set, status);
4000
       else { /* one or two infinities */
4001
	if (decNumberIsInfinite(lhs)) { /* LHS is infinity */
4002
	  /* two infinities with different signs is invalid */
4003
	  if (decNumberIsInfinite(rhs) && diffsign) {
4004
	    *status|=DEC_Invalid_operation;
4005
	    break;
4006
	    }
4007
	  bits=lhs->bits & DECNEG;	/* get sign from LHS */
4008
	  }
4009
	 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
4010
	bits|=DECINF;
4011
	decNumberZero(res);
4012
	res->bits=bits;			/* set +/- infinity */
4013
	} /* an infinity */
4014
      break;
4015
      }
4016

4017
    /* Quick exit for add 0s; return the non-0, modified as need be */
4018
    if (ISZERO(lhs)) {
4019
      Int adjust;			/* work */
4020
      Int lexp=lhs->exponent;		/* save in case LHS==RES */
4021
      bits=lhs->bits;			/* .. */
4022
      residue=0;			/* clear accumulator */
4023
      decCopyFit(res, rhs, set, &residue, status); /* copy (as needed) */
4024
      res->bits^=negate;		/* flip if rhs was negated */
4025
      #if DECSUBSET
4026
      if (set->extended) {		/* exponents on zeros count */
4027
      #endif
4028
	/* exponent will be the lower of the two */
4029
	adjust=lexp-res->exponent;	/* adjustment needed [if -ve] */
4030
	if (ISZERO(res)) {		/* both 0: special IEEE 854 rules */
4031
	  if (adjust<0) res->exponent=lexp;  /* set exponent */
4032
	  /* 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 */
4033
	  if (diffsign) {
4034
	    if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
4035
	     else res->bits=DECNEG;	/* preserve 0 sign */
4036
	    }
4037
	  }
4038
	 else { /* non-0 res */
4039
	  if (adjust<0) {     /* 0-padding needed */
4040
	    if ((res->digits-adjust)>set->digits) {
4041
	      adjust=res->digits-set->digits;	  /* to fit exactly */
4042
	      *status|=DEC_Rounded;		  /* [but exact] */
4043
	      }
4044
	    res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
4045
	    res->exponent+=adjust;		  /* set the exponent. */
4046
	    }
4047
	  } /* non-0 res */
4048
      #if DECSUBSET
4049
	} /* extended */
4050
      #endif
4051
      decFinish(res, set, &residue, status);	  /* clean and finalize */
4052
      break;}
4053

4054
    if (ISZERO(rhs)) {			/* [lhs is non-zero] */
4055
      Int adjust;			/* work */
4056
      Int rexp=rhs->exponent;		/* save in case RHS==RES */
4057
      bits=rhs->bits;			/* be clean */
4058
      residue=0;			/* clear accumulator */
4059
      decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */
4060
      #if DECSUBSET
4061
      if (set->extended) {		/* exponents on zeros count */
4062
      #endif
4063
	/* exponent will be the lower of the two */
4064
	/* [0-0 case handled above] */
4065
	adjust=rexp-res->exponent;	/* adjustment needed [if -ve] */
4066
	if (adjust<0) {	    /* 0-padding needed */
4067
	  if ((res->digits-adjust)>set->digits) {
4068
	    adjust=res->digits-set->digits;	/* to fit exactly */
4069
	    *status|=DEC_Rounded;		/* [but exact] */
4070
	    }
4071
	  res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
4072
	  res->exponent+=adjust;		/* set the exponent. */
4073
	  }
4074
      #if DECSUBSET
4075
	} /* extended */
4076
      #endif
4077
      decFinish(res, set, &residue, status);	  /* clean and finalize */
4078
      break;}
4079

4080
    /* [NB: both fastpath and mainpath code below assume these cases */
4081
    /* (notably 0-0) have already been handled] */
4082

4083
    /* calculate the padding needed to align the operands */
4084
    padding=rhs->exponent-lhs->exponent;
4085

4086
    /* Fastpath cases where the numbers are aligned and normal, the RHS */
4087
    /* is all in one unit, no operand rounding is needed, and no carry, */
4088
    /* lengthening, or borrow is needed */
4089
    if (padding==0
4090
	&& rhs->digits<=DECDPUN
4091
	&& rhs->exponent>=set->emin	/* [some normals drop through] */
4092
	&& rhs->exponent<=set->emax-set->digits+1 /* [could clamp] */
4093
	&& rhs->digits<=reqdigits
4094
	&& lhs->digits<=reqdigits) {
4095
      Int partial=*lhs->lsu;
4096
      if (!diffsign) {			/* adding */
4097
	partial+=*rhs->lsu;
4098
	if ((partial<=DECDPUNMAX)	/* result fits in unit */
4099
	 && (lhs->digits>=DECDPUN ||	/* .. and no digits-count change */
4100
	     partial<(Int)powers[lhs->digits])) { /* .. */
4101
	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4102
	  *res->lsu=(Unit)partial;	/* [copy could have overwritten RHS] */
4103
	  break;
4104
	  }
4105
	/* else drop out for careful add */
4106
	}
4107
       else {				/* signs differ */
4108
	partial-=*rhs->lsu;
4109
	if (partial>0) { /* no borrow needed, and non-0 result */
4110
	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */
4111
	  *res->lsu=(Unit)partial;
4112
	  /* this could have reduced digits [but result>0] */
4113
	  res->digits=decGetDigits(res->lsu, D2U(res->digits));
4114
	  break;
4115
	  }
4116
	/* else drop out for careful subtract */
4117
	}
4118
      }
4119

4120
    /* Now align (pad) the lhs or rhs so they can be added or */
4121
    /* subtracted, as necessary.  If one number is much larger than */
4122
    /* the other (that is, if in plain form there is a least one */
4123
    /* digit between the lowest digit of one and the highest of the */
4124
    /* other) padding with up to DIGITS-1 trailing zeros may be */
4125
    /* needed; then apply rounding (as exotic rounding modes may be */
4126
    /* affected by the residue). */
4127
    rhsshift=0;		      /* rhs shift to left (padding) in Units */
4128
    bits=lhs->bits;	      /* assume sign is that of LHS */
4129
    mult=1;		      /* likely multiplier */
4130

4131
    /* [if padding==0 the operands are aligned; no padding is needed] */
4132
    if (padding!=0) {
4133
      /* some padding needed; always pad the RHS, as any required */
4134
      /* padding can then be effected by a simple combination of */
4135
      /* shifts and a multiply */
4136
      Flag swapped=0;
4137
      if (padding<0) {			/* LHS needs the padding */
4138
	const decNumber *t;
4139
	padding=-padding;		/* will be +ve */
4140
	bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
4141
	t=lhs; lhs=rhs; rhs=t;
4142
	swapped=1;
4143
	}
4144

4145
      /* If, after pad, rhs would be longer than lhs by digits+1 or */
4146
      /* more then lhs cannot affect the answer, except as a residue, */
4147
      /* so only need to pad up to a length of DIGITS+1. */
4148
      if (rhs->digits+padding > lhs->digits+reqdigits+1) {
4149
	/* The RHS is sufficient */
4150
	/* for residue use the relative sign indication... */
4151
	Int shift=reqdigits-rhs->digits;     /* left shift needed */
4152
	residue=1;			     /* residue for rounding */
4153
	if (diffsign) residue=-residue;	     /* signs differ */
4154
	/* copy, shortening if necessary */
4155
	decCopyFit(res, rhs, set, &residue, status);
4156
	/* if it was already shorter, then need to pad with zeros */
4157
	if (shift>0) {
4158
	  res->digits=decShiftToMost(res->lsu, res->digits, shift);
4159
	  res->exponent-=shift;		     /* adjust the exponent. */
4160
	  }
4161
	/* flip the result sign if unswapped and rhs was negated */
4162
	if (!swapped) res->bits^=negate;
4163
	decFinish(res, set, &residue, status);	  /* done */
4164
	break;}
4165

4166
      /* LHS digits may affect result */
4167
      rhsshift=D2U(padding+1)-1;	/* this much by Unit shift .. */
4168
      mult=powers[padding-(rhsshift*DECDPUN)]; /* .. this by multiplication */
4169
      } /* padding needed */
4170

4171
    if (diffsign) mult=-mult;		/* signs differ */
4172

4173
    /* determine the longer operand */
4174
    maxdigits=rhs->digits+padding;	/* virtual length of RHS */
4175
    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4176

4177
    /* Decide on the result buffer to use; if possible place directly */
4178
    /* into result. */
4179
    acc=res->lsu;			/* assume add direct to result */
4180
    /* If destructive overlap, or the number is too long, or a carry or */
4181
    /* borrow to DIGITS+1 might be possible, a buffer must be used. */
4182
    /* [Might be worth more sophisticated tests when maxdigits==reqdigits] */
4183
    if ((maxdigits>=reqdigits)		/* is, or could be, too large */
4184
     || (res==rhs && rhsshift>0)) {	/* destructive overlap */
4185
      /* buffer needed, choose it; units for maxdigits digits will be */
4186
      /* needed, +1 Unit for carry or borrow */
4187
      Int need=D2U(maxdigits)+1;
4188
      acc=accbuff;			/* assume use local buffer */
4189
      if (need*sizeof(Unit)>sizeof(accbuff)) {
4190
	/* printf("malloc add %ld %ld\n", need, sizeof(accbuff)); */
4191
	allocacc=(Unit *)malloc(need*sizeof(Unit));
4192
	if (allocacc==NULL) {		/* hopeless -- abandon */
4193
	  *status|=DEC_Insufficient_storage;
4194
	  break;}
4195
	acc=allocacc;
4196
	}
4197
      }
4198

4199
    res->bits=(uByte)(bits&DECNEG);	/* it's now safe to overwrite.. */
4200
    res->exponent=lhs->exponent;	/* .. operands (even if aliased) */
4201

4202
    #if DECTRACE
4203
      decDumpAr('A', lhs->lsu, D2U(lhs->digits));
4204
      decDumpAr('B', rhs->lsu, D2U(rhs->digits));
4205
      printf("	:h: %ld %ld\n", rhsshift, mult);
4206
    #endif
4207

4208
    /* add [A+B*m] or subtract [A+B*(-m)] */
4209
    res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
4210
			      rhs->lsu, D2U(rhs->digits),
4211
			      rhsshift, acc, mult)
4212
	       *DECDPUN;	   /* [units -> digits] */
4213
    if (res->digits<0) {	   /* borrowed... */
4214
      res->digits=-res->digits;
4215
      res->bits^=DECNEG;	   /* flip the sign */
4216
      }
4217
    #if DECTRACE
4218
      decDumpAr('+', acc, D2U(res->digits));
4219
    #endif
4220

4221
    /* If a buffer was used the result must be copied back, possibly */
4222
    /* shortening.  (If no buffer was used then the result must have */
4223
    /* fit, so can't need rounding and residue must be 0.) */
4224
    residue=0;			   /* clear accumulator */
4225
    if (acc!=res->lsu) {
4226
      #if DECSUBSET
4227
      if (set->extended) {	   /* round from first significant digit */
4228
      #endif
4229
	/* remove leading zeros that were added due to rounding up to */
4230
	/* integral Units -- before the test for rounding. */
4231
	if (res->digits>reqdigits)
4232
	  res->digits=decGetDigits(acc, D2U(res->digits));
4233
	decSetCoeff(res, set, acc, res->digits, &residue, status);
4234
      #if DECSUBSET
4235
	}
4236
       else { /* subset arithmetic rounds from original significant digit */
4237
	/* May have an underestimate.  This only occurs when both */
4238
	/* numbers fit in DECDPUN digits and are padding with a */
4239
	/* negative multiple (-10, -100...) and the top digit(s) become */
4240
	/* 0.  (This only matters when using X3.274 rules where the */
4241
	/* leading zero could be included in the rounding.) */
4242
	if (res->digits<maxdigits) {
4243
	  *(acc+D2U(res->digits))=0; /* ensure leading 0 is there */
4244
	  res->digits=maxdigits;
4245
	  }
4246
	 else {
4247
	  /* remove leading zeros that added due to rounding up to */
4248
	  /* integral Units (but only those in excess of the original */
4249
	  /* maxdigits length, unless extended) before test for rounding. */
4250
	  if (res->digits>reqdigits) {
4251
	    res->digits=decGetDigits(acc, D2U(res->digits));
4252
	    if (res->digits<maxdigits) res->digits=maxdigits;
4253
	    }
4254
	  }
4255
	decSetCoeff(res, set, acc, res->digits, &residue, status);
4256
	/* Now apply rounding if needed before removing leading zeros. */
4257
	/* This is safe because subnormals are not a possibility */
4258
	if (residue!=0) {
4259
	  decApplyRound(res, set, residue, status);
4260
	  residue=0;		     /* did what needed to be done */
4261
	  }
4262
	} /* subset */
4263
      #endif
4264
      } /* used buffer */
4265

4266
    /* strip leading zeros [these were left on in case of subset subtract] */
4267
    res->digits=decGetDigits(res->lsu, D2U(res->digits));
4268

4269
    /* apply checks and rounding */
4270
    decFinish(res, set, &residue, status);
4271

4272
    /* "When the sum of two operands with opposite signs is exactly */
4273
    /* zero, the sign of that sum shall be '+' in all rounding modes */
4274
    /* except round toward -Infinity, in which mode that sign shall be */
4275
    /* '-'."  [Subset zeros also never have '-', set by decFinish.] */
4276
    if (ISZERO(res) && diffsign
4277
     #if DECSUBSET
4278
     && set->extended
4279
     #endif
4280
     && (*status&DEC_Inexact)==0) {
4281
      if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   /* sign - */
4282
				  else res->bits&=~DECNEG;  /* sign + */
4283
      }
4284
    } while(0);				     /* end protected */
4285

4286
  if (allocacc!=NULL) free(allocacc);	     /* drop any storage used */
4287
  #if DECSUBSET
4288
  if (allocrhs!=NULL) free(allocrhs);	     /* .. */
4289
  if (alloclhs!=NULL) free(alloclhs);	     /* .. */
4290
  #endif
4291
  return res;
4292
  } /* decAddOp */
4293

4294
/* ------------------------------------------------------------------ */
4295
/* decDivideOp -- division operation				      */
4296
/*								      */
4297
/*  This routine performs the calculations for all four division      */
4298
/*  operators (divide, divideInteger, remainder, remainderNear).      */
4299
/*								      */
4300
/*  C=A op B							      */
4301
/*								      */
4302
/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)	      */
4303
/*   lhs is A							      */
4304
/*   rhs is B							      */
4305
/*   set is the context						      */
4306
/*   op	 is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
4307
/*   status is the usual accumulator				      */
4308
/*								      */
4309
/* C must have space for set->digits digits.			      */
4310
/*								      */
4311
/* ------------------------------------------------------------------ */
4312
/*   The underlying algorithm of this routine is the same as in the   */
4313
/*   1981 S/370 implementation, that is, non-restoring long division  */
4314
/*   with bi-unit (rather than bi-digit) estimation for each unit     */
4315
/*   multiplier.  In this pseudocode overview, complications for the  */
4316
/*   Remainder operators and division residues for exact rounding are */
4317
/*   omitted for clarity.					      */
4318
/*								      */
4319
/*     Prepare operands and handle special values		      */
4320
/*     Test for x/0 and then 0/x				      */
4321
/*     Exp =Exp1 - Exp2						      */
4322
/*     Exp =Exp +len(var1) -len(var2)				      */
4323
/*     Sign=Sign1 * Sign2					      */
4324
/*     Pad accumulator (Var1) to double-length with 0's (pad1)	      */
4325
/*     Pad Var2 to same length as Var1				      */
4326
/*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
4327
/*     have=0							      */
4328
/*     Do until (have=digits+1 OR residue=0)			      */
4329
/*	 if exp<0 then if integer divide/residue then leave	      */
4330
/*	 this_unit=0						      */
4331
/*	 Do forever						      */
4332
/*	    compare numbers					      */
4333
/*	    if <0 then leave inner_loop				      */
4334
/*	    if =0 then (* quick exit without subtract *) do	      */
4335
/*	       this_unit=this_unit+1; output this_unit		      */
4336
/*	       leave outer_loop; end				      */
4337
/*	    Compare lengths of numbers (mantissae):		      */
4338
/*	    If same then tops2=msu2pair -- {units 1&2 of var2}	      */
4339
/*		    else tops2=msu2plus -- {0, unit 1 of var2}	      */
4340
/*	    tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
4341
/*	    mult=tops1/tops2  -- Good and safe guess at divisor	      */
4342
/*	    if mult=0 then mult=1				      */
4343
/*	    this_unit=this_unit+mult				      */
4344
/*	    subtract						      */
4345
/*	    end inner_loop					      */
4346
/*	  if have\=0 | this_unit\=0 then do			      */
4347
/*	    output this_unit					      */
4348
/*	    have=have+1; end					      */
4349
/*	  var2=var2/10						      */
4350
/*	  exp=exp-1						      */
4351
/*	  end outer_loop					      */
4352
/*     exp=exp+1   -- set the proper exponent			      */
4353
/*     if have=0 then generate answer=0				      */
4354
/*     Return (Result is defined by Var1)			      */
4355
/*								      */
4356
/* ------------------------------------------------------------------ */
4357
/* Two working buffers are needed during the division; one (digits+   */
4358
/* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
4359
/* long subtractions.  These are acc and var1 respectively.	      */
4360
/* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4361
/* The static buffers may be larger than might be expected to allow   */
4362
/* for calls from higher-level functions (notably exp).		      */
4363
/* ------------------------------------------------------------------ */
4364
static decNumber * decDivideOp(decNumber *res,
4365
			       const decNumber *lhs, const decNumber *rhs,
4366
			       decContext *set, Flag op, uInt *status) {
4367
  #if DECSUBSET
4368
  decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
4369
  decNumber *allocrhs=NULL;	   /* .., rhs */
4370
  #endif
4371
  Unit	accbuff[SD2U(DECBUFFER+DECDPUN+10)]; /* local buffer */
4372
  Unit	*acc=accbuff;		   /* -> accumulator array for result */
4373
  Unit	*allocacc=NULL;		   /* -> allocated buffer, iff allocated */
4374
  Unit	*accnext;		   /* -> where next digit will go */
4375
  Int	acclength;		   /* length of acc needed [Units] */
4376
  Int	accunits;		   /* count of units accumulated */
4377
  Int	accdigits;		   /* count of digits accumulated */
4378

4379
  Unit	varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; /* buffer for var1 */
4380
  Unit	*var1=varbuff;		   /* -> var1 array for long subtraction */
4381
  Unit	*varalloc=NULL;		   /* -> allocated buffer, iff used */
4382
  Unit	*msu1;			   /* -> msu of var1 */
4383

4384
  const Unit *var2;		   /* -> var2 array */
4385
  const Unit *msu2;		   /* -> msu of var2 */
4386
  Int	msu2plus;		   /* msu2 plus one [does not vary] */
4387
  eInt	msu2pair;		   /* msu2 pair plus one [does not vary] */
4388

4389
  Int	var1units, var2units;	   /* actual lengths */
4390
  Int	var2ulen;		   /* logical length (units) */
4391
  Int	var1initpad=0;		   /* var1 initial padding (digits) */
4392
  Int	maxdigits;		   /* longest LHS or required acc length */
4393
  Int	mult;			   /* multiplier for subtraction */
4394
  Unit	thisunit;		   /* current unit being accumulated */
4395
  Int	residue;		   /* for rounding */
4396
  Int	reqdigits=set->digits;	   /* requested DIGITS */
4397
  Int	exponent;		   /* working exponent */
4398
  Int	maxexponent=0;		   /* DIVIDE maximum exponent if unrounded */
4399
  uByte bits;			   /* working sign */
4400
  Unit	*target;		   /* work */
4401
  const Unit *source;		   /* .. */
4402
  uLong const *pow;                /* .. */
4403
  Int	shift, cut;		   /* .. */
4404
  #if DECSUBSET
4405
  Int	dropped;		   /* work */
4406
  #endif
4407

4408
  #if DECCHECK
4409
  if (decCheckOperands(res, lhs, rhs, set)) return res;
4410
  #endif
4411

4412
  do {				   /* protect allocated storage */
4413
    #if DECSUBSET
4414
    if (!set->extended) {
4415
      /* reduce operands and set lostDigits status, as needed */
4416
      if (lhs->digits>reqdigits) {
4417
	alloclhs=decRoundOperand(lhs, set, status);
4418
	if (alloclhs==NULL) break;
4419
	lhs=alloclhs;
4420
	}
4421
      if (rhs->digits>reqdigits) {
4422
	allocrhs=decRoundOperand(rhs, set, status);
4423
	if (allocrhs==NULL) break;
4424
	rhs=allocrhs;
4425
	}
4426
      }
4427
    #endif
4428
    /* [following code does not require input rounding] */
4429

4430
    bits=(lhs->bits^rhs->bits)&DECNEG;	/* assumed sign for divisions */
4431

4432
    /* handle infinities and NaNs */
4433
    if (SPECIALARGS) {			/* a special bit set */
4434
      if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
4435
	decNaNs(res, lhs, rhs, set, status);
4436
	break;
4437
	}
4438
      /* one or two infinities */
4439
      if (decNumberIsInfinite(lhs)) {	/* LHS (dividend) is infinite */
4440
	if (decNumberIsInfinite(rhs) || /* two infinities are invalid .. */
4441
	    op & (REMAINDER | REMNEAR)) { /* as is remainder of infinity */
4442
	  *status|=DEC_Invalid_operation;
4443
	  break;
4444
	  }
4445
	/* [Note that infinity/0 raises no exceptions] */
4446
	decNumberZero(res);
4447
	res->bits=bits|DECINF;		/* set +/- infinity */
4448
	break;
4449
	}
4450
       else {				/* RHS (divisor) is infinite */
4451
	residue=0;
4452
	if (op&(REMAINDER|REMNEAR)) {
4453
	  /* result is [finished clone of] lhs */
4454
	  decCopyFit(res, lhs, set, &residue, status);
4455
	  }
4456
	 else {	 /* a division */
4457
	  decNumberZero(res);
4458
	  res->bits=bits;		/* set +/- zero */
4459
	  /* for DIVIDEINT the exponent is always 0.  For DIVIDE, result */
4460
	  /* is a 0 with infinitely negative exponent, clamped to minimum */
4461
	  if (op&DIVIDE) {
4462
	    res->exponent=set->emin-set->digits+1;
4463
	    *status|=DEC_Clamped;
4464
	    }
4465
	  }
4466
	decFinish(res, set, &residue, status);
4467
	break;
4468
	}
4469
      }
4470

4471
    /* handle 0 rhs (x/0) */
4472
    if (ISZERO(rhs)) {			/* x/0 is always exceptional */
4473
      if (ISZERO(lhs)) {
4474
	decNumberZero(res);		/* [after lhs test] */
4475
	*status|=DEC_Division_undefined;/* 0/0 will become NaN */
4476
	}
4477
       else {
4478
	decNumberZero(res);
4479
	if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
4480
	 else {
4481
	  *status|=DEC_Division_by_zero; /* x/0 */
4482
	  res->bits=bits|DECINF;	 /* .. is +/- Infinity */
4483
	  }
4484
	}
4485
      break;}
4486

4487
    /* handle 0 lhs (0/x) */
4488
    if (ISZERO(lhs)) {			/* 0/x [x!=0] */
4489
      #if DECSUBSET
4490
      if (!set->extended) decNumberZero(res);
4491
       else {
4492
      #endif
4493
	if (op&DIVIDE) {
4494
	  residue=0;
4495
	  exponent=lhs->exponent-rhs->exponent; /* ideal exponent */
4496
	  decNumberCopy(res, lhs);	/* [zeros always fit] */
4497
	  res->bits=bits;		/* sign as computed */
4498
	  res->exponent=exponent;	/* exponent, too */
4499
	  decFinalize(res, set, &residue, status);   /* check exponent */
4500
	  }
4501
	 else if (op&DIVIDEINT) {
4502
	  decNumberZero(res);		/* integer 0 */
4503
	  res->bits=bits;		/* sign as computed */
4504
	  }
4505
	 else {				/* a remainder */
4506
	  exponent=rhs->exponent;	/* [save in case overwrite] */
4507
	  decNumberCopy(res, lhs);	/* [zeros always fit] */
4508
	  if (exponent<res->exponent) res->exponent=exponent; /* use lower */
4509
	  }
4510
      #if DECSUBSET
4511
	}
4512
      #endif
4513
      break;}
4514

4515
    /* Precalculate exponent.  This starts off adjusted (and hence fits */
4516
    /* in 31 bits) and becomes the usual unadjusted exponent as the */
4517
    /* division proceeds.  The order of evaluation is important, here, */
4518
    /* to avoid wrap. */
4519
    exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
4520

4521
    /* If the working exponent is -ve, then some quick exits are */
4522
    /* possible because the quotient is known to be <1 */
4523
    /* [for REMNEAR, it needs to be < -1, as -0.5 could need work] */
4524
    if (exponent<0 && !(op==DIVIDE)) {
4525
      if (op&DIVIDEINT) {
4526
	decNumberZero(res);		     /* integer part is 0 */
4527
	#if DECSUBSET
4528
	if (set->extended)
4529
	#endif
4530
	  res->bits=bits;		     /* set +/- zero */
4531
	break;}
4532
      /* fastpath remainders so long as the lhs has the smaller */
4533
      /* (or equal) exponent */
4534
      if (lhs->exponent<=rhs->exponent) {
4535
	if (op&REMAINDER || exponent<-1) {
4536
	  /* It is REMAINDER or safe REMNEAR; result is [finished */
4537
	  /* clone of] lhs  (r = x - 0*y) */
4538
	  residue=0;
4539
	  decCopyFit(res, lhs, set, &residue, status);
4540
	  decFinish(res, set, &residue, status);
4541
	  break;
4542
	  }
4543
	/* [unsafe REMNEAR drops through] */
4544
	}
4545
      } /* fastpaths */
4546

4547
    /* Long (slow) division is needed; roll up the sleeves... */
4548

4549
    /* The accumulator will hold the quotient of the division. */
4550
    /* If it needs to be too long for stack storage, then allocate. */
4551
    acclength=D2U(reqdigits+DECDPUN);	/* in Units */
4552
    if (acclength*sizeof(Unit)>sizeof(accbuff)) {
4553
      /* printf("malloc dvacc %ld units\n", acclength); */
4554
      allocacc=(Unit *)malloc(acclength*sizeof(Unit));
4555
      if (allocacc==NULL) {		/* hopeless -- abandon */
4556
	*status|=DEC_Insufficient_storage;
4557
	break;}
4558
      acc=allocacc;			/* use the allocated space */
4559
      }
4560

4561
    /* var1 is the padded LHS ready for subtractions. */
4562
    /* If it needs to be too long for stack storage, then allocate. */
4563
    /* The maximum units needed for var1 (long subtraction) is: */
4564
    /* Enough for */
4565
    /*	   (rhs->digits+reqdigits-1) -- to allow full slide to right */
4566
    /* or  (lhs->digits)	     -- to allow for long lhs */
4567
    /* whichever is larger */
4568
    /*	 +1		   -- for rounding of slide to right */
4569
    /*	 +1		   -- for leading 0s */
4570
    /*	 +1		   -- for pre-adjust if a remainder or DIVIDEINT */
4571
    /* [Note: unused units do not participate in decUnitAddSub data] */
4572
    maxdigits=rhs->digits+reqdigits-1;
4573
    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
4574
    var1units=D2U(maxdigits)+2;
4575
    /* allocate a guard unit above msu1 for REMAINDERNEAR */
4576
    if (!(op&DIVIDE)) var1units++;
4577
    if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
4578
      /* printf("malloc dvvar %ld units\n", var1units+1); */
4579
      varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
4580
      if (varalloc==NULL) {		/* hopeless -- abandon */
4581
	*status|=DEC_Insufficient_storage;
4582
	break;}
4583
      var1=varalloc;			/* use the allocated space */
4584
      }
4585

4586
    /* Extend the lhs and rhs to full long subtraction length.	The lhs */
4587
    /* is truly extended into the var1 buffer, with 0 padding, so a */
4588
    /* subtract in place is always possible.  The rhs (var2) has */
4589
    /* virtual padding (implemented by decUnitAddSub). */
4590
    /* One guard unit was allocated above msu1 for rem=rem+rem in */
4591
    /* REMAINDERNEAR. */
4592
    msu1=var1+var1units-1;		/* msu of var1 */
4593
    source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */
4594
    for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
4595
    for (; target>=var1; target--) *target=0;
4596

4597
    /* rhs (var2) is left-aligned with var1 at the start */
4598
    var2ulen=var1units;			/* rhs logical length (units) */
4599
    var2units=D2U(rhs->digits);		/* rhs actual length (units) */
4600
    var2=rhs->lsu;			/* -> rhs array */
4601
    msu2=var2+var2units-1;		/* -> msu of var2 [never changes] */
4602
    /* now set up the variables which will be used for estimating the */
4603
    /* multiplication factor.  If these variables are not exact, add */
4604
    /* 1 to make sure that the multiplier is never overestimated. */
4605
    msu2plus=*msu2;			/* it's value .. */
4606
    if (var2units>1) msu2plus++;	/* .. +1 if any more */
4607
    msu2pair=(eInt)*msu2*(DECDPUNMAX+1);/* top two pair .. */
4608
    if (var2units>1) {			/* .. [else treat 2nd as 0] */
4609
      msu2pair+=*(msu2-1);		/* .. */
4610
      if (var2units>2) msu2pair++;	/* .. +1 if any more */
4611
      }
4612

4613
    /* The calculation is working in units, which may have leading zeros, */
4614
    /* but the exponent was calculated on the assumption that they are */
4615
    /* both left-aligned.  Adjust the exponent to compensate: add the */
4616
    /* number of leading zeros in var1 msu and subtract those in var2 msu. */
4617
    /* [This is actually done by counting the digits and negating, as */
4618
    /* lead1=DECDPUN-digits1, and similarly for lead2.] */
4619
    for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
4620
    for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
4621

4622
    /* Now, if doing an integer divide or remainder, ensure that */
4623
    /* the result will be Unit-aligned.	 To do this, shift the var1 */
4624
    /* accumulator towards least if need be.  (It's much easier to */
4625
    /* do this now than to reassemble the residue afterwards, if */
4626
    /* doing a remainder.)  Also ensure the exponent is not negative. */
4627
    if (!(op&DIVIDE)) {
4628
      Unit *u;				/* work */
4629
      /* save the initial 'false' padding of var1, in digits */
4630
      var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
4631
      /* Determine the shift to do. */
4632
      if (exponent<0) cut=-exponent;
4633
       else cut=DECDPUN-exponent%DECDPUN;
4634
      decShiftToLeast(var1, var1units, cut);
4635
      exponent+=cut;			/* maintain numerical value */
4636
      var1initpad-=cut;			/* .. and reduce padding */
4637
      /* clean any most-significant units which were just emptied */
4638
      for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
4639
      } /* align */
4640
     else { /* is DIVIDE */
4641
      maxexponent=lhs->exponent-rhs->exponent;	  /* save */
4642
      /* optimization: if the first iteration will just produce 0, */
4643
      /* preadjust to skip it [valid for DIVIDE only] */
4644
      if (*msu1<*msu2) {
4645
	var2ulen--;			/* shift down */
4646
	exponent-=DECDPUN;		/* update the exponent */
4647
	}
4648
      }
4649

4650
    /* ---- start the long-division loops ------------------------------ */
4651
    accunits=0;				/* no units accumulated yet */
4652
    accdigits=0;			/* .. or digits */
4653
    accnext=acc+acclength-1;		/* -> msu of acc [NB: allows digits+1] */
4654
    for (;;) {				/* outer forever loop */
4655
      thisunit=0;			/* current unit assumed 0 */
4656
      /* find the next unit */
4657
      for (;;) {			/* inner forever loop */
4658
	/* strip leading zero units [from either pre-adjust or from */
4659
	/* subtract last time around].	Leave at least one unit. */
4660
	for (; *msu1==0 && msu1>var1; msu1--) var1units--;
4661

4662
	if (var1units<var2ulen) break;	     /* var1 too low for subtract */
4663
	if (var1units==var2ulen) {	     /* unit-by-unit compare needed */
4664
	  /* compare the two numbers, from msu */
4665
	  const Unit *pv1, *pv2;
4666
	  Unit v2;			     /* units to compare */
4667
	  pv2=msu2;			     /* -> msu */
4668
	  for (pv1=msu1; ; pv1--, pv2--) {
4669
	    /* v1=*pv1 -- always OK */
4670
	    v2=0;			     /* assume in padding */
4671
	    if (pv2>=var2) v2=*pv2;	     /* in range */
4672
	    if (*pv1!=v2) break;	     /* no longer the same */
4673
	    if (pv1==var1) break;	     /* done; leave pv1 as is */
4674
	    }
4675
	  /* here when all inspected or a difference seen */
4676
	  if (*pv1<v2) break;		     /* var1 too low to subtract */
4677
	  if (*pv1==v2) {		     /* var1 == var2 */
4678
	    /* reach here if var1 and var2 are identical; subtraction */
4679
	    /* would increase digit by one, and the residue will be 0 so */
4680
	    /* the calculation is done; leave the loop with residue=0. */
4681
	    thisunit++;			     /* as though subtracted */
4682
	    *var1=0;			     /* set var1 to 0 */
4683
	    var1units=1;		     /* .. */
4684
	    break;  /* from inner */
4685
	    } /* var1 == var2 */
4686
	  /* *pv1>v2.  Prepare for real subtraction; the lengths are equal */
4687
	  /* Estimate the multiplier (there's always a msu1-1)... */
4688
	  /* Bring in two units of var2 to provide a good estimate. */
4689
	  mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
4690
	  } /* lengths the same */
4691
	 else { /* var1units > var2ulen, so subtraction is safe */
4692
	  /* The var2 msu is one unit towards the lsu of the var1 msu, */
4693
	  /* so only one unit for var2 can be used. */
4694
	  mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
4695
	  }
4696
	if (mult==0) mult=1;		     /* must always be at least 1 */
4697
	/* subtraction needed; var1 is > var2 */
4698
	thisunit=(Unit)(thisunit+mult);	     /* accumulate */
4699
	/* subtract var1-var2, into var1; only the overlap needs */
4700
	/* processing, as this is an in-place calculation */
4701
	shift=var2ulen-var2units;
4702
	#if DECTRACE
4703
	  decDumpAr('1', &var1[shift], var1units-shift);
4704
	  decDumpAr('2', var2, var2units);
4705
	  printf("m=%ld\n", -mult);
4706
	#endif
4707
	decUnitAddSub(&var1[shift], var1units-shift,
4708
		      var2, var2units, 0,
4709
		      &var1[shift], -mult);
4710
	#if DECTRACE
4711
	  decDumpAr('#', &var1[shift], var1units-shift);
4712
	#endif
4713
	/* var1 now probably has leading zeros; these are removed at the */
4714
	/* top of the inner loop. */
4715
	} /* inner loop */
4716

4717
      /* The next unit has been calculated in full; unless it's a */
4718
      /* leading zero, add to acc */
4719
      if (accunits!=0 || thisunit!=0) {	     /* is first or non-zero */
4720
	*accnext=thisunit;		     /* store in accumulator */
4721
	/* account exactly for the new digits */
4722
	if (accunits==0) {
4723
	  accdigits++;			     /* at least one */
4724
	  for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
4725
	  }
4726
	 else accdigits+=DECDPUN;
4727
	accunits++;			     /* update count */
4728
	accnext--;			     /* ready for next */
4729
	if (accdigits>reqdigits) break;	     /* have enough digits */
4730
	}
4731

4732
      /* if the residue is zero, the operation is done (unless divide */
4733
      /* or divideInteger and still not enough digits yet) */
4734
      if (*var1==0 && var1units==1) {	     /* residue is 0 */
4735
	if (op&(REMAINDER|REMNEAR)) break;
4736
	if ((op&DIVIDE) && (exponent<=maxexponent)) break;
4737
	/* [drop through if divideInteger] */
4738
	}
4739
      /* also done enough if calculating remainder or integer */
4740
      /* divide and just did the last ('units') unit */
4741
      if (exponent==0 && !(op&DIVIDE)) break;
4742

4743
      /* to get here, var1 is less than var2, so divide var2 by the per- */
4744
      /* Unit power of ten and go for the next digit */
4745
      var2ulen--;			     /* shift down */
4746
      exponent-=DECDPUN;		     /* update the exponent */
4747
      } /* outer loop */
4748

4749
    /* ---- division is complete --------------------------------------- */
4750
    /* here: acc      has at least reqdigits+1 of good results (or fewer */
4751
    /*		      if early stop), starting at accnext+1 (its lsu) */
4752
    /*	     var1     has any residue at the stopping point */
4753
    /*	     accunits is the number of digits collected in acc */
4754
    if (accunits==0) {		   /* acc is 0 */
4755
      accunits=1;		   /* show have a unit .. */
4756
      accdigits=1;		   /* .. */
4757
      *accnext=0;		   /* .. whose value is 0 */
4758
      }
4759
     else accnext++;		   /* back to last placed */
4760
    /* accnext now -> lowest unit of result */
4761

4762
    residue=0;			   /* assume no residue */
4763
    if (op&DIVIDE) {
4764
      /* record the presence of any residue, for rounding */
4765
      if (*var1!=0 || var1units>1) residue=1;
4766
       else { /* no residue */
4767
	/* Had an exact division; clean up spurious trailing 0s. */
4768
	/* There will be at most DECDPUN-1, from the final multiply, */
4769
	/* and then only if the result is non-0 (and even) and the */
4770
	/* exponent is 'loose'. */
4771
	#if DECDPUN>1
4772
	Unit lsu=*accnext;
4773
	if (!(lsu&0x01) && (lsu!=0)) {
4774
	  /* count the trailing zeros */
4775
	  Int drop=0;
4776
	  for (;; drop++) {    /* [will terminate because lsu!=0] */
4777
	    if (exponent>=maxexponent) break;	  /* don't chop real 0s */
4778
	    #if DECDPUN<=4
4779
	      if ((lsu-QUOT10(lsu, drop+1)
4780
		  *powers[drop+1])!=0) break;	  /* found non-0 digit */
4781
	    #else
4782
	      if (lsu%powers[drop+1]!=0) break;	  /* found non-0 digit */
4783
	    #endif
4784
	    exponent++;
4785
	    }
4786
	  if (drop>0) {
4787
	    accunits=decShiftToLeast(accnext, accunits, drop);
4788
	    accdigits=decGetDigits(accnext, accunits);
4789
	    accunits=D2U(accdigits);
4790
	    /* [exponent was adjusted in the loop] */
4791
	    }
4792
	  } /* neither odd nor 0 */
4793
	#endif
4794
	} /* exact divide */
4795
      } /* divide */
4796
     else /* op!=DIVIDE */ {
4797
      /* check for coefficient overflow */
4798
      if (accdigits+exponent>reqdigits) {
4799
	*status|=DEC_Division_impossible;
4800
	break;
4801
	}
4802
      if (op & (REMAINDER|REMNEAR)) {
4803
	/* [Here, the exponent will be 0, because var1 was adjusted */
4804
	/* appropriately.] */
4805
	Int postshift;			     /* work */
4806
	Flag wasodd=0;			     /* integer was odd */
4807
	Unit *quotlsu;			     /* for save */
4808
	Int  quotdigits;		     /* .. */
4809

4810
	bits=lhs->bits;			     /* remainder sign is always as lhs */
4811

4812
	/* Fastpath when residue is truly 0 is worthwhile [and */
4813
	/* simplifies the code below] */
4814
	if (*var1==0 && var1units==1) {	     /* residue is 0 */
4815
	  Int exp=lhs->exponent;	     /* save min(exponents) */
4816
	  if (rhs->exponent<exp) exp=rhs->exponent;
4817
	  decNumberZero(res);		     /* 0 coefficient */
4818
	  #if DECSUBSET
4819
	  if (set->extended)
4820
	  #endif
4821
	  res->exponent=exp;		     /* .. with proper exponent */
4822
	  res->bits=(uByte)(bits&DECNEG);	   /* [cleaned] */
4823
	  decFinish(res, set, &residue, status);   /* might clamp */
4824
	  break;
4825
	  }
4826
	/* note if the quotient was odd */
4827
	if (*accnext & 0x01) wasodd=1;	     /* acc is odd */
4828
	quotlsu=accnext;		     /* save in case need to reinspect */
4829
	quotdigits=accdigits;		     /* .. */
4830

4831
	/* treat the residue, in var1, as the value to return, via acc */
4832
	/* calculate the unused zero digits.  This is the smaller of: */
4833
	/*   var1 initial padding (saved above) */
4834
	/*   var2 residual padding, which happens to be given by: */
4835
	postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
4836
	/* [the 'exponent' term accounts for the shifts during divide] */
4837
	if (var1initpad<postshift) postshift=var1initpad;
4838

4839
	/* shift var1 the requested amount, and adjust its digits */
4840
	var1units=decShiftToLeast(var1, var1units, postshift);
4841
	accnext=var1;
4842
	accdigits=decGetDigits(var1, var1units);
4843
	accunits=D2U(accdigits);
4844

4845
	exponent=lhs->exponent;		/* exponent is smaller of lhs & rhs */
4846
	if (rhs->exponent<exponent) exponent=rhs->exponent;
4847

4848
	/* Now correct the result if doing remainderNear; if it */
4849
	/* (looking just at coefficients) is > rhs/2, or == rhs/2 and */
4850
	/* the integer was odd then the result should be rem-rhs. */
4851
	if (op&REMNEAR) {
4852
	  Int compare, tarunits;	/* work */
4853
	  Unit *up;			/* .. */
4854
	  /* calculate remainder*2 into the var1 buffer (which has */
4855
	  /* 'headroom' of an extra unit and hence enough space) */
4856
	  /* [a dedicated 'double' loop would be faster, here] */
4857
	  tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
4858
				 0, accnext, 1);
4859
	  /* decDumpAr('r', accnext, tarunits); */
4860

4861
	  /* Here, accnext (var1) holds tarunits Units with twice the */
4862
	  /* remainder's coefficient, which must now be compared to the */
4863
	  /* RHS.  The remainder's exponent may be smaller than the RHS's. */
4864
	  compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
4865
				 rhs->exponent-exponent);
4866
	  if (compare==BADINT) {	     /* deep trouble */
4867
	    *status|=DEC_Insufficient_storage;
4868
	    break;}
4869

4870
	  /* now restore the remainder by dividing by two; the lsu */
4871
	  /* is known to be even. */
4872
	  for (up=accnext; up<accnext+tarunits; up++) {
4873
	    Int half;		   /* half to add to lower unit */
4874
	    half=*up & 0x01;
4875
	    *up/=2;		   /* [shift] */
4876
	    if (!half) continue;
4877
	    *(up-1)+=DIV_ROUND_UP(DECDPUNMAX, 2);
4878
	    }
4879
	  /* [accunits still describes the original remainder length] */
4880

4881
	  if (compare>0 || (compare==0 && wasodd)) { /* adjustment needed */
4882
	    Int exp, expunits, exprem;	     /* work */
4883
	    /* This is effectively causing round-up of the quotient, */
4884
	    /* so if it was the rare case where it was full and all */
4885
	    /* nines, it would overflow and hence division-impossible */
4886
	    /* should be raised */
4887
	    Flag allnines=0;		     /* 1 if quotient all nines */
4888
	    if (quotdigits==reqdigits) {     /* could be borderline */
4889
	      for (up=quotlsu; ; up++) {
4890
		if (quotdigits>DECDPUN) {
4891
		  if (*up!=DECDPUNMAX) break;/* non-nines */
4892
		  }
4893
		 else {			     /* this is the last Unit */
4894
		  if (*up==powers[quotdigits]-1) allnines=1;
4895
		  break;
4896
		  }
4897
		quotdigits-=DECDPUN;	     /* checked those digits */
4898
		} /* up */
4899
	      } /* borderline check */
4900
	    if (allnines) {
4901
	      *status|=DEC_Division_impossible;
4902
	      break;}
4903

4904
	    /* rem-rhs is needed; the sign will invert.	 Again, var1 */
4905
	    /* can safely be used for the working Units array. */
4906
	    exp=rhs->exponent-exponent;	     /* RHS padding needed */
4907
	    /* Calculate units and remainder from exponent. */
4908
	    expunits=exp/DECDPUN;
4909
	    exprem=exp%DECDPUN;
4910
	    /* subtract [A+B*(-m)]; the result will always be negative */
4911
	    accunits=-decUnitAddSub(accnext, accunits,
4912
				    rhs->lsu, D2U(rhs->digits),
4913
				    expunits, accnext, -(Int)powers[exprem]);
4914
	    accdigits=decGetDigits(accnext, accunits); /* count digits exactly */
4915
	    accunits=D2U(accdigits);	/* and recalculate the units for copy */
4916
	    /* [exponent is as for original remainder] */
4917
	    bits^=DECNEG;		/* flip the sign */
4918
	    }
4919
	  } /* REMNEAR */
4920
	} /* REMAINDER or REMNEAR */
4921
      } /* not DIVIDE */
4922

4923
    /* Set exponent and bits */
4924
    res->exponent=exponent;
4925
    res->bits=(uByte)(bits&DECNEG);	     /* [cleaned] */
4926

4927
    /* Now the coefficient. */
4928
    decSetCoeff(res, set, accnext, accdigits, &residue, status);
4929

4930
    decFinish(res, set, &residue, status);   /* final cleanup */
4931

4932
    #if DECSUBSET
4933
    /* If a divide then strip trailing zeros if subset [after round] */
4934
    if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, &dropped);
4935
    #endif
4936
    } while(0);				     /* end protected */
4937

4938
  if (varalloc!=NULL) free(varalloc);	/* drop any storage used */
4939
  if (allocacc!=NULL) free(allocacc);	/* .. */
4940
  #if DECSUBSET
4941
  if (allocrhs!=NULL) free(allocrhs);	/* .. */
4942
  if (alloclhs!=NULL) free(alloclhs);	/* .. */
4943
  #endif
4944
  return res;
4945
  } /* decDivideOp */
4946

4947
/* ------------------------------------------------------------------ */
4948
/* decMultiplyOp -- multiplication operation			      */
4949
/*								      */
4950
/*  This routine performs the multiplication C=A x B.		      */
4951
/*								      */
4952
/*   res is C, the result.  C may be A and/or B (e.g., X=X*X)	      */
4953
/*   lhs is A							      */
4954
/*   rhs is B							      */
4955
/*   set is the context						      */
4956
/*   status is the usual accumulator				      */
4957
/*								      */
4958
/* C must have space for set->digits digits.			      */
4959
/*								      */
4960
/* ------------------------------------------------------------------ */
4961
/* 'Classic' multiplication is used rather than Karatsuba, as the     */
4962
/* latter would give only a minor improvement for the short numbers   */
4963
/* expected to be handled most (and uses much more memory).	      */
4964
/*								      */
4965
/* There are two major paths here: the general-purpose ('old code')   */
4966
/* path which handles all DECDPUN values, and a fastpath version      */
4967
/* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
4968
/* than two calls to decUnitAddSub would be made.		      */
4969
/*								      */
4970
/* The fastpath version lumps units together into 8-digit or 9-digit  */
4971
/* chunks, and also uses a lazy carry strategy to minimise expensive  */
4972
/* 64-bit divisions.  The chunks are then broken apart again into     */
4973
/* units for continuing processing.  Despite this overhead, the	      */
4974
/* fastpath can speed up some 16-digit operations by 10x (and much    */
4975
/* more for higher-precision calculations).			      */
4976
/*								      */
4977
/* A buffer always has to be used for the accumulator; in the	      */
4978
/* fastpath, buffers are also always needed for the chunked copies of */
4979
/* of the operand coefficients.					      */
4980
/* Static buffers are larger than needed just for multiply, to allow  */
4981
/* for calls from other operations (notably exp).		      */
4982
/* ------------------------------------------------------------------ */
4983
#define FASTMUL (DECUSE64 && DECDPUN<5)
4984
static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
4985
				 const decNumber *rhs, decContext *set,
4986
				 uInt *status) {
4987
  Int	 accunits;		   /* Units of accumulator in use */
4988
  Int	 exponent;		   /* work */
4989
  Int	 residue=0;		   /* rounding residue */
4990
  uByte	 bits;			   /* result sign */
4991
  Unit	*acc;			   /* -> accumulator Unit array */
4992
  Int	 needbytes;		   /* size calculator */
4993
  void	*allocacc=NULL;		   /* -> allocated accumulator, iff allocated */
4994
  Unit	accbuff[SD2U(DECBUFFER*4+1)]; /* buffer (+1 for DECBUFFER==0, */
4995
				   /* *4 for calls from other operations) */
4996
  const Unit *mer, *mermsup;	   /* work */
4997
  Int	madlength;		   /* Units in multiplicand */
4998
  Int	shift;			   /* Units to shift multiplicand by */
4999

5000
  #if FASTMUL
5001
    /* if DECDPUN is 1 or 3 work in base 10**9, otherwise */
5002
    /* (DECDPUN is 2 or 4) then work in base 10**8 */
5003
    #if DECDPUN & 1		   /* odd */
5004
      #define FASTBASE 1000000000  /* base */
5005
      #define FASTDIGS		9  /* digits in base */
5006
      #define FASTLAZY	       18  /* carry resolution point [1->18] */
5007
    #else
5008
      #define FASTBASE	100000000
5009
      #define FASTDIGS		8
5010
      #define FASTLAZY	     1844  /* carry resolution point [1->1844] */
5011
    #endif
5012
    /* three buffers are used, two for chunked copies of the operands */
5013
    /* (base 10**8 or base 10**9) and one base 2**64 accumulator with */
5014
    /* lazy carry evaluation */
5015
    uInt   zlhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
5016
    uInt  *zlhi=zlhibuff;		  /* -> lhs array */
5017
    uInt  *alloclhi=NULL;		  /* -> allocated buffer, iff allocated */
5018
    uInt   zrhibuff[(DECBUFFER*2+1)/8+1]; /* buffer (+1 for DECBUFFER==0) */
5019
    uInt  *zrhi=zrhibuff;		  /* -> rhs array */
5020
    uInt  *allocrhi=NULL;		  /* -> allocated buffer, iff allocated */
5021
    uLong  zaccbuff[(DECBUFFER*2+1)/4+2]; /* buffer (+1 for DECBUFFER==0) */
5022
    /* [allocacc is shared for both paths, as only one will run] */
5023
    uLong *zacc=zaccbuff;	   /* -> accumulator array for exact result */
5024
    #if DECDPUN==1
5025
    Int	   zoff;		   /* accumulator offset */
5026
    #endif
5027
    uInt  *lip, *rip;		   /* item pointers */
5028
    uInt  *lmsi, *rmsi;		   /* most significant items */
5029
    Int	   ilhs, irhs, iacc;	   /* item counts in the arrays */
5030
    Int	   lazy;		   /* lazy carry counter */
5031
    uLong  lcarry;		   /* uLong carry */
5032
    uInt   carry;		   /* carry (NB not uLong) */
5033
    Int	   count;		   /* work */
5034
    const  Unit *cup;		   /* .. */
5035
    Unit  *up;			   /* .. */
5036
    uLong *lp;			   /* .. */
5037
    Int	   p;			   /* .. */
5038
  #endif
5039

5040
  #if DECSUBSET
5041
    decNumber *alloclhs=NULL;	   /* -> allocated buffer, iff allocated */
5042
    decNumber *allocrhs=NULL;	   /* -> allocated buffer, iff allocated */
5043
  #endif
5044

5045
  #if DECCHECK
5046
  if (decCheckOperands(res, lhs, rhs, set)) return res;
5047
  #endif
5048

5049
  /* precalculate result sign */
5050
  bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
5051

5052
  /* handle infinities and NaNs */
5053
  if (SPECIALARGS) {		   /* a special bit set */
5054
    if (SPECIALARGS & (DECSNAN | DECNAN)) { /* one or two NaNs */
5055
      decNaNs(res, lhs, rhs, set, status);
5056
      return res;}
5057
    /* one or two infinities; Infinity * 0 is invalid */
5058
    if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
5059
      ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
5060
      *status|=DEC_Invalid_operation;
5061
      return res;}
5062
    decNumberZero(res);
5063
    res->bits=bits|DECINF;	   /* infinity */
5064
    return res;}
5065

5066
  /* For best speed, as in DMSRCN [the original Rexx numerics */
5067
  /* module], use the shorter number as the multiplier (rhs) and */
5068
  /* the longer as the multiplicand (lhs) to minimise the number of */
5069
  /* adds (partial products) */
5070
  if (lhs->digits<rhs->digits) {   /* swap... */
5071
    const decNumber *hold=lhs;
5072
    lhs=rhs;
5073
    rhs=hold;
5074
    }
5075

5076
  do {				   /* protect allocated storage */
5077
    #if DECSUBSET
5078
    if (!set->extended) {
5079
      /* reduce operands and set lostDigits status, as needed */
5080
      if (lhs->digits>set->digits) {
5081
	alloclhs=decRoundOperand(lhs, set, status);
5082
	if (alloclhs==NULL) break;
5083
	lhs=alloclhs;
5084
	}
5085
      if (rhs->digits>set->digits) {
5086
	allocrhs=decRoundOperand(rhs, set, status);
5087
	if (allocrhs==NULL) break;
5088
	rhs=allocrhs;
5089
	}
5090
      }
5091
    #endif
5092
    /* [following code does not require input rounding] */
5093

5094
    #if FASTMUL			   /* fastpath can be used */
5095
    /* use the fast path if there are enough digits in the shorter */
5096
    /* operand to make the setup and takedown worthwhile */
5097
    #define NEEDTWO (DECDPUN*2)	   /* within two decUnitAddSub calls */
5098
    if (rhs->digits>NEEDTWO) {	   /* use fastpath... */
5099
      /* calculate the number of elements in each array */
5100
      ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */
5101
      irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; /* .. */
5102
      iacc=ilhs+irhs;
5103

5104
      /* allocate buffers if required, as usual */
5105
      needbytes=ilhs*sizeof(uInt);
5106
      if (needbytes>(Int)sizeof(zlhibuff)) {
5107
	alloclhi=(uInt *)malloc(needbytes);
5108
	zlhi=alloclhi;}
5109
      needbytes=irhs*sizeof(uInt);
5110
      if (needbytes>(Int)sizeof(zrhibuff)) {
5111
	allocrhi=(uInt *)malloc(needbytes);
5112
	zrhi=allocrhi;}
5113

5114
      /* Allocating the accumulator space needs a special case when */
5115
      /* DECDPUN=1 because when converting the accumulator to Units */
5116
      /* after the multiplication each 8-byte item becomes 9 1-byte */
5117
      /* units.	 Therefore iacc extra bytes are needed at the front */
5118
      /* (rounded up to a multiple of 8 bytes), and the uLong */
5119
      /* accumulator starts offset the appropriate number of units */
5120
      /* to the right to avoid overwrite during the unchunking. */
5121
      needbytes=iacc*sizeof(uLong);
5122
      #if DECDPUN==1
5123
      zoff=(iacc+7)/8;	      /* items to offset by */
5124
      needbytes+=zoff*8;
5125
      #endif
5126
      if (needbytes>(Int)sizeof(zaccbuff)) {
5127
	allocacc=(uLong *)malloc(needbytes);
5128
	zacc=(uLong *)allocacc;}
5129
      if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
5130
	*status|=DEC_Insufficient_storage;
5131
	break;}
5132

5133
      acc=(Unit *)zacc;	      /* -> target Unit array */
5134
      #if DECDPUN==1
5135
      zacc+=zoff;	      /* start uLong accumulator to right */
5136
      #endif
5137

5138
      /* assemble the chunked copies of the left and right sides */
5139
      for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
5140
	for (p=0, *lip=0; p<FASTDIGS && count>0;
5141
	     p+=DECDPUN, cup++, count-=DECDPUN)
5142
	  *lip+=*cup*powers[p];
5143
      lmsi=lip-1;     /* save -> msi */
5144
      for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
5145
	for (p=0, *rip=0; p<FASTDIGS && count>0;
5146
	     p+=DECDPUN, cup++, count-=DECDPUN)
5147
	  *rip+=*cup*powers[p];
5148
      rmsi=rip-1;     /* save -> msi */
5149

5150
      /* zero the accumulator */
5151
      for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
5152

5153
      /* Start the multiplication */
5154
      /* Resolving carries can dominate the cost of accumulating the */
5155
      /* partial products, so this is only done when necessary. */
5156
      /* Each uLong item in the accumulator can hold values up to */
5157
      /* 2**64-1, and each partial product can be as large as */
5158
      /* (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to */
5159
      /* itself 18.4 times in a uLong without overflowing, so during */
5160
      /* the main calculation resolution is carried out every 18th */
5161
      /* add -- every 162 digits.  Similarly, when FASTDIGS=8, the */
5162
      /* partial products can be added to themselves 1844.6 times in */
5163
      /* a uLong without overflowing, so intermediate carry */
5164
      /* resolution occurs only every 14752 digits.  Hence for common */
5165
      /* short numbers usually only the one final carry resolution */
5166
      /* occurs. */
5167
      /* (The count is set via FASTLAZY to simplify experiments to */
5168
      /* measure the value of this approach: a 35% improvement on a */
5169
      /* [34x34] multiply.) */
5170
      lazy=FASTLAZY;			     /* carry delay count */
5171
      for (rip=zrhi; rip<=rmsi; rip++) {     /* over each item in rhs */
5172
	lp=zacc+(rip-zrhi);		     /* where to add the lhs */
5173
	for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */
5174
	  *lp+=(uLong)(*lip)*(*rip);	     /* [this should in-line] */
5175
	  } /* lip loop */
5176
	lazy--;
5177
	if (lazy>0 && rip!=rmsi) continue;
5178
	lazy=FASTLAZY;			     /* reset delay count */
5179
	/* spin up the accumulator resolving overflows */
5180
	for (lp=zacc; lp<zacc+iacc; lp++) {
5181
	  if (*lp<FASTBASE) continue;	     /* it fits */
5182
	  lcarry=*lp/FASTBASE;		     /* top part [slow divide] */
5183
	  /* lcarry can exceed 2**32-1, so check again; this check */
5184
	  /* and occasional extra divide (slow) is well worth it, as */
5185
	  /* it allows FASTLAZY to be increased to 18 rather than 4 */
5186
	  /* in the FASTDIGS=9 case */
5187
	  if (lcarry<FASTBASE) carry=(uInt)lcarry;  /* [usual] */
5188
	   else { /* two-place carry [fairly rare] */
5189
	    uInt carry2=(uInt)(lcarry/FASTBASE);    /* top top part */
5190
	    *(lp+2)+=carry2;			    /* add to item+2 */
5191
	    *lp-=((uLong)FASTBASE*FASTBASE*carry2); /* [slow] */
5192
	    carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); /* [inline] */
5193
	    }
5194
	  *(lp+1)+=carry;		     /* add to item above [inline] */
5195
	  *lp-=((uLong)FASTBASE*carry);	     /* [inline] */
5196
	  } /* carry resolution */
5197
	} /* rip loop */
5198

5199
      /* The multiplication is complete; time to convert back into */
5200
      /* units.	 This can be done in-place in the accumulator and in */
5201
      /* 32-bit operations, because carries were resolved after the */
5202
      /* final add.  This needs N-1 divides and multiplies for */
5203
      /* each item in the accumulator (which will become up to N */
5204
      /* units, where 2<=N<=9). */
5205
      for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
5206
	uInt item=(uInt)*lp;		     /* decapitate to uInt */
5207
	for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
5208
	  uInt part=item/(DECDPUNMAX+1);
5209
	  *up=(Unit)(item-(part*(DECDPUNMAX+1)));
5210
	  item=part;
5211
	  } /* p */
5212
	*up=(Unit)item; up++;		     /* [final needs no division] */
5213
	} /* lp */
5214
      accunits=up-acc;			     /* count of units */
5215
      }
5216
     else { /* here to use units directly, without chunking ['old code'] */
5217
    #endif
5218

5219
      /* if accumulator will be too long for local storage, then allocate */
5220
      acc=accbuff;		   /* -> assume buffer for accumulator */
5221
      needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
5222
      if (needbytes>(Int)sizeof(accbuff)) {
5223
	allocacc=(Unit *)malloc(needbytes);
5224
	if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
5225
	acc=(Unit *)allocacc;		     /* use the allocated space */
5226
	}
5227

5228
      /* Now the main long multiplication loop */
5229
      /* Unlike the equivalent in the IBM Java implementation, there */
5230
      /* is no advantage in calculating from msu to lsu.  So, do it */
5231
      /* by the book, as it were. */
5232
      /* Each iteration calculates ACC=ACC+MULTAND*MULT */
5233
      accunits=1;		   /* accumulator starts at '0' */
5234
      *acc=0;			   /* .. (lsu=0) */
5235
      shift=0;			   /* no multiplicand shift at first */
5236
      madlength=D2U(lhs->digits);  /* this won't change */
5237
      mermsup=rhs->lsu+D2U(rhs->digits); /* -> msu+1 of multiplier */
5238

5239
      for (mer=rhs->lsu; mer<mermsup; mer++) {
5240
	/* Here, *mer is the next Unit in the multiplier to use */
5241
	/* If non-zero [optimization] add it... */
5242
	if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
5243
					    lhs->lsu, madlength, 0,
5244
					    &acc[shift], *mer)
5245
					    + shift;
5246
	 else { /* extend acc with a 0; it will be used shortly */
5247
	  *(acc+accunits)=0;	   /* [this avoids length of <=0 later] */
5248
	  accunits++;
5249
	  }
5250
	/* multiply multiplicand by 10**DECDPUN for next Unit to left */
5251
	shift++;		   /* add this for 'logical length' */
5252
	} /* n */
5253
    #if FASTMUL
5254
      } /* unchunked units */
5255
    #endif
5256
    /* common end-path */
5257
    #if DECTRACE
5258
      decDumpAr('*', acc, accunits);	     /* Show exact result */
5259
    #endif
5260

5261
    /* acc now contains the exact result of the multiplication, */
5262
    /* possibly with a leading zero unit; build the decNumber from */
5263
    /* it, noting if any residue */
5264
    res->bits=bits;			     /* set sign */
5265
    res->digits=decGetDigits(acc, accunits); /* count digits exactly */
5266

5267
    /* There can be a 31-bit wrap in calculating the exponent. */
5268
    /* This can only happen if both input exponents are negative and */
5269
    /* both their magnitudes are large.	 If there was a wrap, set a */
5270
    /* safe very negative exponent, from which decFinalize() will */
5271
    /* raise a hard underflow shortly. */
5272
    exponent=lhs->exponent+rhs->exponent;    /* calculate exponent */
5273
    if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
5274
      exponent=-2*DECNUMMAXE;		     /* force underflow */
5275
    res->exponent=exponent;		     /* OK to overwrite now */
5276

5277

5278
    /* Set the coefficient.  If any rounding, residue records */
5279
    decSetCoeff(res, set, acc, res->digits, &residue, status);
5280
    decFinish(res, set, &residue, status);   /* final cleanup */
5281
    } while(0);				/* end protected */
5282

5283
  if (allocacc!=NULL) free(allocacc);	/* drop any storage used */
5284
  #if DECSUBSET
5285
  if (allocrhs!=NULL) free(allocrhs);	/* .. */
5286
  if (alloclhs!=NULL) free(alloclhs);	/* .. */
5287
  #endif
5288
  #if FASTMUL
5289
  if (allocrhi!=NULL) free(allocrhi);	/* .. */
5290
  if (alloclhi!=NULL) free(alloclhi);	/* .. */
5291
  #endif
5292
  return res;
5293
  } /* decMultiplyOp */
5294

5295
/* ------------------------------------------------------------------ */
5296
/* decExpOp -- effect exponentiation				      */
5297
/*								      */
5298
/*   This computes C = exp(A)					      */
5299
/*								      */
5300
/*   res is C, the result.  C may be A				      */
5301
/*   rhs is A							      */
5302
/*   set is the context; note that rounding mode has no effect	      */
5303
/*								      */
5304
/* C must have space for set->digits digits. status is updated but    */
5305
/* not set.							      */
5306
/*								      */
5307
/* Restrictions:						      */
5308
/*								      */
5309
/*   digits, emax, and -emin in the context must be less than	      */
5310
/*   2*DEC_MAX_MATH (1999998), and the rhs must be within these	      */
5311
/*   bounds or a zero.	This is an internal routine, so these	      */
5312
/*   restrictions are contractual and not enforced.		      */
5313
/*								      */
5314
/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5315
/* almost always be correctly rounded, but may be up to 1 ulp in      */
5316
/* error in rare cases.						      */
5317
/*								      */
5318
/* Finite results will always be full precision and Inexact, except   */
5319
/* when A is a zero or -Infinity (giving 1 or 0 respectively).	      */
5320
/* ------------------------------------------------------------------ */
5321
/* This approach used here is similar to the algorithm described in   */
5322
/*								      */
5323
/*   Variable Precision Exponential Function, T. E. Hull and	      */
5324
/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
5325
/*   pp79-91, ACM, June 1986.					      */
5326
/*								      */
5327
/* with the main difference being that the iterations in the series   */
5328
/* evaluation are terminated dynamically (which does not require the  */
5329
/* extra variable-precision variables which are expensive in this     */
5330
/* context).							      */
5331
/*								      */
5332
/* The error analysis in Hull & Abrham's paper applies except for the */
5333
/* round-off error accumulation during the series evaluation.  This   */
5334
/* code does not precalculate the number of iterations and so cannot  */
5335
/* use Horner's scheme.	 Instead, the accumulation is done at double- */
5336
/* precision, which ensures that the additions of the terms are exact */
5337
/* and do not accumulate round-off (and any round-off errors in the   */
5338
/* terms themselves move 'to the right' faster than they can	      */
5339
/* accumulate).	 This code also extends the calculation by allowing,  */
5340
/* in the spirit of other decNumber operators, the input to be more   */
5341
/* precise than the result (the precision used is based on the more   */
5342
/* precise of the input or requested result).			      */
5343
/*								      */
5344
/* Implementation notes:					      */
5345
/*								      */
5346
/* 1. This is separated out as decExpOp so it can be called from      */
5347
/*    other Mathematical functions (notably Ln) with a wider range    */
5348
/*    than normal.  In particular, it can handle the slightly wider   */
5349
/*    (double) range needed by Ln (which has to be able to calculate  */
5350
/*    exp(-x) where x can be the tiniest number (Ntiny).	      */
5351
/*								      */
5352
/* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop	      */
5353
/*    iterations by approximately a third with additional (although    */
5354
/*    diminishing) returns as the range is reduced to even smaller    */
5355
/*    fractions.  However, h (the power of 10 used to correct the     */
5356
/*    result at the end, see below) must be kept <=8 as otherwise     */
5357
/*    the final result cannot be computed.  Hence the leverage is a   */
5358
/*    sliding value (8-h), where potentially the range is reduced     */
5359
/*    more for smaller values.					      */
5360
/*								      */
5361
/*    The leverage that can be applied in this way is severely	      */
5362
/*    limited by the cost of the raise-to-the power at the end,	      */
5363
/*    which dominates when the number of iterations is small (less    */
5364
/*    than ten) or when rhs is short.  As an example, the adjustment  */
5365
/*    x**10,000,000 needs 31 multiplications, all but one full-width. */
5366
/*								      */
5367
/* 3. The restrictions (especially precision) could be raised with    */
5368
/*    care, but the full decNumber range seems very hard within the   */
5369
/*    32-bit limits.						      */
5370
/*								      */
5371
/* 4. The working precisions for the static buffers are twice the     */
5372
/*    obvious size to allow for calls from decNumberPower.	      */
5373
/* ------------------------------------------------------------------ */
5374
static decNumber *decExpOp(decNumber *res, const decNumber *rhs,
5375
                           decContext *set, uInt *status) {
5376
  uInt ignore=0;		   /* working status */
5377
  Int h;			   /* adjusted exponent for 0.xxxx */
5378
  Int p;			   /* working precision */
5379
  Int residue;			   /* rounding residue */
5380
  uInt needbytes;		   /* for space calculations */
5381
  const decNumber *x=rhs;	   /* (may point to safe copy later) */
5382
  decContext aset, tset, dset;	   /* working contexts */
5383
  Int comp;			   /* work */
5384

5385
  /* the argument is often copied to normalize it, so (unusually) it */
5386
  /* is treated like other buffers, using DECBUFFER, +1 in case */
5387
  /* DECBUFFER is 0 */
5388
  decNumber bufr[D2N(DECBUFFER*2+1)];
5389
  decNumber *allocrhs=NULL;	   /* non-NULL if rhs buffer allocated */
5390

5391
  /* the working precision will be no more than set->digits+8+1 */
5392
  /* so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER */
5393
  /* is 0 (and twice that for the accumulator) */
5394

5395
  /* buffer for t, term (working precision plus) */
5396
  decNumber buft[D2N(DECBUFFER*2+9+1)];
5397
  decNumber *allocbuft=NULL;	   /* -> allocated buft, iff allocated */
5398
  decNumber *t=buft;		   /* term */
5399
  /* buffer for a, accumulator (working precision * 2), at least 9 */
5400
  decNumber bufa[D2N(DECBUFFER*4+18+1)];
5401
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
5402
  decNumber *a=bufa;		   /* accumulator */
5403
  /* decNumber for the divisor term; this needs at most 9 digits */
5404
  /* and so can be fixed size [16 so can use standard context] */
5405
  decNumber bufd[D2N(16)];
5406
  decNumber *d=bufd;		   /* divisor */
5407
  decNumber numone;		   /* constant 1 */
5408

5409
  #if DECCHECK
5410
  Int iterations=0;		   /* for later sanity check */
5411
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5412
  #endif
5413

5414
  do {					/* protect allocated storage */
5415
    if (SPECIALARG) {			/* handle infinities and NaNs */
5416
      if (decNumberIsInfinite(rhs)) {	/* an infinity */
5417
	if (decNumberIsNegative(rhs))	/* -Infinity -> +0 */
5418
	  decNumberZero(res);
5419
	 else decNumberCopy(res, rhs);	/* +Infinity -> self */
5420
	}
5421
       else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5422
      break;}
5423

5424
    if (ISZERO(rhs)) {			/* zeros -> exact 1 */
5425
      decNumberZero(res);		/* make clean 1 */
5426
      *res->lsu=1;			/* .. */
5427
      break;}				/* [no status to set] */
5428

5429
    /* e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path */
5430
    /* positive and negative tiny cases which will result in inexact */
5431
    /* 1.  This also allows the later add-accumulate to always be */
5432
    /* exact (because its length will never be more than twice the */
5433
    /* working precision). */
5434
    /* The comparator (tiny) needs just one digit, so use the */
5435
    /* decNumber d for it (reused as the divisor, etc., below); its */
5436
    /* exponent is such that if x is positive it will have */
5437
    /* set->digits-1 zeros between the decimal point and the digit, */
5438
    /* which is 4, and if x is negative one more zero there as the */
5439
    /* more precise result will be of the form 0.9999999 rather than */
5440
    /* 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0 */
5441
    /* or 0.00000004 if digits=7 and x<0.  If RHS not larger than */
5442
    /* this then the result will be 1.000000 */
5443
    decNumberZero(d);			/* clean */
5444
    *d->lsu=4;				/* set 4 .. */
5445
    d->exponent=-set->digits;		/* * 10**(-d) */
5446
    if (decNumberIsNegative(rhs)) d->exponent--;  /* negative case */
5447
    comp=decCompare(d, rhs, 1);		/* signless compare */
5448
    if (comp==BADINT) {
5449
      *status|=DEC_Insufficient_storage;
5450
      break;}
5451
    if (comp>=0) {			/* rhs < d */
5452
      Int shift=set->digits-1;
5453
      decNumberZero(res);		/* set 1 */
5454
      *res->lsu=1;			/* .. */
5455
      res->digits=decShiftToMost(res->lsu, 1, shift);
5456
      res->exponent=-shift;		     /* make 1.0000... */
5457
      *status|=DEC_Inexact | DEC_Rounded;    /* .. inexactly */
5458
      break;} /* tiny */
5459

5460
    /* set up the context to be used for calculating a, as this is */
5461
    /* used on both paths below */
5462
    decContextDefault(&aset, DEC_INIT_DECIMAL64);
5463
    /* accumulator bounds are as requested (could underflow) */
5464
    aset.emax=set->emax;		/* usual bounds */
5465
    aset.emin=set->emin;		/* .. */
5466
    aset.clamp=0;			/* and no concrete format */
5467

5468
    /* calculate the adjusted (Hull & Abrham) exponent (where the */
5469
    /* decimal point is just to the left of the coefficient msd) */
5470
    h=rhs->exponent+rhs->digits;
5471
    /* if h>8 then 10**h cannot be calculated safely; however, when */
5472
    /* h=8 then exp(|rhs|) will be at least exp(1E+7) which is at */
5473
    /* least 6.59E+4342944, so (due to the restriction on Emax/Emin) */
5474
    /* overflow (or underflow to 0) is guaranteed -- so this case can */
5475
    /* be handled by simply forcing the appropriate excess */
5476
    if (h>8) {				/* overflow/underflow */
5477
      /* set up here so Power call below will over or underflow to */
5478
      /* zero; set accumulator to either 2 or 0.02 */
5479
      /* [stack buffer for a is always big enough for this] */
5480
      decNumberZero(a);
5481
      *a->lsu=2;			/* not 1 but < exp(1) */
5482
      if (decNumberIsNegative(rhs)) a->exponent=-2; /* make 0.02 */
5483
      h=8;				/* clamp so 10**h computable */
5484
      p=9;				/* set a working precision */
5485
      }
5486
     else {				/* h<=8 */
5487
      Int maxlever=(rhs->digits>8?1:0);
5488
      /* [could/should increase this for precisions >40 or so, too] */
5489

5490
      /* if h is 8, cannot normalize to a lower upper limit because */
5491
      /* the final result will not be computable (see notes above), */
5492
      /* but leverage can be applied whenever h is less than 8. */
5493
      /* Apply as much as possible, up to a MAXLEVER digits, which */
5494
      /* sets the tradeoff against the cost of the later a**(10**h). */
5495
      /* As h is increased, the working precision below also */
5496
      /* increases to compensate for the "constant digits at the */
5497
      /* front" effect. */
5498
      Int lever=MINI(8-h, maxlever);	/* leverage attainable */
5499
      Int use=-rhs->digits-lever;	/* exponent to use for RHS */
5500
      h+=lever;				/* apply leverage selected */
5501
      if (h<0) {			/* clamp */
5502
	use+=h;				/* [may end up subnormal] */
5503
	h=0;
5504
	}
5505
      /* Take a copy of RHS if it needs normalization (true whenever x>=1) */
5506
      if (rhs->exponent!=use) {
5507
	decNumber *newrhs=bufr;		/* assume will fit on stack */
5508
	needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
5509
	if (needbytes>sizeof(bufr)) {	/* need malloc space */
5510
	  allocrhs=(decNumber *)malloc(needbytes);
5511
	  if (allocrhs==NULL) {		/* hopeless -- abandon */
5512
	    *status|=DEC_Insufficient_storage;
5513
	    break;}
5514
	  newrhs=allocrhs;		/* use the allocated space */
5515
	  }
5516
	decNumberCopy(newrhs, rhs);	/* copy to safe space */
5517
	newrhs->exponent=use;		/* normalize; now <1 */
5518
	x=newrhs;			/* ready for use */
5519
	/* decNumberShow(x); */
5520
	}
5521

5522
      /* Now use the usual power series to evaluate exp(x).  The */
5523
      /* series starts as 1 + x + x^2/2 ... so prime ready for the */
5524
      /* third term by setting the term variable t=x, the accumulator */
5525
      /* a=1, and the divisor d=2. */
5526

5527
      /* First determine the working precision.	 From Hull & Abrham */
5528
      /* this is set->digits+h+2.  However, if x is 'over-precise' we */
5529
      /* need to allow for all its digits to potentially participate */
5530
      /* (consider an x where all the excess digits are 9s) so in */
5531
      /* this case use x->digits+h+2 */
5532
      p=MAXI(x->digits, set->digits)+h+2;    /* [h<=8] */
5533

5534
      /* a and t are variable precision, and depend on p, so space */
5535
      /* must be allocated for them if necessary */
5536

5537
      /* the accumulator needs to be able to hold 2p digits so that */
5538
      /* the additions on the second and subsequent iterations are */
5539
      /* sufficiently exact. */
5540
      needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
5541
      if (needbytes>sizeof(bufa)) {	/* need malloc space */
5542
	allocbufa=(decNumber *)malloc(needbytes);
5543
	if (allocbufa==NULL) {		/* hopeless -- abandon */
5544
	  *status|=DEC_Insufficient_storage;
5545
	  break;}
5546
	a=allocbufa;			/* use the allocated space */
5547
	}
5548
      /* the term needs to be able to hold p digits (which is */
5549
      /* guaranteed to be larger than x->digits, so the initial copy */
5550
      /* is safe); it may also be used for the raise-to-power */
5551
      /* calculation below, which needs an extra two digits */
5552
      needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
5553
      if (needbytes>sizeof(buft)) {	/* need malloc space */
5554
	allocbuft=(decNumber *)malloc(needbytes);
5555
	if (allocbuft==NULL) {		/* hopeless -- abandon */
5556
	  *status|=DEC_Insufficient_storage;
5557
	  break;}
5558
	t=allocbuft;			/* use the allocated space */
5559
	}
5560

5561
      decNumberCopy(t, x);		/* term=x */
5562
      decNumberZero(a); *a->lsu=1;	/* accumulator=1 */
5563
      decNumberZero(d); *d->lsu=2;	/* divisor=2 */
5564
      decNumberZero(&numone); *numone.lsu=1; /* constant 1 for increment */
5565

5566
      /* set up the contexts for calculating a, t, and d */
5567
      decContextDefault(&tset, DEC_INIT_DECIMAL64);
5568
      dset=tset;
5569
      /* accumulator bounds are set above, set precision now */
5570
      aset.digits=p*2;			/* double */
5571
      /* term bounds avoid any underflow or overflow */
5572
      tset.digits=p;
5573
      tset.emin=DEC_MIN_EMIN;		/* [emax is plenty] */
5574
      /* [dset.digits=16, etc., are sufficient] */
5575

5576
      /* finally ready to roll */
5577
      for (;;) {
5578
	#if DECCHECK
5579
	iterations++;
5580
	#endif
5581
	/* only the status from the accumulation is interesting */
5582
	/* [but it should remain unchanged after first add] */
5583
	decAddOp(a, a, t, &aset, 0, status);	       /* a=a+t */
5584
	decMultiplyOp(t, t, x, &tset, &ignore);	       /* t=t*x */
5585
	decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  /* t=t/d */
5586
	/* the iteration ends when the term cannot affect the result, */
5587
	/* if rounded to p digits, which is when its value is smaller */
5588
	/* than the accumulator by p+1 digits.	There must also be */
5589
	/* full precision in a. */
5590
	if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
5591
	    && (a->digits>=p)) break;
5592
	decAddOp(d, d, &numone, &dset, 0, &ignore);    /* d=d+1 */
5593
	} /* iterate */
5594

5595
      #if DECCHECK
5596
      /* just a sanity check; comment out test to show always */
5597
      if (iterations>p+3)
5598
	printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5599
	       iterations, *status, p, x->digits);
5600
      #endif
5601
      } /* h<=8 */
5602

5603
    /* apply postconditioning: a=a**(10**h) -- this is calculated */
5604
    /* at a slightly higher precision than Hull & Abrham suggest */
5605
    if (h>0) {
5606
      Int seenbit=0;		   /* set once a 1-bit is seen */
5607
      Int i;			   /* counter */
5608
      Int n=powers[h];		   /* always positive */
5609
      aset.digits=p+2;		   /* sufficient precision */
5610
      /* avoid the overhead and many extra digits of decNumberPower */
5611
      /* as all that is needed is the short 'multipliers' loop; here */
5612
      /* accumulate the answer into t */
5613
      decNumberZero(t); *t->lsu=1; /* acc=1 */
5614
      for (i=1;;i++){		   /* for each bit [top bit ignored] */
5615
	/* abandon if have had overflow or terminal underflow */
5616
	if (*status & (DEC_Overflow|DEC_Underflow)) { /* interesting? */
5617
	  if (*status&DEC_Overflow || ISZERO(t)) break;}
5618
	n=n<<1;			   /* move next bit to testable position */
5619
	if (n<0) {		   /* top bit is set */
5620
	  seenbit=1;		   /* OK, have a significant bit */
5621
	  decMultiplyOp(t, t, a, &aset, status); /* acc=acc*x */
5622
	  }
5623
	if (i==31) break;	   /* that was the last bit */
5624
	if (!seenbit) continue;	   /* no need to square 1 */
5625
	decMultiplyOp(t, t, t, &aset, status); /* acc=acc*acc [square] */
5626
	} /*i*/ /* 32 bits */
5627
      /* decNumberShow(t); */
5628
      a=t;			   /* and carry on using t instead of a */
5629
      }
5630

5631
    /* Copy and round the result to res */
5632
    residue=1;				/* indicate dirt to right .. */
5633
    if (ISZERO(a)) residue=0;		/* .. unless underflowed to 0 */
5634
    aset.digits=set->digits;		/* [use default rounding] */
5635
    decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5636
    decFinish(res, set, &residue, status);	 /* cleanup/set flags */
5637
    } while(0);				/* end protected */
5638

5639
  if (allocrhs !=NULL) free(allocrhs);	/* drop any storage used */
5640
  if (allocbufa!=NULL) free(allocbufa); /* .. */
5641
  if (allocbuft!=NULL) free(allocbuft); /* .. */
5642
  /* [status is handled by caller] */
5643
  return res;
5644
  } /* decExpOp */
5645

5646
/* ------------------------------------------------------------------ */
5647
/* Initial-estimate natural logarithm table			      */
5648
/*								      */
5649
/*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
5650
/*	     The result is a 4-digit encode of the coefficient (c=the */
5651
/*	     top 14 bits encoding 0-9999) and a 2-digit encode of the */
5652
/*	     exponent (e=the bottom 2 bits encoding 0-3)	      */
5653
/*								      */
5654
/*	     The resulting value is given by:			      */
5655
/*								      */
5656
/*	       v = -c * 10**(-e-3)				      */
5657
/*								      */
5658
/*	     where e and c are extracted from entry k = LNnn[x-10]    */
5659
/*	     where x is truncated (NB) into the range 10 through 99,  */
5660
/*	     and then c = k>>2 and e = k&3.			      */
5661
/* ------------------------------------------------------------------ */
5662
static const uShort LNnn[90] = {
5663
  9016,  8652,  8316,  8008,  7724,  7456,  7208,
5664
  6972,	 6748,	6540,  6340,  6148,  5968,  5792,  5628,  5464,	 5312,
5665
  5164,	 5020,	4884,  4748,  4620,  4496,  4376,  4256,  4144,	 4032,
5666
 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
5667
 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
5668
 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
5669
 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
5670
 10197,	 9685,	9177,  8677,  8185,  7697,  7213,  6737,  6269,	 5801,
5671
  5341,	 4889,	4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
5672
 10130,	 6046, 20055};
5673

5674
/* ------------------------------------------------------------------ */
5675
/* decLnOp -- effect natural logarithm				      */
5676
/*								      */
5677
/*   This computes C = ln(A)					      */
5678
/*								      */
5679
/*   res is C, the result.  C may be A				      */
5680
/*   rhs is A							      */
5681
/*   set is the context; note that rounding mode has no effect	      */
5682
/*								      */
5683
/* C must have space for set->digits digits.			      */
5684
/*								      */
5685
/* Notable cases:						      */
5686
/*   A<0 -> Invalid						      */
5687
/*   A=0 -> -Infinity (Exact)					      */
5688
/*   A=+Infinity -> +Infinity (Exact)				      */
5689
/*   A=1 exactly -> 0 (Exact)					      */
5690
/*								      */
5691
/* Restrictions (as for Exp):					      */
5692
/*								      */
5693
/*   digits, emax, and -emin in the context must be less than	      */
5694
/*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
5695
/*   bounds or a zero.	This is an internal routine, so these	      */
5696
/*   restrictions are contractual and not enforced.		      */
5697
/*								      */
5698
/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
5699
/* almost always be correctly rounded, but may be up to 1 ulp in      */
5700
/* error in rare cases.						      */
5701
/* ------------------------------------------------------------------ */
5702
/* The result is calculated using Newton's method, with each	      */
5703
/* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
5704
/* Epperson 1989.						      */
5705
/*								      */
5706
/* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
5707
/* This has to be calculated at the sum of the precision of x and the */
5708
/* working precision.						      */
5709
/*								      */
5710
/* Implementation notes:					      */
5711
/*								      */
5712
/* 1. This is separated out as decLnOp so it can be called from	      */
5713
/*    other Mathematical functions (e.g., Log 10) with a wider range  */
5714
/*    than normal.  In particular, it can handle the slightly wider   */
5715
/*    (+9+2) range needed by a power function.			      */
5716
/*								      */
5717
/* 2. The speed of this function is about 10x slower than exp, as     */
5718
/*    it typically needs 4-6 iterations for short numbers, and the    */
5719
/*    extra precision needed adds a squaring effect, twice.	      */
5720
/*								      */
5721
/* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
5722
/*    as these are common requests.  ln(10) is used by log10(x).      */
5723
/*								      */
5724
/* 4. An iteration might be saved by widening the LNnn table, and     */
5725
/*    would certainly save at least one if it were made ten times     */
5726
/*    bigger, too (for truncated fractions 0.100 through 0.999).      */
5727
/*    However, for most practical evaluations, at least four or five  */
5728
/*    iterations will be needed -- so this would only speed up by      */
5729
/*    20-25% and that probably does not justify increasing the table  */
5730
/*    size.							      */
5731
/*								      */
5732
/* 5. The static buffers are larger than might be expected to allow   */
5733
/*    for calls from decNumberPower.				      */
5734
/* ------------------------------------------------------------------ */
5735
static decNumber *decLnOp(decNumber *res, const decNumber *rhs,
5736
                          decContext *set, uInt *status) {
5737
  uInt ignore=0;		   /* working status accumulator */
5738
  uInt needbytes;		   /* for space calculations */
5739
  Int residue;			   /* rounding residue */
5740
  Int r;			   /* rhs=f*10**r [see below] */
5741
  Int p;			   /* working precision */
5742
  Int pp;			   /* precision for iteration */
5743
  Int t;			   /* work */
5744

5745
  /* buffers for a (accumulator, typically precision+2) and b */
5746
  /* (adjustment calculator, same size) */
5747
  decNumber bufa[D2N(DECBUFFER+12)];
5748
  decNumber *allocbufa=NULL;	   /* -> allocated bufa, iff allocated */
5749
  decNumber *a=bufa;		   /* accumulator/work */
5750
  decNumber bufb[D2N(DECBUFFER*2+2)];
5751
  decNumber *allocbufb=NULL;	   /* -> allocated bufa, iff allocated */
5752
  decNumber *b=bufb;		   /* adjustment/work */
5753

5754
  decNumber  numone;		   /* constant 1 */
5755
  decNumber  cmp;		   /* work */
5756
  decContext aset, bset;	   /* working contexts */
5757

5758
  #if DECCHECK
5759
  Int iterations=0;		   /* for later sanity check */
5760
  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
5761
  #endif
5762

5763
  do {					/* protect allocated storage */
5764
    if (SPECIALARG) {			/* handle infinities and NaNs */
5765
      if (decNumberIsInfinite(rhs)) {	/* an infinity */
5766
	if (decNumberIsNegative(rhs))	/* -Infinity -> error */
5767
	  *status|=DEC_Invalid_operation;
5768
	 else decNumberCopy(res, rhs);	/* +Infinity -> self */
5769
	}
5770
       else decNaNs(res, rhs, NULL, set, status); /* a NaN */
5771
      break;}
5772

5773
    if (ISZERO(rhs)) {			/* +/- zeros -> -Infinity */
5774
      decNumberZero(res);		/* make clean */
5775
      res->bits=DECINF|DECNEG;		/* set - infinity */
5776
      break;}				/* [no status to set] */
5777

5778
    /* Non-zero negatives are bad... */
5779
    if (decNumberIsNegative(rhs)) {	/* -x -> error */
5780
      *status|=DEC_Invalid_operation;
5781
      break;}
5782

5783
    /* Here, rhs is positive, finite, and in range */
5784

5785
    /* lookaside fastpath code for ln(2) and ln(10) at common lengths */
5786
    if (rhs->exponent==0 && set->digits<=40) {
5787
      #if DECDPUN==1
5788
      if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10) */
5789
      #else
5790
      if (rhs->lsu[0]==10 && rhs->digits==2) {			/* ln(10) */
5791
      #endif
5792
	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5793
	#define LN10 "2.302585092994045684017991454684364207601"
5794
	decNumberFromString(res, LN10, &aset);
5795
	*status|=(DEC_Inexact | DEC_Rounded); /* is inexact */
5796
	break;}
5797
      if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2) */
5798
	aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
5799
	#define LN2 "0.6931471805599453094172321214581765680755"
5800
	decNumberFromString(res, LN2, &aset);
5801
	*status|=(DEC_Inexact | DEC_Rounded);
5802
	break;}
5803
      } /* integer and short */
5804

5805
    /* Determine the working precision.	 This is normally the */
5806
    /* requested precision + 2, with a minimum of 9.  However, if */
5807
    /* the rhs is 'over-precise' then allow for all its digits to */
5808
    /* potentially participate (consider an rhs where all the excess */
5809
    /* digits are 9s) so in this case use rhs->digits+2. */
5810
    p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
5811

5812
    /* Allocate space for the accumulator and the high-precision */
5813
    /* adjustment calculator, if necessary.  The accumulator must */
5814
    /* be able to hold p digits, and the adjustment up to */
5815
    /* rhs->digits+p digits.  They are also made big enough for 16 */
5816
    /* digits so that they can be used for calculating the initial */
5817
    /* estimate. */
5818
    needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
5819
    if (needbytes>sizeof(bufa)) {     /* need malloc space */
5820
      allocbufa=(decNumber *)malloc(needbytes);
5821
      if (allocbufa==NULL) {	      /* hopeless -- abandon */
5822
	*status|=DEC_Insufficient_storage;
5823
	break;}
5824
      a=allocbufa;		      /* use the allocated space */
5825
      }
5826
    pp=p+rhs->digits;
5827
    needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
5828
    if (needbytes>sizeof(bufb)) {     /* need malloc space */
5829
      allocbufb=(decNumber *)malloc(needbytes);
5830
      if (allocbufb==NULL) {	      /* hopeless -- abandon */
5831
	*status|=DEC_Insufficient_storage;
5832
	break;}
5833
      b=allocbufb;		      /* use the allocated space */
5834
      }
5835

5836
    /* Prepare an initial estimate in acc. Calculate this by */
5837
    /* considering the coefficient of x to be a normalized fraction, */
5838
    /* f, with the decimal point at far left and multiplied by */
5839
    /* 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and */
5840
    /*	 ln(x) = ln(f) + ln(10)*r */
5841
    /* Get the initial estimate for ln(f) from a small lookup */
5842
    /* table (see above) indexed by the first two digits of f, */
5843
    /* truncated. */
5844

5845
    decContextDefault(&aset, DEC_INIT_DECIMAL64); /* 16-digit extended */
5846
    r=rhs->exponent+rhs->digits;	/* 'normalised' exponent */
5847
    decNumberFromInt32(a, r);		/* a=r */
5848
    decNumberFromInt32(b, 2302585);	/* b=ln(10) (2.302585) */
5849
    b->exponent=-6;			/*  .. */
5850
    decMultiplyOp(a, a, b, &aset, &ignore);  /* a=a*b */
5851
    /* now get top two digits of rhs into b by simple truncate and */
5852
    /* force to integer */
5853
    residue=0;				/* (no residue) */
5854
    aset.digits=2; aset.round=DEC_ROUND_DOWN;
5855
    decCopyFit(b, rhs, &aset, &residue, &ignore); /* copy & shorten */
5856
    b->exponent=0;			/* make integer */
5857
    t=decGetInt(b);			/* [cannot fail] */
5858
    if (t<10) t=X10(t);			/* adjust single-digit b */
5859
    t=LNnn[t-10];			/* look up ln(b) */
5860
    decNumberFromInt32(b, t>>2);	/* b=ln(b) coefficient */
5861
    b->exponent=-(t&3)-3;		/* set exponent */
5862
    b->bits=DECNEG;			/* ln(0.10)->ln(0.99) always -ve */
5863
    aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; /* restore */
5864
    decAddOp(a, a, b, &aset, 0, &ignore); /* acc=a+b */
5865
    /* the initial estimate is now in a, with up to 4 digits correct. */
5866
    /* When rhs is at or near Nmax the estimate will be low, so we */
5867
    /* will approach it from below, avoiding overflow when calling exp. */
5868

5869
    decNumberZero(&numone); *numone.lsu=1;   /* constant 1 for adjustment */
5870

5871
    /* accumulator bounds are as requested (could underflow, but */
5872
    /* cannot overflow) */
5873
    aset.emax=set->emax;
5874
    aset.emin=set->emin;
5875
    aset.clamp=0;			/* no concrete format */
5876
    /* set up a context to be used for the multiply and subtract */
5877
    bset=aset;
5878
    bset.emax=DEC_MAX_MATH*2;		/* use double bounds for the */
5879
    bset.emin=-DEC_MAX_MATH*2;		/* adjustment calculation */
5880
					/* [see decExpOp call below] */
5881
    /* for each iteration double the number of digits to calculate, */
5882
    /* up to a maximum of p */
5883
    pp=9;				/* initial precision */
5884
    /* [initially 9 as then the sequence starts 7+2, 16+2, and */
5885
    /* 34+2, which is ideal for standard-sized numbers] */
5886
    aset.digits=pp;			/* working context */
5887
    bset.digits=pp+rhs->digits;		/* wider context */
5888
    for (;;) {				/* iterate */
5889
      #if DECCHECK
5890
      iterations++;
5891
      if (iterations>24) break;		/* consider 9 * 2**24 */
5892
      #endif
5893
      /* calculate the adjustment (exp(-a)*x-1) into b.	 This is a */
5894
      /* catastrophic subtraction but it really is the difference */
5895
      /* from 1 that is of interest. */
5896
      /* Use the internal entry point to Exp as it allows the double */
5897
      /* range for calculating exp(-a) when a is the tiniest subnormal. */
5898
      a->bits^=DECNEG;			/* make -a */
5899
      decExpOp(b, a, &bset, &ignore);	/* b=exp(-a) */
5900
      a->bits^=DECNEG;			/* restore sign of a */
5901
      /* now multiply by rhs and subtract 1, at the wider precision */
5902
      decMultiplyOp(b, b, rhs, &bset, &ignore);	       /* b=b*rhs */
5903
      decAddOp(b, b, &numone, &bset, DECNEG, &ignore); /* b=b-1 */
5904

5905
      /* the iteration ends when the adjustment cannot affect the */
5906
      /* result by >=0.5 ulp (at the requested digits), which */
5907
      /* is when its value is smaller than the accumulator by */
5908
      /* set->digits+1 digits (or it is zero) -- this is a looser */
5909
      /* requirement than for Exp because all that happens to the */
5910
      /* accumulator after this is the final rounding (but note that */
5911
      /* there must also be full precision in a, or a=0). */
5912

5913
      if (decNumberIsZero(b) ||
5914
	  (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
5915
	if (a->digits==p) break;
5916
	if (decNumberIsZero(a)) {
5917
	  decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); /* rhs=1 ? */
5918
	  if (cmp.lsu[0]==0) a->exponent=0;	       /* yes, exact 0 */
5919
	   else *status|=(DEC_Inexact | DEC_Rounded);  /* no, inexact */
5920
	  break;
5921
	  }
5922
	/* force padding if adjustment has gone to 0 before full length */
5923
	if (decNumberIsZero(b)) b->exponent=a->exponent-p;
5924
	}
5925

5926
      /* not done yet ... */
5927
      decAddOp(a, a, b, &aset, 0, &ignore);  /* a=a+b for next estimate */
5928
      if (pp==p) continue;		     /* precision is at maximum */
5929
      /* lengthen the next calculation */
5930
      pp=pp*2;				     /* double precision */
5931
      if (pp>p) pp=p;			     /* clamp to maximum */
5932
      aset.digits=pp;			     /* working context */
5933
      bset.digits=pp+rhs->digits;	     /* wider context */
5934
      } /* Newton's iteration */
5935

5936
    #if DECCHECK
5937
    /* just a sanity check; remove the test to show always */
5938
    if (iterations>24)
5939
      printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
5940
	    iterations, *status, p, rhs->digits);
5941
    #endif
5942

5943
    /* Copy and round the result to res */
5944
    residue=1;				/* indicate dirt to right */
5945
    if (ISZERO(a)) residue=0;		/* .. unless underflowed to 0 */
5946
    aset.digits=set->digits;		/* [use default rounding] */
5947
    decCopyFit(res, a, &aset, &residue, status); /* copy & shorten */
5948
    decFinish(res, set, &residue, status);	 /* cleanup/set flags */
5949
    } while(0);				/* end protected */
5950

5951
  if (allocbufa!=NULL) free(allocbufa); /* drop any storage used */
5952
  if (allocbufb!=NULL) free(allocbufb); /* .. */
5953
  /* [status is handled by caller] */
5954
  return res;
5955
  } /* decLnOp */
5956

5957
/* ------------------------------------------------------------------ */
5958
/* decQuantizeOp  -- force exponent to requested value		      */
5959
/*								      */
5960
/*   This computes C = op(A, B), where op adjusts the coefficient     */
5961
/*   of C (by rounding or shifting) such that the exponent (-scale)   */
5962
/*   of C has the value B or matches the exponent of B.		      */
5963
/*   The numerical value of C will equal A, except for the effects of */
5964
/*   any rounding that occurred.				      */
5965
/*								      */
5966
/*   res is C, the result.  C may be A or B			      */
5967
/*   lhs is A, the number to adjust				      */
5968
/*   rhs is B, the requested exponent				      */
5969
/*   set is the context						      */
5970
/*   quant is 1 for quantize or 0 for rescale			      */
5971
/*   status is the status accumulator (this can be called without     */
5972
/*	    risk of control loss)				      */
5973
/*								      */
5974
/* C must have space for set->digits digits.			      */
5975
/*								      */
5976
/* Unless there is an error or the result is infinite, the exponent   */
5977
/* after the operation is guaranteed to be that requested.	      */
5978
/* ------------------------------------------------------------------ */
5979
static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
5980
				 const decNumber *rhs, decContext *set,
5981
				 Flag quant, uInt *status) {
5982
  #if DECSUBSET
5983
  decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
5984
  decNumber *allocrhs=NULL;	   /* .., rhs */
5985
  #endif
5986
  const decNumber *inrhs=rhs;	   /* save original rhs */
5987
  Int	reqdigits=set->digits;	   /* requested DIGITS */
5988
  Int	reqexp;			   /* requested exponent [-scale] */
5989
  Int	residue=0;		   /* rounding residue */
5990
  Int	etiny=set->emin-(reqdigits-1);
5991

5992
  #if DECCHECK
5993
  if (decCheckOperands(res, lhs, rhs, set)) return res;
5994
  #endif
5995

5996
  do {				   /* protect allocated storage */
5997
    #if DECSUBSET
5998
    if (!set->extended) {
5999
      /* reduce operands and set lostDigits status, as needed */
6000
      if (lhs->digits>reqdigits) {
6001
	alloclhs=decRoundOperand(lhs, set, status);
6002
	if (alloclhs==NULL) break;
6003
	lhs=alloclhs;
6004
	}
6005
      if (rhs->digits>reqdigits) { /* [this only checks lostDigits] */
6006
	allocrhs=decRoundOperand(rhs, set, status);
6007
	if (allocrhs==NULL) break;
6008
	rhs=allocrhs;
6009
	}
6010
      }
6011
    #endif
6012
    /* [following code does not require input rounding] */
6013

6014
    /* Handle special values */
6015
    if (SPECIALARGS) {
6016
      /* NaNs get usual processing */
6017
      if (SPECIALARGS & (DECSNAN | DECNAN))
6018
	decNaNs(res, lhs, rhs, set, status);
6019
      /* one infinity but not both is bad */
6020
      else if ((lhs->bits ^ rhs->bits) & DECINF)
6021
	*status|=DEC_Invalid_operation;
6022
      /* both infinity: return lhs */
6023
      else decNumberCopy(res, lhs);	     /* [nop if in place] */
6024
      break;
6025
      }
6026

6027
    /* set requested exponent */
6028
    if (quant) reqexp=inrhs->exponent;	/* quantize -- match exponents */
6029
     else {				/* rescale -- use value of rhs */
6030
      /* Original rhs must be an integer that fits and is in range, */
6031
      /* which could be from -1999999997 to +999999999, thanks to */
6032
      /* subnormals */
6033
      reqexp=decGetInt(inrhs);		     /* [cannot fail] */
6034
      }
6035

6036
    #if DECSUBSET
6037
    if (!set->extended) etiny=set->emin;     /* no subnormals */
6038
    #endif
6039

6040
    if (reqexp==BADINT			     /* bad (rescale only) or .. */
6041
     || reqexp==BIGODD || reqexp==BIGEVEN    /* very big (ditto) or .. */
6042
     || (reqexp<etiny)			     /* < lowest */
6043
     || (reqexp>set->emax)) {		     /* > emax */
6044
      *status|=DEC_Invalid_operation;
6045
      break;}
6046

6047
    /* the RHS has been processed, so it can be overwritten now if necessary */
6048
    if (ISZERO(lhs)) {			     /* zero coefficient unchanged */
6049
      decNumberCopy(res, lhs);		     /* [nop if in place] */
6050
      res->exponent=reqexp;		     /* .. just set exponent */
6051
      #if DECSUBSET
6052
      if (!set->extended) res->bits=0;	     /* subset specification; no -0 */
6053
      #endif
6054
      }
6055
     else {				     /* non-zero lhs */
6056
      Int adjust=reqexp-lhs->exponent;	     /* digit adjustment needed */
6057
      /* if adjusted coefficient will definitely not fit, give up now */
6058
      if ((lhs->digits-adjust)>reqdigits) {
6059
	*status|=DEC_Invalid_operation;
6060
	break;
6061
	}
6062

6063
      if (adjust>0) {			     /* increasing exponent */
6064
	/* this will decrease the length of the coefficient by adjust */
6065
	/* digits, and must round as it does so */
6066
	decContext workset;		     /* work */
6067
	workset=*set;			     /* clone rounding, etc. */
6068
	workset.digits=lhs->digits-adjust;   /* set requested length */
6069
	/* [note that the latter can be <1, here] */
6070
	decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
6071
	decApplyRound(res, &workset, residue, status);	  /* .. and round */
6072
	residue=0;					  /* [used] */
6073
	/* If just rounded a 999s case, exponent will be off by one; */
6074
	/* adjust back (after checking space), if so. */
6075
	if (res->exponent>reqexp) {
6076
	  /* re-check needed, e.g., for quantize(0.9999, 0.001) under */
6077
	  /* set->digits==3 */
6078
	  if (res->digits==reqdigits) {	     /* cannot shift by 1 */
6079
	    *status&=~(DEC_Inexact | DEC_Rounded); /* [clean these] */
6080
	    *status|=DEC_Invalid_operation;
6081
	    break;
6082
	    }
6083
	  res->digits=decShiftToMost(res->lsu, res->digits, 1); /* shift */
6084
	  res->exponent--;		     /* (re)adjust the exponent. */
6085
	  }
6086
	#if DECSUBSET
6087
	if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
6088
	#endif
6089
	} /* increase */
6090
       else /* adjust<=0 */ {		     /* decreasing or = exponent */
6091
	/* this will increase the length of the coefficient by -adjust */
6092
	/* digits, by adding zero or more trailing zeros; this is */
6093
	/* already checked for fit, above */
6094
	decNumberCopy(res, lhs);	     /* [it will fit] */
6095
	/* if padding needed (adjust<0), add it now... */
6096
	if (adjust<0) {
6097
	  res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
6098
	  res->exponent+=adjust;	     /* adjust the exponent */
6099
	  }
6100
	} /* decrease */
6101
      } /* non-zero */
6102

6103
    /* Check for overflow [do not use Finalize in this case, as an */
6104
    /* overflow here is a "don't fit" situation] */
6105
    if (res->exponent>set->emax-res->digits+1) {  /* too big */
6106
      *status|=DEC_Invalid_operation;
6107
      break;
6108
      }
6109
     else {
6110
      decFinalize(res, set, &residue, status);	  /* set subnormal flags */
6111
      *status&=~DEC_Underflow;		/* suppress Underflow [754r] */
6112
      }
6113
    } while(0);				/* end protected */
6114

6115
  #if DECSUBSET
6116
  if (allocrhs!=NULL) free(allocrhs);	/* drop any storage used */
6117
  if (alloclhs!=NULL) free(alloclhs);	/* .. */
6118
  #endif
6119
  return res;
6120
  } /* decQuantizeOp */
6121

6122
/* ------------------------------------------------------------------ */
6123
/* decCompareOp -- compare, min, or max two Numbers		      */
6124
/*								      */
6125
/*   This computes C = A ? B and carries out one of four operations:  */
6126
/*     COMPARE	  -- returns the signum (as a number) giving the      */
6127
/*		     result of a comparison unless one or both	      */
6128
/*		     operands is a NaN (in which case a NaN results)  */
6129
/*     COMPSIG	  -- as COMPARE except that a quiet NaN raises	      */
6130
/*		     Invalid operation.				      */
6131
/*     COMPMAX	  -- returns the larger of the operands, using the    */
6132
/*		     754r maxnum operation			      */
6133
/*     COMPMAXMAG -- ditto, comparing absolute values		      */
6134
/*     COMPMIN	  -- the 754r minnum operation			      */
6135
/*     COMPMINMAG -- ditto, comparing absolute values		      */
6136
/*     COMTOTAL	  -- returns the signum (as a number) giving the      */
6137
/*		     result of a comparison using 754r total ordering */
6138
/*								      */
6139
/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)	      */
6140
/*   lhs is A							      */
6141
/*   rhs is B							      */
6142
/*   set is the context						      */
6143
/*   op	 is the operation flag					      */
6144
/*   status is the usual accumulator				      */
6145
/*								      */
6146
/* C must have space for one digit for COMPARE or set->digits for     */
6147
/* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG.			      */
6148
/* ------------------------------------------------------------------ */
6149
/* The emphasis here is on speed for common cases, and avoiding	      */
6150
/* coefficient comparison if possible.				      */
6151
/* ------------------------------------------------------------------ */
6152
static decNumber *decCompareOp(decNumber *res, const decNumber *lhs,
6153
                               const decNumber *rhs, decContext *set,
6154
                               Flag op, uInt *status) {
6155
  #if DECSUBSET
6156
  decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
6157
  decNumber *allocrhs=NULL;	   /* .., rhs */
6158
  #endif
6159
  Int	result=0;		   /* default result value */
6160
  uByte merged;			   /* work */
6161

6162
  #if DECCHECK
6163
  if (decCheckOperands(res, lhs, rhs, set)) return res;
6164
  #endif
6165

6166
  do {				   /* protect allocated storage */
6167
    #if DECSUBSET
6168
    if (!set->extended) {
6169
      /* reduce operands and set lostDigits status, as needed */
6170
      if (lhs->digits>set->digits) {
6171
	alloclhs=decRoundOperand(lhs, set, status);
6172
	if (alloclhs==NULL) {result=BADINT; break;}
6173
	lhs=alloclhs;
6174
	}
6175
      if (rhs->digits>set->digits) {
6176
	allocrhs=decRoundOperand(rhs, set, status);
6177
	if (allocrhs==NULL) {result=BADINT; break;}
6178
	rhs=allocrhs;
6179
	}
6180
      }
6181
    #endif
6182
    /* [following code does not require input rounding] */
6183

6184
    /* If total ordering then handle differing signs 'up front' */
6185
    if (op==COMPTOTAL) {		/* total ordering */
6186
      if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6187
	result=-1;
6188
	break;
6189
	}
6190
      if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6191
	result=+1;
6192
	break;
6193
	}
6194
      }
6195

6196
    /* handle NaNs specially; let infinities drop through */
6197
    /* This assumes sNaN (even just one) leads to NaN. */
6198
    merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6199
    if (merged) {			/* a NaN bit set */
6200
      if (op==COMPARE);			/* result will be NaN */
6201
       else if (op==COMPSIG)		/* treat qNaN as sNaN */
6202
	*status|=DEC_Invalid_operation | DEC_sNaN;
6203
       else if (op==COMPTOTAL) {	/* total ordering, always finite */
6204
	/* signs are known to be the same; compute the ordering here */
6205
	/* as if the signs are both positive, then invert for negatives */
6206
	if (!decNumberIsNaN(lhs)) result=-1;
6207
	 else if (!decNumberIsNaN(rhs)) result=+1;
6208
	 /* here if both NaNs */
6209
	 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6210
	 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6211
	 else { /* both NaN or both sNaN */
6212
	  /* now it just depends on the payload */
6213
	  result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6214
				rhs->lsu, D2U(rhs->digits), 0);
6215
	  /* [Error not possible, as these are 'aligned'] */
6216
	  } /* both same NaNs */
6217
	if (decNumberIsNegative(lhs)) result=-result;
6218
	break;
6219
	} /* total order */
6220

6221
       else if (merged & DECSNAN);	     /* sNaN -> qNaN */
6222
       else { /* here if MIN or MAX and one or two quiet NaNs */
6223
	/* min or max -- 754r rules ignore single NaN */
6224
	if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6225
	  /* just one NaN; force choice to be the non-NaN operand */
6226
	  op=COMPMAX;
6227
	  if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6228
			     else result=+1; /* pick lhs */
6229
	  break;
6230
	  }
6231
	} /* max or min */
6232
      op=COMPNAN;			     /* use special path */
6233
      decNaNs(res, lhs, rhs, set, status);   /* propagate NaN */
6234
      break;
6235
      }
6236
    /* have numbers */
6237
    if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6238
     else result=decCompare(lhs, rhs, 0);    /* sign matters */
6239
    } while(0);				     /* end protected */
6240

6241
  if (result==BADINT) *status|=DEC_Insufficient_storage; /* rare */
6242
   else {
6243
    if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { /* returning signum */
6244
      if (op==COMPTOTAL && result==0) {
6245
	/* operands are numerically equal or same NaN (and same sign, */
6246
	/* tested first); if identical, leave result 0 */
6247
	if (lhs->exponent!=rhs->exponent) {
6248
	  if (lhs->exponent<rhs->exponent) result=-1;
6249
	   else result=+1;
6250
	  if (decNumberIsNegative(lhs)) result=-result;
6251
	  } /* lexp!=rexp */
6252
	} /* total-order by exponent */
6253
      decNumberZero(res);		/* [always a valid result] */
6254
      if (result!=0) {			/* must be -1 or +1 */
6255
	*res->lsu=1;
6256
	if (result<0) res->bits=DECNEG;
6257
	}
6258
      }
6259
     else if (op==COMPNAN);		/* special, drop through */
6260
     else {				/* MAX or MIN, non-NaN result */
6261
      Int residue=0;			/* rounding accumulator */
6262
      /* choose the operand for the result */
6263
      const decNumber *choice;
6264
      if (result==0) { /* operands are numerically equal */
6265
	/* choose according to sign then exponent (see 754r) */
6266
	uByte slhs=(lhs->bits & DECNEG);
6267
	uByte srhs=(rhs->bits & DECNEG);
6268
	#if DECSUBSET
6269
	if (!set->extended) {		/* subset: force left-hand */
6270
	  op=COMPMAX;
6271
	  result=+1;
6272
	  }
6273
	else
6274
	#endif
6275
	if (slhs!=srhs) {	   /* signs differ */
6276
	  if (slhs) result=-1;	   /* rhs is max */
6277
	       else result=+1;	   /* lhs is max */
6278
	  }
6279
	 else if (slhs && srhs) {  /* both negative */
6280
	  if (lhs->exponent<rhs->exponent) result=+1;
6281
				      else result=-1;
6282
	  /* [if equal, use lhs, technically identical] */
6283
	  }
6284
	 else {			   /* both positive */
6285
	  if (lhs->exponent>rhs->exponent) result=+1;
6286
				      else result=-1;
6287
	  /* [ditto] */
6288
	  }
6289
	} /* numerically equal */
6290
      /* here result will be non-0; reverse if looking for MIN */
6291
      if (op==COMPMIN || op==COMPMINMAG) result=-result;
6292
      choice=(result>0 ? lhs : rhs);	/* choose */
6293
      /* copy chosen to result, rounding if need be */
6294
      decCopyFit(res, choice, set, &residue, status);
6295
      decFinish(res, set, &residue, status);
6296
      }
6297
    }
6298
  #if DECSUBSET
6299
  if (allocrhs!=NULL) free(allocrhs);	/* free any storage used */
6300
  if (alloclhs!=NULL) free(alloclhs);	/* .. */
6301
  #endif
6302
  return res;
6303
  } /* decCompareOp */
6304

6305
/* ------------------------------------------------------------------ */
6306
/* decCompare -- compare two decNumbers by numerical value	      */
6307
/*								      */
6308
/*  This routine compares A ? B without altering them.		      */
6309
/*								      */
6310
/*  Arg1 is A, a decNumber which is not a NaN			      */
6311
/*  Arg2 is B, a decNumber which is not a NaN			      */
6312
/*  Arg3 is 1 for a sign-independent compare, 0 otherwise	      */
6313
/*								      */
6314
/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6315
/*  (the only possible failure is an allocation error)		      */
6316
/* ------------------------------------------------------------------ */
6317
static Int decCompare(const decNumber *lhs, const decNumber *rhs,
6318
		      Flag abs) {
6319
  Int	result;			   /* result value */
6320
  Int	sigr;			   /* rhs signum */
6321
  Int	compare;		   /* work */
6322

6323
  result=1;				     /* assume signum(lhs) */
6324
  if (ISZERO(lhs)) result=0;
6325
  if (abs) {
6326
    if (ISZERO(rhs)) return result;	     /* LHS wins or both 0 */
6327
    /* RHS is non-zero */
6328
    if (result==0) return -1;		     /* LHS is 0; RHS wins */
6329
    /* [here, both non-zero, result=1] */
6330
    }
6331
   else {				     /* signs matter */
6332
    if (result && decNumberIsNegative(lhs)) result=-1;
6333
    sigr=1;				     /* compute signum(rhs) */
6334
    if (ISZERO(rhs)) sigr=0;
6335
     else if (decNumberIsNegative(rhs)) sigr=-1;
6336
    if (result > sigr) return +1;	     /* L > R, return 1 */
6337
    if (result < sigr) return -1;	     /* L < R, return -1 */
6338
    if (result==0) return 0;		       /* both 0 */
6339
    }
6340

6341
  /* signums are the same; both are non-zero */
6342
  if ((lhs->bits | rhs->bits) & DECINF) {    /* one or more infinities */
6343
    if (decNumberIsInfinite(rhs)) {
6344
      if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6345
       else result=-result;		     /* only rhs infinite */
6346
      }
6347
    return result;
6348
    }
6349
  /* must compare the coefficients, allowing for exponents */
6350
  if (lhs->exponent>rhs->exponent) {	     /* LHS exponent larger */
6351
    /* swap sides, and sign */
6352
    const decNumber *temp=lhs;
6353
    lhs=rhs;
6354
    rhs=temp;
6355
    result=-result;
6356
    }
6357
  compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6358
			 rhs->lsu, D2U(rhs->digits),
6359
			 rhs->exponent-lhs->exponent);
6360
  if (compare!=BADINT) compare*=result;	     /* comparison succeeded */
6361
  return compare;
6362
  } /* decCompare */
6363

6364
/* ------------------------------------------------------------------ */
6365
/* decUnitCompare -- compare two >=0 integers in Unit arrays	      */
6366
/*								      */
6367
/*  This routine compares A ? B*10**E where A and B are unit arrays   */
6368
/*  A is a plain integer					      */
6369
/*  B has an exponent of E (which must be non-negative)		      */
6370
/*								      */
6371
/*  Arg1 is A first Unit (lsu)					      */
6372
/*  Arg2 is A length in Units					      */
6373
/*  Arg3 is B first Unit (lsu)					      */
6374
/*  Arg4 is B length in Units					      */
6375
/*  Arg5 is E (0 if the units are aligned)			      */
6376
/*								      */
6377
/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
6378
/*  (the only possible failure is an allocation error, which can      */
6379
/*  only occur if E!=0)						      */
6380
/* ------------------------------------------------------------------ */
6381
static Int decUnitCompare(const Unit *a, Int alength,
6382
			  const Unit *b, Int blength, Int exp) {
6383
  Unit	*acc;			   /* accumulator for result */
6384
  Unit	accbuff[SD2U(DECBUFFER*2+1)]; /* local buffer */
6385
  Unit	*allocacc=NULL;		   /* -> allocated acc buffer, iff allocated */
6386
  Int	accunits, need;		   /* units in use or needed for acc */
6387
  const Unit *l, *r, *u;	   /* work */
6388
  Int	expunits, exprem, result;  /* .. */
6389

6390
  if (exp==0) {			   /* aligned; fastpath */
6391
    if (alength>blength) return 1;
6392
    if (alength<blength) return -1;
6393
    /* same number of units in both -- need unit-by-unit compare */
6394
    l=a+alength-1;
6395
    r=b+alength-1;
6396
    for (;l>=a; l--, r--) {
6397
      if (*l>*r) return 1;
6398
      if (*l<*r) return -1;
6399
      }
6400
    return 0;			   /* all units match */
6401
    } /* aligned */
6402

6403
  /* Unaligned.	 If one is >1 unit longer than the other, padded */
6404
  /* approximately, then can return easily */
6405
  if (alength>blength+(Int)D2U(exp)) return 1;
6406
  if (alength+1<blength+(Int)D2U(exp)) return -1;
6407

6408
  /* Need to do a real subtract.  For this, a result buffer is needed */
6409
  /* even though only the sign is of interest.	Its length needs */
6410
  /* to be the larger of alength and padded blength, +2 */
6411
  need=blength+D2U(exp);		/* maximum real length of B */
6412
  if (need<alength) need=alength;
6413
  need+=2;
6414
  acc=accbuff;				/* assume use local buffer */
6415
  if (need*sizeof(Unit)>sizeof(accbuff)) {
6416
    allocacc=(Unit *)malloc(need*sizeof(Unit));
6417
    if (allocacc==NULL) return BADINT;	/* hopeless -- abandon */
6418
    acc=allocacc;
6419
    }
6420
  /* Calculate units and remainder from exponent. */
6421
  expunits=exp/DECDPUN;
6422
  exprem=exp%DECDPUN;
6423
  /* subtract [A+B*(-m)] */
6424
  accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
6425
			 -(Int)powers[exprem]);
6426
  /* [UnitAddSub result may have leading zeros, even on zero] */
6427
  if (accunits<0) result=-1;		/* negative result */
6428
   else {				/* non-negative result */
6429
    /* check units of the result before freeing any storage */
6430
    for (u=acc; u<acc+accunits-1 && *u==0;) u++;
6431
    result=(*u==0 ? 0 : +1);
6432
    }
6433
  /* clean up and return the result */
6434
  if (allocacc!=NULL) free(allocacc);	/* drop any storage used */
6435
  return result;
6436
  } /* decUnitCompare */
6437

6438
/* ------------------------------------------------------------------ */
6439
/* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
6440
/*								      */
6441
/*  This routine performs the calculation:			      */
6442
/*								      */
6443
/*  C=A+(B*M)							      */
6444
/*								      */
6445
/*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.	      */
6446
/*								      */
6447
/*  A may be shorter or longer than B.				      */
6448
/*								      */
6449
/*  Leading zeros are not removed after a calculation.	The result is */
6450
/*  either the same length as the longer of A and B (adding any	      */
6451
/*  shift), or one Unit longer than that (if a Unit carry occurred).  */
6452
/*								      */
6453
/*  A and B content are not altered unless C is also A or B.	      */
6454
/*  C may be the same array as A or B, but only if no zero padding is */
6455
/*  requested (that is, C may be B only if bshift==0).		      */
6456
/*  C is filled from the lsu; only those units necessary to complete  */
6457
/*  the calculation are referenced.				      */
6458
/*								      */
6459
/*  Arg1 is A first Unit (lsu)					      */
6460
/*  Arg2 is A length in Units					      */
6461
/*  Arg3 is B first Unit (lsu)					      */
6462
/*  Arg4 is B length in Units					      */
6463
/*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
6464
/*  Arg6 is C first Unit (lsu)					      */
6465
/*  Arg7 is M, the multiplier					      */
6466
/*								      */
6467
/*  returns the count of Units written to C, which will be non-zero   */
6468
/*  and negated if the result is negative.  That is, the sign of the  */
6469
/*  returned Int is the sign of the result (positive for zero) and    */
6470
/*  the absolute value of the Int is the count of Units.	      */
6471
/*								      */
6472
/*  It is the caller's responsibility to make sure that C size is     */
6473
/*  safe, allowing space if necessary for a one-Unit carry.	      */
6474
/*								      */
6475
/*  This routine is severely performance-critical; *any* change here  */
6476
/*  must be measured (timed) to assure no performance degradation.    */
6477
/*  In particular, trickery here tends to be counter-productive, as   */
6478
/*  increased complexity of code hurts register optimizations on      */
6479
/*  register-poor architectures.  Avoiding divisions is nearly	      */
6480
/*  always a Good Idea, however.				      */
6481
/*								      */
6482
/* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
6483
/* (IBM Warwick, UK) for some of the ideas used in this routine.      */
6484
/* ------------------------------------------------------------------ */
6485
static Int decUnitAddSub(const Unit *a, Int alength,
6486
			 const Unit *b, Int blength, Int bshift,
6487
			 Unit *c, Int m) {
6488
  const Unit *alsu=a;		   /* A lsu [need to remember it] */
6489
  Unit *clsu=c;			   /* C ditto */
6490
  Unit *minC;			   /* low water mark for C */
6491
  Unit *maxC;			   /* high water mark for C */
6492
  eInt carry=0;			   /* carry integer (could be Long) */
6493
  Int  add;			   /* work */
6494
  #if DECDPUN<=4		   /* myriadal, millenary, etc. */
6495
  Int  est;			   /* estimated quotient */
6496
  #endif
6497

6498
  #if DECTRACE
6499
  if (alength<1 || blength<1)
6500
    printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
6501
  #endif
6502

6503
  maxC=c+alength;		   /* A is usually the longer */
6504
  minC=c+blength;		   /* .. and B the shorter */
6505
  if (bshift!=0) {		   /* B is shifted; low As copy across */
6506
    minC+=bshift;
6507
    /* if in place [common], skip copy unless there's a gap [rare] */
6508
    if (a==c && bshift<=alength) {
6509
      c+=bshift;
6510
      a+=bshift;
6511
      }
6512
     else for (; c<clsu+bshift; a++, c++) {  /* copy needed */
6513
      if (a<alsu+alength) *c=*a;
6514
       else *c=0;
6515
      }
6516
    }
6517
  if (minC>maxC) { /* swap */
6518
    Unit *hold=minC;
6519
    minC=maxC;
6520
    maxC=hold;
6521
    }
6522

6523
  /* For speed, do the addition as two loops; the first where both A */
6524
  /* and B contribute, and the second (if necessary) where only one or */
6525
  /* other of the numbers contribute. */
6526
  /* Carry handling is the same (i.e., duplicated) in each case. */
6527
  for (; c<minC; c++) {
6528
    carry+=*a;
6529
    a++;
6530
    carry+=((eInt)*b)*m;		/* [special-casing m=1/-1 */
6531
    b++;				/* here is not a win] */
6532
    /* here carry is new Unit of digits; it could be +ve or -ve */
6533
    if ((ueInt)carry<=DECDPUNMAX) {	/* fastpath 0-DECDPUNMAX */
6534
      *c=(Unit)carry;
6535
      carry=0;
6536
      continue;
6537
      }
6538
    #if DECDPUN==4			     /* use divide-by-multiply */
6539
      if (carry>=0) {
6540
	est=(((ueInt)carry>>11)*53687)>>18;
6541
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6542
	carry=est;			     /* likely quotient [89%] */
6543
	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6544
	carry++;
6545
	*c-=DECDPUNMAX+1;
6546
	continue;
6547
	}
6548
      /* negative case */
6549
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6550
      est=(((ueInt)carry>>11)*53687)>>18;
6551
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6552
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6553
      if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6554
      carry++;
6555
      *c-=DECDPUNMAX+1;
6556
    #elif DECDPUN==3
6557
      if (carry>=0) {
6558
	est=(((ueInt)carry>>3)*16777)>>21;
6559
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6560
	carry=est;			     /* likely quotient [99%] */
6561
	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6562
	carry++;
6563
	*c-=DECDPUNMAX+1;
6564
	continue;
6565
	}
6566
      /* negative case */
6567
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6568
      est=(((ueInt)carry>>3)*16777)>>21;
6569
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6570
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6571
      if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6572
      carry++;
6573
      *c-=DECDPUNMAX+1;
6574
    #elif DECDPUN<=2
6575
      /* Can use QUOT10 as carry <= 4 digits */
6576
      if (carry>=0) {
6577
	est=QUOT10(carry, DECDPUN);
6578
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6579
	carry=est;			     /* quotient */
6580
	continue;
6581
	}
6582
      /* negative case */
6583
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6584
      est=QUOT10(carry, DECDPUN);
6585
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6586
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6587
    #else
6588
      /* remainder operator is undefined if negative, so must test */
6589
      if ((ueInt)carry<(DECDPUNMAX+1)*2) {   /* fastpath carry +1 */
6590
	*c=(Unit)(carry-(DECDPUNMAX+1));     /* [helps additions] */
6591
	carry=1;
6592
	continue;
6593
	}
6594
      if (carry>=0) {
6595
	*c=(Unit)(carry%(DECDPUNMAX+1));
6596
	carry=carry/(DECDPUNMAX+1);
6597
	continue;
6598
	}
6599
      /* negative case */
6600
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6601
      *c=(Unit)(carry%(DECDPUNMAX+1));
6602
      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6603
    #endif
6604
    } /* c */
6605

6606
  /* now may have one or other to complete */
6607
  /* [pretest to avoid loop setup/shutdown] */
6608
  if (c<maxC) for (; c<maxC; c++) {
6609
    if (a<alsu+alength) {		/* still in A */
6610
      carry+=*a;
6611
      a++;
6612
      }
6613
     else {				/* inside B */
6614
      carry+=((eInt)*b)*m;
6615
      b++;
6616
      }
6617
    /* here carry is new Unit of digits; it could be +ve or -ve and */
6618
    /* magnitude up to DECDPUNMAX squared */
6619
    if ((ueInt)carry<=DECDPUNMAX) {	/* fastpath 0-DECDPUNMAX */
6620
      *c=(Unit)carry;
6621
      carry=0;
6622
      continue;
6623
      }
6624
    /* result for this unit is negative or >DECDPUNMAX */
6625
    #if DECDPUN==4			     /* use divide-by-multiply */
6626
      if (carry>=0) {
6627
	est=(((ueInt)carry>>11)*53687)>>18;
6628
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6629
	carry=est;			     /* likely quotient [79.7%] */
6630
	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6631
	carry++;
6632
	*c-=DECDPUNMAX+1;
6633
	continue;
6634
	}
6635
      /* negative case */
6636
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6637
      est=(((ueInt)carry>>11)*53687)>>18;
6638
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6639
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6640
      if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6641
      carry++;
6642
      *c-=DECDPUNMAX+1;
6643
    #elif DECDPUN==3
6644
      if (carry>=0) {
6645
	est=(((ueInt)carry>>3)*16777)>>21;
6646
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6647
	carry=est;			     /* likely quotient [99%] */
6648
	if (*c<DECDPUNMAX+1) continue;	     /* estimate was correct */
6649
	carry++;
6650
	*c-=DECDPUNMAX+1;
6651
	continue;
6652
	}
6653
      /* negative case */
6654
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6655
      est=(((ueInt)carry>>3)*16777)>>21;
6656
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6657
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6658
      if (*c<DECDPUNMAX+1) continue;	     /* was OK */
6659
      carry++;
6660
      *c-=DECDPUNMAX+1;
6661
    #elif DECDPUN<=2
6662
      if (carry>=0) {
6663
	est=QUOT10(carry, DECDPUN);
6664
	*c=(Unit)(carry-est*(DECDPUNMAX+1)); /* remainder */
6665
	carry=est;			     /* quotient */
6666
	continue;
6667
	}
6668
      /* negative case */
6669
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6670
      est=QUOT10(carry, DECDPUN);
6671
      *c=(Unit)(carry-est*(DECDPUNMAX+1));
6672
      carry=est-(DECDPUNMAX+1);		     /* correctly negative */
6673
    #else
6674
      if ((ueInt)carry<(DECDPUNMAX+1)*2){    /* fastpath carry 1 */
6675
	*c=(Unit)(carry-(DECDPUNMAX+1));
6676
	carry=1;
6677
	continue;
6678
	}
6679
      /* remainder operator is undefined if negative, so must test */
6680
      if (carry>=0) {
6681
	*c=(Unit)(carry%(DECDPUNMAX+1));
6682
	carry=carry/(DECDPUNMAX+1);
6683
	continue;
6684
	}
6685
      /* negative case */
6686
      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); /* make positive */
6687
      *c=(Unit)(carry%(DECDPUNMAX+1));
6688
      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
6689
    #endif
6690
    } /* c */
6691

6692
  /* OK, all A and B processed; might still have carry or borrow */
6693
  /* return number of Units in the result, negated if a borrow */
6694
  if (carry==0) return c-clsu;	   /* no carry, so no more to do */
6695
  if (carry>0) {		   /* positive carry */
6696
    *c=(Unit)carry;		   /* place as new unit */
6697
    c++;			   /* .. */
6698
    return c-clsu;
6699
    }
6700
  /* -ve carry: it's a borrow; complement needed */
6701
  add=1;			   /* temporary carry... */
6702
  for (c=clsu; c<maxC; c++) {
6703
    add=DECDPUNMAX+add-*c;
6704
    if (add<=DECDPUNMAX) {
6705
      *c=(Unit)add;
6706
      add=0;
6707
      }
6708
     else {
6709
      *c=0;
6710
      add=1;
6711
      }
6712
    }
6713
  /* add an extra unit iff it would be non-zero */
6714
  #if DECTRACE
6715
    printf("UAS borrow: add %ld, carry %ld\n", add, carry);
6716
  #endif
6717
  if ((add-carry-1)!=0) {
6718
    *c=(Unit)(add-carry-1);
6719
    c++;		      /* interesting, include it */
6720
    }
6721
  return clsu-c;	      /* -ve result indicates borrowed */
6722
  } /* decUnitAddSub */
6723

6724
/* ------------------------------------------------------------------ */
6725
/* decTrim -- trim trailing zeros or normalize			      */
6726
/*								      */
6727
/*   dn is the number to trim or normalize			      */
6728
/*   set is the context to use to check for clamp		      */
6729
/*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
6730
/*   dropped returns the number of discarded trailing zeros	      */
6731
/*   returns dn							      */
6732
/*								      */
6733
/* If clamp is set in the context then the number of zeros trimmed    */
6734
/* may be limited if the exponent is high.			      */
6735
/* All fields are updated as required.	This is a utility operation,  */
6736
/* so special values are unchanged and no error is possible.	      */
6737
/* ------------------------------------------------------------------ */
6738
static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
6739
			   Int *dropped) {
6740
  Int	d, exp;			   /* work */
6741
  uInt	cut;			   /* .. */
6742
  Unit	*up;			   /* -> current Unit */
6743

6744
  #if DECCHECK
6745
  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
6746
  #endif
6747

6748
  *dropped=0;				/* assume no zeros dropped */
6749
  if ((dn->bits & DECSPECIAL)		/* fast exit if special .. */
6750
    || (*dn->lsu & 0x01)) return dn;	/* .. or odd */
6751
  if (ISZERO(dn)) {			/* .. or 0 */
6752
    dn->exponent=0;			/* (sign is preserved) */
6753
    return dn;
6754
    }
6755

6756
  /* have a finite number which is even */
6757
  exp=dn->exponent;
6758
  cut=1;			   /* digit (1-DECDPUN) in Unit */
6759
  up=dn->lsu;			   /* -> current Unit */
6760
  for (d=0; d<dn->digits-1; d++) { /* [don't strip the final digit] */
6761
    /* slice by powers */
6762
    #if DECDPUN<=4
6763
      uInt quot=QUOT10(*up, cut);
6764
      if ((*up-quot*powers[cut])!=0) break;  /* found non-0 digit */
6765
    #else
6766
      if (*up%powers[cut]!=0) break;	     /* found non-0 digit */
6767
    #endif
6768
    /* have a trailing 0 */
6769
    if (!all) {			   /* trimming */
6770
      /* [if exp>0 then all trailing 0s are significant for trim] */
6771
      if (exp<=0) {		   /* if digit might be significant */
6772
	if (exp==0) break;	   /* then quit */
6773
	exp++;			   /* next digit might be significant */
6774
	}
6775
      }
6776
    cut++;			   /* next power */
6777
    if (cut>DECDPUN) {		   /* need new Unit */
6778
      up++;
6779
      cut=1;
6780
      }
6781
    } /* d */
6782
  if (d==0) return dn;		   /* none to drop */
6783

6784
  /* may need to limit drop if clamping */
6785
  if (set->clamp) {
6786
    Int maxd=set->emax-set->digits+1-dn->exponent;
6787
    if (maxd<=0) return dn;	   /* nothing possible */
6788
    if (d>maxd) d=maxd;
6789
    }
6790

6791
  /* effect the drop */
6792
  decShiftToLeast(dn->lsu, D2U(dn->digits), d);
6793
  dn->exponent+=d;		   /* maintain numerical value */
6794
  dn->digits-=d;		   /* new length */
6795
  *dropped=d;			   /* report the count */
6796
  return dn;
6797
  } /* decTrim */
6798

6799
/* ------------------------------------------------------------------ */
6800
/* decReverse -- reverse a Unit array in place			      */
6801
/*								      */
6802
/*   ulo    is the start of the array				      */
6803
/*   uhi    is the end of the array (highest Unit to include)	      */
6804
/*								      */
6805
/* The units ulo through uhi are reversed in place (if the number     */
6806
/* of units is odd, the middle one is untouched).  Note that the      */
6807
/* digit(s) in each unit are unaffected.			      */
6808
/* ------------------------------------------------------------------ */
6809
static void decReverse(Unit *ulo, Unit *uhi) {
6810
  Unit temp;
6811
  for (; ulo<uhi; ulo++, uhi--) {
6812
    temp=*ulo;
6813
    *ulo=*uhi;
6814
    *uhi=temp;
6815
    }
6816
  return;
6817
  } /* decReverse */
6818

6819
/* ------------------------------------------------------------------ */
6820
/* decShiftToMost -- shift digits in array towards most significant   */
6821
/*								      */
6822
/*   uar    is the array					      */
6823
/*   digits is the count of digits in use in the array		      */
6824
/*   shift  is the number of zeros to pad with (least significant);   */
6825
/*     it must be zero or positive				      */
6826
/*								      */
6827
/*   returns the new length of the integer in the array, in digits    */
6828
/*								      */
6829
/* No overflow is permitted (that is, the uar array must be known to  */
6830
/* be large enough to hold the result, after shifting).		      */
6831
/* ------------------------------------------------------------------ */
6832
static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
6833
  Unit	*target, *source, *first;  /* work */
6834
  Int	cut;			   /* odd 0's to add */
6835
  uInt	next;			   /* work */
6836

6837
  if (shift==0) return digits;	   /* [fastpath] nothing to do */
6838
  if ((digits+shift)<=DECDPUN) {   /* [fastpath] single-unit case */
6839
    *uar=(Unit)(*uar*powers[shift]);
6840
    return digits+shift;
6841
    }
6842

6843
  next=0;			   /* all paths */
6844
  source=uar+D2U(digits)-1;	   /* where msu comes from */
6845
  target=source+D2U(shift);	   /* where upper part of first cut goes */
6846
  cut=DECDPUN-MSUDIGITS(shift);	   /* where to slice */
6847
  if (cut==0) {			   /* unit-boundary case */
6848
    for (; source>=uar; source--, target--) *target=*source;
6849
    }
6850
   else {
6851
    first=uar+D2U(digits+shift)-1; /* where msu of source will end up */
6852
    for (; source>=uar; source--, target--) {
6853
      /* split the source Unit and accumulate remainder for next */
6854
      #if DECDPUN<=4
6855
	uInt quot=QUOT10(*source, cut);
6856
	uInt rem=*source-quot*powers[cut];
6857
	next+=quot;
6858
      #else
6859
	uInt rem=*source%powers[cut];
6860
	next+=*source/powers[cut];
6861
      #endif
6862
      if (target<=first) *target=(Unit)next;   /* write to target iff valid */
6863
      next=rem*powers[DECDPUN-cut];	       /* save remainder for next Unit */
6864
      }
6865
    } /* shift-move */
6866

6867
  /* propagate any partial unit to one below and clear the rest */
6868
  for (; target>=uar; target--) {
6869
    *target=(Unit)next;
6870
    next=0;
6871
    }
6872
  return digits+shift;
6873
  } /* decShiftToMost */
6874

6875
/* ------------------------------------------------------------------ */
6876
/* decShiftToLeast -- shift digits in array towards least significant */
6877
/*								      */
6878
/*   uar   is the array						      */
6879
/*   units is length of the array, in units			      */
6880
/*   shift is the number of digits to remove from the lsu end; it     */
6881
/*     must be zero or positive and <= than units*DECDPUN.	      */
6882
/*								      */
6883
/*   returns the new length of the integer in the array, in units     */
6884
/*								      */
6885
/* Removed digits are discarded (lost).	 Units not required to hold   */
6886
/* the final result are unchanged.				      */
6887
/* ------------------------------------------------------------------ */
6888
static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
6889
  Unit	*target, *up;		   /* work */
6890
  Int	cut, count;		   /* work */
6891
  Int	quot, rem;		   /* for division */
6892

6893
  if (shift==0) return units;	   /* [fastpath] nothing to do */
6894
  if (shift==units*DECDPUN) {	   /* [fastpath] little to do */
6895
    *uar=0;			   /* all digits cleared gives zero */
6896
    return 1;			   /* leaves just the one */
6897
    }
6898

6899
  target=uar;			   /* both paths */
6900
  cut=MSUDIGITS(shift);
6901
  if (cut==DECDPUN) {		   /* unit-boundary case; easy */
6902
    up=uar+D2U(shift);
6903
    for (; up<uar+units; target++, up++) *target=*up;
6904
    return target-uar;
6905
    }
6906

6907
  /* messier */
6908
  up=uar+D2U(shift-cut);	   /* source; correct to whole Units */
6909
  count=units*DECDPUN-shift;	   /* the maximum new length */
6910
  #if DECDPUN<=4
6911
    quot=QUOT10(*up, cut);
6912
  #else
6913
    quot=*up/powers[cut];
6914
  #endif
6915
  for (; ; target++) {
6916
    *target=(Unit)quot;
6917
    count-=(DECDPUN-cut);
6918
    if (count<=0) break;
6919
    up++;
6920
    quot=*up;
6921
    #if DECDPUN<=4
6922
      quot=QUOT10(quot, cut);
6923
      rem=*up-quot*powers[cut];
6924
    #else
6925
      rem=quot%powers[cut];
6926
      quot=quot/powers[cut];
6927
    #endif
6928
    *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
6929
    count-=cut;
6930
    if (count<=0) break;
6931
    }
6932
  return target-uar+1;
6933
  } /* decShiftToLeast */
6934

6935
#if DECSUBSET
6936
/* ------------------------------------------------------------------ */
6937
/* decRoundOperand -- round an operand	[used for subset only]	      */
6938
/*								      */
6939
/*   dn is the number to round (dn->digits is > set->digits)	      */
6940
/*   set is the relevant context				      */
6941
/*   status is the status accumulator				      */
6942
/*								      */
6943
/*   returns an allocated decNumber with the rounded result.	      */
6944
/*								      */
6945
/* lostDigits and other status may be set by this.		      */
6946
/*								      */
6947
/* Since the input is an operand, it must not be modified.	      */
6948
/* Instead, return an allocated decNumber, rounded as required.	      */
6949
/* It is the caller's responsibility to free the allocated storage.   */
6950
/*								      */
6951
/* If no storage is available then the result cannot be used, so NULL */
6952
/* is returned.							      */
6953
/* ------------------------------------------------------------------ */
6954
static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
6955
				  uInt *status) {
6956
  decNumber *res;			/* result structure */
6957
  uInt newstatus=0;			/* status from round */
6958
  Int  residue=0;			/* rounding accumulator */
6959

6960
  /* Allocate storage for the returned decNumber, big enough for the */
6961
  /* length specified by the context */
6962
  res=(decNumber *)malloc(sizeof(decNumber)
6963
			  +(D2U(set->digits)-1)*sizeof(Unit));
6964
  if (res==NULL) {
6965
    *status|=DEC_Insufficient_storage;
6966
    return NULL;
6967
    }
6968
  decCopyFit(res, dn, set, &residue, &newstatus);
6969
  decApplyRound(res, set, residue, &newstatus);
6970

6971
  /* If that set Inexact then "lost digits" is raised... */
6972
  if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
6973
  *status|=newstatus;
6974
  return res;
6975
  } /* decRoundOperand */
6976
#endif
6977

6978
/* ------------------------------------------------------------------ */
6979
/* decCopyFit -- copy a number, truncating the coefficient if needed  */
6980
/*								      */
6981
/*   dest is the target decNumber				      */
6982
/*   src  is the source decNumber				      */
6983
/*   set is the context [used for length (digits) and rounding mode]  */
6984
/*   residue is the residue accumulator				      */
6985
/*   status contains the current status to be updated		      */
6986
/*								      */
6987
/* (dest==src is allowed and will be a no-op if fits)		      */
6988
/* All fields are updated as required.				      */
6989
/* ------------------------------------------------------------------ */
6990
static void decCopyFit(decNumber *dest, const decNumber *src,
6991
		       decContext *set, Int *residue, uInt *status) {
6992
  dest->bits=src->bits;
6993
  dest->exponent=src->exponent;
6994
  decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
6995
  } /* decCopyFit */
6996

6997
/* ------------------------------------------------------------------ */
6998
/* decSetCoeff -- set the coefficient of a number		      */
6999
/*								      */
7000
/*   dn	   is the number whose coefficient array is to be set.	      */
7001
/*	   It must have space for set->digits digits		      */
7002
/*   set   is the context [for size]				      */
7003
/*   lsu   -> lsu of the source coefficient [may be dn->lsu]	      */
7004
/*   len   is digits in the source coefficient [may be dn->digits]    */
7005
/*   residue is the residue accumulator.  This has values as in	      */
7006
/*	   decApplyRound, and will be unchanged unless the	      */
7007
/*	   target size is less than len.  In this case, the	      */
7008
/*	   coefficient is truncated and the residue is updated to     */
7009
/*	   reflect the previous residue and the dropped digits.	      */
7010
/*   status is the status accumulator, as usual			      */
7011
/*								      */
7012
/* The coefficient may already be in the number, or it can be an      */
7013
/* external intermediate array.	 If it is in the number, lsu must ==  */
7014
/* dn->lsu and len must == dn->digits.				      */
7015
/*								      */
7016
/* Note that the coefficient length (len) may be < set->digits, and   */
7017
/* in this case this merely copies the coefficient (or is a no-op     */
7018
/* if dn->lsu==lsu).						      */
7019
/*								      */
7020
/* Note also that (only internally, from decQuantizeOp and	      */
7021
/* decSetSubnormal) the value of set->digits may be less than one,    */
7022
/* indicating a round to left.	This routine handles that case	      */
7023
/* correctly; caller ensures space.				      */
7024
/*								      */
7025
/* dn->digits, dn->lsu (and as required), and dn->exponent are	      */
7026
/* updated as necessary.   dn->bits (sign) is unchanged.	      */
7027
/*								      */
7028
/* DEC_Rounded status is set if any digits are discarded.	      */
7029
/* DEC_Inexact status is set if any non-zero digits are discarded, or */
7030
/*			 incoming residue was non-0 (implies rounded) */
7031
/* ------------------------------------------------------------------ */
7032
/* mapping array: maps 0-9 to canonical residues, so that a residue */
7033
/* can be adjusted in the range [-1, +1] and achieve correct rounding */
7034
/*			       0  1  2	3  4  5	 6  7  8  9 */
7035
static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
7036
static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
7037
			Int len, Int *residue, uInt *status) {
7038
  Int	discard;	      /* number of digits to discard */
7039
  uInt	cut;		      /* cut point in Unit */
7040
  const Unit *up;	      /* work */
7041
  Unit	*target;	      /* .. */
7042
  Int	count;		      /* .. */
7043
  #if DECDPUN<=4
7044
  uInt	temp;		      /* .. */
7045
  #endif
7046

7047
  discard=len-set->digits;    /* digits to discard */
7048
  if (discard<=0) {	      /* no digits are being discarded */
7049
    if (dn->lsu!=lsu) {	      /* copy needed */
7050
      /* copy the coefficient array to the result number; no shift needed */
7051
      count=len;	      /* avoids D2U */
7052
      up=lsu;
7053
      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7054
	*target=*up;
7055
      dn->digits=len;	      /* set the new length */
7056
      }
7057
    /* dn->exponent and residue are unchanged, record any inexactitude */
7058
    if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
7059
    return;
7060
    }
7061

7062
  /* some digits must be discarded ... */
7063
  dn->exponent+=discard;      /* maintain numerical value */
7064
  *status|=DEC_Rounded;	      /* accumulate Rounded status */
7065
  if (*residue>1) *residue=1; /* previous residue now to right, so reduce */
7066

7067
  if (discard>len) {	      /* everything, +1, is being discarded */
7068
    /* guard digit is 0 */
7069
    /* residue is all the number [NB could be all 0s] */
7070
    if (*residue<=0) {	      /* not already positive */
7071
      count=len;	      /* avoids D2U */
7072
      for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { /* found non-0 */
7073
	*residue=1;
7074
	break;		      /* no need to check any others */
7075
	}
7076
      }
7077
    if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7078
    *dn->lsu=0;		      /* coefficient will now be 0 */
7079
    dn->digits=1;	      /* .. */
7080
    return;
7081
    } /* total discard */
7082

7083
  /* partial discard [most common case] */
7084
  /* here, at least the first (most significant) discarded digit exists */
7085

7086
  /* spin up the number, noting residue during the spin, until get to */
7087
  /* the Unit with the first discarded digit.  When reach it, extract */
7088
  /* it and remember its position */
7089
  count=0;
7090
  for (up=lsu;; up++) {
7091
    count+=DECDPUN;
7092
    if (count>=discard) break; /* full ones all checked */
7093
    if (*up!=0) *residue=1;
7094
    } /* up */
7095

7096
  /* here up -> Unit with first discarded digit */
7097
  cut=discard-(count-DECDPUN)-1;
7098
  if (cut==DECDPUN-1) {	      /* unit-boundary case (fast) */
7099
    Unit half=(Unit)powers[DECDPUN]>>1;
7100
    /* set residue directly */
7101
    if (*up>=half) {
7102
      if (*up>half) *residue=7;
7103
      else *residue+=5;	      /* add sticky bit */
7104
      }
7105
     else { /* <half */
7106
      if (*up!=0) *residue=3; /* [else is 0, leave as sticky bit] */
7107
      }
7108
    if (set->digits<=0) {     /* special for Quantize/Subnormal :-( */
7109
      *dn->lsu=0;	      /* .. result is 0 */
7110
      dn->digits=1;	      /* .. */
7111
      }
7112
     else {		      /* shift to least */
7113
      count=set->digits;      /* now digits to end up with */
7114
      dn->digits=count;	      /* set the new length */
7115
      up++;		      /* move to next */
7116
      /* on unit boundary, so shift-down copy loop is simple */
7117
      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
7118
	*target=*up;
7119
      }
7120
    } /* unit-boundary case */
7121

7122
   else { /* discard digit is in low digit(s), and not top digit */
7123
    uInt  discard1;		   /* first discarded digit */
7124
    uInt  quot, rem;		   /* for divisions */
7125
    if (cut==0) quot=*up;	   /* is at bottom of unit */
7126
     else /* cut>0 */ {		   /* it's not at bottom of unit */
7127
      #if DECDPUN<=4
7128
	quot=QUOT10(*up, cut);
7129
	rem=*up-quot*powers[cut];
7130
      #else
7131
	rem=*up%powers[cut];
7132
	quot=*up/powers[cut];
7133
      #endif
7134
      if (rem!=0) *residue=1;
7135
      }
7136
    /* discard digit is now at bottom of quot */
7137
    #if DECDPUN<=4
7138
      temp=(quot*6554)>>16;	   /* fast /10 */
7139
      /* Vowels algorithm here not a win (9 instructions) */
7140
      discard1=quot-X10(temp);
7141
      quot=temp;
7142
    #else
7143
      discard1=quot%10;
7144
      quot=quot/10;
7145
    #endif
7146
    /* here, discard1 is the guard digit, and residue is everything */
7147
    /* else [use mapping array to accumulate residue safely] */
7148
    *residue+=resmap[discard1];
7149
    cut++;			   /* update cut */
7150
    /* here: up -> Unit of the array with bottom digit */
7151
    /*	     cut is the division point for each Unit */
7152
    /*	     quot holds the uncut high-order digits for the current unit */
7153
    if (set->digits<=0) {	   /* special for Quantize/Subnormal :-( */
7154
      *dn->lsu=0;		   /* .. result is 0 */
7155
      dn->digits=1;		   /* .. */
7156
      }
7157
     else {			   /* shift to least needed */
7158
      count=set->digits;	   /* now digits to end up with */
7159
      dn->digits=count;		   /* set the new length */
7160
      /* shift-copy the coefficient array to the result number */
7161
      for (target=dn->lsu; ; target++) {
7162
	*target=(Unit)quot;
7163
	count-=(DECDPUN-cut);
7164
	if (count<=0) break;
7165
	up++;
7166
	quot=*up;
7167
	#if DECDPUN<=4
7168
	  quot=QUOT10(quot, cut);
7169
	  rem=*up-quot*powers[cut];
7170
	#else
7171
	  rem=quot%powers[cut];
7172
	  quot=quot/powers[cut];
7173
	#endif
7174
	*target=(Unit)(*target+rem*powers[DECDPUN-cut]);
7175
	count-=cut;
7176
	if (count<=0) break;
7177
	} /* shift-copy loop */
7178
      } /* shift to least */
7179
    } /* not unit boundary */
7180

7181
  if (*residue!=0) *status|=DEC_Inexact; /* record inexactitude */
7182
  return;
7183
  } /* decSetCoeff */
7184

7185
/* ------------------------------------------------------------------ */
7186
/* decApplyRound -- apply pending rounding to a number		      */
7187
/*								      */
7188
/*   dn	   is the number, with space for set->digits digits	      */
7189
/*   set   is the context [for size and rounding mode]		      */
7190
/*   residue indicates pending rounding, being any accumulated	      */
7191
/*	   guard and sticky information.  It may be:		      */
7192
/*	   6-9: rounding digit is >5				      */
7193
/*	   5:	rounding digit is exactly half-way		      */
7194
/*	   1-4: rounding digit is <5 and >0			      */
7195
/*	   0:	the coefficient is exact			      */
7196
/*	  -1:	as 1, but the hidden digits are subtractive, that     */
7197
/*		is, of the opposite sign to dn.	 In this case the     */
7198
/*		coefficient must be non-0.  This case occurs when     */
7199
/*		subtracting a small number (which can be reduced to   */
7200
/*		a sticky bit); see decAddOp.			      */
7201
/*   status is the status accumulator, as usual			      */
7202
/*								      */
7203
/* This routine applies rounding while keeping the length of the      */
7204
/* coefficient constant.  The exponent and status are unchanged	      */
7205
/* except if:							      */
7206
/*								      */
7207
/*   -- the coefficient was increased and is all nines (in which      */
7208
/*	case Overflow could occur, and is handled directly here so    */
7209
/*	the caller does not need to re-test for overflow)	      */
7210
/*								      */
7211
/*   -- the coefficient was decreased and becomes all nines (in which */
7212
/*	case Underflow could occur, and is also handled directly).    */
7213
/*								      */
7214
/* All fields in dn are updated as required.			      */
7215
/*								      */
7216
/* ------------------------------------------------------------------ */
7217
static void decApplyRound(decNumber *dn, decContext *set, Int residue,
7218
			  uInt *status) {
7219
  Int  bump;		      /* 1 if coefficient needs to be incremented */
7220
			      /* -1 if coefficient needs to be decremented */
7221

7222
  if (residue==0) return;     /* nothing to apply */
7223

7224
  bump=0;		      /* assume a smooth ride */
7225

7226
  /* now decide whether, and how, to round, depending on mode */
7227
  switch (set->round) {
7228
    case DEC_ROUND_05UP: {    /* round zero or five up (for reround) */
7229
      /* This is the same as DEC_ROUND_DOWN unless there is a */
7230
      /* positive residue and the lsd of dn is 0 or 5, in which case */
7231
      /* it is bumped; when residue is <0, the number is therefore */
7232
      /* bumped down unless the final digit was 1 or 6 (in which */
7233
      /* case it is bumped down and then up -- a no-op) */
7234
      Int lsd5=*dn->lsu%5;     /* get lsd and quintate */
7235
      if (residue<0 && lsd5!=1) bump=-1;
7236
       else if (residue>0 && lsd5==0) bump=1;
7237
      /* [bump==1 could be applied directly; use common path for clarity] */
7238
      break;} /* r-05 */
7239

7240
    case DEC_ROUND_DOWN: {
7241
      /* no change, except if negative residue */
7242
      if (residue<0) bump=-1;
7243
      break;} /* r-d */
7244

7245
    case DEC_ROUND_HALF_DOWN: {
7246
      if (residue>5) bump=1;
7247
      break;} /* r-h-d */
7248

7249
    case DEC_ROUND_HALF_EVEN: {
7250
      if (residue>5) bump=1;		/* >0.5 goes up */
7251
       else if (residue==5) {		/* exactly 0.5000... */
7252
	/* 0.5 goes up iff [new] lsd is odd */
7253
	if (*dn->lsu & 0x01) bump=1;
7254
	}
7255
      break;} /* r-h-e */
7256

7257
    case DEC_ROUND_HALF_UP: {
7258
      if (residue>=5) bump=1;
7259
      break;} /* r-h-u */
7260

7261
    case DEC_ROUND_UP: {
7262
      if (residue>0) bump=1;
7263
      break;} /* r-u */
7264

7265
    case DEC_ROUND_CEILING: {
7266
      /* same as _UP for positive numbers, and as _DOWN for negatives */
7267
      /* [negative residue cannot occur on 0] */
7268
      if (decNumberIsNegative(dn)) {
7269
	if (residue<0) bump=-1;
7270
	}
7271
       else {
7272
	if (residue>0) bump=1;
7273
	}
7274
      break;} /* r-c */
7275

7276
    case DEC_ROUND_FLOOR: {
7277
      /* same as _UP for negative numbers, and as _DOWN for positive */
7278
      /* [negative residue cannot occur on 0] */
7279
      if (!decNumberIsNegative(dn)) {
7280
	if (residue<0) bump=-1;
7281
	}
7282
       else {
7283
	if (residue>0) bump=1;
7284
	}
7285
      break;} /* r-f */
7286

7287
    default: {	    /* e.g., DEC_ROUND_MAX */
7288
      *status|=DEC_Invalid_context;
7289
      #if DECTRACE || (DECCHECK && DECVERB)
7290
      printf("Unknown rounding mode: %d\n", set->round);
7291
      #endif
7292
      break;}
7293
    } /* switch */
7294

7295
  /* now bump the number, up or down, if need be */
7296
  if (bump==0) return;			     /* no action required */
7297

7298
  /* Simply use decUnitAddSub unless bumping up and the number is */
7299
  /* all nines.	 In this special case set to 100... explicitly */
7300
  /* and adjust the exponent by one (as otherwise could overflow */
7301
  /* the array) */
7302
  /* Similarly handle all-nines result if bumping down. */
7303
  if (bump>0) {
7304
    Unit *up;				     /* work */
7305
    uInt count=dn->digits;		     /* digits to be checked */
7306
    for (up=dn->lsu; ; up++) {
7307
      if (count<=DECDPUN) {
7308
	/* this is the last Unit (the msu) */
7309
	if (*up!=powers[count]-1) break;     /* not still 9s */
7310
	/* here if it, too, is all nines */
7311
	*up=(Unit)powers[count-1];	     /* here 999 -> 100 etc. */
7312
	for (up=up-1; up>=dn->lsu; up--) *up=0; /* others all to 0 */
7313
	dn->exponent++;			     /* and bump exponent */
7314
	/* [which, very rarely, could cause Overflow...] */
7315
	if ((dn->exponent+dn->digits)>set->emax+1) {
7316
	  decSetOverflow(dn, set, status);
7317
	  }
7318
	return;				     /* done */
7319
	}
7320
      /* a full unit to check, with more to come */
7321
      if (*up!=DECDPUNMAX) break;	     /* not still 9s */
7322
      count-=DECDPUN;
7323
      } /* up */
7324
    } /* bump>0 */
7325
   else {				     /* -1 */
7326
    /* here checking for a pre-bump of 1000... (leading 1, all */
7327
    /* other digits zero) */
7328
    Unit *up, *sup;			     /* work */
7329
    uInt count=dn->digits;		     /* digits to be checked */
7330
    for (up=dn->lsu; ; up++) {
7331
      if (count<=DECDPUN) {
7332
	/* this is the last Unit (the msu) */
7333
	if (*up!=powers[count-1]) break;     /* not 100.. */
7334
	/* here if have the 1000... case */
7335
	sup=up;				     /* save msu pointer */
7336
	*up=(Unit)powers[count]-1;	     /* here 100 in msu -> 999 */
7337
	/* others all to all-nines, too */
7338
	for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
7339
	dn->exponent--;			     /* and bump exponent */
7340

7341
	/* iff the number was at the subnormal boundary (exponent=etiny) */
7342
	/* then the exponent is now out of range, so it will in fact get */
7343
	/* clamped to etiny and the final 9 dropped. */
7344
	/* printf(">> emin=%d exp=%d sdig=%d\n", set->emin, */
7345
	/*	  dn->exponent, set->digits); */
7346
	if (dn->exponent+1==set->emin-set->digits+1) {
7347
	  if (count==1 && dn->digits==1) *sup=0;  /* here 9 -> 0[.9] */
7348
	   else {
7349
	    *sup=(Unit)powers[count-1]-1;    /* here 999.. in msu -> 99.. */
7350
	    dn->digits--;
7351
	    }
7352
	  dn->exponent++;
7353
	  *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7354
	  }
7355
	return;				     /* done */
7356
	}
7357

7358
      /* a full unit to check, with more to come */
7359
      if (*up!=0) break;		     /* not still 0s */
7360
      count-=DECDPUN;
7361
      } /* up */
7362

7363
    } /* bump<0 */
7364

7365
  /* Actual bump needed.  Do it. */
7366
  decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
7367
  } /* decApplyRound */
7368

7369
#if DECSUBSET
7370
/* ------------------------------------------------------------------ */
7371
/* decFinish -- finish processing a number			      */
7372
/*								      */
7373
/*   dn is the number						      */
7374
/*   set is the context						      */
7375
/*   residue is the rounding accumulator (as in decApplyRound)	      */
7376
/*   status is the accumulator					      */
7377
/*								      */
7378
/* This finishes off the current number by:			      */
7379
/*    1. If not extended:					      */
7380
/*	 a. Converting a zero result to clean '0'		      */
7381
/*	 b. Reducing positive exponents to 0, if would fit in digits  */
7382
/*    2. Checking for overflow and subnormals (always)		      */
7383
/* Note this is just Finalize when no subset arithmetic.	      */
7384
/* All fields are updated as required.				      */
7385
/* ------------------------------------------------------------------ */
7386
static void decFinish(decNumber *dn, decContext *set, Int *residue,
7387
		      uInt *status) {
7388
  if (!set->extended) {
7389
    if ISZERO(dn) {		   /* value is zero */
7390
      dn->exponent=0;		   /* clean exponent .. */
7391
      dn->bits=0;		   /* .. and sign */
7392
      return;			   /* no error possible */
7393
      }
7394
    if (dn->exponent>=0) {	   /* non-negative exponent */
7395
      /* >0; reduce to integer if possible */
7396
      if (set->digits >= (dn->exponent+dn->digits)) {
7397
	dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
7398
	dn->exponent=0;
7399
	}
7400
      }
7401
    } /* !extended */
7402

7403
  decFinalize(dn, set, residue, status);
7404
  } /* decFinish */
7405
#endif
7406

7407
/* ------------------------------------------------------------------ */
7408
/* decFinalize -- final check, clamp, and round of a number	      */
7409
/*								      */
7410
/*   dn is the number						      */
7411
/*   set is the context						      */
7412
/*   residue is the rounding accumulator (as in decApplyRound)	      */
7413
/*   status is the status accumulator				      */
7414
/*								      */
7415
/* This finishes off the current number by checking for subnormal     */
7416
/* results, applying any pending rounding, checking for overflow,     */
7417
/* and applying any clamping.					      */
7418
/* Underflow and overflow conditions are raised as appropriate.	      */
7419
/* All fields are updated as required.				      */
7420
/* ------------------------------------------------------------------ */
7421
static void decFinalize(decNumber *dn, decContext *set, Int *residue,
7422
			uInt *status) {
7423
  Int shift;				/* shift needed if clamping */
7424
  Int tinyexp=set->emin-dn->digits+1;	/* precalculate subnormal boundary */
7425

7426
  /* Must be careful, here, when checking the exponent as the */
7427
  /* adjusted exponent could overflow 31 bits [because it may already */
7428
  /* be up to twice the expected]. */
7429

7430
  /* First test for subnormal.	This must be done before any final */
7431
  /* round as the result could be rounded to Nmin or 0. */
7432
  if (dn->exponent<=tinyexp) {		/* prefilter */
7433
    Int comp;
7434
    decNumber nmin;
7435
    /* A very nasty case here is dn == Nmin and residue<0 */
7436
    if (dn->exponent<tinyexp) {
7437
      /* Go handle subnormals; this will apply round if needed. */
7438
      decSetSubnormal(dn, set, residue, status);
7439
      return;
7440
      }
7441
    /* Equals case: only subnormal if dn=Nmin and negative residue */
7442
    decNumberZero(&nmin);
7443
    nmin.lsu[0]=1;
7444
    nmin.exponent=set->emin;
7445
    comp=decCompare(dn, &nmin, 1);		  /* (signless compare) */
7446
    if (comp==BADINT) {				  /* oops */
7447
      *status|=DEC_Insufficient_storage;	  /* abandon... */
7448
      return;
7449
      }
7450
    if (*residue<0 && comp==0) {		  /* neg residue and dn==Nmin */
7451
      decApplyRound(dn, set, *residue, status);	  /* might force down */
7452
      decSetSubnormal(dn, set, residue, status);
7453
      return;
7454
      }
7455
    }
7456

7457
  /* now apply any pending round (this could raise overflow). */
7458
  if (*residue!=0) decApplyRound(dn, set, *residue, status);
7459

7460
  /* Check for overflow [redundant in the 'rare' case] or clamp */
7461
  if (dn->exponent<=set->emax-set->digits+1) return;   /* neither needed */
7462

7463

7464
  /* here when might have an overflow or clamp to do */
7465
  if (dn->exponent>set->emax-dn->digits+1) {	       /* too big */
7466
    decSetOverflow(dn, set, status);
7467
    return;
7468
    }
7469
  /* here when the result is normal but in clamp range */
7470
  if (!set->clamp) return;
7471

7472
  /* here when need to apply the IEEE exponent clamp (fold-down) */
7473
  shift=dn->exponent-(set->emax-set->digits+1);
7474

7475
  /* shift coefficient (if non-zero) */
7476
  if (!ISZERO(dn)) {
7477
    dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
7478
    }
7479
  dn->exponent-=shift;	 /* adjust the exponent to match */
7480
  *status|=DEC_Clamped;	 /* and record the dirty deed */
7481
  return;
7482
  } /* decFinalize */
7483

7484
/* ------------------------------------------------------------------ */
7485
/* decSetOverflow -- set number to proper overflow value	      */
7486
/*								      */
7487
/*   dn is the number (used for sign [only] and result)		      */
7488
/*   set is the context [used for the rounding mode, etc.]	      */
7489
/*   status contains the current status to be updated		      */
7490
/*								      */
7491
/* This sets the sign of a number and sets its value to either	      */
7492
/* Infinity or the maximum finite value, depending on the sign of     */
7493
/* dn and the rounding mode, following IEEE 854 rules.		      */
7494
/* ------------------------------------------------------------------ */
7495
static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
7496
  Flag needmax=0;		   /* result is maximum finite value */
7497
  uByte sign=dn->bits&DECNEG;	   /* clean and save sign bit */
7498

7499
  if (ISZERO(dn)) {		   /* zero does not overflow magnitude */
7500
    Int emax=set->emax;			     /* limit value */
7501
    if (set->clamp) emax-=set->digits-1;     /* lower if clamping */
7502
    if (dn->exponent>emax) {		     /* clamp required */
7503
      dn->exponent=emax;
7504
      *status|=DEC_Clamped;
7505
      }
7506
    return;
7507
    }
7508

7509
  decNumberZero(dn);
7510
  switch (set->round) {
7511
    case DEC_ROUND_DOWN: {
7512
      needmax=1;		   /* never Infinity */
7513
      break;} /* r-d */
7514
    case DEC_ROUND_05UP: {
7515
      needmax=1;		   /* never Infinity */
7516
      break;} /* r-05 */
7517
    case DEC_ROUND_CEILING: {
7518
      if (sign) needmax=1;	   /* Infinity if non-negative */
7519
      break;} /* r-c */
7520
    case DEC_ROUND_FLOOR: {
7521
      if (!sign) needmax=1;	   /* Infinity if negative */
7522
      break;} /* r-f */
7523
    default: break;		   /* Infinity in all other cases */
7524
    }
7525
  if (needmax) {
7526
    decSetMaxValue(dn, set);
7527
    dn->bits=sign;		   /* set sign */
7528
    }
7529
   else dn->bits=sign|DECINF;	   /* Value is +/-Infinity */
7530
  *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
7531
  } /* decSetOverflow */
7532

7533
/* ------------------------------------------------------------------ */
7534
/* decSetMaxValue -- set number to +Nmax (maximum normal value)	      */
7535
/*								      */
7536
/*   dn is the number to set					      */
7537
/*   set is the context [used for digits and emax]		      */
7538
/*								      */
7539
/* This sets the number to the maximum positive value.		      */
7540
/* ------------------------------------------------------------------ */
7541
static void decSetMaxValue(decNumber *dn, decContext *set) {
7542
  Unit *up;			   /* work */
7543
  Int count=set->digits;	   /* nines to add */
7544
  dn->digits=count;
7545
  /* fill in all nines to set maximum value */
7546
  for (up=dn->lsu; ; up++) {
7547
    if (count>DECDPUN) *up=DECDPUNMAX;	/* unit full o'nines */
7548
     else {				/* this is the msu */
7549
      *up=(Unit)(powers[count]-1);
7550
      break;
7551
      }
7552
    count-=DECDPUN;		   /* filled those digits */
7553
    } /* up */
7554
  dn->bits=0;			   /* + sign */
7555
  dn->exponent=set->emax-set->digits+1;
7556
  } /* decSetMaxValue */
7557

7558
/* ------------------------------------------------------------------ */
7559
/* decSetSubnormal -- process value whose exponent is <Emin	      */
7560
/*								      */
7561
/*   dn is the number (used as input as well as output; it may have   */
7562
/*	   an allowed subnormal value, which may need to be rounded)  */
7563
/*   set is the context [used for the rounding mode]		      */
7564
/*   residue is any pending residue				      */
7565
/*   status contains the current status to be updated		      */
7566
/*								      */
7567
/* If subset mode, set result to zero and set Underflow flags.	      */
7568
/*								      */
7569
/* Value may be zero with a low exponent; this does not set Subnormal */
7570
/* but the exponent will be clamped to Etiny.			      */
7571
/*								      */
7572
/* Otherwise ensure exponent is not out of range, and round as	      */
7573
/* necessary.  Underflow is set if the result is Inexact.	      */
7574
/* ------------------------------------------------------------------ */
7575
static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
7576
			    uInt *status) {
7577
  decContext workset;	      /* work */
7578
  Int	     etiny, adjust;   /* .. */
7579

7580
  #if DECSUBSET
7581
  /* simple set to zero and 'hard underflow' for subset */
7582
  if (!set->extended) {
7583
    decNumberZero(dn);
7584
    /* always full overflow */
7585
    *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
7586
    return;
7587
    }
7588
  #endif
7589

7590
  /* Full arithmetic -- allow subnormals, rounded to minimum exponent */
7591
  /* (Etiny) if needed */
7592
  etiny=set->emin-(set->digits-1);	/* smallest allowed exponent */
7593

7594
  if ISZERO(dn) {			/* value is zero */
7595
    /* residue can never be non-zero here */
7596
    #if DECCHECK
7597
      if (*residue!=0) {
7598
	printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
7599
	*status|=DEC_Invalid_operation;
7600
	}
7601
    #endif
7602
    if (dn->exponent<etiny) {		/* clamp required */
7603
      dn->exponent=etiny;
7604
      *status|=DEC_Clamped;
7605
      }
7606
    return;
7607
    }
7608

7609
  *status|=DEC_Subnormal;		/* have a non-zero subnormal */
7610
  adjust=etiny-dn->exponent;		/* calculate digits to remove */
7611
  if (adjust<=0) {			/* not out of range; unrounded */
7612
    /* residue can never be non-zero here, except in the Nmin-residue */
7613
    /* case (which is a subnormal result), so can take fast-path here */
7614
    /* it may already be inexact (from setting the coefficient) */
7615
    if (*status&DEC_Inexact) *status|=DEC_Underflow;
7616
    return;
7617
    }
7618

7619
  /* adjust>0, so need to rescale the result so exponent becomes Etiny */
7620
  /* [this code is similar to that in rescale] */
7621
  workset=*set;				/* clone rounding, etc. */
7622
  workset.digits=dn->digits-adjust;	/* set requested length */
7623
  workset.emin-=adjust;			/* and adjust emin to match */
7624
  /* [note that the latter can be <1, here, similar to Rescale case] */
7625
  decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
7626
  decApplyRound(dn, &workset, *residue, status);
7627

7628
  /* Use 754R/854 default rule: Underflow is set iff Inexact */
7629
  /* [independent of whether trapped] */
7630
  if (*status&DEC_Inexact) *status|=DEC_Underflow;
7631

7632
  /* if rounded up a 999s case, exponent will be off by one; adjust */
7633
  /* back if so [it will fit, because it was shortened earlier] */
7634
  if (dn->exponent>etiny) {
7635
    dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
7636
    dn->exponent--;			/* (re)adjust the exponent. */
7637
    }
7638

7639
  /* if rounded to zero, it is by definition clamped... */
7640
  if (ISZERO(dn)) *status|=DEC_Clamped;
7641
  } /* decSetSubnormal */
7642

7643
/* ------------------------------------------------------------------ */
7644
/* decCheckMath - check entry conditions for a math function	      */
7645
/*								      */
7646
/*   This checks the context and the operand			      */
7647
/*								      */
7648
/*   rhs is the operand to check				      */
7649
/*   set is the context to check				      */
7650
/*   status is unchanged if both are good			      */
7651
/*								      */
7652
/* returns non-zero if status is changed, 0 otherwise		      */
7653
/*								      */
7654
/* Restrictions enforced:					      */
7655
/*								      */
7656
/*   digits, emax, and -emin in the context must be less than	      */
7657
/*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
7658
/*   non-zero.	Invalid_operation is set in the status if a	      */
7659
/*   restriction is violated.					      */
7660
/* ------------------------------------------------------------------ */
7661
static uInt decCheckMath(const decNumber *rhs, decContext *set,
7662
			 uInt *status) {
7663
  uInt save=*status;			     /* record */
7664
  if (set->digits>DEC_MAX_MATH
7665
   || set->emax>DEC_MAX_MATH
7666
   || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
7667
   else if ((rhs->digits>DEC_MAX_MATH
7668
     || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
7669
     || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
7670
     && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
7671
  return (*status!=save);
7672
  } /* decCheckMath */
7673

7674
/* ------------------------------------------------------------------ */
7675
/* decGetInt -- get integer from a number			      */
7676
/*								      */
7677
/*   dn is the number [which will not be altered]		      */
7678
/*								      */
7679
/*   returns one of:						      */
7680
/*     BADINT if there is a non-zero fraction			      */
7681
/*     the converted integer					      */
7682
/*     BIGEVEN if the integer is even and magnitude > 2*10**9	      */
7683
/*     BIGODD  if the integer is odd  and magnitude > 2*10**9	      */
7684
/*								      */
7685
/* This checks and gets a whole number from the input decNumber.      */
7686
/* The sign can be determined from dn by the caller when BIGEVEN or   */
7687
/* BIGODD is returned.						      */
7688
/* ------------------------------------------------------------------ */
7689
static Int decGetInt(const decNumber *dn) {
7690
  Int  theInt;				/* result accumulator */
7691
  const Unit *up;			/* work */
7692
  Int  got;				/* digits (real or not) processed */
7693
  Int  ilength=dn->digits+dn->exponent; /* integral length */
7694
  Flag neg=decNumberIsNegative(dn);	/* 1 if -ve */
7695

7696
  /* The number must be an integer that fits in 10 digits */
7697
  /* Assert, here, that 10 is enough for any rescale Etiny */
7698
  #if DEC_MAX_EMAX > 999999999
7699
    #error GetInt may need updating [for Emax]
7700
  #endif
7701
  #if DEC_MIN_EMIN < -999999999
7702
    #error GetInt may need updating [for Emin]
7703
  #endif
7704
  if (ISZERO(dn)) return 0;		/* zeros are OK, with any exponent */
7705

7706
  up=dn->lsu;				/* ready for lsu */
7707
  theInt=0;				/* ready to accumulate */
7708
  if (dn->exponent>=0) {		/* relatively easy */
7709
    /* no fractional part [usual]; allow for positive exponent */
7710
    got=dn->exponent;
7711
    }
7712
   else { /* -ve exponent; some fractional part to check and discard */
7713
    Int count=-dn->exponent;		/* digits to discard */
7714
    /* spin up whole units until reach the Unit with the unit digit */
7715
    for (; count>=DECDPUN; up++) {
7716
      if (*up!=0) return BADINT;	/* non-zero Unit to discard */
7717
      count-=DECDPUN;
7718
      }
7719
    if (count==0) got=0;		/* [a multiple of DECDPUN] */
7720
     else {				/* [not multiple of DECDPUN] */
7721
      Int rem;				/* work */
7722
      /* slice off fraction digits and check for non-zero */
7723
      #if DECDPUN<=4
7724
	theInt=QUOT10(*up, count);
7725
	rem=*up-theInt*powers[count];
7726
      #else
7727
	rem=*up%powers[count];		/* slice off discards */
7728
	theInt=*up/powers[count];
7729
      #endif
7730
      if (rem!=0) return BADINT;	/* non-zero fraction */
7731
      /* it looks good */
7732
      got=DECDPUN-count;		/* number of digits so far */
7733
      up++;				/* ready for next */
7734
      }
7735
    }
7736
  /* now it's known there's no fractional part */
7737

7738
  /* tricky code now, to accumulate up to 9.3 digits */
7739
  if (got==0) {theInt=*up; got+=DECDPUN; up++;} /* ensure lsu is there */
7740

7741
  if (ilength<11) {
7742
    Int save=theInt;
7743
    /* collect any remaining unit(s) */
7744
    for (; got<ilength; up++) {
7745
      theInt+=*up*powers[got];
7746
      got+=DECDPUN;
7747
      }
7748
    if (ilength==10) {			/* need to check for wrap */
7749
      if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
7750
	 /* [that test also disallows the BADINT result case] */
7751
       else if (neg && theInt>1999999997) ilength=11;
7752
       else if (!neg && theInt>999999999) ilength=11;
7753
      if (ilength==11) theInt=save;	/* restore correct low bit */
7754
      }
7755
    }
7756

7757
  if (ilength>10) {			/* too big */
7758
    if (theInt&1) return BIGODD;	/* bottom bit 1 */
7759
    return BIGEVEN;			/* bottom bit 0 */
7760
    }
7761

7762
  if (neg) theInt=-theInt;		/* apply sign */
7763
  return theInt;
7764
  } /* decGetInt */
7765

7766
/* ------------------------------------------------------------------ */
7767
/* decDecap -- decapitate the coefficient of a number		      */
7768
/*								      */
7769
/*   dn	  is the number to be decapitated			      */
7770
/*   drop is the number of digits to be removed from the left of dn;  */
7771
/*     this must be <= dn->digits (if equal, the coefficient is	      */
7772
/*     set to 0)						      */
7773
/*								      */
7774
/* Returns dn; dn->digits will be <= the initial digits less drop     */
7775
/* (after removing drop digits there may be leading zero digits	      */
7776
/* which will also be removed).	 Only dn->lsu and dn->digits change.  */
7777
/* ------------------------------------------------------------------ */
7778
static decNumber *decDecap(decNumber *dn, Int drop) {
7779
  Unit *msu;				/* -> target cut point */
7780
  Int cut;				/* work */
7781
  if (drop>=dn->digits) {		/* losing the whole thing */
7782
    #if DECCHECK
7783
    if (drop>dn->digits)
7784
      printf("decDecap called with drop>digits [%ld>%ld]\n",
7785
	     (LI)drop, (LI)dn->digits);
7786
    #endif
7787
    dn->lsu[0]=0;
7788
    dn->digits=1;
7789
    return dn;
7790
    }
7791
  msu=dn->lsu+D2U(dn->digits-drop)-1;	/* -> likely msu */
7792
  cut=MSUDIGITS(dn->digits-drop);	/* digits to be in use in msu */
7793
  if (cut!=DECDPUN) *msu%=powers[cut];	/* clear left digits */
7794
  /* that may have left leading zero digits, so do a proper count... */
7795
  dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
7796
  return dn;
7797
  } /* decDecap */
7798

7799
/* ------------------------------------------------------------------ */
7800
/* decBiStr -- compare string with pairwise options		      */
7801
/*								      */
7802
/*   targ is the string to compare				      */
7803
/*   str1 is one of the strings to compare against (length may be 0)  */
7804
/*   str2 is the other; it must be the same length as str1	      */
7805
/*								      */
7806
/*   returns 1 if strings compare equal, (that is, it is the same     */
7807
/*   length as str1 and str2, and each character of targ is in either */
7808
/*   str1 or str2 in the corresponding position), or 0 otherwise      */
7809
/*								      */
7810
/* This is used for generic caseless compare, including the awkward   */
7811
/* case of the Turkish dotted and dotless Is.  Use as (for example):  */
7812
/*   if (decBiStr(test, "mike", "MIKE")) ...			      */
7813
/* ------------------------------------------------------------------ */
7814
static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
7815
  for (;;targ++, str1++, str2++) {
7816
    if (*targ!=*str1 && *targ!=*str2) return 0;
7817
    /* *targ has a match in one (or both, if terminator) */
7818
    if (*targ=='\0') break;
7819
    } /* forever */
7820
  return 1;
7821
  } /* decBiStr */
7822

7823
/* ------------------------------------------------------------------ */
7824
/* decNaNs -- handle NaN operand or operands			      */
7825
/*								      */
7826
/*   res     is the result number				      */
7827
/*   lhs     is the first operand				      */
7828
/*   rhs     is the second operand, or NULL if none		      */
7829
/*   context is used to limit payload length			      */
7830
/*   status  contains the current status			      */
7831
/*   returns res in case convenient				      */
7832
/*								      */
7833
/* Called when one or both operands is a NaN, and propagates the      */
7834
/* appropriate result to res.  When an sNaN is found, it is changed   */
7835
/* to a qNaN and Invalid operation is set.			      */
7836
/* ------------------------------------------------------------------ */
7837
static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
7838
			   const decNumber *rhs, decContext *set,
7839
			   uInt *status) {
7840
  /* This decision tree ends up with LHS being the source pointer, */
7841
  /* and status updated if need be */
7842
  if (lhs->bits & DECSNAN)
7843
    *status|=DEC_Invalid_operation | DEC_sNaN;
7844
   else if (rhs==NULL);
7845
   else if (rhs->bits & DECSNAN) {
7846
    lhs=rhs;
7847
    *status|=DEC_Invalid_operation | DEC_sNaN;
7848
    }
7849
   else if (lhs->bits & DECNAN);
7850
   else lhs=rhs;
7851

7852
  /* propagate the payload */
7853
  if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7854
   else { /* too long */
7855
    const Unit *ul;
7856
    Unit *ur, *uresp1;
7857
    /* copy safe number of units, then decapitate */
7858
    res->bits=lhs->bits;		/* need sign etc. */
7859
    uresp1=res->lsu+D2U(set->digits);
7860
    for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
7861
    res->digits=D2U(set->digits)*DECDPUN;
7862
    /* maybe still too long */
7863
    if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
7864
    }
7865

7866
  res->bits&=~DECSNAN;	      /* convert any sNaN to NaN, while */
7867
  res->bits|=DECNAN;	      /* .. preserving sign */
7868
  res->exponent=0;	      /* clean exponent */
7869
			      /* [coefficient was copied/decapitated] */
7870
  return res;
7871
  } /* decNaNs */
7872

7873
/* ------------------------------------------------------------------ */
7874
/* decStatus -- apply non-zero status				      */
7875
/*								      */
7876
/*   dn	    is the number to set if error			      */
7877
/*   status contains the current status (not yet in context)	      */
7878
/*   set    is the context					      */
7879
/*								      */
7880
/* If the status is an error status, the number is set to a NaN,      */
7881
/* unless the error was an overflow, divide-by-zero, or underflow,    */
7882
/* in which case the number will have already been set.		      */
7883
/*								      */
7884
/* The context status is then updated with the new status.  Note that */
7885
/* this may raise a signal, so control may never return from this     */
7886
/* routine (hence resources must be recovered before it is called).   */
7887
/* ------------------------------------------------------------------ */
7888
static void decStatus(decNumber *dn, uInt status, decContext *set) {
7889
  if (status & DEC_NaNs) {		/* error status -> NaN */
7890
    /* if cause was an sNaN, clear and propagate [NaN is already set up] */
7891
    if (status & DEC_sNaN) status&=~DEC_sNaN;
7892
     else {
7893
      decNumberZero(dn);		/* other error: clean throughout */
7894
      dn->bits=DECNAN;			/* and make a quiet NaN */
7895
      }
7896
    }
7897
  decContextSetStatus(set, status);	/* [may not return] */
7898
  return;
7899
  } /* decStatus */
7900

7901
/* ------------------------------------------------------------------ */
7902
/* decGetDigits -- count digits in a Units array		      */
7903
/*								      */
7904
/*   uar is the Unit array holding the number (this is often an	      */
7905
/*	    accumulator of some sort)				      */
7906
/*   len is the length of the array in units [>=1]		      */
7907
/*								      */
7908
/*   returns the number of (significant) digits in the array	      */
7909
/*								      */
7910
/* All leading zeros are excluded, except the last if the array has   */
7911
/* only zero Units.						      */
7912
/* ------------------------------------------------------------------ */
7913
/* This may be called twice during some operations. */
7914
static Int decGetDigits(Unit *uar, Int len) {
7915
  Unit *up=uar+(len-1);		   /* -> msu */
7916
  Int  digits=(len-1)*DECDPUN+1;   /* possible digits excluding msu */
7917
  #if DECDPUN>4
7918
  uInt const *pow;		   /* work */
7919
  #endif
7920
				   /* (at least 1 in final msu) */
7921
  #if DECCHECK
7922
  if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
7923
  #endif
7924

7925
  for (; up>=uar; up--) {
7926
    if (*up==0) {		   /* unit is all 0s */
7927
      if (digits==1) break;	   /* a zero has one digit */
7928
      digits-=DECDPUN;		   /* adjust for 0 unit */
7929
      continue;}
7930
    /* found the first (most significant) non-zero Unit */
7931
    #if DECDPUN>1		   /* not done yet */
7932
    if (*up<10) break;		   /* is 1-9 */
7933
    digits++;
7934
    #if DECDPUN>2		   /* not done yet */
7935
    if (*up<100) break;		   /* is 10-99 */
7936
    digits++;
7937
    #if DECDPUN>3		   /* not done yet */
7938
    if (*up<1000) break;	   /* is 100-999 */
7939
    digits++;
7940
    #if DECDPUN>4		   /* count the rest ... */
7941
    for (pow=&powers[4]; *up>=*pow; pow++) digits++;
7942
    #endif
7943
    #endif
7944
    #endif
7945
    #endif
7946
    break;
7947
    } /* up */
7948
  return digits;
7949
  } /* decGetDigits */
7950

7951
/* ------------------------------------------------------------------ */
7952
/* mulUInt128ByPowOf10 -- multiply a 128-bit unsigned integer by a    */
7953
/* power of 10.                                                       */
7954
/*                                                                    */
7955
/*   The 128-bit factor composed of plow and phigh is multiplied      */
7956
/*   by 10^exp.                                                       */
7957
/*                                                                    */
7958
/*   plow   pointer to the low 64 bits of the first factor            */
7959
/*   phigh  pointer to the high 64 bits of the first factor           */
7960
/*   exp    the exponent of the power of 10 of the second factor      */
7961
/*                                                                    */
7962
/* If the result fits in 128 bits, returns false and the              */
7963
/* multiplication result through plow and phigh.                      */
7964
/* Otherwise, returns true.                                           */
7965
/* ------------------------------------------------------------------ */
7966
static bool mulUInt128ByPowOf10(uLong *plow, uLong *phigh, uInt pow10)
7967
{
7968
    while (pow10 >= ARRAY_SIZE(powers)) {
7969
        if (mulu128(plow, phigh, powers[ARRAY_SIZE(powers) - 1])) {
7970
            /* Overflow */
7971
            return true;
7972
        }
7973
        pow10 -= ARRAY_SIZE(powers) - 1;
7974
    }
7975

7976
    if (pow10 > 0) {
7977
        return mulu128(plow, phigh, powers[pow10]);
7978
    } else {
7979
        return false;
7980
    }
7981
}
7982

7983
#if DECTRACE | DECCHECK
7984
/* ------------------------------------------------------------------ */
7985
/* decNumberShow -- display a number [debug aid]		      */
7986
/*   dn is the number to show					      */
7987
/*								      */
7988
/* Shows: sign, exponent, coefficient (msu first), digits	      */
7989
/*    or: sign, special-value					      */
7990
/* ------------------------------------------------------------------ */
7991
/* this is public so other modules can use it */
7992
void decNumberShow(const decNumber *dn) {
7993
  const Unit *up;		   /* work */
7994
  uInt u, d;			   /* .. */
7995
  Int cut;			   /* .. */
7996
  char isign='+';		   /* main sign */
7997
  if (dn==NULL) {
7998
    printf("NULL\n");
7999
    return;}
8000
  if (decNumberIsNegative(dn)) isign='-';
8001
  printf(" >> %c ", isign);
8002
  if (dn->bits&DECSPECIAL) {	   /* Is a special value */
8003
    if (decNumberIsInfinite(dn)) printf("Infinity");
8004
     else {				     /* a NaN */
8005
      if (dn->bits&DECSNAN) printf("sNaN");  /* signalling NaN */
8006
       else printf("NaN");
8007
      }
8008
    /* if coefficient and exponent are 0, no more to do */
8009
    if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
8010
      printf("\n");
8011
      return;}
8012
    /* drop through to report other information */
8013
    printf(" ");
8014
    }
8015

8016
  /* now carefully display the coefficient */
8017
  up=dn->lsu+D2U(dn->digits)-1;		/* msu */
8018
  printf("%ld", (LI)*up);
8019
  for (up=up-1; up>=dn->lsu; up--) {
8020
    u=*up;
8021
    printf(":");
8022
    for (cut=DECDPUN-1; cut>=0; cut--) {
8023
      d=u/powers[cut];
8024
      u-=d*powers[cut];
8025
      printf("%ld", (LI)d);
8026
      } /* cut */
8027
    } /* up */
8028
  if (dn->exponent!=0) {
8029
    char esign='+';
8030
    if (dn->exponent<0) esign='-';
8031
    printf(" E%c%ld", esign, (LI)abs(dn->exponent));
8032
    }
8033
  printf(" [%ld]\n", (LI)dn->digits);
8034
  } /* decNumberShow */
8035
#endif
8036

8037
#if DECTRACE || DECCHECK
8038
/* ------------------------------------------------------------------ */
8039
/* decDumpAr -- display a unit array [debug/check aid]		      */
8040
/*   name is a single-character tag name			      */
8041
/*   ar	  is the array to display				      */
8042
/*   len  is the length of the array in Units			      */
8043
/* ------------------------------------------------------------------ */
8044
static void decDumpAr(char name, const Unit *ar, Int len) {
8045
  Int i;
8046
  const char *spec;
8047
  #if DECDPUN==9
8048
    spec="%09d ";
8049
  #elif DECDPUN==8
8050
    spec="%08d ";
8051
  #elif DECDPUN==7
8052
    spec="%07d ";
8053
  #elif DECDPUN==6
8054
    spec="%06d ";
8055
  #elif DECDPUN==5
8056
    spec="%05d ";
8057
  #elif DECDPUN==4
8058
    spec="%04d ";
8059
  #elif DECDPUN==3
8060
    spec="%03d ";
8061
  #elif DECDPUN==2
8062
    spec="%02d ";
8063
  #else
8064
    spec="%d ";
8065
  #endif
8066
  printf("  :%c: ", name);
8067
  for (i=len-1; i>=0; i--) {
8068
    if (i==len-1) printf("%ld ", (LI)ar[i]);
8069
     else printf(spec, ar[i]);
8070
    }
8071
  printf("\n");
8072
  return;}
8073
#endif
8074

8075
#if DECCHECK
8076
/* ------------------------------------------------------------------ */
8077
/* decCheckOperands -- check operand(s) to a routine		      */
8078
/*   res is the result structure (not checked; it will be set to      */
8079
/*	    quiet NaN if error found (and it is not NULL))	      */
8080
/*   lhs is the first operand (may be DECUNRESU)		      */
8081
/*   rhs is the second (may be DECUNUSED)			      */
8082
/*   set is the context (may be DECUNCONT)			      */
8083
/*   returns 0 if both operands, and the context are clean, or 1      */
8084
/*     otherwise (in which case the context will show an error,	      */
8085
/*     unless NULL).  Note that res is not cleaned; caller should     */
8086
/*     handle this so res=NULL case is safe.			      */
8087
/* The caller is expected to abandon immediately if 1 is returned.    */
8088
/* ------------------------------------------------------------------ */
8089
static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
8090
			     const decNumber *rhs, decContext *set) {
8091
  Flag bad=0;
8092
  if (set==NULL) {		   /* oops; hopeless */
8093
    #if DECTRACE || DECVERB
8094
    printf("Reference to context is NULL.\n");
8095
    #endif
8096
    bad=1;
8097
    return 1;}
8098
   else if (set!=DECUNCONT
8099
     && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
8100
    bad=1;
8101
    #if DECTRACE || DECVERB
8102
    printf("Bad context [digits=%ld round=%ld].\n",
8103
	   (LI)set->digits, (LI)set->round);
8104
    #endif
8105
    }
8106
   else {
8107
    if (res==NULL) {
8108
      bad=1;
8109
      #if DECTRACE
8110
      /* this one not DECVERB as standard tests include NULL */
8111
      printf("Reference to result is NULL.\n");
8112
      #endif
8113
      }
8114
    if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
8115
    if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
8116
    }
8117
  if (bad) {
8118
    if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
8119
    if (res!=DECUNRESU && res!=NULL) {
8120
      decNumberZero(res);
8121
      res->bits=DECNAN;	      /* qNaN */
8122
      }
8123
    }
8124
  return bad;
8125
  } /* decCheckOperands */
8126

8127
/* ------------------------------------------------------------------ */
8128
/* decCheckNumber -- check a number				      */
8129
/*   dn is the number to check					      */
8130
/*   returns 0 if the number is clean, or 1 otherwise		      */
8131
/*								      */
8132
/* The number is considered valid if it could be a result from some   */
8133
/* operation in some valid context.				      */
8134
/* ------------------------------------------------------------------ */
8135
static Flag decCheckNumber(const decNumber *dn) {
8136
  const Unit *up;	      /* work */
8137
  uInt maxuint;		      /* .. */
8138
  Int ae, d, digits;	      /* .. */
8139
  Int emin, emax;	      /* .. */
8140

8141
  if (dn==NULL) {	      /* hopeless */
8142
    #if DECTRACE
8143
    /* this one not DECVERB as standard tests include NULL */
8144
    printf("Reference to decNumber is NULL.\n");
8145
    #endif
8146
    return 1;}
8147

8148
  /* check special values */
8149
  if (dn->bits & DECSPECIAL) {
8150
    if (dn->exponent!=0) {
8151
      #if DECTRACE || DECVERB
8152
      printf("Exponent %ld (not 0) for a special value [%02x].\n",
8153
	     (LI)dn->exponent, dn->bits);
8154
      #endif
8155
      return 1;}
8156

8157
    /* 2003.09.08: NaNs may now have coefficients, so next tests Inf only */
8158
    if (decNumberIsInfinite(dn)) {
8159
      if (dn->digits!=1) {
8160
	#if DECTRACE || DECVERB
8161
	printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
8162
	#endif
8163
	return 1;}
8164
      if (*dn->lsu!=0) {
8165
	#if DECTRACE || DECVERB
8166
	printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
8167
	#endif
8168
	decDumpAr('I', dn->lsu, D2U(dn->digits));
8169
	return 1;}
8170
      } /* Inf */
8171
    /* 2002.12.26: negative NaNs can now appear through proposed IEEE */
8172
    /*		   concrete formats (decimal64, etc.). */
8173
    return 0;
8174
    }
8175

8176
  /* check the coefficient */
8177
  if (dn->digits<1 || dn->digits>DECNUMMAXP) {
8178
    #if DECTRACE || DECVERB
8179
    printf("Digits %ld in number.\n", (LI)dn->digits);
8180
    #endif
8181
    return 1;}
8182

8183
  d=dn->digits;
8184

8185
  for (up=dn->lsu; d>0; up++) {
8186
    if (d>DECDPUN) maxuint=DECDPUNMAX;
8187
     else {		      /* reached the msu */
8188
      maxuint=powers[d]-1;
8189
      if (dn->digits>1 && *up<powers[d-1]) {
8190
	#if DECTRACE || DECVERB
8191
	printf("Leading 0 in number.\n");
8192
	decNumberShow(dn);
8193
	#endif
8194
	return 1;}
8195
      }
8196
    if (*up>maxuint) {
8197
      #if DECTRACE || DECVERB
8198
      printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
8199
	      (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
8200
      #endif
8201
      return 1;}
8202
    d-=DECDPUN;
8203
    }
8204

8205
  /* check the exponent.  Note that input operands can have exponents */
8206
  /* which are out of the set->emin/set->emax and set->digits range */
8207
  /* (just as they can have more digits than set->digits). */
8208
  ae=dn->exponent+dn->digits-1;	   /* adjusted exponent */
8209
  emax=DECNUMMAXE;
8210
  emin=DECNUMMINE;
8211
  digits=DECNUMMAXP;
8212
  if (ae<emin-(digits-1)) {
8213
    #if DECTRACE || DECVERB
8214
    printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
8215
    decNumberShow(dn);
8216
    #endif
8217
    return 1;}
8218
  if (ae>+emax) {
8219
    #if DECTRACE || DECVERB
8220
    printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
8221
    decNumberShow(dn);
8222
    #endif
8223
    return 1;}
8224

8225
  return 0;		 /* it's OK */
8226
  } /* decCheckNumber */
8227

8228
/* ------------------------------------------------------------------ */
8229
/* decCheckInexact -- check a normal finite inexact result has digits */
8230
/*   dn is the number to check					      */
8231
/*   set is the context (for status and precision)		      */
8232
/*   sets Invalid operation, etc., if some digits are missing	      */
8233
/* [this check is not made for DECSUBSET compilation or when	      */
8234
/* subnormal is not set]					      */
8235
/* ------------------------------------------------------------------ */
8236
static void decCheckInexact(const decNumber *dn, decContext *set) {
8237
  #if !DECSUBSET && DECEXTFLAG
8238
    if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
8239
     && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
8240
      #if DECTRACE || DECVERB
8241
      printf("Insufficient digits [%ld] on normal Inexact result.\n",
8242
	     (LI)dn->digits);
8243
      decNumberShow(dn);
8244
      #endif
8245
      decContextSetStatus(set, DEC_Invalid_operation);
8246
      }
8247
  #else
8248
    /* next is a noop for quiet compiler */
8249
    if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
8250
  #endif
8251
  return;
8252
  } /* decCheckInexact */
8253
#endif
8254

8255
#if DECALLOC
8256
#undef malloc
8257
#undef free
8258
/* ------------------------------------------------------------------ */
8259
/* decMalloc -- accountable allocation routine			      */
8260
/*   n is the number of bytes to allocate			      */
8261
/*								      */
8262
/* Semantics is the same as the stdlib malloc routine, but bytes      */
8263
/* allocated are accounted for globally, and corruption fences are    */
8264
/* added before and after the 'actual' storage.			      */
8265
/* ------------------------------------------------------------------ */
8266
/* This routine allocates storage with an extra twelve bytes; 8 are   */
8267
/* at the start and hold:					      */
8268
/*   0-3 the original length requested				      */
8269
/*   4-7 buffer corruption detection fence (DECFENCE, x4)	      */
8270
/* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
8271
/* ------------------------------------------------------------------ */
8272
static void *decMalloc(size_t n) {
8273
  uInt	size=n+12;		   /* true size */
8274
  void	*alloc;			   /* -> allocated storage */
8275
  uInt	*j;			   /* work */
8276
  uByte *b, *b0;		   /* .. */
8277

8278
  alloc=malloc(size);		   /* -> allocated storage */
8279
  if (alloc==NULL) return NULL;	   /* out of strorage */
8280
  b0=(uByte *)alloc;		   /* as bytes */
8281
  decAllocBytes+=n;		   /* account for storage */
8282
  j=(uInt *)alloc;		   /* -> first four bytes */
8283
  *j=n;				   /* save n */
8284
  /* printf(" alloc ++ dAB: %ld (%d)\n", decAllocBytes, n); */
8285
  for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
8286
  for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
8287
  return b0+8;			   /* -> play area */
8288
  } /* decMalloc */
8289

8290
/* ------------------------------------------------------------------ */
8291
/* decFree -- accountable free routine				      */
8292
/*   alloc is the storage to free				      */
8293
/*								      */
8294
/* Semantics is the same as the stdlib malloc routine, except that    */
8295
/* the global storage accounting is updated and the fences are	      */
8296
/* checked to ensure that no routine has written 'out of bounds'.     */
8297
/* ------------------------------------------------------------------ */
8298
/* This routine first checks that the fences have not been corrupted. */
8299
/* It then frees the storage using the 'truw' storage address (that   */
8300
/* is, offset by 8).						      */
8301
/* ------------------------------------------------------------------ */
8302
static void decFree(void *alloc) {
8303
  uInt	*j, n;			   /* pointer, original length */
8304
  uByte *b, *b0;		   /* work */
8305

8306
  if (alloc==NULL) return;	   /* allowed; it's a nop */
8307
  b0=(uByte *)alloc;		   /* as bytes */
8308
  b0-=8;			   /* -> true start of storage */
8309
  j=(uInt *)b0;			   /* -> first four bytes */
8310
  n=*j;				   /* lift */
8311
  for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
8312
    printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
8313
	   b-b0-8, (Int)b0);
8314
  for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
8315
    printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
8316
	   b-b0-8, (Int)b0, n);
8317
  free(b0);			   /* drop the storage */
8318
  decAllocBytes-=n;		   /* account for storage */
8319
  /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n); */
8320
  } /* decFree */
8321
#define malloc(a) decMalloc(a)
8322
#define free(a) decFree(a)
8323
#endif
8324