// Copyright (c) 1997-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\epoc\arm\uc_realx.cpp

 // 

 //

 #include "u32std.h"

 #include <e32math.h>

 GLDEF_C void PanicOverUnderflowDividebyZero(const TInt aErr)

 //

 // Panics if there is an overflow or underflow or divide by zero

 //

 	{

 //	if (aErr==KErrOverflow)

 //		Panic(EMathOverflow);

 //	if (aErr==KErrUnderflow)

 //		Panic(EMathUnderflow);

 //	if (aErr==KErrDivideByZero)

 //		Panic(EMathDivideByZero);

 //	if (aErr==KErrArgument)

 //		Panic(EMathBadOperand);

 	User::Panic(_L("MATHX"),aErr);

 	}

 #ifdef __REALS_MACHINE_CODED__

 extern "C" void __math_exception(TInt aErrType) 

 //

 // Decides on type of maths exception according to error and raises exception.

 // Added by AnnW, December 1996

 //

 	{

 	TExcType excType=EExcGeneral;

 	switch (aErrType)

 		{

 	case KErrArgument:				// error due to invalid operation

 		excType=EExcFloatInvalidOperation;

 		break;

 	case KErrDivideByZero:

 		excType=EExcFloatDivideByZero;

 		break;

 	case KErrOverflow:

 		excType=EExcFloatOverflow;

 		break;

 	case KErrUnderflow:

 		excType=EExcFloatUnderflow;

 		break;

 /*

 	// also errors due to inexact result

 	case KErrInexact:		// const not defined yet

 		excType=EExcFloatInexact;

 		break;

 */

 	default:

 		// Unknown error

 //		Panic(EMathUnknownError);

 		User::Panic(_L("MATHX"),KErrGeneral);

 		}

 	User::RaiseException(excType);

 	}

 #endif

 #ifdef __EABI_CTORS__

 EXPORT_C TRealX::TRealX()

 /**

 Constructs a default extended precision object.

 This sets the value to zero.

 */

 	{

 	// Be Brutal (this should be as efficient as the naked versions)

         TUint * me = (TUint *)this;

 	me[0]=me[1]=me[2]=0;

 	}

 EXPORT_C TRealX::TRealX(TUint anExp, TUint aMantHi, TUint aMantLo)

 /**

 Constructs an extended precision object from an explicit exponent and

 a 64 bit mantissa.

 @param anExp   The exponent 

 @param aMantHi The high order 32 bits of the 64 bit mantissa 

 @param aMantLo The low order 32 bits of the 64 bit mantissa 

 */

 	{

 	// Be Brutal (this should be as efficient as the naked versions)

         TUint * me = (TUint *)this;

 	me[0]=aMantLo;

 	me[1]=aMantHi;

 	me[2]=anExp;

 	}

 EXPORT_C TRealX::TRealX(TInt anInt)

 /**

 Constructs an extended precision object from a signed integer value.

 @param anInt The signed integer value.

 */

 	{

 	TRealX::operator=(anInt);

 	}

 EXPORT_C TRealX::TRealX(const TInt64& anInt)

 /**

 Constructs an extended precision object from a 64 bit integer.

 @param anInt A reference to a 64 bit integer. 

 */

 	{

 	TRealX::operator=(anInt);

 	}

 EXPORT_C TRealX::TRealX(TUint anInt)

 /**

 Constructs an extended precision object from an unsigned integer value.

 @param anInt The unsigned integer value.

 */

 	{

 	TRealX::operator=(anInt);

 	}

 EXPORT_C TRealX::TRealX(TReal32 aReal)__SOFTFP

 /**

 Constructs an extended precision object from

 a single precision floating point number.

 @param aReal The single precision floating point value.

 */

 	{

 	TRealX::operator=(aReal);

 	}

 EXPORT_C TRealX::TRealX(TReal64 aReal)__SOFTFP

 /**

 Constructs an extended precision object from

 a double precision floating point number.

 @param aReal The double precision floating point value.

 */

 	{

 	TRealX::operator=(aReal);

 	}

 #endif