Lines Matching refs:pResult
1203 * @param pResult The resultant.
1207 static int rtBigNumMagnitudeAdd(PRTBIGNUM pResult, PCRTBIGNUM pAugend, PCRTBIGNUM pAddend)
1209 Assert(!pResult->fCurScrambled); Assert(!pAugend->fCurScrambled); Assert(!pAddend->fCurScrambled);
1210 Assert(pResult != pAugend); Assert(pResult != pAddend);
1213 int rc = rtBigNumSetUsed(pResult, cElements);
1222 pResult->pauElements[i] = rtBigNumElementAddWithCarry(rtBigNumGetElement(pAugend, i),
1227 rc = rtBigNumSetUsed(pResult, cElements + 1);
1229 pResult->pauElements[cElements++] = 1;
1231 Assert(pResult->cUsed == cElements || RT_FAILURE_NP(rc));
1247 * @param pResult There to store the result.
1251 static int rtBigNumMagnitudeSub(PRTBIGNUM pResult, PCRTBIGNUM pMinuend, PCRTBIGNUM pSubtrahend)
1253 Assert(!pResult->fCurScrambled); Assert(!pMinuend->fCurScrambled); Assert(!pSubtrahend->fCurScrambled);
1254 Assert(pResult != pMinuend); Assert(pResult != pSubtrahend);
1265 rc = rtBigNumSetUsedEx(pResult, pMinuend->cUsed, RTBIGNUM_ZERO_ALIGN(pMinuend->cUsed));
1278 rtBigNumMagnitudeSubAssemblyWorker(pResult->pauElements, pMinuend->pauElements,
1285 AssertMsg(pResult->pauElements[i] == uCorrect, ("[%u]=%#x, expected %#x\n", i, pResult->pauElements[i], uCorrect));
1294 pResult->pauElements[i] = rtBigNumElementSubWithBorrow(pMinuend->pauElements[i],
1303 rtBigNumStripTrailingZeros(pResult);
1310 rc = rtBigNumMagnitudeCopy(pResult, pMinuend);
1365 RTDECL(int) RTBigNumAdd(PRTBIGNUM pResult, PCRTBIGNUM pAugend, PCRTBIGNUM pAddend)
1367 Assert(pResult != pAugend); Assert(pResult != pAddend);
1368 AssertReturn(pResult->fSensitive >= (pAugend->fSensitive | pAddend->fSensitive), VERR_BIGNUM_SENSITIVE_INPUT);
1370 int rc = rtBigNumUnscramble(pResult);
1373 RTBIGNUM_ASSERT_VALID(pResult);
1390 pResult->fNegative = pAugend->fNegative;
1391 rc = rtBigNumMagnitudeAdd(pResult, pAugend, pAddend);
1402 pResult->fNegative = pAugend->fNegative;
1403 rc = rtBigNumMagnitudeSub(pResult, pAugend, pAddend);
1404 if (!pResult->cUsed)
1405 pResult->fNegative = 0;
1409 pResult->fNegative = pAddend->fNegative;
1410 rc = rtBigNumMagnitudeSub(pResult, pAddend, pAugend);
1416 rtBigNumScramble(pResult);
1422 RTDECL(int) RTBigNumSubtract(PRTBIGNUM pResult, PCRTBIGNUM pMinuend, PCRTBIGNUM pSubtrahend)
1424 Assert(pResult != pMinuend); Assert(pResult != pSubtrahend);
1425 AssertReturn(pResult->fSensitive >= (pMinuend->fSensitive | pSubtrahend->fSensitive), VERR_BIGNUM_SENSITIVE_INPUT);
1427 int rc = rtBigNumUnscramble(pResult);
1430 RTBIGNUM_ASSERT_VALID(pResult);
1449 pResult->fNegative = pMinuend->fNegative;
1450 rc = rtBigNumMagnitudeAdd(pResult, pMinuend, pSubtrahend);
1458 pResult->fNegative = pMinuend->fNegative;
1459 rc = rtBigNumMagnitudeSub(pResult, pMinuend, pSubtrahend);
1468 pResult->fNegative = !pMinuend->fNegative;
1469 rc = rtBigNumMagnitudeSub(pResult, pSubtrahend, pMinuend);
1479 pResult->fNegative = 0;
1480 rtBigNumSetUsed(pResult, 0);
1482 rtBigNumScramble(pResult);
1495 RTDECL(int) RTBigNumNegate(PRTBIGNUM pResult, PCRTBIGNUM pBigNum)
1497 int rc = RTBigNumAssign(pResult, pBigNum);
1499 rc = RTBigNumNegateThis(pResult);
1509 * @param pResult Where to store the result.
1513 static int rtBigNumMagnitudeMultiply(PRTBIGNUM pResult, PCRTBIGNUM pMultiplicand, PCRTBIGNUM pMultiplier)
1515 Assert(pResult != pMultiplicand); Assert(pResult != pMultiplier);
1516 Assert(!pResult->fCurScrambled); Assert(!pMultiplicand->fCurScrambled); Assert(!pMultiplier->fCurScrambled);
1523 pResult->fNegative = 0;
1524 rtBigNumSetUsed(pResult, 0);
1533 int rc = rtBigNumSetUsed(pResult, cMax);
1536 RT_BZERO(pResult->pauElements, pResult->cUsed * RTBIGNUM_ELEMENT_SIZE);
1539 rtBigNumMagnitudeMultiplyAssemblyWorker(pResult->pauElements,
1561 pResult->pauElements[k] = rtBigNumElementAddWithCarry(pResult->pauElements[k], uLo, &fCarry);
1563 pResult->pauElements[k] = rtBigNumElementAddWithCarry(pResult->pauElements[k], uHi, &fCarry);
1567 pResult->pauElements[k] = rtBigNumElementAddWithCarry(pResult->pauElements[k], 0, &fCarry);
1575 rtBigNumStripTrailingZeros(pResult);
1581 RTDECL(int) RTBigNumMultiply(PRTBIGNUM pResult, PCRTBIGNUM pMultiplicand, PCRTBIGNUM pMultiplier)
1583 Assert(pResult != pMultiplicand); Assert(pResult != pMultiplier);
1584 AssertReturn(pResult->fSensitive >= (pMultiplicand->fSensitive | pMultiplier->fSensitive), VERR_BIGNUM_SENSITIVE_INPUT);
1586 int rc = rtBigNumUnscramble(pResult);
1589 RTBIGNUM_ASSERT_VALID(pResult);
1606 pResult->fNegative = pMultiplicand->fNegative ^ pMultiplier->fNegative;
1607 rc = rtBigNumMagnitudeMultiply(pResult, pMultiplicand, pMultiplier);
1613 rtBigNumScramble(pResult);
1746 * @param pResult Where to store the result.
1750 static int rtBigNumMagnitudeShiftLeft(PRTBIGNUM pResult, PCRTBIGNUM pValue, uint32_t cBits)
1761 rc = rtBigNumSetUsedEx(pResult, 0, RT_ALIGN_32(cBitsNew, RTBIGNUM_ELEMENT_BITS) / RTBIGNUM_ELEMENT_BITS);
1763 rc = rtBigNumSetUsed(pResult, RT_ALIGN_32(cBitsNew, RTBIGNUM_ELEMENT_BITS) / RTBIGNUM_ELEMENT_BITS);
1768 PRTBIGNUMELEMENT pauDst = pResult->pauElements;
1796 rc = rtBigNumSetUsed(pResult, 0);
1799 rc = rtBigNumMagnitudeCopy(pResult, pValue);
1804 RTDECL(int) RTBigNumShiftLeft(PRTBIGNUM pResult, PCRTBIGNUM pValue, uint32_t cBits)
1806 Assert(pResult != pValue);
1807 AssertReturn(pResult->fSensitive >= pValue->fSensitive, VERR_BIGNUM_SENSITIVE_INPUT);
1809 int rc = rtBigNumUnscramble(pResult);
1812 RTBIGNUM_ASSERT_VALID(pResult);
1818 pResult->fNegative = pValue->fNegative;
1819 rc = rtBigNumMagnitudeShiftLeft(pResult, pValue, cBits);
1823 rtBigNumScramble(pResult);
1835 * @param pResult Where to store the result.
1839 static int rtBigNumMagnitudeShiftRight(PRTBIGNUM pResult, PCRTBIGNUM pValue, uint32_t cBits)
1849 rc = rtBigNumSetUsed(pResult, cElementsNew);
1854 PRTBIGNUMELEMENT pauDst = pResult->pauElements;
1874 rc = rtBigNumSetUsed(pResult, 0);
1877 rc = rtBigNumMagnitudeCopy(pResult, pValue);
1882 RTDECL(int) RTBigNumShiftRight(PRTBIGNUM pResult, PCRTBIGNUM pValue, uint32_t cBits)
1884 Assert(pResult != pValue);
1885 AssertReturn(pResult->fSensitive >= pValue->fSensitive, VERR_BIGNUM_SENSITIVE_INPUT);
1887 int rc = rtBigNumUnscramble(pResult);
1890 RTBIGNUM_ASSERT_VALID(pResult);
1896 pResult->fNegative = pValue->fNegative;
1897 rc = rtBigNumMagnitudeShiftRight(pResult, pValue, cBits);
1898 if (!pResult->cUsed)
1899 pResult->fNegative = 0;
1903 rtBigNumScramble(pResult);
2581 * @param pResult Where to return power.
2585 static int rtBigNumMagnitudeExponentiate(PRTBIGNUM pResult, PCRTBIGNUM pBase, PCRTBIGNUM pExponent)
2587 Assert(pResult != pBase); Assert(pResult != pExponent);
2588 Assert(!pResult->fCurScrambled); Assert(!pBase->fCurScrambled); Assert(!pExponent->fCurScrambled);
2597 rc = rtBigNumSetUsed(pResult, 1);
2599 pResult->pauElements[0] = 1;
2605 return rtBigNumMagnitudeCopy(pResult, pBase);
2616 rc = rtBigNumSetUsed(pResult, 1);
2619 pResult->pauElements[0] = 1;
2623 rc = rtBigNumCloneInternal(&TmpMultiplicand, pResult);
2636 rc = rtBigNumMagnitudeCopy(&TmpMultiplicand, pResult);
2638 rc = rtBigNumMagnitudeMultiply(pResult, &TmpMultiplicand, &Pow2);
2663 RTDECL(int) RTBigNumExponentiate(PRTBIGNUM pResult, PCRTBIGNUM pBase, PCRTBIGNUM pExponent)
2665 Assert(pResult != pBase); Assert(pResult != pExponent);
2666 AssertReturn(pResult->fSensitive >= (pBase->fSensitive | pExponent->fSensitive), VERR_BIGNUM_SENSITIVE_INPUT);
2668 int rc = rtBigNumUnscramble(pResult);
2671 RTBIGNUM_ASSERT_VALID(pResult);
2682 pResult->fNegative = pBase->fNegative; /* sign unchanged. */
2683 rc = rtBigNumMagnitudeExponentiate(pResult, pBase, pExponent);
2692 rtBigNumScramble(pResult);
2706 * @param pResult Where to return the remainder of the power.
2711 static int rtBigNumMagnitudeModExp(PRTBIGNUM pResult, PRTBIGNUM pBase, PRTBIGNUM pExponent, PRTBIGNUM pModulus)
2713 Assert(pResult != pBase); Assert(pResult != pBase); Assert(pResult != pExponent); Assert(pResult != pModulus);
2714 Assert(!pResult->fCurScrambled); Assert(!pBase->fCurScrambled); Assert(!pExponent->fCurScrambled); Assert(!pModulus->fCurScrambled);
2727 rtBigNumSetUsed(pResult, 0);
2734 rc = rtBigNumSetUsed(pResult, 1);
2736 pResult->pauElements[0] = 1;
2742 return rtBigNumMagnitudeModulo(pResult, pBase, pModulus);
2748 rc = rtBigNumSetUsed(pResult, pModulus->cUsed + 1);
2750 rc = rtBigNumSetUsed(pResult, 1);
2753 pResult->pauElements[0] = 1;
2764 rtBigNumInitZeroTemplate(&TmpMultiplicand, pResult);
2767 rtBigNumInitZeroTemplate(&TmpProduct, pResult);
2782 rc = rtBigNumMagnitudeCopy(&TmpMultiplicand, pResult);
2786 rc = rtBigNumMagnitudeModulo(pResult, &TmpProduct, pModulus);
2814 RTDECL(int) RTBigNumModExp(PRTBIGNUM pResult, PRTBIGNUM pBase, PRTBIGNUM pExponent, PRTBIGNUM pModulus)
2816 Assert(pResult != pBase); Assert(pResult != pBase); Assert(pResult != pExponent); Assert(pResult != pModulus);
2817 AssertReturn(pResult->fSensitive >= (pBase->fSensitive | pExponent->fSensitive | pModulus->fSensitive),
2820 int rc = rtBigNumUnscramble(pResult);
2823 RTBIGNUM_ASSERT_VALID(pResult);
2838 pResult->fNegative = pModulus->fNegative; /* pBase ^ pExponent / pModulus; result = remainder. */
2839 rc = rtBigNumMagnitudeModExp(pResult, pBase, pExponent, pModulus);
2849 rtBigNumScramble(pResult);