// Copyright 2014 PDFium Authors. All rights reserved. | |

// Use of this source code is governed by a BSD-style license that can be | |

// found in the LICENSE file. | |

// Original code by Matt McCutchen, see the LICENSE file. | |

#include "BigUnsigned.hh" | |

// Memory management definitions have moved to the bottom of NumberlikeArray.hh. | |

// The templates used by these constructors and converters are at the bottom of | |

// BigUnsigned.hh. | |

BigUnsigned::BigUnsigned(unsigned long x) { initFromPrimitive (x); } | |

BigUnsigned::BigUnsigned(unsigned int x) { initFromPrimitive (x); } | |

BigUnsigned::BigUnsigned(unsigned short x) { initFromPrimitive (x); } | |

BigUnsigned::BigUnsigned( long x) { initFromSignedPrimitive(x); } | |

BigUnsigned::BigUnsigned( int x) { initFromSignedPrimitive(x); } | |

BigUnsigned::BigUnsigned( short x) { initFromSignedPrimitive(x); } | |

unsigned long BigUnsigned::toUnsignedLong () const { return convertToPrimitive <unsigned long >(); } | |

unsigned int BigUnsigned::toUnsignedInt () const { return convertToPrimitive <unsigned int >(); } | |

unsigned short BigUnsigned::toUnsignedShort() const { return convertToPrimitive <unsigned short>(); } | |

long BigUnsigned::toLong () const { return convertToSignedPrimitive< long >(); } | |

int BigUnsigned::toInt () const { return convertToSignedPrimitive< int >(); } | |

short BigUnsigned::toShort () const { return convertToSignedPrimitive< short>(); } | |

// BIT/BLOCK ACCESSORS | |

void BigUnsigned::setBlock(Index i, Blk newBlock) { | |

if (newBlock == 0) { | |

if (i < len) { | |

blk[i] = 0; | |

zapLeadingZeros(); | |

} | |

// If i >= len, no effect. | |

} else { | |

if (i >= len) { | |

// The nonzero block extends the number. | |

allocateAndCopy(i+1); | |

// Zero any added blocks that we aren't setting. | |

for (Index j = len; j < i; j++) | |

blk[j] = 0; | |

len = i+1; | |

} | |

blk[i] = newBlock; | |

} | |

} | |

/* Evidently the compiler wants BigUnsigned:: on the return type because, at | |

* that point, it hasn't yet parsed the BigUnsigned:: on the name to get the | |

* proper scope. */ | |

BigUnsigned::Index BigUnsigned::bitLength() const { | |

if (isZero()) | |

return 0; | |

else { | |

Blk leftmostBlock = getBlock(len - 1); | |

Index leftmostBlockLen = 0; | |

while (leftmostBlock != 0) { | |

leftmostBlock >>= 1; | |

leftmostBlockLen++; | |

} | |

return leftmostBlockLen + (len - 1) * N; | |

} | |

} | |

void BigUnsigned::setBit(Index bi, bool newBit) { | |

Index blockI = bi / N; | |

Blk block = getBlock(blockI), mask = Blk(1) << (bi % N); | |

block = newBit ? (block | mask) : (block & ~mask); | |

setBlock(blockI, block); | |

} | |

// COMPARISON | |

BigUnsigned::CmpRes BigUnsigned::compareTo(const BigUnsigned &x) const { | |

// A bigger length implies a bigger number. | |

if (len < x.len) | |

return less; | |

else if (len > x.len) | |

return greater; | |

else { | |

// Compare blocks one by one from left to right. | |

Index i = len; | |

while (i > 0) { | |

i--; | |

if (blk[i] == x.blk[i]) | |

continue; | |

else if (blk[i] > x.blk[i]) | |

return greater; | |

else | |

return less; | |

} | |

// If no blocks differed, the numbers are equal. | |

return equal; | |

} | |

} | |

// COPY-LESS OPERATIONS | |

/* | |

* On most calls to copy-less operations, it's safe to read the inputs little by | |

* little and write the outputs little by little. However, if one of the | |

* inputs is coming from the same variable into which the output is to be | |

* stored (an "aliased" call), we risk overwriting the input before we read it. | |

* In this case, we first compute the result into a temporary BigUnsigned | |

* variable and then copy it into the requested output variable *this. | |

* Each put-here operation uses the DTRT_ALIASED macro (Do The Right Thing on | |

* aliased calls) to generate code for this check. | |

* | |

* I adopted this approach on 2007.02.13 (see Assignment Operators in | |

* BigUnsigned.hh). Before then, put-here operations rejected aliased calls | |

* with an exception. I think doing the right thing is better. | |

* | |

* Some of the put-here operations can probably handle aliased calls safely | |

* without the extra copy because (for example) they process blocks strictly | |

* right-to-left. At some point I might determine which ones don't need the | |

* copy, but my reasoning would need to be verified very carefully. For now | |

* I'll leave in the copy. | |

*/ | |

#define DTRT_ALIASED(cond, op) \ | |

if (cond) { \ | |

BigUnsigned tmpThis; \ | |

tmpThis.op; \ | |

*this = tmpThis; \ | |

return; \ | |

} | |

void BigUnsigned::add(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, add(a, b)); | |

// If one argument is zero, copy the other. | |

if (a.len == 0) { | |

operator =(b); | |

return; | |

} else if (b.len == 0) { | |

operator =(a); | |

return; | |

} | |

// Some variables... | |

// Carries in and out of an addition stage | |

bool carryIn, carryOut; | |

Blk temp; | |

Index i; | |

// a2 points to the longer input, b2 points to the shorter | |

const BigUnsigned *a2, *b2; | |

if (a.len >= b.len) { | |

a2 = &a; | |

b2 = &b; | |

} else { | |

a2 = &b; | |

b2 = &a; | |

} | |

// Set prelimiary length and make room in this BigUnsigned | |

len = a2->len + 1; | |

allocate(len); | |

// For each block index that is present in both inputs... | |

for (i = 0, carryIn = false; i < b2->len; i++) { | |

// Add input blocks | |

temp = a2->blk[i] + b2->blk[i]; | |

// If a rollover occurred, the result is less than either input. | |

// This test is used many times in the BigUnsigned code. | |

carryOut = (temp < a2->blk[i]); | |

// If a carry was input, handle it | |

if (carryIn) { | |

temp++; | |

carryOut |= (temp == 0); | |

} | |

blk[i] = temp; // Save the addition result | |

carryIn = carryOut; // Pass the carry along | |

} | |

// If there is a carry left over, increase blocks until | |

// one does not roll over. | |

for (; i < a2->len && carryIn; i++) { | |

temp = a2->blk[i] + 1; | |

carryIn = (temp == 0); | |

blk[i] = temp; | |

} | |

// If the carry was resolved but the larger number | |

// still has blocks, copy them over. | |

for (; i < a2->len; i++) | |

blk[i] = a2->blk[i]; | |

// Set the extra block if there's still a carry, decrease length otherwise | |

if (carryIn) | |

blk[i] = 1; | |

else | |

len--; | |

} | |

void BigUnsigned::subtract(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, subtract(a, b)); | |

if (b.len == 0) { | |

// If b is zero, copy a. | |

operator =(a); | |

return; | |

} else if (a.len < b.len) | |

// If a is shorter than b, the result is negative. | |

abort(); | |

// Some variables... | |

bool borrowIn, borrowOut; | |

Blk temp; | |

Index i; | |

// Set preliminary length and make room | |

len = a.len; | |

allocate(len); | |

// For each block index that is present in both inputs... | |

for (i = 0, borrowIn = false; i < b.len; i++) { | |

temp = a.blk[i] - b.blk[i]; | |

// If a reverse rollover occurred, | |

// the result is greater than the block from a. | |

borrowOut = (temp > a.blk[i]); | |

// Handle an incoming borrow | |

if (borrowIn) { | |

borrowOut |= (temp == 0); | |

temp--; | |

} | |

blk[i] = temp; // Save the subtraction result | |

borrowIn = borrowOut; // Pass the borrow along | |

} | |

// If there is a borrow left over, decrease blocks until | |

// one does not reverse rollover. | |

for (; i < a.len && borrowIn; i++) { | |

borrowIn = (a.blk[i] == 0); | |

blk[i] = a.blk[i] - 1; | |

} | |

/* If there's still a borrow, the result is negative. | |

* Throw an exception, but zero out this object so as to leave it in a | |

* predictable state. */ | |

if (borrowIn) { | |

len = 0; | |

abort(); | |

} else | |

// Copy over the rest of the blocks | |

for (; i < a.len; i++) | |

blk[i] = a.blk[i]; | |

// Zap leading zeros | |

zapLeadingZeros(); | |

} | |

/* | |

* About the multiplication and division algorithms: | |

* | |

* I searched unsucessfully for fast C++ built-in operations like the `b_0' | |

* and `c_0' Knuth describes in Section 4.3.1 of ``The Art of Computer | |

* Programming'' (replace `place' by `Blk'): | |

* | |

* ``b_0[:] multiplication of a one-place integer by another one-place | |

* integer, giving a two-place answer; | |

* | |

* ``c_0[:] division of a two-place integer by a one-place integer, | |

* provided that the quotient is a one-place integer, and yielding | |

* also a one-place remainder.'' | |

* | |

* I also missed his note that ``[b]y adjusting the word size, if | |

* necessary, nearly all computers will have these three operations | |

* available'', so I gave up on trying to use algorithms similar to his. | |

* A future version of the library might include such algorithms; I | |

* would welcome contributions from others for this. | |

* | |

* I eventually decided to use bit-shifting algorithms. To multiply `a' | |

* and `b', we zero out the result. Then, for each `1' bit in `a', we | |

* shift `b' left the appropriate amount and add it to the result. | |

* Similarly, to divide `a' by `b', we shift `b' left varying amounts, | |

* repeatedly trying to subtract it from `a'. When we succeed, we note | |

* the fact by setting a bit in the quotient. While these algorithms | |

* have the same O(n^2) time complexity as Knuth's, the ``constant factor'' | |

* is likely to be larger. | |

* | |

* Because I used these algorithms, which require single-block addition | |

* and subtraction rather than single-block multiplication and division, | |

* the innermost loops of all four routines are very similar. Study one | |

* of them and all will become clear. | |

*/ | |

/* | |

* This is a little inline function used by both the multiplication | |

* routine and the division routine. | |

* | |

* `getShiftedBlock' returns the `x'th block of `num << y'. | |

* `y' may be anything from 0 to N - 1, and `x' may be anything from | |

* 0 to `num.len'. | |

* | |

* Two things contribute to this block: | |

* | |

* (1) The `N - y' low bits of `num.blk[x]', shifted `y' bits left. | |

* | |

* (2) The `y' high bits of `num.blk[x-1]', shifted `N - y' bits right. | |

* | |

* But we must be careful if `x == 0' or `x == num.len', in | |

* which case we should use 0 instead of (2) or (1), respectively. | |

* | |

* If `y == 0', then (2) contributes 0, as it should. However, | |

* in some computer environments, for a reason I cannot understand, | |

* `a >> b' means `a >> (b % N)'. This means `num.blk[x-1] >> (N - y)' | |

* will return `num.blk[x-1]' instead of the desired 0 when `y == 0'; | |

* the test `y == 0' handles this case specially. | |

*/ | |

inline BigUnsigned::Blk getShiftedBlock(const BigUnsigned &num, | |

BigUnsigned::Index x, unsigned int y) { | |

BigUnsigned::Blk part1 = (x == 0 || y == 0) ? 0 : (num.blk[x - 1] >> (BigUnsigned::N - y)); | |

BigUnsigned::Blk part2 = (x == num.len) ? 0 : (num.blk[x] << y); | |

return part1 | part2; | |

} | |

void BigUnsigned::multiply(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, multiply(a, b)); | |

// If either a or b is zero, set to zero. | |

if (a.len == 0 || b.len == 0) { | |

len = 0; | |

return; | |

} | |

/* | |

* Overall method: | |

* | |

* Set this = 0. | |

* For each 1-bit of `a' (say the `i2'th bit of block `i'): | |

* Add `b << (i blocks and i2 bits)' to *this. | |

*/ | |

// Variables for the calculation | |

Index i, j, k; | |

unsigned int i2; | |

Blk temp; | |

bool carryIn, carryOut; | |

// Set preliminary length and make room | |

len = a.len + b.len; | |

allocate(len); | |

// Zero out this object | |

for (i = 0; i < len; i++) | |

blk[i] = 0; | |

// For each block of the first number... | |

for (i = 0; i < a.len; i++) { | |

// For each 1-bit of that block... | |

for (i2 = 0; i2 < N; i2++) { | |

if ((a.blk[i] & (Blk(1) << i2)) == 0) | |

continue; | |

/* | |

* Add b to this, shifted left i blocks and i2 bits. | |

* j is the index in b, and k = i + j is the index in this. | |

* | |

* `getShiftedBlock', a short inline function defined above, | |

* is now used for the bit handling. It replaces the more | |

* complex `bHigh' code, in which each run of the loop dealt | |

* immediately with the low bits and saved the high bits to | |

* be picked up next time. The last run of the loop used to | |

* leave leftover high bits, which were handled separately. | |

* Instead, this loop runs an additional time with j == b.len. | |

* These changes were made on 2005.01.11. | |

*/ | |

for (j = 0, k = i, carryIn = false; j <= b.len; j++, k++) { | |

/* | |

* The body of this loop is very similar to the body of the first loop | |

* in `add', except that this loop does a `+=' instead of a `+'. | |

*/ | |

temp = blk[k] + getShiftedBlock(b, j, i2); | |

carryOut = (temp < blk[k]); | |

if (carryIn) { | |

temp++; | |

carryOut |= (temp == 0); | |

} | |

blk[k] = temp; | |

carryIn = carryOut; | |

} | |

// No more extra iteration to deal with `bHigh'. | |

// Roll-over a carry as necessary. | |

for (; carryIn; k++) { | |

blk[k]++; | |

carryIn = (blk[k] == 0); | |

} | |

} | |

} | |

// Zap possible leading zero | |

if (blk[len - 1] == 0) | |

len--; | |

} | |

/* | |

* DIVISION WITH REMAINDER | |

* This monstrous function mods *this by the given divisor b while storing the | |

* quotient in the given object q; at the end, *this contains the remainder. | |

* The seemingly bizarre pattern of inputs and outputs was chosen so that the | |

* function copies as little as possible (since it is implemented by repeated | |

* subtraction of multiples of b from *this). | |

* | |

* "modWithQuotient" might be a better name for this function, but I would | |

* rather not change the name now. | |

*/ | |

void BigUnsigned::divideWithRemainder(const BigUnsigned &b, BigUnsigned &q) { | |

/* Defending against aliased calls is more complex than usual because we | |

* are writing to both *this and q. | |

* | |

* It would be silly to try to write quotient and remainder to the | |

* same variable. Rule that out right away. */ | |

if (this == &q) | |

abort(); | |

/* Now *this and q are separate, so the only concern is that b might be | |

* aliased to one of them. If so, use a temporary copy of b. */ | |

if (this == &b || &q == &b) { | |

BigUnsigned tmpB(b); | |

divideWithRemainder(tmpB, q); | |

return; | |

} | |

/* | |

* Knuth's definition of mod (which this function uses) is somewhat | |

* different from the C++ definition of % in case of division by 0. | |

* | |

* We let a / 0 == 0 (it doesn't matter much) and a % 0 == a, no | |

* exceptions thrown. This allows us to preserve both Knuth's demand | |

* that a mod 0 == a and the useful property that | |

* (a / b) * b + (a % b) == a. | |

*/ | |

if (b.len == 0) { | |

q.len = 0; | |

return; | |

} | |

/* | |

* If *this.len < b.len, then *this < b, and we can be sure that b doesn't go into | |

* *this at all. The quotient is 0 and *this is already the remainder (so leave it alone). | |

*/ | |

if (len < b.len) { | |

q.len = 0; | |

return; | |

} | |

// At this point we know (*this).len >= b.len > 0. (Whew!) | |

/* | |

* Overall method: | |

* | |

* For each appropriate i and i2, decreasing: | |

* Subtract (b << (i blocks and i2 bits)) from *this, storing the | |

* result in subtractBuf. | |

* If the subtraction succeeds with a nonnegative result: | |

* Turn on bit i2 of block i of the quotient q. | |

* Copy subtractBuf back into *this. | |

* Otherwise bit i2 of block i remains off, and *this is unchanged. | |

* | |

* Eventually q will contain the entire quotient, and *this will | |

* be left with the remainder. | |

* | |

* subtractBuf[x] corresponds to blk[x], not blk[x+i], since 2005.01.11. | |

* But on a single iteration, we don't touch the i lowest blocks of blk | |

* (and don't use those of subtractBuf) because these blocks are | |

* unaffected by the subtraction: we are subtracting | |

* (b << (i blocks and i2 bits)), which ends in at least `i' zero | |

* blocks. */ | |

// Variables for the calculation | |

Index i, j, k; | |

unsigned int i2; | |

Blk temp; | |

bool borrowIn, borrowOut; | |

/* | |

* Make sure we have an extra zero block just past the value. | |

* | |

* When we attempt a subtraction, we might shift `b' so | |

* its first block begins a few bits left of the dividend, | |

* and then we'll try to compare these extra bits with | |

* a nonexistent block to the left of the dividend. The | |

* extra zero block ensures sensible behavior; we need | |

* an extra block in `subtractBuf' for exactly the same reason. | |

*/ | |

Index origLen = len; // Save real length. | |

/* To avoid an out-of-bounds access in case of reallocation, allocate | |

* first and then increment the logical length. */ | |

allocateAndCopy(len + 1); | |

len++; | |

blk[origLen] = 0; // Zero the added block. | |

// subtractBuf holds part of the result of a subtraction; see above. | |

Blk *subtractBuf = new Blk[len]; | |

// Set preliminary length for quotient and make room | |

q.len = origLen - b.len + 1; | |

q.allocate(q.len); | |

// Zero out the quotient | |

for (i = 0; i < q.len; i++) | |

q.blk[i] = 0; | |

// For each possible left-shift of b in blocks... | |

i = q.len; | |

while (i > 0) { | |

i--; | |

// For each possible left-shift of b in bits... | |

// (Remember, N is the number of bits in a Blk.) | |

q.blk[i] = 0; | |

i2 = N; | |

while (i2 > 0) { | |

i2--; | |

/* | |

* Subtract b, shifted left i blocks and i2 bits, from *this, | |

* and store the answer in subtractBuf. In the for loop, `k == i + j'. | |

* | |

* Compare this to the middle section of `multiply'. They | |

* are in many ways analogous. See especially the discussion | |

* of `getShiftedBlock'. | |

*/ | |

for (j = 0, k = i, borrowIn = false; j <= b.len; j++, k++) { | |

temp = blk[k] - getShiftedBlock(b, j, i2); | |

borrowOut = (temp > blk[k]); | |

if (borrowIn) { | |

borrowOut |= (temp == 0); | |

temp--; | |

} | |

// Since 2005.01.11, indices of `subtractBuf' directly match those of `blk', so use `k'. | |

subtractBuf[k] = temp; | |

borrowIn = borrowOut; | |

} | |

// No more extra iteration to deal with `bHigh'. | |

// Roll-over a borrow as necessary. | |

for (; k < origLen && borrowIn; k++) { | |

borrowIn = (blk[k] == 0); | |

subtractBuf[k] = blk[k] - 1; | |

} | |

/* | |

* If the subtraction was performed successfully (!borrowIn), | |

* set bit i2 in block i of the quotient. | |

* | |

* Then, copy the portion of subtractBuf filled by the subtraction | |

* back to *this. This portion starts with block i and ends-- | |

* where? Not necessarily at block `i + b.len'! Well, we | |

* increased k every time we saved a block into subtractBuf, so | |

* the region of subtractBuf we copy is just [i, k). | |

*/ | |

if (!borrowIn) { | |

q.blk[i] |= (Blk(1) << i2); | |

while (k > i) { | |

k--; | |

blk[k] = subtractBuf[k]; | |

} | |

} | |

} | |

} | |

// Zap possible leading zero in quotient | |

if (q.blk[q.len - 1] == 0) | |

q.len--; | |

// Zap any/all leading zeros in remainder | |

zapLeadingZeros(); | |

// Deallocate subtractBuf. | |

// (Thanks to Brad Spencer for noticing my accidental omission of this!) | |

delete [] subtractBuf; | |

} | |

/* BITWISE OPERATORS | |

* These are straightforward blockwise operations except that they differ in | |

* the output length and the necessity of zapLeadingZeros. */ | |

void BigUnsigned::bitAnd(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, bitAnd(a, b)); | |

// The bitwise & can't be longer than either operand. | |

len = (a.len >= b.len) ? b.len : a.len; | |

allocate(len); | |

Index i; | |

for (i = 0; i < len; i++) | |

blk[i] = a.blk[i] & b.blk[i]; | |

zapLeadingZeros(); | |

} | |

void BigUnsigned::bitOr(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, bitOr(a, b)); | |

Index i; | |

const BigUnsigned *a2, *b2; | |

if (a.len >= b.len) { | |

a2 = &a; | |

b2 = &b; | |

} else { | |

a2 = &b; | |

b2 = &a; | |

} | |

allocate(a2->len); | |

for (i = 0; i < b2->len; i++) | |

blk[i] = a2->blk[i] | b2->blk[i]; | |

for (; i < a2->len; i++) | |

blk[i] = a2->blk[i]; | |

len = a2->len; | |

// Doesn't need zapLeadingZeros. | |

} | |

void BigUnsigned::bitXor(const BigUnsigned &a, const BigUnsigned &b) { | |

DTRT_ALIASED(this == &a || this == &b, bitXor(a, b)); | |

Index i; | |

const BigUnsigned *a2, *b2; | |

if (a.len >= b.len) { | |

a2 = &a; | |

b2 = &b; | |

} else { | |

a2 = &b; | |

b2 = &a; | |

} | |

allocate(a2->len); | |

for (i = 0; i < b2->len; i++) | |

blk[i] = a2->blk[i] ^ b2->blk[i]; | |

for (; i < a2->len; i++) | |

blk[i] = a2->blk[i]; | |

len = a2->len; | |

zapLeadingZeros(); | |

} | |

void BigUnsigned::bitShiftLeft(const BigUnsigned &a, int b) { | |

DTRT_ALIASED(this == &a, bitShiftLeft(a, b)); | |

if (b < 0) { | |

if (b << 1 == 0) | |

abort(); | |

else { | |

bitShiftRight(a, -b); | |

return; | |

} | |

} | |

Index shiftBlocks = b / N; | |

unsigned int shiftBits = b % N; | |

// + 1: room for high bits nudged left into another block | |

len = a.len + shiftBlocks + 1; | |

allocate(len); | |

Index i, j; | |

for (i = 0; i < shiftBlocks; i++) | |

blk[i] = 0; | |

for (j = 0, i = shiftBlocks; j <= a.len; j++, i++) | |

blk[i] = getShiftedBlock(a, j, shiftBits); | |

// Zap possible leading zero | |

if (blk[len - 1] == 0) | |

len--; | |

} | |

void BigUnsigned::bitShiftRight(const BigUnsigned &a, int b) { | |

DTRT_ALIASED(this == &a, bitShiftRight(a, b)); | |

if (b < 0) { | |

if (b << 1 == 0) | |

abort(); | |

else { | |

bitShiftLeft(a, -b); | |

return; | |

} | |

} | |

// This calculation is wacky, but expressing the shift as a left bit shift | |

// within each block lets us use getShiftedBlock. | |

Index rightShiftBlocks = (b + N - 1) / N; | |

unsigned int leftShiftBits = N * rightShiftBlocks - b; | |

// Now (N * rightShiftBlocks - leftShiftBits) == b | |

// and 0 <= leftShiftBits < N. | |

if (rightShiftBlocks >= a.len + 1) { | |

// All of a is guaranteed to be shifted off, even considering the left | |

// bit shift. | |

len = 0; | |

return; | |

} | |

// Now we're allocating a positive amount. | |

// + 1: room for high bits nudged left into another block | |

len = a.len + 1 - rightShiftBlocks; | |

allocate(len); | |

Index i, j; | |

for (j = rightShiftBlocks, i = 0; j <= a.len; j++, i++) | |

blk[i] = getShiftedBlock(a, j, leftShiftBits); | |

// Zap possible leading zero | |

if (blk[len - 1] == 0) | |

len--; | |

} | |

// INCREMENT/DECREMENT OPERATORS | |

// Prefix increment | |

void BigUnsigned::operator ++() { | |

Index i; | |

bool carry = true; | |

for (i = 0; i < len && carry; i++) { | |

blk[i]++; | |

carry = (blk[i] == 0); | |

} | |

if (carry) { | |

// Allocate and then increase length, as in divideWithRemainder | |

allocateAndCopy(len + 1); | |

len++; | |

blk[i] = 1; | |

} | |

} | |

// Postfix increment: same as prefix | |

void BigUnsigned::operator ++(int) { | |

operator ++(); | |

} | |

// Prefix decrement | |

void BigUnsigned::operator --() { | |

if (len == 0) | |

abort(); | |

Index i; | |

bool borrow = true; | |

for (i = 0; borrow; i++) { | |

borrow = (blk[i] == 0); | |

blk[i]--; | |

} | |

// Zap possible leading zero (there can only be one) | |

if (blk[len - 1] == 0) | |

len--; | |

} | |

// Postfix decrement: same as prefix | |

void BigUnsigned::operator --(int) { | |

operator --(); | |

} |