Function decFinalize

extern/decNumber/decNumber.c:7272–7333

------------------------------------------------------------------ */ decFinalize -- final check, clamp, and round of a number */ / dn is the number */ set is the context */ residue is the rounding accumulator (as in decApplyRound) */ status is the status accumulator

/* All fields are updated as required.                                */
/* ------------------------------------------------------------------ */
static void decFinalize(decNumber *dn, decContext *set, Int *residue,
                        uInt *status) {
  Int shift;                            // shift needed if clamping
  Int tinyexp=set->emin-dn->digits+1;   // precalculate subnormal boundary

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

  // First test for subnormal.  This must be done before any final
  // round as the result could be rounded to Nmin or 0.
  if (dn->exponent<=tinyexp) {          // prefilter
    Int comp;
    decNumber nmin;
    // A very nasty case here is dn == Nmin and residue<0
    if (dn->exponent<tinyexp) {
      // Go handle subnormals; this will apply round if needed.
      decSetSubnormal(dn, set, residue, status);
      return;
      }
    // Equals case: only subnormal if dn=Nmin and negative residue
    decNumberZero(&nmin);
    nmin.lsu[0]=1;
    nmin.exponent=set->emin;
    comp=decCompare(dn, &nmin, 1);                // (signless compare)
    if (comp==BADINT) {                           // oops
      *status|=DEC_Insufficient_storage;          // abandon...
      return;
      }
    if (*residue<0 && comp==0) {                  // neg residue and dn==Nmin
      decApplyRound(dn, set, *residue, status);   // might force down
      decSetSubnormal(dn, set, residue, status);
      return;
      }
    }

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

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


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

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

  // shift coefficient (if non-zero)
  if (!ISZERO(dn)) {
    dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
    }