/*

* Copyright (c) 2003-2009 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: 

*

*/

/**

 @file 

 @internalComponent

*/

#ifndef __BIGINT_WORDS_H__

#define __BIGINT_WORDS_H__

#include "../common/inlines.h"

inline void ArraySetBit(TUint* aS, TUint aJ)

	{

	aS[aJ/WORD_BITS] |= (1L << (aJ%WORD_BITS));

	}

inline TUint CountWords(const TUint *X, TUint N)

	{

	while (N && X[N-1]==0)

		N--;

	return N;

	}

inline void SetWords(TUint *r, TUint a, TUint n)

	{

	Mem::Fill(r, WordsToBytes(n), a);

	}

inline void CopyWords(TUint *r, const TUint *a, TUint n)

	{

	Mem::Copy(r, a, WordsToBytes(n));

	}

inline TUint ShiftWordsLeftByBits(TUint *r, TUint n, TUint shiftBits)

	{

	assert (shiftBits<WORD_BITS);

	TUint u, carry=0;

	if (shiftBits)

		for (TUint i=0; i<n; i++)

			{

			u = r[i];

			r[i] = (u << shiftBits) | carry;

			carry = u >> (WORD_BITS-shiftBits);

			}

	return carry;

	}

inline TUint ShiftWordsRightByBits(TUint *r, TUint n, TUint shiftBits)

{

	assert (shiftBits<WORD_BITS);

	TUint u, carry=0;

	if (shiftBits)

		for (int i=n-1; i>=0; i--)

			{

			u = r[i];

			r[i] = (u >> shiftBits) | carry;

			carry = u << (WORD_BITS-shiftBits);

			}

	return carry;

	}

inline TUint CryptoMin(TUint aLeft, TUint aRight) 

	{

	return(aLeft<aRight ? aLeft : aRight);

	}

inline TUint CryptoMax(TUint aLeft, TUint aRight)

	{

	return(aLeft<aRight ? aRight : aLeft);

	}

inline void ShiftWordsLeftByWords(TUint *r, TUint n, TUint shiftWords)

	{

	shiftWords = CryptoMin(shiftWords, n);

	if (shiftWords)

		{

		for (TUint i=n-1; i>=shiftWords; i--)

			r[i] = r[i-shiftWords];

		SetWords(r, 0, shiftWords);

		}

	}

inline void ShiftWordsRightByWords(TUint *r, TUint n, TUint shiftWords)

	{

	shiftWords = CryptoMin(shiftWords, n);

	if (shiftWords)

		{

		for (TUint i=0; i+shiftWords<n; i++)

			r[i] = r[i+shiftWords];

		SetWords(r+n-shiftWords, 0, shiftWords);

		}

	}

inline TUint BytePrecision(TUint aValue)

	{

	TUint x=4;

	if(aValue < 0x10000) aValue <<=16, x-=2;

	if(aValue < 0x1000000) x--;

	if(!aValue) x=0;

	return x;

	}

inline TUint BitPrecision(TUint aValue)

	{

	if(!aValue) return 0;

	TUint x=32;

	if(aValue < 0x10000)    aValue<<=16, x-=16;

	if(aValue < 0x1000000)  aValue<<=8, x-=8;

	if(aValue < 0x10000000) aValue<<=4, x-=4;

	if(aValue < 0x40000000) aValue<<=2, x-=2;

	if(aValue < 0x80000000) --x;

	return x;

	}

static const TUint RoundupSizeTable[] = {2, 2, 2, 4, 4, 8, 8, 8, 8};

static inline TUint RoundupSize(TUint n)

	{

    if (n<=8)

        return RoundupSizeTable[n];

    else if (n<=16)

        return 16;

    else if (n<=32)

        return 32;

    else if (n<=64)

        return 64;

    else return 1U << BitPrecision(n-1);

	}

#endif