514 lines
19 KiB
C++
514 lines
19 KiB
C++
#include "precompiled.h"
|
|
#include "0ad_warning_disable.h"
|
|
//***************************************************************************
|
|
//
|
|
// SrExpTABLE.H
|
|
// By Marcelo Kallmann 08/98 - Brazil
|
|
//
|
|
//***************************************************************************
|
|
|
|
# include <math.h>
|
|
# include <string.h>
|
|
# include <stdlib.h>
|
|
|
|
# include "sr_array.h"
|
|
# include "sr_string.h"
|
|
# include "sr_exp_table.h"
|
|
|
|
//# define SR_USE_TRACE1 // Parse
|
|
//# define SR_USE_TRACE2 // Eval
|
|
//# define SR_USE_TRACE3 // Table
|
|
# include "sr_trace.h"
|
|
|
|
// ============================= EToken ========================================
|
|
|
|
typedef SrExpTable::Token EToken;
|
|
|
|
inline void setNumb ( EToken& t, double d ) { t.type=(char)EToken::Numb; t.data.realval=d; }
|
|
inline void setVar ( EToken& t, int id ) { t.type=(char)EToken::Var; t.data.index=id; }
|
|
inline void setFunc ( EToken& t, int id ) { t.type=(char)EToken::Func; t.data.index=id; }
|
|
inline void setBinOp ( EToken& t, char op ) { t.type=(char)EToken::BinOp; t.data.code=op; }
|
|
inline void setUnaOp ( EToken& t, char op ) { t.type=(char)EToken::UnaOp; t.data.code=op; }
|
|
inline void setLeftPar ( EToken& t ) { t.type=(char)EToken::LeftPar; }
|
|
inline void setRightPar ( EToken& t ) { t.type=(char)EToken::RightPar; }
|
|
|
|
//======================= Modes while parsing =================================
|
|
|
|
enum srParMode { srParModeUnary, srParModeBinary, srParModeFunction };
|
|
|
|
//======================== functions methods ===================================
|
|
|
|
enum srFunc { srFuncAbs, srFuncAcos, srFuncAsin, srFuncAtan, srFuncCeil,
|
|
srFuncCos, srFuncExp, srFuncFact, srFuncFloor, srFuncLn,
|
|
srFuncLog, srFuncRound, srFuncSign, srFuncSin, srFuncSqrt,
|
|
srFuncTan, srFuncUndefined }; // Alphabetical order !
|
|
|
|
static const char *Functions[] = { "abs", "acos", "asin", "atan", "ceil",
|
|
"cos", "exp", "fact", "floor", "ln",
|
|
"log", "round", "sign", "sin", "sqrt",
|
|
"tan" }; // Alphabetical order !
|
|
|
|
static int compfunc ( const void *a, const void *b )
|
|
{
|
|
return strcmp ( ((char*)a), *((char**)b) );
|
|
}
|
|
|
|
static srFunc func_code ( const char *st )
|
|
{
|
|
void *result = bsearch ( (const void*)st, // to search
|
|
(const void*)Functions, // table
|
|
(size_t)srFuncUndefined, // num elems in table
|
|
(size_t)sizeof(char*), // size of each elem in table
|
|
compfunc // compare function
|
|
);
|
|
if (!result) return srFuncUndefined;
|
|
return (srFunc) ( ((intptr_t)result-(intptr_t)Functions)/sizeof(int) );
|
|
}
|
|
|
|
const char *SrExpTable::function_name ( int index )
|
|
{
|
|
if ( index<0 || index>=(int)srFuncUndefined ) return 0;
|
|
return Functions[index];
|
|
}
|
|
|
|
static int oprank ( char op )
|
|
{
|
|
switch ( op )
|
|
{ case '[' : return 8;
|
|
case '^' : case '%' : return 7;
|
|
case '/' : case '*' : case '|' : return 6;
|
|
case '+' : case '-' : return 5;
|
|
case '>' : case '<' :
|
|
case ')' : case '(' : // >= <=
|
|
case '~' : case '=' : return 4;
|
|
case 'a' : case 'o' : return 3; // and or
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//===================================== messages ==============================
|
|
// Global functions :
|
|
|
|
SrExpTable::Msg SrExpTable::translate_error ( SrInput::ErrorType e )
|
|
{
|
|
switch ( e )
|
|
{ case SrInput::UndefChar : return MsgUndefChar;
|
|
case SrInput::TooBig : return MsgNameTooBig;
|
|
case SrInput::OpenString : return MsgStringNotClosed;
|
|
case SrInput::InvalidPoint : return MsgMisplacedDecPoint;
|
|
default : return MsgOk;
|
|
}
|
|
}
|
|
|
|
const char* SrExpTable::msg_desc ( SrExpTable::Msg m )
|
|
{
|
|
switch ( m )
|
|
{ // messages translated from sr_input.h :
|
|
case MsgUndefChar : return SrInput::error_desc ( SrInput::UndefChar );
|
|
case MsgNameTooBig : return SrInput::error_desc ( SrInput::TooBig );
|
|
case MsgStringNotClosed : return SrInput::error_desc ( SrInput::OpenString );
|
|
case MsgMisplacedDecPoint : return SrInput::error_desc ( SrInput::InvalidPoint );
|
|
// new messages :
|
|
case MsgOk : return "Ok";
|
|
case MsgUnexpectedEndOfFile : return "Unexpected end of file encountered";
|
|
case MsgUndefinedName : return "Undefined variable";
|
|
case MsgUndefBinOp : return "Undefined binary operator: internal error";
|
|
case MsgUndefUnaOp : return "Undefined unary operator: internal error";
|
|
case MsgUndefPreDefFunc : return "Undefined pre-defined function: internal error";
|
|
case MsgOperandExpected : return "Operand expected in expression";
|
|
case MsgOperatorExpected : return "Operator expected in expression";
|
|
case MsgFuncWithoutPar : return "Function name must be followed by a left parenthesis";
|
|
case MsgDivideByZero : return "Divide by zero";
|
|
case MsgRaisedZeroToNeg : return "Cannot raise zero to a negative power";
|
|
case MsgRaisedNegToReal : return "Cannot raise a negative number to a non-integer power";
|
|
case MsgUnmatchedParentesis : return "Unmatched parentesis";
|
|
case MsgAcosArgsOutOfRange : return "Arc cos arguments out of range";
|
|
case MsgAsinArgsOutOfRange : return "Arc sin arguments out of range";
|
|
case MsgStackEmpty : return "Stack is empty";
|
|
case MsgSqrtArgIsNeg : return "Sqrt argument is negative";
|
|
default : return NULL;
|
|
}
|
|
}
|
|
|
|
//============================ internal ======================================
|
|
|
|
# define ISBINARY(c) strchr("+-*/^%|><=[",c)
|
|
# define ISUNARY(c) strchr("+-!",c)
|
|
|
|
static bool is_binary ( const SrString& token )
|
|
{
|
|
if ( strchr("+-*/^%|><~=[",token[0]) ) return true;
|
|
if ( token=="and" || token=="or" ) return true;
|
|
return false;
|
|
}
|
|
|
|
static SrExpTable::Msg get_translated_token ( SrInput& in,
|
|
int& curline,
|
|
EToken& etok,
|
|
srParMode mode,
|
|
const char* delimeters,
|
|
SrExpTableVarManager* varman )
|
|
{
|
|
SrInput::TokenType toktype;
|
|
SrString token;
|
|
|
|
toktype = in.get_token(token);
|
|
curline = in.curline();
|
|
if ( toktype==SrInput::Error ) return SrExpTable::translate_error ( in.last_error() );
|
|
if ( toktype==SrInput::EndOfFile ) return SrExpTable::MsgUnexpectedEndOfFile;
|
|
|
|
if ( delimeters && toktype==SrInput::Delimiter && strchr(delimeters,token[0]) )
|
|
{ in.unget_token ( token, toktype );
|
|
return SrExpTable::MsgUnexpectedEndOfFile; // permits to stop the parser before end of file
|
|
}
|
|
|
|
if ( mode==srParModeUnary && ISUNARY(token[0]) )
|
|
{ setUnaOp ( etok, token[0] );
|
|
SR_TRACE1 ( "Got a unary op: ["<<token<<"]" );
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
if ( (mode==srParModeBinary || mode==srParModeFunction) && is_binary(token) )
|
|
{ char op = token[0];
|
|
if ( op=='>' || op=='<' )
|
|
{ toktype = in.get_token(token);
|
|
if ( toktype==SrInput::Error ) return SrExpTable::translate_error ( in.last_error() );
|
|
curline = in.curline();
|
|
if ( op=='>' && token[0]=='=' ) op = ')'; // that will mean >=
|
|
else
|
|
if ( op=='<' && token[0]=='=' ) op = '('; // that will mean <=
|
|
else
|
|
if ( op=='<' && token[0]=='>' ) op = '~'; // <> mean difference op ~
|
|
else
|
|
in.unget_token ( token, toktype );
|
|
}
|
|
else if ( op=='=' )
|
|
{ toktype = in.get_token(token);
|
|
if ( toktype==SrInput::Error ) return SrExpTable::translate_error ( in.last_error() );
|
|
if ( token[0]!='=' ) return SrExpTable::MsgWrongEqualOperator;
|
|
}
|
|
else if ( op=='[' )
|
|
{
|
|
in.unget_token ( "(", SrInput::Delimiter ); // so that arrays indices may form an expression
|
|
}
|
|
setBinOp ( etok, op );
|
|
SR_TRACE1 ( "Got a binary op: ["<<op<<"]");
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
if ( token[0]=='(' ) { setLeftPar(etok); SR_TRACE1("Got a left par.\n"); return SrExpTable::MsgOk; }
|
|
if ( token[0]==')' ) { setRightPar(etok); SR_TRACE1("Got a right par.\n"); return SrExpTable::MsgOk; }
|
|
if ( token[0]==']' ) { setRightPar(etok); SR_TRACE1("Got array right par.\n"); return SrExpTable::MsgOk; }
|
|
|
|
if ( toktype==SrInput::Name ) // bool(int), func or var
|
|
{ if ( strcmp(token,"true")==0 ) { setNumb(etok,1.0); SR_TRACE1("Got a true.\n"); return SrExpTable::MsgOk; }
|
|
if ( strcmp(token,"false")==0 ) { setNumb(etok,0.0); SR_TRACE1("Got a false.\n"); return SrExpTable::MsgOk; }
|
|
|
|
srFunc f = func_code ( token ); // found a func?
|
|
if ( f!=srFuncUndefined )
|
|
{ setFunc(etok,f); SR_TRACE1("Got func ["<<(Functions[(int)f])<<"]"); return SrExpTable::MsgOk; }
|
|
|
|
if ( !varman ) return SrExpTable::MsgUndefinedName; // found a name that is not a function or variable
|
|
setVar ( etok, varman->get_variable_index(token) ); // get the user index for the variable
|
|
SR_TRACE1("Got a var ["<<token<<"], index "<<etok.data.index );
|
|
if ( etok.data.index<0 ) return SrExpTable::MsgUndefinedName;
|
|
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
if ( toktype==SrInput::Integer || toktype==SrInput::Real )
|
|
{ setNumb(etok,(double)atof(token)); SR_TRACE1("Got a number: "<<(atof(token))); return SrExpTable::MsgOk; }
|
|
|
|
return SrExpTable::MsgUndefChar;
|
|
}
|
|
|
|
//===================================== SrExpTable ===================================================
|
|
|
|
SrExpTable::SrExpTable ()
|
|
{
|
|
_varman = 0;
|
|
_delimiters = 0;
|
|
}
|
|
|
|
SrExpTable::~SrExpTable ()
|
|
{
|
|
if ( _varman ) _varman->unref();
|
|
delete _delimiters;
|
|
}
|
|
|
|
void SrExpTable::set_var_manager ( SrExpTableVarManager* var_man )
|
|
{
|
|
if ( _varman ) _varman->unref();
|
|
_varman = var_man;
|
|
_varman->ref();
|
|
}
|
|
|
|
void SrExpTable::set_parser_delimiters ( const char *delimiters )
|
|
{
|
|
sr_string_set ( _delimiters, delimiters );
|
|
}
|
|
|
|
SrExpTable::Msg SrExpTable::parse ( SrInput& in, int &curline )
|
|
{
|
|
Msg msg;
|
|
Token etok, t;
|
|
srParMode mode = srParModeUnary;
|
|
|
|
_table.size ( 0 );
|
|
_stack.size ( 0 );
|
|
|
|
while ( true )
|
|
{
|
|
msg = get_translated_token ( in, curline, etok, mode, _delimiters, _varman );
|
|
if ( msg==MsgUnexpectedEndOfFile ) break;
|
|
if ( msg!=MsgOk ) return msg;
|
|
|
|
if ( mode==srParModeUnary && (etok.type==Token::BinOp||etok.type==Token::RightPar) )
|
|
{ return MsgOperandExpected; }
|
|
|
|
if ( mode==srParModeBinary && etok.type!=Token::BinOp && etok.type!=Token::RightPar )
|
|
{ return MsgOperatorExpected; }
|
|
|
|
if ( mode==srParModeFunction && etok.type!=Token::LeftPar )
|
|
{ return MsgFuncWithoutPar; }
|
|
|
|
switch ( etok.type )
|
|
{ case Token::Numb :
|
|
case Token::Var : _stack.push(etok); mode=srParModeBinary; break;
|
|
case Token::LeftPar :
|
|
case Token::UnaOp : _stack.push(etok); mode=srParModeUnary; break;
|
|
case Token::Func : _stack.push(etok); mode=srParModeFunction; break;
|
|
|
|
case Token::BinOp :
|
|
while ( !_stack.empty() )
|
|
{ t=_stack.top ();
|
|
if ( t.type==Token::BinOp && oprank(etok.data.code)>oprank(t.data.code) ) break;
|
|
if ( t.type==Token::LeftPar ) break;
|
|
_stack.pop(); _table.push(t);
|
|
}
|
|
_stack.push(etok); mode=srParModeUnary; break;
|
|
|
|
case Token::RightPar :
|
|
if ( _stack.empty() ) return MsgStackEmpty;
|
|
while ( !_stack.empty() )
|
|
{ t=_stack.pop();
|
|
if (t.type==Token::LeftPar) break;
|
|
_table.push(t);
|
|
}
|
|
if ( t.type!=Token::LeftPar ) return MsgOk; // here the stack will be empty
|
|
if ( !_stack.empty() && _stack.top().type==Token::Func )
|
|
_table.push( _stack.pop() );
|
|
mode=srParModeBinary;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( mode==srParModeUnary) return MsgOperandExpected;
|
|
|
|
while ( !_stack.empty() )
|
|
{ if ( _stack.top().type==Token::LeftPar ) { return MsgUnmatchedParentesis; }
|
|
_table.push( _stack.pop() );
|
|
}
|
|
|
|
_table.push().type=Token::EndMark; // mark the end
|
|
|
|
# ifdef SR_USE_TRACE3
|
|
sr_out << "ExpTable: " << *this << srnl;
|
|
# endif
|
|
|
|
return MsgOk;
|
|
}
|
|
|
|
static SrExpTable::Msg operateBinOp ( double x, double y, char op,
|
|
SrArray<EToken>& stack,
|
|
SrExpTableVarManager* varman )
|
|
{
|
|
double r;
|
|
switch ( op )
|
|
{ case '[' : r = varman->get_variable_value(int(x),int(y)); break;
|
|
case '+' : r = x+y; break;
|
|
case '-' : r = x-y; break;
|
|
case '/' : if (!y) return SrExpTable::MsgDivideByZero; r=x/y; break;
|
|
case '|' : if (!y) return SrExpTable::MsgDivideByZero; r=(double)(((int)x)|((int)y)); break;
|
|
case '*' : r=x*y; break;
|
|
case '%' : r = (x/100.0)*y; break;
|
|
case '^' : if ( x==0.0 && y<0.0 ) return SrExpTable::MsgRaisedZeroToNeg;
|
|
if ( x<0.0 && y!=(int)y ) return SrExpTable::MsgRaisedNegToReal;
|
|
r=pow(x,y); break;
|
|
case 'a' : r = x!=0 && y!=0? 1.0:0.0; break;
|
|
case 'o' : r = x!=0 || y!=0? 1.0:0.0; break;
|
|
case '>' : r = x>y? 1.0:0.0; break;
|
|
case '<' : r = x<y? 1.0:0.0; break;
|
|
case ')' : r = x>=y? 1.0:0.0; break;
|
|
case '(' : r = x<=y? 1.0:0.0; break;
|
|
case '~' : r = x!=y? 1.0:0.0; break;
|
|
case '=' : r = x==y? 1.0:0.0; break;
|
|
default : return SrExpTable::MsgUndefBinOp;
|
|
}
|
|
SR_TRACE2 ( "Operating: "<< x << " " << op << " " << y << " = " << r );
|
|
setNumb ( stack.push(), r );
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
static SrExpTable::Msg operateUnaOp ( double x, char op, SrArray<EToken>& stack )
|
|
{
|
|
double r;
|
|
switch ( op )
|
|
{ case '+' : r=x; break;
|
|
case '-' : r=-x; break;
|
|
case '!' : r = x==0? 1.0:0.0; break;
|
|
default : return SrExpTable::MsgUndefUnaOp;
|
|
}
|
|
SR_TRACE2 ( "Operating: " << op << " " << x << " = " << r );
|
|
|
|
setNumb ( stack.push(), r );
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
static double dround ( double x ) { return (x>0.0)? (double)(long int)(x+0.5) : (double)(long int)(x-0.5); }
|
|
static double dsign ( double x ) { return (x<0.0)? -1: (x>0.0)? 1:0; }
|
|
static double dfact ( int x ) { if(x<2)return 1l; long m=(long)x; while(--x>1)m*=(long)x; return(double)m; }
|
|
|
|
static SrExpTable::Msg operateFunc ( double x, srFunc f, SrArray<EToken>& stack )
|
|
{
|
|
double r;
|
|
switch ( f )
|
|
{ case srFuncAbs : r = x<0.0? -x:x; break;
|
|
case srFuncAcos : if ( x<-1.0 || x>1.0 ) return SrExpTable::MsgAcosArgsOutOfRange;
|
|
r=acos(x); break;
|
|
case srFuncAsin : if ( x<-1.0 || x>1.0 ) return SrExpTable::MsgAsinArgsOutOfRange;
|
|
r=asin(x); break;
|
|
case srFuncAtan : r=atan(x); break;
|
|
case srFuncCeil : r=ceil(x); break;
|
|
case srFuncCos : r=cos(x); break;
|
|
case srFuncExp : r=pow(SR_E,x); break;
|
|
case srFuncFact : r=dfact((int)x); break;
|
|
case srFuncFloor : r=floor(x); break;
|
|
case srFuncLn : r=log(x); break;
|
|
case srFuncLog : r=log10(x); break;
|
|
case srFuncSign : r=dsign(x); break;
|
|
case srFuncSin : r=sin(x); break;
|
|
case srFuncSqrt : if ( x<-0.0 ) return SrExpTable::MsgSqrtArgIsNeg;
|
|
r=sqrt(x); break;
|
|
case srFuncTan : r=tan(x); break;
|
|
case srFuncRound : r=dround(x); break;
|
|
default : return SrExpTable::MsgUndefPreDefFunc;
|
|
}
|
|
|
|
SR_TRACE2 ( "Operating: " << Functions[f] << "(" << x << ") = " << r );
|
|
|
|
setNumb ( stack.push(), r );
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
|
|
static SrExpTable::Msg pop_value ( double &v, SrArray<EToken>& stack,
|
|
SrExpTableVarManager* varman, bool isarrayop )
|
|
{
|
|
if ( stack.empty() ) return SrExpTable::MsgStackEmpty;
|
|
EToken t = stack.pop();
|
|
|
|
if ( t.type==EToken::Var )
|
|
{ v = isarrayop? (double)t.data.index : varman->get_variable_value(t.data.index,-1);
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
else if ( t.type==EToken::Numb )
|
|
{ v = t.data.realval;
|
|
return SrExpTable::MsgOk;
|
|
}
|
|
else
|
|
return SrExpTable::MsgOperandExpected;
|
|
}
|
|
|
|
SrExpTable::Msg SrExpTable::evaluate ( double &result )
|
|
{
|
|
int i;
|
|
double u, v;
|
|
Token::Type t;
|
|
Msg msg;
|
|
|
|
_stack.size ( 0 );
|
|
|
|
for ( i=0; i<_table.size(); i++ )
|
|
{ t = (Token::Type) _table[i].type;
|
|
if ( t==Token::EndMark ) break; // Found a mark for the end (only when not compressed)
|
|
|
|
if ( t==Token::Numb || t==Token::Var ) // a value
|
|
{ _stack.push ( _table[i] );
|
|
}
|
|
else
|
|
{ msg = pop_value ( v, _stack, _varman, false );
|
|
if ( msg!=MsgOk ) return msg;
|
|
|
|
switch ( t )
|
|
{ case Token::Func :
|
|
msg = operateFunc ( v, (srFunc)_table[i].data.index, _stack );
|
|
break;
|
|
|
|
case Token::UnaOp :
|
|
msg = operateUnaOp ( v, _table[i].data.code, _stack );
|
|
break;
|
|
|
|
case Token::BinOp :
|
|
msg = pop_value ( u, _stack, _varman, _table[i].data.code=='['?true:false );
|
|
if ( msg!=MsgOk ) break;
|
|
msg = operateBinOp ( u, v, _table[i].data.code, _stack, _varman );
|
|
break;
|
|
}
|
|
|
|
if ( msg!=MsgOk ) return msg;
|
|
}
|
|
}
|
|
|
|
if ( _stack.size()!=1 ) return MsgOperatorExpected;
|
|
|
|
return pop_value ( result, _stack, _varman, false );
|
|
}
|
|
|
|
void SrExpTable::compress ()
|
|
{
|
|
_table.compress ();
|
|
_stack.compress();
|
|
}
|
|
|
|
/*! Takes the internal data of t, and leave t as an empty table. */
|
|
// void take_data ( SrExpTable& t );
|
|
|
|
// void take_data ( SrArray<SrExpTableToken>& tokens );
|
|
// void leave_data ( SrArray<SrExpTableToken>& tokens );
|
|
|
|
/*
|
|
void SrExpTable::take_data ( SrExpTable& t )
|
|
{
|
|
if ( _tokens ) free ( _tokens );
|
|
_tokens = t._tokens; t._tokens = 0;
|
|
_size = t._size; t._size = 0;
|
|
_capacity = t._capacity; t._capacity = 0;
|
|
}
|
|
*/
|
|
|
|
//=============================== friends ============================
|
|
|
|
SrOutput& operator << ( SrOutput& o, const SrExpTable& t )
|
|
{
|
|
EToken tk;
|
|
|
|
for ( int i=0; i<t._table.size(); i++ )
|
|
{ tk = t._table[i];
|
|
|
|
switch ( tk.type )
|
|
{ case EToken::Numb : o<<tk.data.realval<<srspc; break;
|
|
case EToken::Var : o<<"var:"<<tk.data.index<<srspc; break;
|
|
case EToken::Func : o<<Functions[tk.data.index]<<srspc; break;
|
|
case EToken::UnaOp :
|
|
case EToken::BinOp : o<<tk.data.code<<srspc; break;
|
|
case EToken::EndMark : return o;
|
|
}
|
|
}
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
//============================ End of File ==============================
|
|
|