// 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