/*

* Copyright (c) 2003-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <random.h>

#include <bigint.h>

#include <e32std.h>

#include <euserext.h>

#include <securityerr.h>

#include "words.h"

#include "algorithms.h"

#include "windowslider.h"

#include "stackinteger.h"

#include "mont.h"

/**

* Creates a new buffer containing the big-endian binary representation of this

* integer.

*

* Note that it does not support the exporting of negative integers.

*

* @return	The new buffer.

* 

* @leave KErrNegativeExportNotSupported	If this instance is a negative integer.

*

*/

EXPORT_C HBufC8* TInteger::BufferLC() const

	{

	if(IsNegative())

		{

		User::Leave(KErrNegativeExportNotSupported);

		}

	TUint bytes = ByteCount();

	HBufC8* buf = HBufC8::NewMaxLC(bytes);

	TUint8* bufPtr = (TUint8*)(buf->Ptr());

	TUint8* regPtr = (TUint8*)Ptr();

	// we internally store the number little endian, as a string we want it big

	// endian

	for(TUint i=0,j=bytes-1; i<bytes; )

		{

		bufPtr[i++] = regPtr[j--];

		}

	return buf;

	}

EXPORT_C HBufC8* TInteger::BufferWithNoTruncationLC() const

 	{

 	if(IsNegative())

 		{

 		User::Leave(KErrNegativeExportNotSupported);

 		}

 	TUint wordCount = Size();

 	TUint bytes = (wordCount)*WORD_SIZE;

  	HBufC8* buf = HBufC8::NewMaxLC(bytes);

 	TUint8* bufPtr = (TUint8*)(buf->Ptr());

	TUint8* regPtr = (TUint8*)Ptr();

	for(TUint i=0,j=bytes-1; i<bytes; )

 		{

 		bufPtr[i++] = regPtr[j--];

 		}

	return buf;

	}

/** 

* Gets the number of words required to represent this RInteger.

* 

* @return	The size of the integer in words.

*

*/

EXPORT_C TUint TInteger::WordCount() const

	{

	return CountWords(Ptr(), Size());

	}

/**

* Gets the number of bytes required to represent this RInteger.

* 

* @return	The size of the integer in bytes.

* 

*/

EXPORT_C TUint TInteger::ByteCount() const

	{

	TUint wordCount = WordCount();

	if(wordCount)

		{

		return (wordCount-1)*WORD_SIZE + BytePrecision((Ptr())[wordCount-1]);

		}

	else 

		{

		return 0;

		}

	}

/** 

* Get the number of bits required to represent this RInteger.

* 

* @return	The size of the integer in bits.

* 

*/

EXPORT_C TUint TInteger::BitCount() const

	{

	TUint wordCount = WordCount();

	if(wordCount)

		{

		return (wordCount-1)*WORD_BITS + BitPrecision(Ptr()[wordCount-1]);

		}

	else 

		{

		return 0;

		}

	}

//These 3 declarations instantiate a constant 0, 1, 2 for ease of use and

//quick construction elsewhere in the code.  Note that the functions

//returning references to this static data return const references as you can't

//modify the ROM ;)

//word 0: Size of storage in words

//word 1: Pointer to storage

//word 2: LSW of storage

//word 3: MSW of storage

//Note that the flag bits in word 1 (Ptr()) are zero in the case of a positive

//stack based integer (SignBit == 0, IsHeapBasedBit == 0)

const TUint KBigintZero[4] = {2, (TUint)(KBigintZero+2), 0, 0};

const TUint KBigintOne[4] = {2, (TUint)(KBigintOne+2), 1, 0};

const TUint KBigintTwo[4] = {2, (TUint)(KBigintTwo+2), 2, 0};

/** 

 * Gets the TInteger that represents zero

 *

 * @return	The TInteger representing zero

 */

EXPORT_C const TInteger& TInteger::Zero(void)

	{

	return *reinterpret_cast<const TStackInteger64*>(KBigintZero);

	}

/** 

 * Gets the TInteger that represents one

 *

 * @return	The TInteger representing one

 */

EXPORT_C const TInteger& TInteger::One(void)

	{

	return *reinterpret_cast<const TStackInteger64*>(KBigintOne);

	}

/** 

 * Gets the TInteger that represents two

 *

 * @return	The TInteger representing two

 */

EXPORT_C const TInteger& TInteger::Two(void)

	{

	return *reinterpret_cast<const TStackInteger64*>(KBigintTwo);

	}

EXPORT_C RInteger TInteger::PlusL(const TInteger& aOperand) const

	{

	RInteger sum;

    if (NotNegative())

		{

        if (aOperand.NotNegative())

            sum = PositiveAddL(*this, aOperand);

        else

            sum = PositiveSubtractL(*this, aOperand);

		}

    else

		{

        if (aOperand.NotNegative())

            sum = PositiveSubtractL(aOperand, *this);

        else

			{

            sum = PositiveAddL(*this, aOperand);

			sum.SetSign(TInteger::ENegative);

			}

		}

	return sum;

	}

EXPORT_C RInteger TInteger::MinusL(const TInteger& aOperand) const

	{

	RInteger diff;

    if (NotNegative())

		{

        if (aOperand.NotNegative())

            diff = PositiveSubtractL(*this, aOperand);

        else

            diff = PositiveAddL(*this, aOperand);

		}

    else

		{

        if (aOperand.NotNegative())

			{

            diff = PositiveAddL(*this, aOperand);

			diff.SetSign(TInteger::ENegative);

			}

        else

            diff = PositiveSubtractL(aOperand, *this);

		}

	return diff;

	}

EXPORT_C RInteger TInteger::TimesL(const TInteger& aOperand) const

	{

	RInteger product = PositiveMultiplyL(*this, aOperand);

	if (NotNegative() != aOperand.NotNegative())

		{

		product.Negate();

		}

	return product;

	}

EXPORT_C RInteger TInteger::DividedByL(const TInteger& aOperand) const

	{

	RInteger quotient;

	RInteger remainder;

	DivideL(remainder, quotient, *this, aOperand);

	remainder.Close();

	return quotient;

	}

EXPORT_C RInteger TInteger::ModuloL(const TInteger& aOperand) const

	{

	RInteger remainder;

	RInteger quotient;

	DivideL(remainder, quotient, *this, aOperand);

	quotient.Close();

	return remainder;

	}

EXPORT_C TUint TInteger::ModuloL(TUint aOperand) const

	{

	if(!aOperand)

		{

		User::Leave(KErrDivideByZero);

		}

	return Modulo(*this, aOperand);

	}

EXPORT_C RInteger TInteger::ModularMultiplyL(const TInteger& aA, const TInteger& aB,

	const TInteger& aMod) 

	{

	RInteger product = aA.TimesL(aB);

	CleanupStack::PushL(product);

	RInteger reduced = product.ModuloL(aMod);

	CleanupStack::PopAndDestroy(&product); 

	return reduced;

	}

EXPORT_C RInteger TInteger::ModularExponentiateL(const TInteger& aBase, 

	const TInteger& aExp, const TInteger& aMod) 

	{

	CMontgomeryStructure* mont = CMontgomeryStructure::NewLC(aMod);

	RInteger result = RInteger::NewL(mont->ExponentiateL(aBase, aExp));

	CleanupStack::PopAndDestroy(mont);

	return result;

	}

EXPORT_C RInteger TInteger::GCDL(const TInteger& aOperand) const

	{

	//Binary GCD algorithm -- see HAC 14.4.1

	//with a slight variation -- our g counts shifts rather than actually

	//shifting.  We then do one shift at the end.

	assert(NotNegative());

	assert(aOperand.NotNegative());

	RInteger x = RInteger::NewL(*this);

	CleanupStack::PushL(x);

	RInteger y = RInteger::NewL(aOperand);

	CleanupStack::PushL(y);

	// 1 Ensure x >= y

	if( x < y )

		{

		TClassSwap(x, y);

		}

	TUint g = 0;

	// 2 while x and y even x <- x/2, y <- y/2

	while( x.IsEven() && y.IsEven() )

		{

		x >>= 1;

		y >>= 1;

		++g;

		}

	// 3 while x != 0

	while( x.NotZero() )

		{

		// 3.1 while x even x <- x/2

		while( x.IsEven() )

			{

			x >>= 1;

			}

		// 3.2 while y even y <- y/2

		while( y.IsEven() )

			{

			y >>= 1;

			}

		// 3.3 t <- abs(x-y)/2

		RInteger t = x.MinusL(y);

		t >>= 1;

		t.SetSign(TInteger::EPositive);

		// 3.4 If x>=y then x <- t else y <- t

		if( x >= y )

			{

			x.Set(t);

			}

		else 

			{

			y.Set(t);

			}

		}

	// 4 Return (g*y) (equiv to y<<=g as our g was counting shifts not actually

	//shifting)

	y <<= g;

	CleanupStack::Pop(&y);

	CleanupStack::PopAndDestroy(&x); 

	return y;

	}

EXPORT_C RInteger TInteger::InverseModL(const TInteger& aMod) const

	{

	assert(aMod.NotNegative());

	RInteger result;

	if(IsNegative() || *this>=aMod)

		{

		RInteger temp = ModuloL(aMod);

		CleanupClosePushL(temp);

		result = temp.InverseModL(aMod);

		CleanupStack::PopAndDestroy(&temp);

		return result;

		}

	if(aMod.IsEven())

		{

		if( !aMod || IsEven() )

			{

			return RInteger::NewL(Zero());

			}

		if( *this == One() )

			{

			return RInteger::NewL(One());

			}

		RInteger u = aMod.InverseModL(*this); 

		CleanupClosePushL(u);

		if(!u)

			{

			result = RInteger::NewL(Zero());

			}

		else 

			{

			//calculates (aMod*(*this-u)+1)/(*this) 

			result = MinusL(u);

			CleanupClosePushL(result);

			result *= aMod;

			++result;

			result /= *this;

			CleanupStack::Pop(&result); 

			}

		CleanupStack::PopAndDestroy(&u);

		return result;

		}

	result = RInteger::NewEmptyL(aMod.Size());

	CleanupClosePushL(result);

	RInteger workspace = RInteger::NewEmptyL(aMod.Size() * 4);

	TUint k = AlmostInverse(result.Ptr(), workspace.Ptr(), Ptr(), Size(),

		aMod.Ptr(), aMod.Size());

	DivideByPower2Mod(result.Ptr(), result.Ptr(), k, aMod.Ptr(), aMod.Size());

	workspace.Close();

	CleanupStack::Pop(&result);

	return result;

	}

EXPORT_C TInteger& TInteger::operator+=(const TInteger& aOperand)

	{

	this->Set(PlusL(aOperand));

    return *this;

	}

EXPORT_C TInteger& TInteger::operator-=(const TInteger& aOperand)

	{

	this->Set(MinusL(aOperand));

    return *this;

	}

EXPORT_C TInteger& TInteger::operator*=(const TInteger& aOperand)

	{

	this->Set(TimesL(aOperand));

	return *this;

	}

EXPORT_C TInteger& TInteger::operator/=(const TInteger& aOperand)

	{

	this->Set(DividedByL(aOperand));

	return *this;

	}

EXPORT_C TInteger& TInteger::operator%=(const TInteger& aOperand)

	{

	this->Set(ModuloL(aOperand));

	return *this;

	}

EXPORT_C TInteger& TInteger::operator+=(TInt aOperand)

	{

	TStackInteger64 operand(aOperand);

	*this += operand;

	return *this;

	}

EXPORT_C TInteger& TInteger::operator-=(TInt aOperand)

	{

	TStackInteger64 operand(aOperand);

	*this -= operand;

	return *this;

	}

EXPORT_C TInteger& TInteger::operator*=(TInt aOperand)

	{

	TStackInteger64 operand(aOperand);

	*this *= operand;

	return *this;

	}

EXPORT_C TInteger& TInteger::operator--()

	{

    if (IsNegative())

		{

        if (Increment(Ptr(), Size()))

			{

            CleanGrowL(2*Size());

            (Ptr())[Size()/2]=1;

			}

		}

    else

		{

        if (Decrement(Ptr(), Size()))

			{

			this->CopyL(-1);

			}

		}

    return *this;	

	}

EXPORT_C TInteger& TInteger::operator++()

	{

	if(NotNegative())

		{

		if(Increment(Ptr(), Size()))

			{

			CleanGrowL(2*Size());

			(Ptr())[Size()/2]=1;

			}

		}

	else

		{

		DecrementNoCarry(Ptr(), Size());

		if(WordCount()==0)

			{

			this->CopyL(Zero());

			}

		}

	return *this;

	}

EXPORT_C TInteger& TInteger::operator <<=(TUint aBits)

	{

	const TUint wordCount = WordCount();

	const TUint shiftWords = aBits / WORD_BITS;

	const TUint shiftBits = aBits % WORD_BITS;

	CleanGrowL(wordCount+BitsToWords(aBits));

	ShiftWordsLeftByWords(Ptr(), wordCount + shiftWords, shiftWords);

	ShiftWordsLeftByBits(Ptr()+shiftWords, wordCount + BitsToWords(shiftBits), 

		shiftBits);

	return *this;

	}

EXPORT_C TInteger& TInteger::operator >>=(TUint aBits)

	{

	const TUint wordCount = WordCount();

	const TUint shiftWords = aBits / WORD_BITS;

	const TUint shiftBits = aBits % WORD_BITS;

	ShiftWordsRightByWords(Ptr(), wordCount, shiftWords);

	if(wordCount > shiftWords)

		{

		ShiftWordsRightByBits(Ptr(), wordCount - shiftWords, shiftBits);

		}

	if(IsNegative() && WordCount()==0) // avoid negative 0

		{

		SetSign(EPositive);

		}

	return *this;

	}

EXPORT_C TInt TInteger::UnsignedCompare(const TInteger& aThat) const

	{

	TUint size = WordCount();

	TUint thatSize = aThat.WordCount();

	if( size == thatSize )

		return Compare(Ptr(), aThat.Ptr(), size);

	else

		return size > thatSize ? 1 : -1;

	}

EXPORT_C TInt TInteger::SignedCompare(const TInteger& aThat) const

	{

    if (NotNegative())

		{

        if (aThat.NotNegative())

            return UnsignedCompare(aThat);

        else

            return 1;

		}

    else

		{

        if (aThat.NotNegative())

            return -1;

        else

            return -UnsignedCompare(aThat);

		}

	}

EXPORT_C TBool TInteger::operator!() const

	{

	//Ptr()[0] is just a quick way of weeding out non-zero numbers without

	//doing a full WordCount() == 0.  Very good odds that a non-zero number

	//will have a bit set in the least significant word

	return IsNegative() ? EFalse : (Ptr()[0]==0 && WordCount()==0);

	}

EXPORT_C TInt TInteger::SignedCompare(TInt aInteger) const

	{

	TStackInteger64 temp(aInteger);

	return SignedCompare(temp);

	}

/* TBool IsPrimeL(void) const 

 * and all primality related functions are implemented in primes.cpp */

EXPORT_C TBool TInteger::Bit(TUint aBitPos) const

	{

	if( aBitPos/WORD_BITS >= Size() )

		{

		return 0;

		}

	else 

		{

		return (((Ptr())[aBitPos/WORD_BITS] >> (aBitPos % WORD_BITS)) & 1);

		}

	}

EXPORT_C void TInteger::SetBit(TUint aBitPos) 

	{

	if( aBitPos/WORD_BITS < Size() )

		{

		ArraySetBit(Ptr(), aBitPos);

		}

	}

EXPORT_C void TInteger::Negate() 

	{

	if(!!(*this)) //don't flip sign if *this==0

		{

		SetSign(TSign((~Sign())&KSignMask));

		}

	}

EXPORT_C void TInteger::CopyL(const TInteger& aInteger, TBool aAllowShrink)

	{

	if(aAllowShrink)

		{

		CleanResizeL(aInteger.Size());

		}

	else

		{

		CleanGrowL(aInteger.Size());

		}

	Construct(aInteger);

	}

EXPORT_C void TInteger::CopyL(TInt aInteger, TBool aAllowShrink)

	{

	if(aAllowShrink)

		{

		CleanResizeL(2);

		}

	else

		{

		CleanGrowL(2);

		}

	Construct(aInteger);

	}

EXPORT_C void TInteger::Set(const RInteger& aInteger)

	{

	assert(IsHeapBased());

	Mem::FillZ(Ptr(), WordsToBytes(Size()));

	User::Free(Ptr());

	iPtr = aInteger.iPtr;

	iSize = aInteger.iSize;

	}

RInteger TInteger::PositiveAddL(const TInteger &aA, const TInteger& aB) const

	{

	RInteger sum = RInteger::NewEmptyL(CryptoMax(aA.Size(), aB.Size()));

	const word aSize = aA.Size();

	const word bSize = aB.Size();

	const word* const aReg = aA.Ptr();

	const word* const bReg = aB.Ptr();

	word* const sumReg = sum.Ptr();

	word carry;

	if (aSize == bSize)

		carry = Add(sumReg, aReg, bReg, aSize);

	else if (aSize > bSize)

		{

		carry = Add(sumReg, aReg, bReg, bSize);

		CopyWords(sumReg+bSize, aReg+bSize, aSize-bSize);

		carry = Increment(sumReg+bSize, aSize-bSize, carry);

		}

	else

		{

		carry = Add(sumReg, aReg, bReg, aSize);

		CopyWords(sumReg+aSize, bReg+aSize, bSize-aSize);

		carry = Increment(sumReg+aSize, bSize-aSize, carry);

		}

	if (carry)

		{

		CleanupStack::PushL(sum);

		sum.CleanGrowL(2*sum.Size());

		CleanupStack::Pop(&sum);

		sum.Ptr()[sum.Size()/2] = 1;

		}

	sum.SetSign(TInteger::EPositive);

	return sum;

	}

RInteger TInteger::PositiveSubtractL(const TInteger &aA, const TInteger& aB) const

	{

	RInteger diff = RInteger::NewEmptyL(CryptoMax(aA.Size(), aB.Size()));

	unsigned aSize = aA.WordCount();

	aSize += aSize%2;

	unsigned bSize = aB.WordCount();

	bSize += bSize%2;

	const word* const aReg = aA.Ptr();

	const word* const bReg = aB.Ptr();

	word* const diffReg = diff.Ptr();

	if (aSize == bSize)

		{

		if (Compare(aReg, bReg, aSize) >= 0)

			{

			Subtract(diffReg, aReg, bReg, aSize);

			diff.SetSign(TInteger::EPositive);

			}

		else

			{

			Subtract(diffReg, bReg, aReg, aSize);

			diff.SetSign(TInteger::ENegative);

			}

		}

	else if (aSize > bSize)

		{

		word borrow = Subtract(diffReg, aReg, bReg, bSize);

		CopyWords(diffReg+bSize, aReg+bSize, aSize-bSize);

		borrow = Decrement(diffReg+bSize, aSize-bSize, borrow);

		assert(!borrow);

		diff.SetSign(TInteger::EPositive);

		}

	else

		{

		word borrow = Subtract(diffReg, bReg, aReg, aSize);

		CopyWords(diffReg+aSize, bReg+aSize, bSize-aSize);

		borrow = Decrement(diffReg+aSize, bSize-aSize, borrow);

		assert(!borrow);

		diff.SetSign(TInteger::ENegative);

		}

	return diff;

	}

RInteger TInteger::PositiveMultiplyL(const TInteger &aA, const TInteger &aB) const

	{

	unsigned aSize = RoundupSize(aA.WordCount());

	unsigned bSize = RoundupSize(aB.WordCount());

	RInteger product = RInteger::NewEmptyL(aSize+bSize);

	CleanupClosePushL(product);

	RInteger workspace = RInteger::NewEmptyL(aSize + bSize);

	AsymmetricMultiply(product.Ptr(), workspace.Ptr(), aA.Ptr(), aSize, aB.Ptr(), 

		bSize);

	workspace.Close();

	CleanupStack::Pop(&product);

	return product;

	}

TUint TInteger::Modulo(const TInteger& aDividend, TUint aDivisor) const

	{

	assert(aDivisor);

	TUint i = aDividend.WordCount();

	TUint remainder = 0;

	while(i--)

		{

		remainder = TUint(MAKE_DWORD(aDividend.Ptr()[i], remainder) % aDivisor);

		}

	return remainder;

	}

void TInteger::PositiveDivideL(RInteger &aRemainder, RInteger &aQuotient,

	const TInteger &aDividend, const TInteger &aDivisor) const

	{

	unsigned dividendSize = aDividend.WordCount();

	unsigned divisorSize = aDivisor.WordCount();

	if (!divisorSize)

		{

		User::Leave(KErrDivideByZero);

		}

	if (aDividend.UnsignedCompare(aDivisor) == -1)

		{

		aRemainder.CreateNewL(aDividend.Size());

		CleanupStack::PushL(aRemainder);

		aRemainder.CopyL(aDividend); //set remainder to a

		aRemainder.SetSign(TInteger::EPositive);

		aQuotient.CleanNewL(2); //Set quotient to zero

		CleanupStack::Pop(&aRemainder);

		return;

		}

	dividendSize += dividendSize%2;	// round up to next even number

	divisorSize += divisorSize%2;

	aRemainder.CleanNewL(divisorSize);

	CleanupStack::PushL(aRemainder);

	aQuotient.CleanNewL(dividendSize-divisorSize+2);

	CleanupStack::PushL(aQuotient);

	RInteger T = RInteger::NewEmptyL(dividendSize+2*divisorSize+4);

	Divide(aRemainder.Ptr(), aQuotient.Ptr(), T.Ptr(), aDividend.Ptr(), 

		dividendSize, aDivisor.Ptr(), divisorSize);

	T.Close();

	CleanupStack::Pop(2, &aRemainder); //aQuotient, aRemainder

	}

void TInteger::DivideL(RInteger& aRemainder, RInteger& aQuotient, 

	const TInteger& aDividend, const TInteger& aDivisor) const

    {

    PositiveDivideL(aRemainder, aQuotient, aDividend, aDivisor);

    if (aDividend.IsNegative())

        {

        aQuotient.Negate();

        if (aRemainder.NotZero())

            {

            --aQuotient;

			assert(aRemainder.Size() <= aDivisor.Size());

			Subtract(aRemainder.Ptr(), aDivisor.Ptr(), aRemainder.Ptr(), 

				aRemainder.Size());

            }

        }

    if (aDivisor.IsNegative())

        aQuotient.Negate();

    }

void TInteger::RandomizeL(TUint aBits, TRandomAttribute aAttr)

	{

	if(!aBits)

		{

		return;

		}

	const TUint bytes = BitsToBytes(aBits);

	const TUint words = BitsToWords(aBits);

	CleanGrowL(words);

	TPtr8 buf((TUint8*)(Ptr()), bytes, WordsToBytes(Size()));

	TUint bitpos = aBits % BYTE_BITS;

	TRAPD(err, GenerateRandomBytesL(buf));

	if((err != KErrNone) && (err != KErrNotSecure))

	    User::Leave(err);

	//mask with 0 all bits above the num requested in the most significant byte

	if(bitpos)

		{

		buf[bytes-1] = TUint8( buf[bytes-1] & ((1L << bitpos) - 1) );

		}

	//set most significant (top) bit 

	if(aAttr == ETopBitSet || aAttr == ETop2BitsSet)

		{

		SetBit(aBits-1); //Set bit counts from 0

		assert(BitCount() == aBits);

		assert(Bit(aBits-1));

		}

	//set 2nd bit from top

	if(aAttr == ETop2BitsSet)

		{

		SetBit(aBits-2); //Set bit counts from 0

		assert(BitCount() == aBits);

		assert(Bit(aBits-1));

		assert(Bit(aBits-2));

		}

	}

void TInteger::RandomizeL(const TInteger& aMin, const TInteger& aMax)

	{

	assert(aMax > aMin);

	assert(aMin.NotNegative());

	RInteger range = RInteger::NewL(aMax);

	CleanupStack::PushL(range);

	range -= aMin;

	const TUint bits = range.BitCount();

	//if we find a number < range then aMin+range < aMax 

	do

		{

		RandomizeL(bits, EAllBitsRandom);

		} 

	while(*this > range);

	*this += aMin;

	CleanupStack::PopAndDestroy(&range);

	}

/* void PrimeRandomizeL(TUint aBits, TRandomAttribute aAttr)

 * and all primality related functions are implemented in primes.cpp */

void TInteger::CreateNewL(TUint aNewSize)

	{

	//should only be called on construction

	assert(!iPtr);

	TUint newSize = RoundupSize(aNewSize);

	SetPtr((TUint*)User::AllocL(WordsToBytes(newSize)));

	SetSize(newSize);

	SetHeapBased();

	}

void TInteger::CleanNewL(TUint aNewSize)

	{

	CreateNewL(aNewSize);

	Mem::FillZ(Ptr(), WordsToBytes(Size())); //clear integer storage

	}

void TInteger::CleanGrowL(TUint aNewSize)

	{

	assert(IsHeapBased());

	TUint newSize = RoundupSize(aNewSize);

	TUint oldSize = Size();

	if(newSize > oldSize)

		{

		TUint* oldPtr = Ptr();

		//1) allocate new memory and set ptr and size

		SetPtr((TUint*)User::AllocL(WordsToBytes(newSize)));

		SetSize(newSize);

		//2) copy old mem to new mem

		Mem::Copy(Ptr(), oldPtr, WordsToBytes(oldSize));

		//3) zero all old memory

		Mem::FillZ(oldPtr, WordsToBytes(oldSize));

		//4) give back old memory

		User::Free(oldPtr);

		//5) zero new memory from end of copy to end of growth

		Mem::FillZ(Ptr() + oldSize, WordsToBytes(newSize-oldSize));

		}

	}

void TInteger::CleanResizeL(TUint aNewSize)

	{

	assert(IsHeapBased());

	TUint newSize = RoundupSize(aNewSize);

	TUint oldSize = Size();

	if(newSize > oldSize)

		{

		CleanGrowL(aNewSize);

		}

	else if(newSize < oldSize)

		{

		TUint* oldPtr = Ptr();

		//1) zero memory above newsize

		Mem::FillZ(oldPtr+WordsToBytes(aNewSize),WordsToBytes(oldSize-newSize));

		//2) ReAlloc cell.  Since our newsize is less than oldsize, it is

		//guarenteed not to move.  Thus this is just freeing part of our old

		//cell to the heap for other uses.

		SetPtr((TUint*)User::ReAllocL(Ptr(), WordsToBytes(newSize)));

		SetSize(newSize);

		}

	}

EXPORT_C TInteger::TInteger() : iSize(0), iPtr(0)

	{

	}

void TInteger::Construct(const TDesC8& aValue)

	{

	assert(Size() >= BytesToWords(aValue.Size()));

	if(aValue.Size() > 0)

		{

		//People write numbers with the most significant digits first (big

		//endian) but we store our numbers in little endian.  Hence we need to

		//reverse the string by bytes.

		TUint bytes = aValue.Size();

		TUint8* i = (TUint8*)Ptr();

		TUint8* j = (TUint8*)aValue.Ptr() + bytes;

		//Swap the endianess of the number itself

		// (msb) 01 02 03 04 05 06 (lsb) becomes ->

		// (lsb) 06 05 04 03 02 01 (msb)

		while( j != (TUint8*)aValue.Ptr() )

			{

			*i++ = *--j;

			}

		Mem::FillZ((TUint8*)Ptr() + bytes, WordsToBytes(Size()) - bytes);

		}

	else

		{

		//if size is zero, we zero the whole register

		Mem::FillZ((TUint8*)Ptr(), WordsToBytes(Size()));

		}

	SetSign(EPositive);

	}

void TInteger::Construct(const TInteger& aInteger)

	{

	assert(Size() >= aInteger.Size());

	CopyWords(Ptr(), aInteger.Ptr(), aInteger.Size());

	if(Size() > aInteger.Size())

		{

		Mem::FillZ(Ptr()+aInteger.Size(), WordsToBytes(Size()-aInteger.Size()));

		}

	SetSign(aInteger.Sign());

	}

void TInteger::Construct(TInt aInteger)

	{

	Construct((TUint)aInteger);

	if(aInteger < 0)

		{

		SetSign(ENegative);

		Ptr()[0] = -aInteger;

		}

	}

void TInteger::Construct(TUint aInteger)

	{

	assert(Size() >= 2);

	SetSign(EPositive);

	Ptr()[0] = aInteger;

	Mem::FillZ(Ptr()+1, WordsToBytes(Size()-1));

	}

void TInteger::ConstructStack(TUint aWords, TUint aInteger)

	{

	SetPtr((TUint*)(this)+2);

	//SetStackBased(); //Not strictly needed as stackbased is a 0 at bit 1

	SetSize(aWords);

	assert(Size() >= 2);

	Ptr()[0] = aInteger;

	Mem::FillZ(&(Ptr()[1]), WordsToBytes(Size()-1));

	}

void TInteger::ConstructStack(TUint aWords, const TInteger& aInteger)

	{

	SetPtr((TUint*)(this)+2);

	//SetStackBased(); //Not strictly needed as stackbased is a 0 at bit 1

	SetSize(aWords);