lb_maths.cpp

在手机操作系统symbina上使用的一个脚本扩展语言的代码实现,可以参考用于自己的开发

// LB_MATHS.CPP
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#include <opcodes.h>
#include <e32math.h>
#include <oplapi.h>
#include <opltran.h>
#include "frame.h"
#include "oplutil.h"

// TOplRealFormat class

TOplRealFormat::TOplRealFormat(TInt aUserFlags)
	{

	iType|=KDoNotUseTriads;
	if (!(aUserFlags&KOplStateTwoDigitExp)) 
		iType|=KAllowThreeDigitExp;
	}

TOplRealFormat::TOplRealFormat(TInt aUserFlags,TInt aWidth)
	{
	
	iWidth=aWidth;
	iType|=KDoNotUseTriads;
	if (!(aUserFlags&KOplStateTwoDigitExp)) 
		iType|=KAllowThreeDigitExp;
	}

TOplRealFormat::TOplRealFormat(TInt aUserFlags,TInt aWidth,TInt aPlaces)
	{
	
	iWidth=aWidth;
	iPlaces=aPlaces;
	iType|=KDoNotUseTriads;
	if (!(aUserFlags&KOplStateTwoDigitExp)) 
		iType|=KAllowThreeDigitExp;
	}

void OpCode::AddFloat(CStack& aStack, COplRuntime&, CFrame*)
	{
    
	TRealX right(aStack.PopReal64());
	TRealX left(aStack.PopReal64());
	User::LeaveIfError(left.AddEq(right));
	aStack.Push(TReal64(left));
	}
	
void OpCode::SubtractFloat(CStack& aStack, COplRuntime&, CFrame*)
	{

	TRealX right(aStack.PopReal64());
	TRealX left(aStack.PopReal64());
	User::LeaveIfError(left.SubEq(right));
	aStack.Push(TReal64(left));
	}
	
// 50h

void OpCode::MultiplyFloat(CStack& aStack, COplRuntime& , CFrame* )
	{

	TRealX right(aStack.PopReal64());
	TRealX left(aStack.PopReal64());
	User::LeaveIfError(left.MultEq(right));
	aStack.Push(TReal64(left));
	}

void OpCode::DivideFloat(CStack& aStack, COplRuntime& , CFrame* )
	{

	TRealX denominator(aStack.PopReal64());
	TRealX numerator(aStack.PopReal64());
	User::LeaveIfError(numerator.DivEq(denominator));
	aStack.Push(TReal64(numerator));
	}
	
void OpCode::PowerOfInt(CStack& aStack, COplRuntime& , CFrame* )
	{

	TInt16 powerOf=aStack.PopInt16();
	TInt16 number=aStack.PopInt16();
	TInt16 result=1;

	if (powerOf<=0 && number==0)
		User::Leave(KOplErrInvalidArgs);
	if (number==0)
		{
		aStack.Push(number);
		return;
		}
	if (number!=1)
		{		
		for (;powerOf>0;powerOf--)
			result=OplUtil::MultiplyL(result,number);
		for (;powerOf<0;powerOf++)
			result=(TInt16)(result/number);
		}
	aStack.Push((TInt16)result);
	}
	
void OpCode::PowerOfLong(CStack& aStack, COplRuntime& , CFrame* )
	{

	TInt32 powerOf=aStack.PopInt32();
	TInt32 number=aStack.PopInt32();
	TInt32 result=1;
	if (powerOf<=0 && number==0)
		User::Leave(KOplErrInvalidArgs);
	if (number==0)
		{
		aStack.Push(number);
		return;
		}
	if (number!=1)
		{		
		for (;powerOf>0;powerOf--)
			result=OplUtil::MultiplyL(result,number);
		for (;powerOf<0;powerOf++)
			result/=number;
		}
	aStack.Push(result);
	}

void OpCode::PowerOfFloat(CStack& aStack, COplRuntime& , CFrame* )
	{

	TReal powerOf=aStack.PopReal64();
	TReal number=aStack.PopReal64();
	TReal result;
	User::LeaveIfError(Math::Pow(result,number,powerOf));
	aStack.Push(result);
	}

#define _EVAL_IN_RUNTIME
#ifdef _EVAL_IN_RUNTIME	
void FuncOpCode::Eval(CStack& aStack, COplRuntime& aRuntime, CFrame* aFramePtr)
/*
Evaluate an expression
In:		String expression
Out:	Float result
Leaves on error
*/
	{
	TPtrC string=aStack.PopString();
    // translate expression
    TTranslateError anError;
    COplEvalTranslator *pT=COplEvalTranslator::NewLC();
	CBufFlat *pQc=CBufFlat::NewL(32);
	CleanupStack::PushL(pQc);
	TInt maxStackDepth;
	if (pT->Translate(string,anError,*pQc,maxStackDepth)!=KErrNone) // **** CHANGED TO MAP TRAN ERRORS
		{
		TInt resId;
		User::Leave(OplAPI::MapTranslatorError(anError.Error(),resId));
		}
	if (aStack.FreeBytes()<maxStackDepth)
	    User::LeaveIfError(KOplErrNoMemory);    // not enough stack
    // set IP and run the Qcode
    TUint8* ip=aRuntime.IP();
    TUint8* pQcode=(TUint8*) (pQc->Ptr(0)).Ptr();
    aRuntime.SetIP(pQcode);
	aFramePtr->IncEvalNestCount();
    TInt err=aRuntime.Execute();
	aFramePtr->DecEvalNestCount();
    aRuntime.SetIP(ip);
    // propagate any error
    User::LeaveIfError(err);
    CleanupStack::PopAndDestroy(2);
	}
#endif

void OpCode::PercentGreaterThan(CStack& aStack, COplRuntime& , CFrame* )		
	{
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    User::LeaveIfError(a.DivEq(100.0));
    a.AddEq(1.0);
    User::LeaveIfError(b.DivEq(a));
    aStack.Push(TReal64(b));
    }
	
void OpCode::PercentLessThan(CStack& aStack, COplRuntime& , CFrame* )		
    {
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    TRealX temp(100.0);
    User::LeaveIfError(temp.DivEq(a));
    temp.AddEq(1.0);
    User::LeaveIfError(b.DivEq(temp));
    aStack.Push(TReal64(b));
    }
	
void OpCode::PercentSubtract(CStack& aStack, COplRuntime& , CFrame* )		
	{
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    User::LeaveIfError(a.MultEq(b));
    User::LeaveIfError(a.DivEq(100.0));
    User::LeaveIfError(b.SubEq(a));
    aStack.Push(TReal64(b));
    }
	
void OpCode::PercentMultiply(CStack& aStack, COplRuntime& , CFrame* )		
	{
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    User::LeaveIfError(a.MultEq(b));
    User::LeaveIfError(a.DivEq(100.0));
    aStack.Push(TReal64(a));
    }
	
void OpCode::PercentDivide(CStack& aStack, COplRuntime& , CFrame* )			
	{
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    User::LeaveIfError(b.MultEq(100.0));
    User::LeaveIfError(b.DivEq(a));
    aStack.Push(TReal64(b));
    }

void OpCode::PercentAdd(CStack& aStack, COplRuntime& , CFrame* )				
	{
    TRealX a(aStack.PopReal64());
    TRealX b(aStack.PopReal64());
    User::LeaveIfError(a.MultEq(b));
    User::LeaveIfError(a.DivEq(100.0));
    User::LeaveIfError(b.AddEq(a));
    aStack.Push(TReal64(b));
    }

void FuncOpCode::Abs(CStack& aStack, COplRuntime& , CFrame* )
	{
	TReal arg=aStack.PopReal64();
	aStack.Push(arg>=0.0 ? arg : -arg);
	}

void FuncOpCode::IAbs(CStack& aStack, COplRuntime& , CFrame* )
	{
	TInt32 arg=aStack.PopInt32();
	aStack.Push(arg>=0 ? arg : -arg);
	}

void FuncOpCode::ACos( CStack& aStack, COplRuntime& , CFrame* /*  */)
	{
	User::LeaveIfError(Math::ACos(*aStack.StackPtr().Real,*aStack.StackPtr().Real));
	}

void FuncOpCode::ASin(CStack& aStack, COplRuntime& , CFrame* )
	{
	User::LeaveIfError(Math::ASin(*aStack.StackPtr().Real,*aStack.StackPtr().Real));	
	}

void FuncOpCode::ATan(CStack& aStack, COplRuntime& , CFrame* )
	{
	User::LeaveIfError(Math::ATan(*aStack.StackPtr().Real,*aStack.StackPtr().Real));
	}

void FuncOpCode::Cos(CStack& aStack, COplRuntime& , CFrame* )
	{
	User::LeaveIfError(Math::Cos(*aStack.StackPtr().Real,*aStack.StackPtr().Real));
	}

void FuncOpCode::Deg(CStack& aStack, COplRuntime& , CFrame* )
	{
    TRealX arg(aStack.PopReal64());
    User::LeaveIfError(arg.MultEq(KRadToDeg));
    aStack.Push(TReal64(arg));
	}

void FuncOpCode::Exp(CStack& aStack, COplRuntime& , CFrame* )
	{
	User::LeaveIfError(Math::Exp(*aStack.StackPtr().Real,*aStack.StackPtr().Real));
	}

void FuncOpCode::Flt(CStack& aStack, COplRuntime& , CFrame* )
    // long to double	
	{
	TInt32 arg=aStack.PopInt32();
	aStack.Push(TReal(arg));
	}

void FuncOpCode::Intf(CStack& aStack, COplRuntime& , CFrame* )
	// double to integerised double
	{
    User::LeaveIfError(Math::Int(*aStack.StackPtr().Real,*aStack.StackPtr().Real));
	}