// 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_rtod.cpp
// 
//

#include "um_std.h"

#include <e32debug.h>

#define KNeedsRounding 0x1000
#if (KRealFormatTypeFlagsMask| KRealFormatTypesMask) & KNeedsRounding 
	#error KNeedsRounding already uses 0x1000
#endif

const TInt KMinThreeDigitExponent=100;

_LIT8(KLit8Plus,"+");
_LIT8(KLit8Minus,"-");
_LIT8(KLit8Zero,"0");
_LIT8(KLit8Inf,"Inf");
_LIT8(KLit8Nan,"NaN");

LOCAL_C TInt round(const TText8* aBuf, const TInt aLen)
//
// Round number in buffer depending on digit at aBuf[aLen]. 
// Return value is carry from most significant digit.
//
	{
	__ASSERT_DEBUG(aLen>=0,Panic(EMathUnexpectedError1));
	TText8* pB=(TText8*)aBuf+aLen;
	if (*pB<'5')
		return 0;	// round down
	while(--pB>=aBuf)
		{
		TText8 d=*pB;
		if (d<'9')
			{
			++d;
			*pB=d;
			return 0;
			}
		*pB='0';
		}
	// carry propagates to exponent
	*++pB='1';
	if (aLen>0)
		pB[aLen]='0';
	return 1;
	}

TUint mult10(TUint64& a)
//
// Multiply a 64-bit binary fraction in a (MSB=2^-1) by 10
// Return the fractional part in a, the integer part in the return value.
//
	{
	const TUint64 ten = 10;
	TUint64 high;
	Math::UMul64(a, ten, high, a);
	return static_cast<TUint>(high);
	}

LOCAL_C TInt fDigLim(TDes8& aTrg, const TReal& aSrc, TInt& aExp, const TBool aLimit)
//
// Convert the TReal at address aSrc to a decimal form suitable for use by a
// formatting routine. Writes the result into the descriptor at aTrg and the
// exponent in aExp. Returns the length of the string or a negative error number.
//
// AnnW, November 1996 - changed to handle all numbers in TReal64/96 range.
//
// The first character in aBuf is one of:
//
// '0' - indicates that aSrc is exactly zero.
//
// '+' - indicates a positive number and is followed by between 1 and KMaxPrecision
// decimal digits representing a mantissa in the range 0.1 to less than 1.0 which 
// corresponds to the decimal exponent returned in aExp.
//
// '-' - indicates a negative mantissa and is otherwise the same as for '+'.
//
// If aLimit is ETrue then the format is limited to KPrecisionLimit significant digits
// 
	{
	
	TRealX x;
	TInt r=x.Set(aSrc);

	if (x.IsZero())
		{
		aTrg=KLit8Zero();
		return 1;
		}
	else	// sets sign in all cases, including specials
		aTrg=(x.iSign ? KLit8Minus() : KLit8Plus());
		
	if (r!=KErrNone)
		return r;

	x.iSign=0;
	TInt e=TInt(x.iExp)-0x7fff;		// 2^e<=Abs(x)<2^(e+1)
	e*=19728;						// log10(2)*65536 = 19728.301796...
									// max error due to omission of fractional part is 9889 (towards zero)
	e-=9889;						// account for error, e may be too small by up to 19778
									// Now have 10^(e/65536)<=Abs(x)<4.007*10^(e/65536)
	e>>=16;							// Divide by 65536 - this always rounds towards -infinity
									// Now have 10^e<=Abs(x)<40.07*10^e
	e+=1;							// Now have 0.1<=Abs(x)/10^e<4.07
	Math::MultPow10X(x,-e);			// x*=10^-e so now 0.1<=x<4.07
	if (x.iExp>=0x7fff)
		{
		++e;
		Math::MultPow10X(x,-1);		// if x>=1, multiply x by 10^-1 and increment e
		}

	TUint64 mantissa = MAKE_TUINT64(x.iMantHi, x.iMantLo);

	if (x.iExp<0x7ffe)
		mantissa >>= (0x7ffe - x.iExp);	// shift to make exponent 0x7ffe, i.e. mantissa in range 0.1<=m<1

	TInt prec=aLimit?KPrecisionLimit:KMaxPrecision;

	while ( mantissa && (aTrg.Length() < (prec + 2)) )
		{
		TUint d = mult10(mantissa);
		aTrg.Append(d+'0');
		}
	if (aTrg.Length()>=prec+2)
		{
		e+=round(aTrg.Ptr()+1,prec);
		aTrg.SetLength(prec+1);
		}
	aExp=e;
	return aTrg.Length();
	}

LOCAL_C TInt doExponent(TDes8* This, TDes8& aDigBuf, const TInt afDigLimSize, TInt aExp,
	const TInt aNumPlcs, const TInt aNumSpace, const TText aPoint, const TUint flags)
//
// Convert the intermediate number represented in aDigBuf into its exponential representation
// and place into aTrg.
// This representation ensures that numbers are displayed to aNumDecPlcs+1 significant figures,
// but this is NOT a constant value in KTRealFormatGeneral mode. 
//
// AnnW, November 1996 - changed to be able to take three-figure exponents if allowed by flags.
// 
	{

	TInt err;
	TInt expSpace;
	TInt useSigFigs=flags & KUseSigFigs;
	TInt nDig=(useSigFigs ? Min(aNumPlcs,afDigLimSize) : aNumPlcs+1);	
	TInt threeDigitExp=flags & KAllowThreeDigitExp;

	if ((flags & KNeedsRounding) && afDigLimSize>nDig)
		aExp+=round(aDigBuf.Ptr()+1,nDig);	

	if (useSigFigs)			// discard trailing zeros
		{
		while(nDig>1 && aDigBuf[nDig]=='0')
			{
			nDig--;
			}
		}
	
	if (aDigBuf[0]!='0')
	// 100.5 is stored in aDigBuf as +1005 with and exp of 3, but it is to be displayed
	// as 1.005 so exp must be decremented to 2
		aExp--;

	// Added by AnnW
	if (threeDigitExp)
		{
		expSpace=(Abs(aExp)>=KMinThreeDigitExponent)?5:4;
		}
	else
		{
		err=(aExp<=-KMinThreeDigitExponent ? KErrUnderflow : (aExp>=KMinThreeDigitExponent ? KErrOverflow : KErrNone));
		if (err!=KErrNone)
			return(err);
		expSpace=4;
		}
	
	// Check that number will fit in aNumSpace
	if (aNumSpace<(expSpace+nDig+(nDig>1?1:0)))
	// exponent + significant figures + point(if necessary)
		return(KErrGeneral);
	// end of added

	if (aDigBuf[0]=='0')  // number to be converted is 0
		{
		This->Append('0');
		if (nDig>1 && !useSigFigs)
			{
			This->Append(aPoint);
			This->AppendFill('0',aNumPlcs);
			}
		}
	else
		{
		This->Append(TChar(aDigBuf[1]));
		if (nDig>1)
			{
			This->Append(aPoint);
			for (TInt ii=2; ii<=nDig; ii++)
				{
				if (!useSigFigs)
					// pad with zeros
					This->Append(TChar(ii<aDigBuf.Length() ? aDigBuf[ii]:'0'));
				else
					// do not pad with zeros
					This->Append(TChar(aDigBuf[ii]));
				}
			}
		}
	
	This->Append('E');
	if (aExp<0) 
		{
		aExp=-aExp;
		This->Append('-');
		}
	else
		This->Append('+');

	// Added by AnnW
	TInt tempExp;
	if (threeDigitExp && aExp>99)		
		{								
		This->Append(aExp/100+'0');
		tempExp=aExp%100;
		}								
	else								
		tempExp = aExp;				
	// end of added

	This->Append(tempExp/10+'0'); 
	This->Append(tempExp%10+'0');
	return(KErrNone);
	}

LOCAL_C TInt doFixed(TDes8 *This,TDes8 &aDigBuf,const TInt afDigLimSize,TInt aExp,const TInt aNumDecPlcs,
				const TInt aNumSpace,const TRealFormat &aFormat,const TUint flags)
//
// Convert the intermediate number represented in aDigBuf into its fixed representation and
// place into aTrg
//
// AnnW, November 1996 - changed to allow extra space to be left for potential sign, so that
// positive and negative numbers of the same exponent are displayed to the same precision.
//
	{

	TInt err;
	TInt doNotUseTriads=flags & KDoNotUseTriads;
	TInt newNumSpace=aNumSpace;
	// To allow positive and negative numbers with the same exponent to	have the same number of 
	// significant figures.
	if ((flags & KExtraSpaceForSign) && (aDigBuf[0]!='-'))
		newNumSpace--;

	TInt roundOffset = aNumDecPlcs+aExp;
	if (roundOffset>=0 && afDigLimSize>roundOffset && (flags & KNeedsRounding))
		aExp+=round(aDigBuf.Ptr()+1,roundOffset);

	if (newNumSpace<((aExp>0?aExp:1)+(aNumDecPlcs?aNumDecPlcs+1:0)+(!doNotUseTriads && aFormat.iTriLen && (aExp>(TInt)aFormat.iTriLen)?(aExp-1)/3:0)))
	// exponent +ve and space < space needed for (digits before point + point + decimal places + triads)
		{
		err=(aExp>0 ? KErrOverflow : KErrGeneral);
		return(err);
		}

	if (aExp<=0) // hence number is of the form 0.NNNN
		{
		This->Append('0');
		if (aNumDecPlcs)
			{
			aExp=-aExp;
			TInt nDig=aNumDecPlcs-aExp;	// number of digits required from aDigBuf
			This->Append(aFormat.iPoint);
			if (aExp>aNumDecPlcs)	 
				aExp=aNumDecPlcs;
			This->AppendFill('0',aExp);
			if (nDig>0)	 
				{
				for (TInt ii=1; ii<nDig+1; ii++)
					This->Append(TChar(ii<aDigBuf.Length() ? aDigBuf[ii]:'0'));
				}
			}
		else	// no decimal places
			{
			if (aDigBuf[0]=='-')
				{
				This->Delete(0,2);	// delete -0 from This
				This->Append('0');
				}
			}
		}
	else  // aExp > 0 hence number is of the form NNNN.NNNN
		{
		for (TInt jj=1,ii=aExp; ii; ii--,jj++)
			{
			if (!doNotUseTriads && aFormat.iTriLen && aExp>(TInt)aFormat.iTriLen && !(ii%3) && ii!=aExp)
				This->Append(aFormat.iTriad);
			This->Append(TChar(jj>=aDigBuf.Length() ? '0' : aDigBuf[jj]));
			}
		if (aNumDecPlcs>0)
			{
			This->Append(aFormat.iPoint);
			for (TInt ii=aExp+1; ii<aNumDecPlcs+aExp+1; ii++)
				This->Append(TChar(ii<aDigBuf.Length() ? aDigBuf[ii] : '0'));
			}
		}

	return(KErrNone);
	}

LOCAL_C TInt doNoExponent(TDes8 *This, TDes8 &aDigBuf,const TInt afDigLimSize,TInt aExp,
	const TInt aMaxSigFigs,const TInt aNumSpace, const TRealFormat &aFormat,const TUint flags)
//
// Added by AnnW, November 1996
// Convert the intermediate number represented in aDigBuf into its no exponent representation
// and place into aTrg
// Changed April 1997 - If there is not enough space for the number of s.f., zeros, points, triads,
// etc, then the number of significant figs is reduced to fit.  Overflow if too big to fit and 
// underflow if no significance can be seen.
//
	{

	TInt doNotUseTriads=flags & KDoNotUseTriads;
	TInt numSpace=aNumSpace;
	if ((flags & KExtraSpaceForSign) && (aDigBuf[0]!='-'))
		numSpace--;

	TInt nTriadSeps=(!doNotUseTriads && aFormat.iTriLen && (aExp>(TInt)aFormat.iTriLen))?(aExp-1)/3:0;
	TInt maxDig=Min(aMaxSigFigs,afDigLimSize);
	TInt maxSpace=numSpace-(aExp<=0?(2-aExp):((aExp<maxDig?1:aExp-maxDig)+nTriadSeps));
	TInt nDig=Min(maxSpace,maxDig);
	if (afDigLimSize>nDig && nDig<15 && nDig>=0 && (flags & KNeedsRounding) && round(aDigBuf.Ptr()+1,nDig)) 
		aExp++;
		
	if (aDigBuf[0]=='0')	// do zero first (numSpace>=0 so OK)
		This->Append('0');
	else
		{
		// check for overflow/underflow
		if ((aExp+nTriadSeps)>numSpace)
			return(KErrOverflow);
		if (nDig<=0)
			return(KErrUnderflow);

		if ((flags&(TUint)KRealFormatTypesMask)!=(TUint)KRealFormatCalculator && aExp>aMaxSigFigs)
			return(KErrOverflow);
		
		TInt nDecPlcs=nDig-aExp;
		while(nDecPlcs>0 && aDigBuf[nDig]=='0')
			{ // discard trailing zeros (already done in calculator)
			nDecPlcs--;
			nDig--;
			}
		
		if (aExp<=0) // hence number is of the form 0.NNNN
			{
			This->Append('0');
			aExp=-aExp;
			// if (nDecPlcs<=0) do nothing	
			if (nDecPlcs>0)	 
				{
				This->Append(aFormat.iPoint);
				This->AppendFill('0',aExp);
				for (TInt ii=1; ii<=nDig; ii++)
					This->Append(TChar(aDigBuf[ii]));
				}
			}
		else  // aExp > 0 hence number is of the form NNNN.NNNN
			{
			for (TInt jj=1,ii=aExp; ii; ii--,jj++)
				{
				if (!doNotUseTriads && aFormat.iTriLen && aExp>(TInt)aFormat.iTriLen && !(ii%3) && ii!=aExp)
					This->Append(aFormat.iTriad);
				This->Append(TChar(jj<=nDig ? aDigBuf[jj] : '0'));
				}
			if (nDecPlcs>0)	
				{
				This->Append(aFormat.iPoint);
				for (TInt ii=aExp+1; ii<=nDig; ii++)
					This->Append(TChar(aDigBuf[ii]));	
				}
			}
		}

	return(KErrNone);
	}

LOCAL_C TInt doGeneral(TDes8 *This,TReal aSrc,TDes8 &aDigBuf,const TInt afDigLimSize,TInt aExp,
			TInt aNumDecPlcs,const TInt aNumSpace,const TRealFormat &aFormat,TUint flags) __SOFTFP
//
// Convert the intermediate number represented in aDigBuf into either its fixed representation or
// its exponential representation as appropriate and place the result in aTrg
// 
// Annw, November 1996 - changed to allow space for sign in fixed mode, three-figure exponent.
	{

	TBool rounded=((flags & KNeedsRounding)==0);
	TInt nDig=aDigBuf.Length()-1;	 // no of digits without sign
	TInt type;

	// Set up tempNumSpace to allow for leaving one space free for +ve nos in fixed format
	TInt fixedNumSpace=aNumSpace;
	if ((flags & KExtraSpaceForSign) && (aDigBuf[0]!='-'))
		fixedNumSpace--;
	if (fixedNumSpace<=0)
		return(KErrGeneral);

	FOREVER
		{
		// If aNumSpace < 5 cannot use exponential format, i.e. not enough space for XE+NN.
		// If the exponent >= -3 (i.e. aExp >= -2), it is always more (or equally) efficient
		// to use non-exponential format for negative exponents, i.e. XE-03 takes same no of
		// spaces as 0.00X, and for positive exponents use fixed form as far as possible. 
		
		// for Java do not used fixed format for exponents >=7  
		// expMax=Min(fixedNumSpace,7)
		// and replace "fixednumSpace" with "expMax" in next line

		if (aNumSpace<5 || (aExp>=-2 && aExp<=fixedNumSpace))
			{
			type=KRealFormatFixed;

			// if there is at least one digit before decimal point or no. is zero
			if (aExp>0 || !aSrc)
				{
				if (nDig!=aExp)
				// nDig is the number of digits which will be used
				// a decimal point needed if exponent < digits in digbuf and numspace < nDig,
				// so nDig is one less than otherwise
				nDig=((nDig-aExp)>0 && fixedNumSpace>aExp)?Min(fixedNumSpace-1,nDig):Min(fixedNumSpace,nDig);
				aNumDecPlcs=nDig-aExp;
				}
		 	else
				{
				// need space for "0." and to avoid white spaces
				aNumDecPlcs=Min(fixedNumSpace-2,nDig-aExp); 
				// need space for "0.0...0" before any digits used
				nDig=aNumDecPlcs+aExp; 
				if (nDig<0)
					return KErrGeneral;
				}
			}
		else
			{
			type=KRealFormatExponent;		// Do NOT use significant figures
			// Need to allow space for exponent
			TInt tempNumSpace=aNumSpace-4;	// 4 = E+NN
			if ((flags & KAllowThreeDigitExp) && (Abs(aExp-1)>=100))
				tempNumSpace--;				// 5 = E+NNN			
			// if more than one digit available and enough digits to fill space, need to reduce
			// number of digits to allow for '.'
			if (((nDig=Min(tempNumSpace,nDig))>1) && nDig==tempNumSpace) 
				nDig--; 
			// in any case, aNumDecPlcs is one less that the number of digits,
			// i.e. one digit before the point
			aNumDecPlcs=nDig-1;
			}
		// if too many digbuf chars to fit then we need to round
		// round() returns 1 if had to carry from msdigit
		if ((afDigLimSize>nDig && !rounded) && ((rounded=round(aDigBuf.Ptr()+1,nDig))!=0))
			aExp++;
		else
			break;
		}		
	while(aNumDecPlcs>0 && aDigBuf[nDig]=='0')
		{ // discard trailing zeros
		aNumDecPlcs--;
		nDig--;
		}	
	flags=flags & ~KNeedsRounding;
	
	if (type==KRealFormatExponent)
		return(doExponent(This,aDigBuf,afDigLimSize,aExp,aNumDecPlcs,aNumSpace,(TText)aFormat.iPoint,flags));
	return(doFixed(This,aDigBuf,afDigLimSize,aExp,aNumDecPlcs,aNumSpace,aFormat,flags));
	}

 LOCAL_C TInt doCalculator(TDes8 *This,TDes8 &aDigBuf,const TInt afDigLimSize,TInt aExp,
			TInt aMaxSigFigs,const TInt aMaxSpace,const TRealFormat &aFormat, TUint flags)
//
// Added by AnnW, November 1996
// Convert the intermediate number represented in aDigBuf into either its no exponent or its 
// exponential representation with a fixed number of significant figures and place the result 
// in aTrg
// 
	{

	TBool threeDigExp=((flags & KAllowThreeDigitExp)!=0);

	// first check that enough space has been allowed for all the possible characters
	// point + sign + all sig figs + exponent
	if (aMaxSpace<(2+aMaxSigFigs+(threeDigExp?5:4)))
		return(KErrGeneral);

	// now discard trailing zeros
	TInt nDig=afDigLimSize;
	while(nDig>1 && aDigBuf[nDig]=='0')
		{
		nDig--;
		}

	TInt maxDig=Min(aMaxSigFigs,nDig);	// max digs available
	TBool rounded=((flags & KNeedsRounding)==0);
	TInt type;	
	TBool useNoExp;

	FOREVER
		{
		useNoExp=ETrue;
		nDig=maxDig;
		
		// use no exponent for all numbers which will not use > aMaxSigFigs digits
		if (aExp>aMaxSigFigs || (aExp<=0 && (1-aExp+nDig)>aMaxSigFigs))
			useNoExp=EFalse;
		
		if (useNoExp)
			type=KRealFormatNoExponent;
		else
			{
			type=KRealFormatExponent;
			threeDigExp=((Abs(aExp-1)>=KMinThreeDigitExponent && threeDigExp)!=0);
			TInt temp=aMaxSpace-(threeDigExp?5:4);
			nDig=Min(maxDig,temp-((temp>1 && maxDig>1)?1:0));
			}
			
		// if too many digbuf chars to fit then we need to round
		// round() returns 1 if had to carry from msdigit
		if ((afDigLimSize>nDig && !rounded) && ((rounded=round(aDigBuf.Ptr()+1,nDig))!=0))
			{
			aExp++;
			maxDig=1;
			}
		else
			break;
		}
 
	TInt numSpace=aMaxSpace-(aDigBuf[0]=='-'?1:0);
	flags=flags & ~KNeedsRounding;

	if (type==KRealFormatExponent)
		return(doExponent(This,aDigBuf,afDigLimSize,aExp,nDig,numSpace,(TText)aFormat.iPoint,flags));
	else
		{
		flags|=KExtraSpaceForSign;
		return(doNoExponent(This,aDigBuf,afDigLimSize,aExp,nDig,numSpace,aFormat,flags));
		}
	}

TInt ProcessErrors(TDes8* aDes, TInt anError)
	{
	if (anError==KErrNone)
		return aDes->Length();
	if (anError==KErrUnderflow)
		aDes->Append(TChar('0'));
	if (anError==KErrOverflow)
		aDes->Append(KLit8Inf());
	if (anError==KErrArgument)
		aDes->Append(KLit8Nan());
	return anError;
	}

LOCAL_C TInt rtob(TDes8 *This,TReal aVal,const TRealFormat &aFormat) __SOFTFP
//
// Converts the real at aSrc. Returns the length of the converted string or an error number
// if the buffer is too small, the number is out of range or there is insufficient KMaxPrecision
// to represent the number.
//
// The conversion format is interpreted as follows:
// KRealFormatFixed - ndec decimal places (including zero), negative values with a leading minus 
// sign, triad separators are available and a space may be left in front of positive numbers to 
// allow negative positve numbers to be given to the same precision.
// KRealFormatExponent - exponent notation specifying either decimal places or significant
// figures in the mantissa and a signed exponent given to a maximum of two or three digits,
// and no triad separator.
// KTRealFormatGeneral - converts either as fixed or exponent to make best use of the available
// width. The number of decimal spaces is chosen automatically as a function of width
// (ndec is ignored),  no triad.
// KRealFormatNoExponent - as KRealForamtFixed, but specifying maximum significant figures and
// not introducing trailing zeros.
// KRealFormatCalculator - as KRealFormatGeneral, but behaves as a conventional calculator. A
// maximum number of significant figures is specified and the number is displayed without an
// exponent whenever possible, with no trailing zeros and no triads.
// 
// If an error value other than KErrGeneral is returned the real is converted to some string:
// "+/-Inf" if the error is KErrOverflow, "NaN" if the error is KErrArgument or "0" if it is 
// KErrUnderflow.
//
	{
	if (aFormat.iWidth>This->MaxLength())
		return(KErrGeneral);	 
	TBuf8<0x20> digbuf;
	TInt exp=0;
	TInt numspace=aFormat.iWidth;
	TInt maxspace=numspace;
	TInt ret=fDigLim(digbuf,aVal,exp,((aFormat.iType & KGeneralLimit)!=0)); 
	digbuf.ZeroTerminate();
	TInt type, flags;

	if (digbuf[0]=='0')
		exp=0;
	else 
		{
		if (digbuf[0]=='-' && ret!=KErrArgument)	// NaN has no sign
			{
			This->Append('-');
			numspace--;
			}
		if (ret<0)
			return ProcessErrors(This, ret);
		else
			ret--;
		}

	//Added by AnnW
	if (numspace<=0)
		return(KErrGeneral);
	if (aFormat.iType & ~KRealFormatTypesMask & ~KRealFormatTypeFlagsMask)
		return(KErrGeneral);
	type=aFormat.iType & KRealFormatTypesMask;
	flags=((aFormat.iType & KRealFormatTypeFlagsMask)| KNeedsRounding);
	// end of added

	switch(type)
		{
	case KRealFormatFixed:
		flags=flags & ~KUseSigFigs;	// if flag is NOT set and iTriLen!=0, uses triads
		ret=doFixed(This,digbuf,ret,exp,aFormat.iPlaces,numspace,aFormat,flags);
		break;
	case KRealFormatExponent:
		ret=doExponent(This,digbuf,ret,exp,aFormat.iPlaces,numspace,(TText)aFormat.iPoint,flags);
		break;
	case KRealFormatGeneral:
		flags=(flags & ~KUseSigFigs) | KDoNotUseTriads;
		ret=doGeneral(This,aVal,digbuf,ret,exp,aFormat.iPlaces,numspace,aFormat,flags);
		break;
	case KRealFormatNoExponent:
		flags=flags | KUseSigFigs;	// if flag is NOT set and iTriLen!=0, uses triads	
		ret=doNoExponent(This,digbuf,ret,exp,aFormat.iPlaces,numspace,aFormat,flags);
		break;
	case KRealFormatCalculator:
		flags=(flags | KUseSigFigs) | KDoNotUseTriads | KRealFormatCalculator;
		ret=doCalculator(This,digbuf,ret,exp,aFormat.iPlaces,maxspace,aFormat,flags);
		break;
	default:
		return(KErrGeneral);
		}
	return ProcessErrors(This, ret);
	}



	  
EXPORT_C TRealFormat::TRealFormat()
/**
Default constructor.

The public data members of the constructed object are assigned
the following values:

TRealFormat::iType   - set to KRealFormatGeneral

TRealFormat::iWidth  - set to KDefaultRealWidth

TRealFormat::iPlaces - set to 0

TRealFormat::iPoint  - set to the decimal separator character defined in
                       a TLocale object and returned by the DecimalSeparator()
                       member function of that class.

TRealFormat::iTriad  - set to the character used to delimit groups of three
                       digits in the integer portion of a number; the character
                       is defined in a TLocale object and returned by the
                       ThousandsSeparator() member function of that class.

TRealFormat::iTriLen - set to 1

@see TLocale::DecimalSeparator
@see TLocale::ThousandsSeparator
*/
	{

	iType=KRealFormatGeneral;
	iWidth=KDefaultRealWidth;
	iPlaces=0;
	TLocale locale;
	iPoint=locale.DecimalSeparator();
	iTriad=locale.ThousandsSeparator();
	iTriLen=1;
	}




EXPORT_C TRealFormat::TRealFormat(TInt aWidth)
/**
Constructs the object taking the width of the character representation.

The remaining public data members of the constructed object are assigned
the following values:

TRealFormat::iType   - set to KRealFormatGeneral

TRealFormat::iWidth  - set to the aWidth argument

TRealFormat::iPlaces - set to 0

TRealFormat::iPoint  - set to the decimal separator character defined in
                       a TLocale object and returned by the DecimalSeparator()
                       member function of that class.

TRealFormat::iTriad  - set to the character used to delimit groups of three
                       digits in the integer portion of a number; the character
                       is defined in a TLocale object and returned by the
                       ThousandsSeparator() member function of that class.

TRealFormat::iTriLen - set to 1

@param aWidth The width of the character representation of the real number.

@see TLocale::DecimalSeparator
@see TLocale::ThousandsSeparator
*/
	{

	iType=KRealFormatGeneral;
	iWidth=aWidth;
	iPlaces=0;
	TLocale locale;
	iPoint=locale.DecimalSeparator();
	iTriad=locale.ThousandsSeparator();
	iTriLen=1;
	}




EXPORT_C TRealFormat::TRealFormat(TInt aWidth,TInt aDecimals)
/**
Constructs the object taking the width of the character representation
and a value which is interpreted as the number of digits to follow
the decimal point.

The remaining public data members of the constructed object are assigned
the following values:

TRealFormat::iType   - set to KRealFormatFixed

TRealFormat::iWidth  - set to the aWidth argument

TRealFormat::iPlaces - set to the aDecimals argument

TRealFormat::iPoint  - set to the decimal separator character defined in
                       a TLocale object and returned by the DecimalSeparator()
                       member function of that class.

TRealFormat::iTriad  - set to the character used to delimit groups of three
                       digits in the integer portion of a number; the character
                       is defined in a TLocale object and returned by the
                       ThousandsSeparator() member function of that class.

TRealFormat::iTriLen - set to 1

Note that if the iType data member is changed after construction, aDecimalPlaces
may be interpreted as the number of significant digits. For more information,
see KRealFormatFixed and the other format types, and KExtraSpaceForSign and the
other format flags.

@param aWidth    The width of the character representation of the real number.
@param aDecimals The number of digits to follow the decimal point.

@see TLocale::DecimalSeparator() 
@see TLocale::ThousandsSeparator() 
@see KRealFormatFixed 
@see KExtraSpaceForSign 
*/
	{

	iType=KRealFormatFixed;
	iWidth=aWidth;
	iPlaces=aDecimals;
	TLocale locale;
	iPoint=locale.DecimalSeparator();
	iTriad=locale.ThousandsSeparator();
	iTriLen=1;
	}



					
EXPORT_C TInt Math::Round(TReal &aTrg,const TReal &aSrc,TInt aDecimalPlaces)
/**
Rounds to a specified number of decimal places.

The function rounds a number to a given number, n, of decimal places.
Rounding may be thought of as multiplying the number by 10 to the power of n,
rounding to the nearest integer, and then dividing the result by 10 to
the power of n and returning that as the answer.

In the process of rounding, numbers ending with .5 are rounded away from zero,
so that 1.5 becomes 2, 2.5 becomes 3, -1.5 becomes -2, etc.

@param aTrg           A reference containing the result. 
@param aSrc           The number to be rounded. 
@param aDecimalPlaces The number of decimal places to round to: must be
                      zero or positive.

@return KErrNone if successful, otherwise another of the system-wide error codes. 
*/
	{

	if (aSrc==0.0)
		{
		aTrg=aSrc;
		return(KErrNone);
		}
	TInt ret,exp;
	TBuf8<0x20> rbuf;
	if ((ret=fDigLim(rbuf,aSrc,exp,EFalse))<0) 
		return(ret);
	if ((exp+aDecimalPlaces)<0)
		{ // Number too small to be rounded
		aTrg=0;
		return(KErrNone);
		}    
	if ((ret-2)<(exp+aDecimalPlaces))	//ret is the string length, including prefixed +/-		
		{ // Rounding will have no effect
		aTrg=aSrc;
		return(KErrNone);
		}       
	if ((ret=round(rbuf.Ptr()+1,exp+aDecimalPlaces))!=KErrNone)
		exp++;
 	rbuf.Insert(1,TPtrC8((TText8*)".",1));
	rbuf.SetLength(exp+aDecimalPlaces+2);
	if (!(exp+aDecimalPlaces))
		rbuf.Append('0');
//	rbuf.AppendFormat(TPtrC8((TText8*)"%c%d",4),'E',exp);
	rbuf.Append(TChar('E'));
	rbuf.AppendNum(exp);
	return(((TLex8)rbuf).Val(aTrg,(TChar)'.'));
	}        

EXPORT_C TInt TDes8::Num(TReal aVal,const TRealFormat &aFormat) __SOFTFP
/**
Converts the specified floating point number into a character representation 
and copies the conversion into this descriptor, replacing any existing data.

The length of this descriptor is set to reflect the new data.
	
The character representation of the real number is dictated by the specified 
format.

Note that the function leaves if the iType data member of the specified
TRealFormat object has both an invalid character representation format
(i.e. the format type) and invalid format flags.	        

@param aVal    The floating point number to be converted. 
@param aFormat The format of the conversion. 

@return If the conversion is successful, the length of this descriptor. If 
        the conversion fails, a negative value indicating the cause of failure.
        In addition, extra information on the cause of the failure may be
        appended onto this descriptor. The possible values and their meaning
        are:
        
        1.KErrArgument - the supplied floating point number is not a valid
          number. The three characters NaN are appended to this descriptor.
          
        2.KErrOverflow - the number is too large to represent.
        2.1 For positive overflow, the three characters Inf are appended 
            to this descriptor.
        2.2 For negative overflow, the four characters -Inf are appended 
	        to this descriptor.
	        
	    3.KErrUnderflow - the number is too small to represent.
	    3.1 For positive underflow, the three characters Inf are appended
	        to this descriptor. 
        3.2	For negative underflow, the four characters -Inf are appended
            to this descriptor. 
	    
	    4.KErrGeneral - the conversion cannot be completed. There are a
	      number of possible reasons for this, but the two most common
	      are:
	    4.1 the maximum number of characters necessary to represent the number,
	        as defined in the TRealFormat object, is greater than the maximum
	        length of this descriptor
	    4.2 the character representation format (i.e. the format type), as
	        defined in the TRealFormat object is not recognised.
	        
@see TRealFormat::iType
*/
	{

	Zero();
	return(rtob(this,aVal,aFormat));
	}

EXPORT_C TInt TDes8::AppendNum(TReal aVal,const TRealFormat &aFormat) __SOFTFP
/**
Converts the specified floating point number into a character representation 
and appends the conversion onto the end of this descriptor's data.

The length of this descriptor is incremented to reflect the new content.
	
The character representation of the real number is dictated by the specified 
format.
	
@param aVal    The floating point number to be converted. 
@param aFormat The format of the conversion. 

@return If the conversion is successful, the length of this descriptor. If 
        the conversion fails, a negative value indicating the cause of failure.
        In addition, extra information on the cause of the failure may be
        appended onto this descriptor. The possible values and their meaning
        are:
        
        1.KErrArgument - the supplied floating point number is not a valid
          number. The three characters NaN are appended to this descriptor.
          
        2.KErrOverflow - the number is too large to represent.
        2.1 For positive overflow, the three characters Inf are appended 
            to this descriptor.
        2.2 For negative overflow, the four characters -Inf are appended 
	        to this descriptor.
	        
	    3.KErrUnderflow - the number is too small to represent.
	    3.1 For positive underflow, the three characters Inf are appended
	        to this descriptor. 
        3.2	For negative underflow, the four characters -Inf are appended
            to this descriptor. 
	    
	    4.KErrGeneral - the conversion cannot be completed. There are a
	      number of possible reasons for this, but the two most common
	      are:
	    4.1 the maximum number of characters necessary to represent the number,
	        as defined in the TRealFormat object, is greater than the maximum
	        length of this descriptor
	    4.2 the character representation format (i.e. the format type), as
	        defined in the TRealFormat object is not recognised
*/
	{

	return(rtob(this,aVal,aFormat));
	}

EXPORT_C TInt TDes16::Num(TReal aVal,const TRealFormat &aFormat) __SOFTFP
/**
Converts the specified floating point number into a character representation 
and copies the conversion into this descriptor, replacing any existing data.

The length of this descriptor is set to reflect the new data.
	
The character representation of the real number is dictated by the specified 
format.

Note that the function leaves if the iType data member of the specified
TRealFormat object has both an invalid character representation format
(i.e. the format type) and invalid format flags.	        

@param aVal    The floating point number to be converted. 
@param aFormat The format of the conversion. 

@return If the conversion is successful, the length of this descriptor. If 
        the conversion fails, a negative value indicating the cause of failure.
        In addition, extra information on the cause of the failure may be
        appended onto this descriptor. The possible values and their meaning
        are:
        
        1.KErrArgument - the supplied floating point number is not a valid
          number. The three characters NaN are appended to this descriptor.
          
        2.KErrOverflow - the number is too large to represent.
        2.1 For positive overflow, the three characters Inf are appended 
            to this descriptor.
        2.2 For negative overflow, the four characters -Inf are appended 
	        to this descriptor.
	        
	    3.KErrUnderflow - the number is too small to represent.
	    3.1 For positive underflow, the three characters Inf are appended
	        to this descriptor. 
        3.2	For negative underflow, the four characters -Inf are appended
            to this descriptor. 
	    
	    4.KErrGeneral - the conversion cannot be completed. There are a
	      number of possible reasons for this, but the two most common
	      are:
	    4.1 the maximum number of characters necessary to represent the number,
	        as defined in the TRealFormat object, is greater than the maximum
	        length of this descriptor
	    4.2 the character representation format (i.e. the format type), as
	        defined in the TRealFormat object is not recognised.
	        
@see TRealFormat::iType
*/
	{

	Zero();
	return (AppendNum(aVal,aFormat));
	}

EXPORT_C TInt TDes16::AppendNum(TReal aVal,const TRealFormat &aFormat) __SOFTFP
/**
Converts the specified floating point number into a character representation 
and appends the conversion onto the end of this descriptor's data.

The length of this descriptor is incremented to reflect the new content.
	
The character representation of the real number is dictated by the specified 
format.
	
@param aVal    The floating point number to be converted. 
@param aFormat The format of the conversion. 

@return If the conversion is successful, the length of this descriptor. If 
        the conversion fails, a negative value indicating the cause of failure.
        In addition, extra information on the cause of the failure may be
        appended onto this descriptor. The possible values and their meaning
        are:
        
        1.KErrArgument - the supplied floating point number is not a valid
          number. The three characters NaN are appended to this descriptor.
          
        2.KErrOverflow - the number is too large to represent.
        2.1 For positive overflow, the three characters Inf are appended 
            to this descriptor.
        2.2 For negative overflow, the four characters -Inf are appended 
	        to this descriptor.
	        
	    3.KErrUnderflow - the number is too small to represent.
	    3.1 For positive underflow, the three characters Inf are appended
	        to this descriptor. 
        3.2	For negative underflow, the four characters -Inf are appended
            to this descriptor. 
	    
	    4.KErrGeneral - the conversion cannot be completed. There are a
	      number of possible reasons for this, but the two most common
	      are:
	    4.1 the maximum number of characters necessary to represent the number,
	        as defined in the TRealFormat object, is greater than the maximum
	        length of this descriptor
	    4.2 the character representation format (i.e. the format type), as
	        defined in the TRealFormat object is not recognised
*/
	{

	HBufC8 *temp=HBufC8::New(MaxLength());
	if (temp==NULL)
		return(KErrNoMemory);
	TPtr8 p(temp->Des());
	TInt ret=rtob(&p,aVal,aFormat);
	const TText8 *pTemp=temp->Ptr();
	for (TInt ii=temp->Length();ii>0;ii--)
		Append(*pTemp++);
	if (ret>0)
		ret=Length();
	User::Free(temp);
	return (ret);
	}
