Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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\us_gcc.cpp
//
//
#include "us_std.h"
#include <e32math.h>
extern "C" {
EXPORT_C TInt64 __fixsfdi(TReal32 a1)
//
// Convert float to long long
//
{
const TRealX f(a1);
const TInt64 ret = f;
return ret;
}
} // end of extern "C" declaration
#ifndef __REALS_MACHINE_CODED__
LOCAL_C void MathException(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::RaiseException(excType);
}
EXPORT_C TReal32 __addsf3(TReal32 a1,TReal32 a2)
//
// Add two floats
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal32 trg;
x1.Add(res,x2); // need not check error because no underflow and others will not be lost in conversion
TInt ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return(trg);
}
EXPORT_C TReal64 __adddf3(TReal64 a1,TReal64 a2)
//
// Add two doubles
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal64 trg;
x1.Add(res,x2); // need not check error because no underflow and others will not be lost in conversion
TInt ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return(trg);
}
EXPORT_C TReal32 __subsf3(TReal32 a1,TReal32 a2)
//
// Subtract two floats
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal32 trg;
x1.Sub(res,x2); // need not check error because no underflow and others will not be lost in conversion
TInt ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return(trg);
}
EXPORT_C TReal64 __subdf3(TReal64 a1,TReal64 a2)
//
// Subtract two doubles
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal64 trg;
x1.Sub(res,x2); // need not check error because no underflow and others will not be lost in conversion
TInt ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return(trg);
}
EXPORT_C TInt __cmpsf3(TReal32 a1,TReal32 a2)
//
// Compare two floats
//
{
TRealX x1=a1;
TRealX x2=a2;
if (x1<x2)
return(-1);
if (x1>x2)
return(1);
return(0);
}
EXPORT_C TInt __cmpdf3(TReal64 a1,TReal64 a2)
//
// Compare two doubles
//
{
TRealX x1=a1;
TRealX x2=a2;
if (x1<x2)
return(-1);
if (x1>x2)
return(1);
return(0);
}
EXPORT_C TInt __eqsf2(TReal32 a1,TReal32 a2)
//
// Compare if two floats are equal
//
{
TRealX x1=a1;
TRealX x2=a2;
return (x1==x2 ? 0 : 1);
}
EXPORT_C TInt __eqdf2(TReal64 a1,TReal64 a2)
//
// Compare if two doubles are equal
//
{
TRealX x1=a1;
TRealX x2=a2;
return (x1==x2 ? 0 : 1);
}
EXPORT_C TInt __nesf2(TReal32 a1,TReal32 a2)
//
// Compare if two floats are not equal
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1!=x2 ? 1 : 0);
}
EXPORT_C TInt __nedf2(TReal64 a1,TReal64 a2)
//
// Compare if two doubles are not equal
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1!=x2 ? 1 : 0);
}
EXPORT_C TInt __gtsf2(TReal32 a1,TReal32 a2)
//
// Compare if one float is greater than another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1>x2 ? +1 : -1);
}
EXPORT_C TInt __gtdf2(TReal64 a1,TReal64 a2)
//
// Compare if one double is greater than another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1>x2 ? +1 : -1);
}
EXPORT_C TInt __gesf2(TReal32 a1,TReal32 a2)
//
// Compare if one float is greater than or equal to another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1>=x2 ? 1 : -1);
}
EXPORT_C TInt __gedf2(TReal64 a1,TReal64 a2)
//
// Compare if one double is greater than or equal to another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1>=x2 ? 1 : -1);
}
EXPORT_C TInt __ltsf2(TReal32 a1,TReal32 a2)
//
// Compare if one float is less than another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1<x2 ? -1 : +1);
}
EXPORT_C TInt __ltdf2(TReal64 a1,TReal64 a2)
//
// Compare if one double is less than another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1<x2 ? -1 : +1);
}
EXPORT_C TInt __lesf2(TReal32 a1,TReal32 a2)
//
// Compare if one float is less than or equal to another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1<=x2 ? -1 : +1);
}
EXPORT_C TInt __ledf2(TReal64 a1,TReal64 a2)
//
// Compare if one double is less than or equal to another
//
{
TRealX x1=a1;
TRealX x2=a2;
return(x1<=x2 ? -1 : +1);
}
EXPORT_C TReal32 __mulsf3(TReal32 a1,TReal32 a2)
//
// Multiply two floats
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal32 trg;
TInt ret=x1.Mult(res,x2);
if (ret==KErrNone) // must check this because if underflow, error is lost in conversion
ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return((TReal32)res);
}
EXPORT_C TReal64 __muldf3(TReal64 a1,TReal64 a2)
//
// Multiply two doubles
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal64 trg;
TInt ret=x1.Mult(res,x2);
if (ret==KErrNone) // must check this because if underflow, error is lost in conversion
ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return((TReal64)res);
}
EXPORT_C TReal32 __divsf3(TReal32 a1,TReal32 a2)
//
// Divide two floats
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal32 trg;
TInt ret=x1.Div(res,x2);
if (ret==KErrNone) // must check this because if underflow, error is lost in conversion
ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return((TReal32)res);
}
EXPORT_C TReal64 __divdf3(TReal64 a1,TReal64 a2)
//
// Divide two doubles
//
{
TRealX x1=a1;
TRealX x2=a2;
TRealX res;
TReal64 trg;
TInt ret=x1.Div(res,x2);
if (ret==KErrNone) // must check this because if underflow, error is lost in conversion
ret=res.GetTReal(trg);
if (ret!=KErrNone)
MathException(ret);
return((TReal64)res);
}
EXPORT_C TReal32 __negsf2(TReal32 a1)
//
// Negate a float
//
{
TRealX x1=a1;
return((TReal32)-x1);
}
EXPORT_C TReal64 __negdf2(TReal64 a1)
//
// Negate a double
//
{
TRealX x1=a1;
return((TReal64)-x1);
}
EXPORT_C TReal32 __floatsisf(TInt a1)
//
// Convert int to float
//
{
return((TReal32)TRealX(a1));
}
EXPORT_C TReal64 __floatsidf(TInt a1)
//
// Convert int to double
//
{
return((TReal64)TRealX(a1));
}
EXPORT_C TInt __fixsfsi(TReal32 a1)
//
// Convert float to int
//
{
return((TInt)TRealX(a1));
}
EXPORT_C TInt __fixdfsi(TReal64 a1)
//
// Convert double to int
//
{
return((TInt)TRealX(a1));
}
EXPORT_C TReal64 __extendsfdf2(TReal32 a1)
//
// Convert a float to a double
//
{
return((TReal64)TRealX(a1));
}
EXPORT_C TReal32 __truncdfsf2(TReal64 a1)
//
// Convert a double to a float
// Raises an exception if conversion results in an error
//
{
TRealX x1=a1;
TInt ret;
TReal32 trg;
if ((ret=x1.GetTReal(trg))!=KErrNone)
MathException(ret);
return(trg);
}
#endif //__REALS_MACHINE_CODED__