157 /*	lhs -- left hand side (operand, of an operation)	      */
229 static Int	   decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
280 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
927 /*   lhs is A							      */
934 decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,  in decNumberAdd()  argument
937   decAddOp(res, lhs, rhs, set, 0, &status);  in decNumberAdd()
951 /*   lhs is A							      */
960 decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,  in decNumberAnd()  argument
967   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberAnd()
970   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)  in decNumberAnd()
977   ua=lhs->lsu;				/* bottom-up */  in decNumberAnd()
980   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */  in decNumberAnd()
1022 /*   lhs is A							      */
1028 decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,  in decNumberCompare()  argument
1031   decCompareOp(res, lhs, rhs, set, COMPARE, &status);  in decNumberCompare()
1042 /*   lhs is A							      */
1048 decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,  in decNumberCompareSignal()  argument
1051   decCompareOp(res, lhs, rhs, set, COMPSIG, &status);  in decNumberCompareSignal()
1062 /*   lhs is A							      */
1069 decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,  in decNumberCompareTotal()  argument
1072   decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);  in decNumberCompareTotal()
1083 /*   lhs is A							      */
1090 decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,  in decNumberCompareTotalMag()  argument
1101   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberCompareTotalMag()
1106     if (decNumberIsNegative(lhs)) {	/* lhs<0 */  in decNumberCompareTotalMag()
1108       needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);  in decNumberCompareTotalMag()
1116       decNumberCopy(a, lhs);		/* copy content */  in decNumberCompareTotalMag()
1118       lhs=a;				/* use copy from here on */  in decNumberCompareTotalMag()
1134     decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);  in decNumberCompareTotalMag()
1149 /*   lhs is A							      */
1155 decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,  in decNumberDivide()  argument
1158   decDivideOp(res, lhs, rhs, set, DIVIDE, &status);  in decNumberDivide()
1172 /*   lhs is A							      */
1178 decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,  in decNumberDivideInteger()  argument
1181   decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);  in decNumberDivideInteger()
1257 /*   lhs is A							      */
1267 decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,  in decNumberFMA()  argument
1279   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberFMA()
1290     if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))  in decNumberFMA()
1295     dcmul.digits=lhs->digits+rhs->digits; /* just enough */  in decNumberFMA()
1311     decMultiplyOp(acc, lhs, rhs, &dcmul, &status);  in decNumberFMA()
1695 /*   lhs is A							      */
1701 decNumber * decNumberMax(decNumber *res, const decNumber *lhs,  in decNumberMax()  argument
1704   decCompareOp(res, lhs, rhs, set, COMPMAX, &status);  in decNumberMax()
1718 /*   lhs is A							      */
1724 decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,  in decNumberMaxMag()  argument
1727   decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);  in decNumberMaxMag()
1741 /*   lhs is A							      */
1747 decNumber * decNumberMin(decNumber *res, const decNumber *lhs,  in decNumberMin()  argument
1750   decCompareOp(res, lhs, rhs, set, COMPMIN, &status);  in decNumberMin()
1764 /*   lhs is A							      */
1770 decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,  in decNumberMinMag()  argument
1773   decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);  in decNumberMinMag()
1894 /*   lhs is A							      */
1900 decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,  in decNumberNextToward()  argument
1907   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberNextToward()
1910   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {  in decNumberNextToward()
1911     decNaNs(res, lhs, rhs, set, &status);  in decNumberNextToward()
1914     result=decCompare(lhs, rhs, 0);	/* sign matters */  in decNumberNextToward()
1917       if (result==0) decNumberCopySign(res, lhs, rhs); /* easy */  in decNumberNextToward()
1920 	if (result<0) {			/* lhs<rhs, do nextplus */  in decNumberNextToward()
1922 	  if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {  in decNumberNextToward()
1930 	 else {				/* lhs>rhs, do nextminus */  in decNumberNextToward()
1932 	  if ((lhs->bits&(DECINF|DECNEG))==DECINF) {  in decNumberNextToward()
1942 	decAddOp(res, lhs, &dtiny, &workset, sub, &status); /* + or - */  in decNumberNextToward()
1959 /*   lhs is A							      */
1968 decNumber * decNumberOr(decNumber *res, const decNumber *lhs,  in decNumberOr()  argument
1975   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberOr()
1978   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)  in decNumberOr()
1984   ua=lhs->lsu;				/* bottom-up */  in decNumberOr()
1987   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */  in decNumberOr()
2062 /*   lhs is A							      */
2068 decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,  in decNumberMultiply()  argument
2071   decMultiplyOp(res, lhs, rhs, set, &status);  in decNumberMultiply()
2085 /*   lhs is A							      */
2105 decNumber * decNumberPower(decNumber *res, const decNumber *lhs,  in decNumberPower()  argument
2108   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */  in decNumberPower()
2132   /* same again for possible 1/lhs calculation */  in decNumberPower()
2136   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberPower()
2142       if (lhs->digits>reqdigits) {  in decNumberPower()
2143 	alloclhs=decRoundOperand(lhs, set, &status);  in decNumberPower()
2145 	lhs=alloclhs;  in decNumberPower()
2156     /* handle NaNs and rhs Infinity (lhs infinity is harder) */  in decNumberPower()
2158       if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { /* NaNs */  in decNumberPower()
2159 	decNaNs(res, lhs, rhs, set, &status);  in decNumberPower()
2163 	if (decNumberIsNegative(lhs)	/* lhs<0 */  in decNumberPower()
2164 	 && !decNumberIsZero(lhs))	/* .. */  in decNumberPower()
2166 	 else {				/* lhs >=0 */  in decNumberPower()
2169 	  decNumberCompare(dac, lhs, &dnOne, set); /* lhs ? 1 */  in decNumberPower()
2171 	  if (decNumberIsNegative(dac)) {    /* lhs<1 */  in decNumberPower()
2174 	   else if (dac->lsu[0]==0) {	     /* lhs=1 */  in decNumberPower()
2182 	   else {			     /* lhs>1 */  in decNumberPower()
2185 	  } /* lhs>=0 */  in decNumberPower()
2187       /* [lhs infinity drops through] */  in decNumberPower()
2199     if (decNumberIsNegative(lhs)	/* -x .. */  in decNumberPower()
2202     /* handle LHS infinity */  in decNumberPower()
2203     if (decNumberIsInfinite(lhs)) {	/* [NaNs already handled] */  in decNumberPower()
2209 	if (!rhsint && decNumberIsNegative(lhs)) {  in decNumberPower()
2218     /* similarly handle LHS zero */  in decNumberPower()
2219     if (decNumberIsZero(lhs)) {  in decNumberPower()
2245     /* here both lhs and rhs are finite; rhs==0 is handled in the */  in decNumberPower()
2248       /* any -ve lhs is bad, as is either operand or context out of */  in decNumberPower()
2250       if (decNumberIsNegative(lhs)) {  in decNumberPower()
2253       if (decCheckMath(lhs, set, &status)  in decNumberPower()
2261       /* calculate the result using exp(ln(lhs)*rhs), which can */  in decNumberPower()
2263       /* is enough to contain the full information in the lhs (which */  in decNumberPower()
2271       aset.digits=MAXI(lhs->digits, set->digits)+6+4;  in decNumberPower()
2297     /* [needbytes also used below if 1/lhs needed] */  in decNumberPower()
2311       decLnOp(dac, lhs, &aset, &status);     /* dac=ln(lhs) */  in decNumberPower()
2312       /* [no error possible, as lhs 0 already handled] */  in decNumberPower()
2335       /* invert the lhs now rather than inverting the result later */  in decNumberPower()
2340 	if (set->extended) {		/* need to calculate 1/lhs */  in decNumberPower()
2342 	  /* divide lhs into 1, putting result in dac [dac=1/dac] */  in decNumberPower()
2343 	  decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);  in decNumberPower()
2344 	  /* now locate or allocate space for the inverted lhs */  in decNumberPower()
2353 	  decNumberCopy(inv, dac);	/* copy the 1/lhs */  in decNumberPower()
2355 	  lhs=inv;			/* .. and go forward with new lhs */  in decNumberPower()
2373 	  decMultiplyOp(dac, dac, lhs, &aset, &status); /* dac=dac*x */  in decNumberPower()
2441 /*   lhs is A, the number to adjust				      */
2450 decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,  in decNumberQuantize()  argument
2453   decQuantizeOp(res, lhs, rhs, set, 1, &status);  in decNumberQuantize()
2529 /*   lhs is A, the number to adjust				      */
2538 decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,  in decNumberRescale()  argument
2541   decQuantizeOp(res, lhs, rhs, set, 0, &status);  in decNumberRescale()
2552 /*   lhs is A							      */
2558 decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,  in decNumberRemainder()  argument
2561   decDivideOp(res, lhs, rhs, set, REMAINDER, &status);  in decNumberRemainder()
2575 /*   lhs is A							      */
2581 decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,  in decNumberRemainderNear()  argument
2584   decDivideOp(res, lhs, rhs, set, REMNEAR, &status);  in decNumberRemainderNear()
2599 /*   lhs is A							      */
2605 /* the exponent or the sign of A.  If lhs->digits is less than	      */
2617 decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,  in decNumberRotate()  argument
2623   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberRotate()
2627   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))  in decNumberRotate()
2628     decNaNs(res, lhs, rhs, set, &status);  in decNumberRotate()
2639       decNumberCopy(res, lhs);  in decNumberRotate()
2643        && !decNumberIsInfinite(res)) {	     /* lhs was infinite */  in decNumberRotate()
2733 /*   lhs is a number to test					      */
2738 decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,  in decNumberSameQuantum()  argument
2743   if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;  in decNumberSameQuantum()
2747     if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;  in decNumberSameQuantum()
2748      else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;  in decNumberSameQuantum()
2751    else if (lhs->exponent==rhs->exponent) ret=1;  in decNumberSameQuantum()
2765 /*   lhs is A, the number to adjust				      */
2773 decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,  in decNumberScaleB()  argument
2780   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberScaleB()
2783   /* Handle special values except lhs infinite */  in decNumberScaleB()
2784   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))  in decNumberScaleB()
2785     decNaNs(res, lhs, rhs, set, &status);  in decNumberScaleB()
2790     /* lhs is a number; rhs is a finite with q==0 */  in decNumberScaleB()
2797       decNumberCopy(res, lhs);		     /* all done if infinite lhs */  in decNumberScaleB()
2802 	} /* finite LHS */  in decNumberScaleB()
2815 /*   lhs is A							      */
2830 decNumber * decNumberShift(decNumber *res, const decNumber *lhs,  in decNumberShift()  argument
2836   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberShift()
2840   if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))  in decNumberShift()
2841     decNaNs(res, lhs, rhs, set, &status);  in decNumberShift()
2852       decNumberCopy(res, lhs);  in decNumberShift()
3287 /*   lhs is A							      */
3293 decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,  in decNumberSubtract()  argument
3297   decAddOp(res, lhs, rhs, set, DECNEG, &status);  in decNumberSubtract()
3373 /*   lhs is A							      */
3382 decNumber * decNumberXor(decNumber *res, const decNumber *lhs,  in decNumberXor()  argument
3389   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decNumberXor()
3392   if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)  in decNumberXor()
3398   ua=lhs->lsu;				/* bottom-up */  in decNumberXor()
3401   msua=ua+D2U(lhs->digits)-1;		/* -> msu of lhs */  in decNumberXor()
3576 /*   lhs is A							      */
3582 decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,  in decNumberCopySign()  argument
3589   decNumberCopy(res, lhs);  in decNumberCopySign()
3921 /*   lhs is A							      */
3950 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,  in decAddOp()  argument
3954   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */  in decAddOp()
3972   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decAddOp()
3979       if (lhs->digits>reqdigits) {  in decAddOp()
3980 	alloclhs=decRoundOperand(lhs, set, status);  in decAddOp()
3982 	lhs=alloclhs;  in decAddOp()
3994     diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);  in decAddOp()
3999 	decNaNs(res, lhs, rhs, set, status);  in decAddOp()
4001 	if (decNumberIsInfinite(lhs)) { /* LHS is infinity */  in decAddOp()
4007 	  bits=lhs->bits & DECNEG;	/* get sign from LHS */  in decAddOp()
4018     if (ISZERO(lhs)) {  in decAddOp()
4020       Int lexp=lhs->exponent;		/* save in case LHS==RES */  in decAddOp()
4021       bits=lhs->bits;			/* .. */  in decAddOp()
4054     if (ISZERO(rhs)) {			/* [lhs is non-zero] */  in decAddOp()
4059       decCopyFit(res, lhs, set, &residue, status); /* copy (as needed) */  in decAddOp()
4084     padding=rhs->exponent-lhs->exponent;  in decAddOp()
4094 	&& lhs->digits<=reqdigits) {  in decAddOp()
4095       Int partial=*lhs->lsu;  in decAddOp()
4099 	 && (lhs->digits>=DECDPUN ||	/* .. and no digits-count change */  in decAddOp()
4100 	     partial<(Int)powers[lhs->digits])) { /* .. */  in decAddOp()
4101 	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */  in decAddOp()
4110 	  if (res!=lhs) decNumberCopy(res, lhs);  /* not in place */  in decAddOp()
4120     /* Now align (pad) the lhs or rhs so they can be added or */  in decAddOp()
4128     bits=lhs->bits;	      /* assume sign is that of LHS */  in decAddOp()
4137       if (padding<0) {			/* LHS needs the padding */  in decAddOp()
4141 	t=lhs; lhs=rhs; rhs=t;  in decAddOp()
4145       /* If, after pad, rhs would be longer than lhs by digits+1 or */  in decAddOp()
4146       /* more then lhs cannot affect the answer, except as a residue, */  in decAddOp()
4148       if (rhs->digits+padding > lhs->digits+reqdigits+1) {  in decAddOp()
4166       /* LHS digits may affect result */  in decAddOp()
4175     if (lhs->digits>maxdigits) maxdigits=lhs->digits;  in decAddOp()
4200     res->exponent=lhs->exponent;	/* .. operands (even if aliased) */  in decAddOp()
4203       decDumpAr('A', lhs->lsu, D2U(lhs->digits));  in decAddOp()
4209     res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),  in decAddOp()
4303 /*   lhs is A							      */
4360 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
4365 			       const decNumber *lhs, const decNumber *rhs,  in decDivideOp()  argument
4368   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */  in decDivideOp()
4392   Int	maxdigits;		   /* longest LHS or required acc length */  in decDivideOp()
4409   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decDivideOp()
4416       if (lhs->digits>reqdigits) {  in decDivideOp()
4417 	alloclhs=decRoundOperand(lhs, set, status);  in decDivideOp()
4419 	lhs=alloclhs;  in decDivideOp()
4430     bits=(lhs->bits^rhs->bits)&DECNEG;	/* assumed sign for divisions */  in decDivideOp()
4435 	decNaNs(res, lhs, rhs, set, status);  in decDivideOp()
4439       if (decNumberIsInfinite(lhs)) {	/* LHS (dividend) is infinite */  in decDivideOp()
4453 	  /* result is [finished clone of] lhs */  in decDivideOp()
4454 	  decCopyFit(res, lhs, set, &residue, status);  in decDivideOp()
4473       if (ISZERO(lhs)) {  in decDivideOp()
4474 	decNumberZero(res);		/* [after lhs test] */  in decDivideOp()
4487     /* handle 0 lhs (0/x) */  in decDivideOp()
4488     if (ISZERO(lhs)) {			/* 0/x [x!=0] */  in decDivideOp()
4495 	  exponent=lhs->exponent-rhs->exponent; /* ideal exponent */  in decDivideOp()
4496 	  decNumberCopy(res, lhs);	/* [zeros always fit] */  in decDivideOp()
4507 	  decNumberCopy(res, lhs);	/* [zeros always fit] */  in decDivideOp()
4519     exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);  in decDivideOp()
4532       /* fastpath remainders so long as the lhs has the smaller */  in decDivideOp()
4534       if (lhs->exponent<=rhs->exponent) {  in decDivideOp()
4537 	  /* clone of] lhs  (r = x - 0*y) */  in decDivideOp()
4539 	  decCopyFit(res, lhs, set, &residue, status);  in decDivideOp()
4561     /* var1 is the padded LHS ready for subtractions. */  in decDivideOp()
4566     /* or  (lhs->digits)	     -- to allow for long lhs */  in decDivideOp()
4573     if (lhs->digits>maxdigits) maxdigits=lhs->digits;  in decDivideOp()
4586     /* Extend the lhs and rhs to full long subtraction length.	The lhs */  in decDivideOp()
4593     source=lhs->lsu+D2U(lhs->digits)-1; /* msu of input array */  in decDivideOp()
4594     for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;  in decDivideOp()
4630       var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;  in decDivideOp()
4641       maxexponent=lhs->exponent-rhs->exponent;	  /* save */  in decDivideOp()
4810 	bits=lhs->bits;			     /* remainder sign is always as lhs */  in decDivideOp()
4815 	  Int exp=lhs->exponent;	     /* save min(exponents) */  in decDivideOp()
4835 	postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;  in decDivideOp()
4845 	exponent=lhs->exponent;		/* exponent is smaller of lhs & rhs */  in decDivideOp()
4953 /*   lhs is A							      */
4984 static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,  in decMultiplyOp()  argument
5016     uInt  *zlhi=zlhibuff;		  /* -> lhs array */  in decMultiplyOp()
5046   if (decCheckOperands(res, lhs, rhs, set)) return res;  in decMultiplyOp()
5050   bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);  in decMultiplyOp()
5055       decNaNs(res, lhs, rhs, set, status);  in decMultiplyOp()
5058     if (((lhs->bits & DECINF)==0 && ISZERO(lhs))  in decMultiplyOp()
5068   /* the longer as the multiplicand (lhs) to minimise the number of */  in decMultiplyOp()
5070   if (lhs->digits<rhs->digits) {   /* swap... */  in decMultiplyOp()
5071     const decNumber *hold=lhs;  in decMultiplyOp()
5072     lhs=rhs;  in decMultiplyOp()
5080       if (lhs->digits>set->digits) {  in decMultiplyOp()
5081 	alloclhs=decRoundOperand(lhs, set, status);  in decMultiplyOp()
5083 	lhs=alloclhs;  in decMultiplyOp()
5100       ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; /* [ceiling] */  in decMultiplyOp()
5139       for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)  in decMultiplyOp()
5172 	lp=zacc+(rip-zrhi);		     /* where to add the lhs */  in decMultiplyOp()
5173 	for (lip=zlhi; lip<=lmsi; lip++, lp++) { /* over each item in lhs */  in decMultiplyOp()
5221       needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);  in decMultiplyOp()
5236       madlength=D2U(lhs->digits);  /* this won't change */  in decMultiplyOp()
5243 					    lhs->lsu, madlength, 0,  in decMultiplyOp()
5272     exponent=lhs->exponent+rhs->exponent;    /* calculate exponent */  in decMultiplyOp()
5273     if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)  in decMultiplyOp()
5967 /*   lhs is A, the number to adjust				      */
5979 static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,  argument
5983   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
5993   if (decCheckOperands(res, lhs, rhs, set)) return res;
6000       if (lhs->digits>reqdigits) {
6001 	alloclhs=decRoundOperand(lhs, set, status);
6003 	lhs=alloclhs;
6018 	decNaNs(res, lhs, rhs, set, status);
6020       else if ((lhs->bits ^ rhs->bits) & DECINF)
6022       /* both infinity: return lhs */
6023       else decNumberCopy(res, lhs);	     /* [nop if in place] */
6048     if (ISZERO(lhs)) {			     /* zero coefficient unchanged */
6049       decNumberCopy(res, lhs);		     /* [nop if in place] */
6055      else {				     /* non-zero lhs */
6056       Int adjust=reqexp-lhs->exponent;	     /* digit adjustment needed */
6058       if ((lhs->digits-adjust)>reqdigits) {
6068 	workset.digits=lhs->digits-adjust;   /* set requested length */
6070 	decCopyFit(res, lhs, &workset, &residue, status); /* fit to result */
6094 	decNumberCopy(res, lhs);	     /* [it will fit] */
6140 /*   lhs is A							      */
6152 static decNumber *decCompareOp(decNumber *res, const decNumber *lhs,  argument
6156   decNumber *alloclhs=NULL;	   /* non-NULL if rounded lhs allocated */
6163   if (decCheckOperands(res, lhs, rhs, set)) return res;
6170       if (lhs->digits>set->digits) {
6171 	alloclhs=decRoundOperand(lhs, set, status);
6173 	lhs=alloclhs;
6186       if (decNumberIsNegative(lhs) && !decNumberIsNegative(rhs)) {
6190       if (!decNumberIsNegative(lhs) && decNumberIsNegative(rhs)) {
6198     merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6206 	if (!decNumberIsNaN(lhs)) result=-1;
6209 	 else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
6210 	 else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
6213 	  result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6217 	if (decNumberIsNegative(lhs)) result=-result;
6224 	if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
6227 	  if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6228 			     else result=+1; /* pick lhs */
6233       decNaNs(res, lhs, rhs, set, status);   /* propagate NaN */
6237     if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
6238      else result=decCompare(lhs, rhs, 0);    /* sign matters */
6247 	if (lhs->exponent!=rhs->exponent) {
6248 	  if (lhs->exponent<rhs->exponent) result=-1;
6250 	  if (decNumberIsNegative(lhs)) result=-result;
6266 	uByte slhs=(lhs->bits & DECNEG);
6277 	       else result=+1;	   /* lhs is max */
6280 	  if (lhs->exponent<rhs->exponent) result=+1;
6282 	  /* [if equal, use lhs, technically identical] */
6285 	  if (lhs->exponent>rhs->exponent) result=+1;
6292       choice=(result>0 ? lhs : rhs);	/* choose */
6317 static Int decCompare(const decNumber *lhs, const decNumber *rhs,  argument
6323   result=1;				     /* assume signum(lhs) */
6324   if (ISZERO(lhs)) result=0;
6326     if (ISZERO(rhs)) return result;	     /* LHS wins or both 0 */
6328     if (result==0) return -1;		     /* LHS is 0; RHS wins */
6332     if (result && decNumberIsNegative(lhs)) result=-1;
6342   if ((lhs->bits | rhs->bits) & DECINF) {    /* one or more infinities */
6344       if (decNumberIsInfinite(lhs)) result=0;/* both infinite */
6350   if (lhs->exponent>rhs->exponent) {	     /* LHS exponent larger */
6352     const decNumber *temp=lhs;
6353     lhs=rhs;
6357   compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
6359 			 rhs->exponent-lhs->exponent);
7827 /*   lhs     is the first operand				      */
7837 static decNumber * decNaNs(decNumber *res, const decNumber *lhs,  argument
7840   /* This decision tree ends up with LHS being the source pointer, */
7842   if (lhs->bits & DECSNAN)
7846     lhs=rhs;
7849    else if (lhs->bits & DECNAN);
7850    else lhs=rhs;
7853   if (lhs->digits<=set->digits) decNumberCopy(res, lhs); /* easy */
7858     res->bits=lhs->bits;		/* need sign etc. */
7860     for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
8080 /*   lhs is the first operand (may be DECUNRESU)		      */
8089 static Flag decCheckOperands(decNumber *res, const decNumber *lhs,  argument
8114     if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));