// Copyright (c) 1995-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:

 // e32\euser\maths\um_dtor.cpp

 // 

 //

 #include "um_std.h"

 const TInt KMaxScanDigits = 19;	// maximum number of decimal digits guaranteed not to overflow TUint64

 void TLex8::Scndig(TInt& aSig, TInt& aExp, TUint64& aDl)

 //

 // Scans a decimal digit field and accumulates the value to a TUint64 at aDl

 // Used before decimal point - do not drop trailing zeros.

 //

 	{

 	FOREVER

 		{

 		if (iNext>=iEnd)

 			break;

 		TChar c=Peek();

 		if (!c.IsDigit())

 			break;

 		else

 			c=Get();

 		if (aSig<KMaxScanDigits)

 			{

 			aDl *= 10;				// Multiply accumulator by 10

 			aDl+=((TUint)c)-'0';	// Add current digit

 			aSig++;

 			}

 		else

 			aExp++;

 		}														  

 	}

 void TLex8::ScndigAfterPoint(TInt& aSig, TUint64& aDl)

 //

 // Scans a decimal digit field and accumulates the value to a TUint64 at aDl

 // Used after decimal point - drops trailing zeros.

 //

 // Could be improved with change to header file!!

 	{

 	TInt trailing=0;	// no of trailing zeros

 	TInt leading=0;		// no of leading zeros

 	TInt n;

 	TChar c;

 	FOREVER

 		{

 		if (iNext>=iEnd)

 			break;

 		c=Peek();

 		if (!c.IsDigit())

 			break;

 		else

 			{

 			c=Get();

 			if (c=='0')

 				{

 				if (aDl!=0)		// possible trailing zeros

 					trailing++;	

 				else			// if aDl==0 multiplying by 10 and adding 0 has no effect  

 					{

 					leading++;

 					aSig++;		// leading zeros have significance

 					}

 				}	

 			else if ((aSig<KMaxScanDigits+leading && !trailing) || (trailing && aSig+trailing+1<KMaxScanDigits))

 				{

 				// first multiply, taking account of preceeding zeros

 				for (n=trailing; n>=0; n--)

 					{

 					aDl *= 10;			// Multiply accumulator by 10

 					}

 				// now add current digit

 				aDl+=((TUint)c)-'0';

 				// now update significant digits used

 				aSig+=trailing+1;

 				trailing=0;

 				}

 			}

 		}

 	}	

 void TLex16::Scndig(TInt& aSig, TInt& aExp, TUint64& aDl)

 //

 // Scans a decimal digit field and accumulates the value to a TUint64 at aDl

 //

 	{

 	FOREVER

 		{

 		TChar c=Peek();

 		if (!c.IsDigit())

 			break;

 		else

 			c=Get();

 		if (aSig<KMaxScanDigits)

 			{

 			aDl *= 10;				// Multiply accumulator by 10

 			aDl+=((TUint)c)-'0';	// Add current digit

 			aSig++;

 			}

 		else

 			aExp++;

 		}														  

 	}

 EXPORT_C TInt TLex8::Val(TReal32& aVal)

 //

 // Convert a 32 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex8::Val(TReal32& aVal, TChar aPoint)

 //

 // Convert a 32 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x,aPoint);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex8::Val(TReal64& aVal)

 //

 // Convert a 64 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex8::Val(TReal64& aVal, TChar aPoint)

 //

 // Convert a 64 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x,aPoint);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 TInt TLex8::Val(TRealX& aVal)

 //

 // Convert an extended real. Use the locale decimal point.

 //

 	{

 	TLocale locale;

 	return(Val(aVal,locale.DecimalSeparator()));

 	}

 TInt TLex8::Val(TRealX& aVal, TChar aPoint)

 //

 // Convert an extended real.

 //

 	{

 	TLexMark8 start(iNext);

 	if (iNext>=iEnd)

 		return(KErrGeneral);

 	TUint64 n(0);

 	TBool minus=EFalse;

 	if (Peek()=='-')

 		{

 		Inc();

 		minus=ETrue;

 		}

 	else if (Peek()=='+')

 		Inc();

 	TInt digflg=Peek().IsDigit();

 	while (Peek()=='0')		// Skip leading zeros

 		Inc();

 	TInt nsig=0;

 	TInt nskip=0;

 	Scndig(nsig,nskip,n);

 	TInt nint=nsig;

 	TInt nfract=0;

 	if (Peek()==aPoint)

 		{

 		Inc();

 		if (!digflg)

 			digflg=Peek().IsDigit();

 		ScndigAfterPoint(nsig,n);	// skip trailing zeros

 		nfract=nsig-nint;

 		}

 	if (!digflg)

 		{

 		UnGetToMark(start);

 		return(KErrGeneral);	// Not a number

 		}

 	TInt nexp=0;

 	TInt r;

 	if (Peek()=='E' || Peek()=='e')

 		{

 		TLexMark8 rollback(iNext);

 		Inc();

 		r=Val(nexp);

 		if (r!=KErrNone)

 			{

 			if (r==KErrOverflow)

 				{

 				aVal.SetInfinite(minus);

 				return r;

 				}

 			else

 				{

 				//it wasn't a number after the 'e', so rollback to the 'e'

 				UnGetToMark(rollback);

 				}

 			}

 		}

 	if (n == 0)

 		{

 		aVal.SetZero();

 		return KErrNone;

 		}

 	// Clear msb and if it was set then add 2^63 to aVal as a TRealX

 	// as TRealX can only be set from a TInt64.

 	TUint32 nh = I64HIGH(n);

 	n <<= 1;	// Clear the msb of n (64 bit number so this is most efficient method).

 	n >>= 1;

 	aVal = TInt64(n);

 	if (nh & 0x80000000u)

 		{

 		TRealX nhx(1);

 		nhx.iExp = (TUint16)(nhx.iExp + 63);

 		aVal += nhx;

 		}

 	if (minus)

 		aVal = -aVal;

 	nexp += nskip - nfract;

 	r=Math::MultPow10X(aVal,nexp);

 	return r;

 	}

 EXPORT_C TInt TLex16::Val(TReal32& aVal)

 //

 // Convert a 32 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex16::Val(TReal32& aVal, TChar aPoint)

 //

 // Convert a 32 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x,aPoint);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex16::Val(TReal64& aVal)

 //

 // Convert a 64 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 EXPORT_C TInt TLex16::Val(TReal64& aVal, TChar aPoint)

 //

 // Convert a 64 bit real.

 //

 	{

 	TRealX x;

 	TInt r=Val(x,aPoint);

 	if (r==KErrNone)

 		r=x.GetTReal(aVal);

 	return r;

 	}

 TInt TLex16::Val(TRealX& aVal)

 //

 // Convert an extended real. Use the locale decimal point.

 //

 	{

 	TLocale locale;

 	return(Val(aVal,locale.DecimalSeparator()));

 	}

 TInt TLex16::Val(TRealX& aVal, TChar aPoint)

 //

 // Convert a 64 bit real

 //

 	{

 	HBufC8 *temp=HBufC8::New(iEnd-iNext);

 	if (temp==NULL)

 		return(KErrNoMemory);

 	TPtr8 tdes(temp->Des());

 	for (const TText* p = (TText*)iNext; p < (TText*)iEnd; p++)

 		{

 		TChar c = *p;

 		if (c == aPoint)

 			c = '.';

 		else if (c == '.')

 			c = ' ';

 		else if (c > 255)

 			c = ' ';

 		tdes.Append((TUint8)c);

 		}

 	aPoint = '.';

 	TLex8 lex(tdes);

 	lex.Mark();

 	TInt r=lex.Val(aVal,aPoint);

 	User::Free(temp);

 	if (r==KErrNone)

 		Inc(lex.TokenLength());

 	return r;

 	}