dt/int/sc_nbutils.cc

634     sc_digit carry = 0; // Also used as sum to save space.
638         carry += (*u++) + (*v++);
639         (*w++) = carry & DIGIT_MASK;
640         carry >>= BITS_PER_DIGIT;
643     // Propagate the carry.
644     while (carry && (u < uend)) {
645         carry = (*u++) + 1;
646         (*w++) = carry & DIGIT_MASK;
647         carry >>= BITS_PER_DIGIT;
654     // Propagate the carry if it is still 1.
655     if (carry)
675     sc_digit carry = 0; // Also used as sum to save space.
679         carry += (*u) + (*v++);
680         (*u++) = carry & DIGIT_MASK;
681         carry >>= BITS_PER_DIGIT;
684     // Propagate the carry.
685     while (carry && (u < uend)) {
686         carry = (*u) + 1;
687         (*u++) = carry & DIGIT_MASK;
688         carry >>= BITS_PER_DIGIT;
692     if (carry != 0) {
720     sc_digit carry = 0; // Also used as sum to save space.
724         carry += (*u) + (*v++);
725         (*u++) = carry & DIGIT_MASK;
726         carry >>= BITS_PER_DIGIT;
730     if (carry != 0) {
752     sc_digit carry = (*u++) + v;
753     (*w++) = carry & DIGIT_MASK;
754     carry >>= BITS_PER_DIGIT;
756     // Propagate the carry.
757     while (carry && (u < uend)) {
758         carry = (*u++) + 1;
759         (*w++) = carry & DIGIT_MASK;
760         carry >>= BITS_PER_DIGIT;
767     // Propagate the carry if it is still 1.
768     if (carry)
1002      carry = A * C + high_half(prod_h)
1015      NOTE: sc_max(prod_l, prod_h, carry) <= 2 * x^2 - 1, so any
1029 #define prod_h carry
1042         sc_digit carry = 0;
1057             sc_digit prod_l = (*w) + u_l * v_l + low_half(carry);
1059                 high_half(prod_l) + high_half(carry);
1061             carry = u_h * v_h + high_half(prod_h);
1063         (*w) = carry;
1079 #define prod_h carry
1082     sc_digit carry = 0;
1089         sc_digit prod_l = v * low_half(u_AB) + low_half(carry);
1090         prod_h = v * high_half(u_AB) + high_half(prod_l) + high_half(carry);
1092         carry = high_half(prod_h);
1094     (*w) = carry;
1108 #define   prod_h carry
1109     sc_digit carry = 0;
1115         sc_digit prod_l = v * low_half(u[i]) + low_half(carry);
1116         prod_h = v * high_half(u[i]) + high_half(prod_l) + high_half(carry);
1118         carry = high_half(prod_h);
1123     if (carry != 0) {
1218             sc_digit carry = 0;
1221                 carry += y[i] * qk;
1222                 sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
1224                 carry = (carry >> BITS_PER_BYTE) +
1228             // If carry, qk may be one too large.
1229             if (carry) {
1231                 carry = (xk[ylen] + BYTE_RADIX) - carry;
1232                 xk[ylen] = (uchar)(carry & BYTE_MASK);
1233                 carry = 1 - (carry >> BITS_PER_BYTE);
1235                 if (carry) {
1242                   carry = 0;
1245                       carry += xk[i] + y[i];
1246                       xk[i] = (uchar)(carry & BYTE_MASK);
1247                       carry >>= BITS_PER_BYTE;
1250                   if (carry)
1253                 }  // second if carry
1254             }  // first if carry
1407             sc_digit carry = 0;
1410                 carry += y[i] * qk;
1411                 sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
1413                 carry = (carry >> BITS_PER_BYTE) +
1417             if (carry) {
1419                 carry = (xk[ylen] + BYTE_RADIX) - carry;
1420                 xk[ylen] = (uchar)(carry & BYTE_MASK);
1421                 carry = 1 - (carry >> BITS_PER_BYTE);
1423                 if (carry) {
1428                   carry = 0;
1431                       carry += xk[i] + y[i];
1432                       xk[i] = (uchar)(carry & BYTE_MASK);
1433                       carry >>= BITS_PER_BYTE;
1436                   if (carry)
1438                 }  // second if carry
1439             } // first if carry
1570         sc_digit carry = 0;
1573             (*viter++) = (((vval & mask) << BITS_PER_BYTE) | carry);
1574             carry = vval >> nsr;
1578             (*viter) = carry;
1625     sc_digit carry = 0;
1629         (*uiter++) = (((uval & mask) << nsl) | carry);
1630         carry = uval >> nsr;
1634         (*uiter) = carry;
1684     sc_digit carry = (fill & mask) << nsl;
1688         (*uiter) = (uval >> nsr) | carry;
1689         carry = (uval & mask) << nsl;