NLMISC::CEvalNumExpr Class Reference

#include <eval_num_expr.h>

Inheritance diagram for NLMISC::CEvalNumExpr:

---

Detailed Description

This class preforms numerical expression parsing.

Definition at line 37 of file eval_num_expr.h.

Public Types
enum	TReturnState {   NoError, UnkownValue, ValueError, UnkownFunction,   FunctionError, NumberSyntaxError, UnkownOperator, MustBeOpen,   MustBeClose, MustBeComa, MustBeExpression, NotUnaryOperator,   MustBeEnd, MustBeDoubleQuote, DividByZero, ReturnValueCount }
	Eval return error. More...
Public Member Functions
TReturnState	evalExpression (const char *expression, double &result, int *errorIndex, uint32 userData=0)
const char *	getErrorString (TReturnState state) const
	Get error string.
bool	internalCheck ()
virtual	~CEvalNumExpr ()
Protected Member Functions
virtual TReturnState	evalFunction (const char *funcName, double arg0, double arg1, double &result)
virtual TReturnState	evalFunction (const char *funcName, double arg0, double &result)
virtual TReturnState	evalValue (const char *value, double &result, uint32 userData)
	Overridable functions.
Private Types
enum	{ InternalStringLen = 32, InternalOperator = 4 }
enum	TOperator {   Not = 0, Tilde, Mul, Div,   Remainder, Plus, Minus, ULeftShift,   URightShift, SLeftShift, SRightShift, Inferior,   InferiorEqual, Superior, SuperiorEqual, Equal,   NotEqual, And, Or, Xor,   LogicalAnd, LogicalOr, LogicalXor, OperatorCount,   NotOperator, ExtOperator }
enum	TReservedWord {   Abs = 0, Acos, Asin, Atan,   Atan2, Ceil, Cos, Cosh,   Exp, Exponent, Floor, Int,   Log, Log10, Mantissa, Max,   Min, Pow, Rand, Round,   Sin, Sinh, Sq, Sqrt,   Tan, Tanh, ReservedWordCount }
enum	TToken {   Number, Function1, Function2, String,   Operator, Open, Close, Coma,   End }
	Implementation Expression tokens. More...
Private Member Functions
TReturnState	evalExpression (double &result, TToken &nextToken, uint32 userData)
	Evaluate an expression.
TReturnState	getNextToken (TToken &token)
	Internal functions Get the next token.
TReturnState	readDecimal (double &value)
	Read a decimal double.
void	readIntegerNumberDecimal (double &value)
	Read an integer.
Private Attributes
const char *	_ExprPtr
std::string	_InternalStlString
char	_InternalString [InternalStringLen]
	Current string.
const char *	_InternalStringPtr
TOperator	_Op
	Current operator.
TReservedWord	_ReservedWordFound
	Reserved word.
TReturnState	_State
	Members.
double	_Value
	Current value.
Static Private Attributes
const char *	_ErrorString [ReturnValueCount]
const TOperator	_OperatorArray [128]
const int	_OperatorPrecedence []
const char *	_ReservedWord [ReservedWordCount]
const TToken	_ReservedWordToken [ReservedWordCount]
	Static values Char to operator array.
const bool	_StringChar [128]

---

Member Enumeration Documentation

anonymous enum [private]

Enumeration values: InternalStringLen  InternalOperator  Definition at line 289 of file eval_num_expr.h. { InternalStringLen = 32, InternalOperator = 4, };

enum NLMISC::CEvalNumExpr::TOperator [private]

Enumeration values: Not  Tilde  Mul  Div  Remainder  Plus  Minus  ULeftShift  URightShift  SLeftShift  SRightShift  Inferior  InferiorEqual  Superior  SuperiorEqual  Equal  NotEqual  And  Or  Xor  LogicalAnd  LogicalOr  LogicalXor  OperatorCount  NotOperator  ExtOperator  Definition at line 226 of file eval_num_expr.h. { Not = 0, // ! Tilde, // ~ Mul, // * Div, // / Remainder, // % Plus, // + Minus, // - ULeftShift, // << URightShift, // >> SLeftShift, // <- SRightShift, // -> Inferior, // < InferiorEqual, // <= Superior, // > SuperiorEqual, // >= Equal, // == NotEqual, // != And, // & Or, // | Xor, // ^ LogicalAnd, // && LogicalOr, // || LogicalXor, // ^^ OperatorCount, // NotOperator, // This is not an operator ExtOperator, // This is a 2 charcters operator };

enum NLMISC::CEvalNumExpr::TReservedWord [private]

Enumeration values: Abs  Acos  Asin  Atan  Atan2  Ceil  Cos  Cosh  Exp  Exponent  Floor  Int  Log  Log10  Mantissa  Max  Min  Pow  Rand  Round  Sin  Sinh  Sq  Sqrt  Tan  Tanh  ReservedWordCount  Definition at line 257 of file eval_num_expr.h. Referenced by evalExpression(), and getNextToken(). { Abs = 0, Acos, Asin, Atan, Atan2, Ceil, Cos, Cosh, Exp, Exponent, Floor, Int, Log, Log10, Mantissa, Max, Min, Pow, Rand, Round, Sin, Sinh, Sq, Sqrt, Tan, Tanh, ReservedWordCount, };

enum NLMISC::CEvalNumExpr::TReturnState

Eval return error. Enumeration values: NoError  UnkownValue  ValueError  UnkownFunction  FunctionError  NumberSyntaxError  UnkownOperator  MustBeOpen  MustBeClose  MustBeComa  MustBeExpression  NotUnaryOperator  MustBeEnd  MustBeDoubleQuote  DividByZero  ReturnValueCount  Definition at line 42 of file eval_num_expr.h. Referenced by evalExpression(), and getNextToken(). { NoError, // No error UnkownValue, // Unkown value has been parsed ValueError, // Error during user defined value evaluation UnkownFunction, // Unkown function has been parsed FunctionError, // Error during user defined function evaluation NumberSyntaxError, // Syntax error in a number expression UnkownOperator, // Unkown operator MustBeOpen, // Should be a open parentesis MustBeClose, // Should be a close parentesis MustBeComa, // Should be a coma character MustBeExpression, // Should be an expression NotUnaryOperator, // Should not be an unary operator MustBeEnd, // Should be the end MustBeDoubleQuote, // Should be a double quote DividByZero, // Divide by zero ReturnValueCount };

enum NLMISC::CEvalNumExpr::TToken [private]

Implementation Expression tokens. Enumeration values: Number  Function1  Function2  String  Operator  Open  Close  Coma  End  Definition at line 212 of file eval_num_expr.h. { Number, // This is a number Function1, // This is a function with one argu Function2, // This is a function with two argu String, // This is a user string Operator, // This is an operator Open, // ( Close, // ) Coma, // , End, // End of string };

---

Constructor & Destructor Documentation

virtual NLMISC::CEvalNumExpr::~CEvalNumExpr (   )  [inline, virtual]

Definition at line 40 of file eval_num_expr.h. {}

---

Member Function Documentation

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::evalExpression (  double &  result, TToken &  nextToken, uint32  userData )  [private]

Evaluate an expression. Definition at line 616 of file eval_num_expr.cpp. References _InternalStringPtr, _OperatorPrecedence, _ReservedWordFound, Abs, Acos, And, arg1, Asin, Atan, Atan2, Ceil, Close, Coma, Cos, Cosh, Div, DividByZero, Equal, evalExpression(), evalFunction(), evalValue(), Exponent, Floor, Function1, Function2, getNextToken(), index, Inferior, InferiorEqual, InternalOperator, InternalStringLen, Log10, LogicalAnd, LogicalOr, LogicalXor, Mantissa, Minus, Mul, MustBeClose, MustBeComa, MustBeExpression, MustBeOpen, nlstop, Not, NotEqual, NotOperator, NotUnaryOperator, Number, Open, Or, Plus, Pow, Rand, Sin, Sinh, sint, SLeftShift, Sq, Sqrt, SRightShift, Superior, SuperiorEqual, Tan, Tanh, Tilde, TReservedWord, TReturnState, uint, uint32, ULeftShift, URightShift, value, and Xor. { // Array of result uint exprCount = 0; double result[InternalOperator]; vector<double> resultSup; uint opCount = 0; TOperator resultOp[InternalOperator]; vector<TOperator> resultOpSup; // Read a token TReturnState error = getNextToken (nextToken); if (error != NoError) return error; while (1) { // Unary opertor uint unaryOpCount = 0; TOperator resultUnaryOp[InternalOperator]; vector<TOperator> resultUnaryOpSup; // Current value double value; // Unary operator ? if ( (nextToken == Operator) && ( (_Op == Minus) || (_Op == Not) || (_Op == Tilde) ) ) { // Push the unary operator if (unaryOpCount<InternalOperator) resultUnaryOp[unaryOpCount] = _Op; else resultUnaryOpSup.push_back (_Op); unaryOpCount++; // Read next token error = getNextToken (nextToken); if (error != NoError) return error; } // Parenthesis ? if (nextToken == Open) { // Eval sub expression error = evalExpression (value, nextToken, userData); if (error == NoError) { if (nextToken != Close) return MustBeClose; } else return error; // Get next token error = getNextToken (nextToken); if (error != NoError) return error; } // This is a function ? else if ( (nextToken == Function1) || (nextToken == Function2) ) { TToken backupedToken = nextToken; // Get the function TReservedWord reservedWord = _ReservedWordFound; // Read a token error = getNextToken (nextToken); if (error == NoError) { // Open ? if (nextToken != Open) { return MustBeOpen; } // Eval an expression double arg0; error = evalExpression (arg0, nextToken, userData); if (error == NoError) { // 2 arg ? if (backupedToken == Function2) { if (nextToken == Coma) { // Second argument double arg1; error = evalExpression (arg1, nextToken, userData); if (error == NoError) { // Final with close ? if (nextToken == Close) { switch (reservedWord) { case Atan2: value = atan2 (arg0, arg1); break; case Max: value = (arg0>arg1) ? arg0 : arg1; break; case Min: value = (arg0<arg1) ? arg0 : arg1; break; case Pow: value = pow (arg0, arg1); break; case Rand: value = arg0 + (arg1-arg0) * (double)rand () / (double)(RAND_MAX+1); break; default: // Can't be hear after getToken nlstop; } } else return MustBeClose; } else return error; } else return MustBeComa; } else { if (nextToken == Close) { // Eval the function switch (reservedWord) { case Abs: value = fabs (arg0); break; case Acos: value = acos (arg0); break; case Asin: value = asin (arg0); break; case Atan: value = atan (arg0); break; case Ceil: value = ceil (arg0); break; case Cosh: value = cosh (arg0); break; case Cos: value = cos (arg0); break; case Exponent: { int exponent; frexp( arg0, &exponent); value = (double)exponent; } break; case Exp: value = exp (arg0); break; case Floor: value = floor (arg0); break; case Int: value = (double)(int)(arg0); break; case Log10: value = log10 (arg0); break; case Log: value = log (arg0); break; case Mantissa: { int exponent; value = frexp( arg0, &exponent); } break; case Round: value = floor (arg0 + 0.5); break; case Sinh: value = sinh (arg0); break; case Sin: value = sin (arg0); break; case Sqrt: value = sqrt (arg0); break; case Sq: value = arg0 * arg0; break; case Tanh: value = tanh (arg0); break; case Tan: value = tan (arg0); break; default: // Can't be hear after getToken nlstop; } } else return MustBeClose; } } else return error; } else return error; // Get next token error = getNextToken (nextToken); if (error != NoError) return error; } else if (nextToken == Number) { // Save the internal value value = _Value; // Get next token error = getNextToken (nextToken); if (error != NoError) return error; } else if (nextToken == String) { // Copy the string char internalString[InternalStringLen]; std::string internalStlString; const char *internalStringPtr; if (strlen (_InternalStringPtr) >= InternalStringLen-1) { internalStlString = _InternalStringPtr; internalStringPtr = internalStlString.c_str (); } else { strcpy (internalString ,_InternalStringPtr); internalStringPtr = internalString; } // Read a token error = getNextToken (nextToken); if (error == NoError) { // Open ? if (nextToken == Open) { // Eval an expression double arg0; error = evalExpression (arg0, nextToken, userData); if (error == NoError) { if (nextToken == Coma) { // Second argument double arg1; error = evalExpression (arg1, nextToken, userData); if (error == NoError) { // Final with close ? if (nextToken == Close) { // Eval the function error = evalFunction (internalStringPtr, arg0, arg1, value); if (error != NoError) return error; // Get next token error = getNextToken (nextToken); if (error != NoError) return error; } else return MustBeClose; } else return error; } else { if (nextToken == Close) { // Eval the function error = evalFunction (internalStringPtr, arg0, value); if (error != NoError) return error; // Get next token error = getNextToken (nextToken); if (error != NoError) return error; } else return MustBeClose; } } else return error; } else { // This is a user value error = evalValue (internalStringPtr, value, userData); if (error != NoError) return error; } } else return error; } else { return MustBeExpression; } // Eval unary operator sint i; for (i=unaryOpCount-1; i>=0; i--) { switch ((i<InternalOperator)?resultUnaryOp[i]:resultUnaryOpSup[i-InternalOperator]) { case Not: value = (double)(uint)((floor (value+0.5)==0.0)); break; case Tilde: value = (double)~((uint)floor (value+0.5)); break; case Minus: value = -value; break; default: // Can't be hear after getToken nlstop; } } // Push the value if (exprCount < InternalOperator) result[exprCount] = value; else resultSup.push_back (value); exprCount++; // Look for an operator // Operator ? if (nextToken == Operator) { // Yes, push it if (opCount < InternalOperator) resultOp[opCount] = _Op; else resultOpSup.push_back (_Op); opCount++; } else { // Exit the evaluate loop break; } // Next token error = getNextToken (nextToken); } // Reduce the expression uint index = 1; while (exprCount != 1) { // Reduct ? TOperator before = (((index-1)<InternalOperator)?resultOp[index-1]:resultOpSup[index-1-InternalOperator]); TOperator after = (index < opCount)?(((index)<InternalOperator)?resultOp[index]:resultOpSup[index-InternalOperator]):NotOperator; if ((index == opCount) || (_OperatorPrecedence[before] <= _OperatorPrecedence[after])) { // Eval the value double &v0 = ((index-1)<InternalOperator)?result[index-1]:resultSup[index-1-InternalOperator]; double &v1 = ((index)<InternalOperator)?result[index]:resultSup[index-InternalOperator]; // Choose the operator switch (before) { case Not: case Tilde: return NotUnaryOperator; case Mul: v0 *= v1; break; case Div: if (v1 == 0) { return DividByZero; } else { v0 /= v1; } break; case Remainder: v0 = fmod (v0, v1); break; case Plus: v0 += v1; break; case Minus: v0 -= v1; break; case ULeftShift: v0 = (double)(((uint)floor (v0 + 0.5))<<((uint)floor (v1 + 0.5))); break; case URightShift: v0 = (double)(((uint)floor (v0 + 0.5))>>((uint)floor (v1 + 0.5))); break; case SLeftShift: v0 = (double)(((sint)floor (v0 + 0.5))<<((sint)floor (v1 + 0.5))); break; case SRightShift: v0 = (double)(((sint)floor (v0 + 0.5))>>((sint)floor (v1 + 0.5))); break; case Inferior: v0 = (v0<v1)?1.0:0.0; break; case InferiorEqual: v0 = (v0<=v1)?1.0:0.0; break; case Superior: v0 = (v0>v1)?1.0:0.0; break; case SuperiorEqual: v0 = (v0>=v1)?1.0:0.0; break; case Equal: v0 = (v0==v1)?1.0:0.0; break; case NotEqual: v0 = (v0!=v1)?1.0:0.0; break; case And: v0 = (double)(((uint)floor (v0 + 0.5)) & ((uint)floor (v1 + 0.5))); break; case Or: v0 = (double)(((uint)floor (v0 + 0.5)) | ((uint)floor (v1 + 0.5))); break; case Xor: v0 = (double)(((uint)floor (v0 + 0.5)) ^ ((uint)floor (v1 + 0.5))); break; case LogicalAnd: v0 = (double)(uint)((floor (v0 + 0.5) != 0.0) && (floor (v1 + 0.5) != 0.0)); break; case LogicalOr: v0 = (double)(uint)((floor (v0 + 0.5) != 0.0) || (floor (v1 + 0.5) != 0.0)); break; case LogicalXor: { bool b0 = floor (v0 + 0.5) != 0.0; bool b1 = floor (v1 + 0.5) != 0.0; v0 = (double)(uint)((b0&&!b1) || ((!b0)&&b1)); } break; default: nlstop; } // Decal others values uint i = index; for (; i<exprCount-1; i++) { // Copy if (i<InternalOperator) result[i] = (i+1<InternalOperator)?result[i+1]:resultSup[i+1-InternalOperator]; else resultSup[i-InternalOperator] = (i+1<InternalOperator)?result[i+1]:resultSup[i+1-InternalOperator]; } exprCount--; // Decal operators i = index-1; for (; i<opCount-1; i++) { // Copy if (i<InternalOperator) resultOp[i] = (i+1<InternalOperator)?resultOp[i+1]:resultOpSup[i+1-InternalOperator]; else resultOpSup[i-InternalOperator] = (i+1<InternalOperator)?resultOp[i+1]:resultOpSup[i+1-InternalOperator]; } opCount--; // Last one ? if (index > 1) index--; } else index++; } finalResult = result[0]; return NoError; }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::evalExpression (  const char *  expression, double &  result, int *  errorIndex, uint32  userData = 0 )

Evaluate a numerical expression. Doesn't allocate heap memory for common complexity expression. Parameters: expression  is an expression string. See the expression grammar. result  is filled with the result if the function returns "NoError". errorIndex  is a pointer on an integer value filled with the index of the parsing error in the input string if function doesn't return "NoError". This value can be NULL. userData  is a user data used by user eval function Returns: NoError if the expression has been parsed. Result is filled with the evaluated value. This expression must follow the following grammar with the following evaluation priority: expression: '-' expression | '!' expression // Returns true if a equal false, else false (logical not) | '~' expression // Returns ~ round(a) (bitwise not) | '(' expression ')' | expression operator expression | function1 '(' expression ')' | function2 '(' expression ',' expression ')' | number | constant | string // User defined value, evaluated by the evalValue() callback operator: '*' // Calculates (a * b) | '/' // Calculates (a / b) | '%' // Calculates the remainder of (a / b) | '+' // Calculates (a + b) | '-' // Calculates (a - b) | '<<' // Returns round(a) left 32 bits unsigned shift by round(b) | '>>' // Returns round(a) right 32 bits unsigned shift by round(b) | '<-' // Returns round(a) left 32 bits signed shift by round(b) | '->' // Returns round(a) right 32 bits signed shift by round(b) | '<' // Returns true if a is strictly smaller than b | '<=' // Returns true if a is smaller or equal than b | '>' // Returns true if a is strictly bigger than b | '>=' // Returns true if a is bigger or equal than b | '==' // Returns true if a equal b, else returns false (warning, performs a floating point comparison) | '!=' // Returns false if a equal b, else returns true (warning, performs a floating point comparison) | '&' // Returns round(a) & round(b) over 32 bits | '|' // Returns round(a) | round(b) over 32 bits | '^' // Returns round(a) ^ round(b) over 32 bits | '&&' // Returns true if a equal true and b equal true else returns false | '||' // Returns true if a equal true or b equal true else returns false | '^^' // Returns true if a equal true and b equal false, or, a equal false and b equal 1.0, else returns false function1: abs // Calculates the absolute value | acos // Calculates the arccosine | asin // Calculates the arcsine | atan // Calculates the arctangent | ceil // Calculates the ceiling of a value ( ceil(-1.1) = -1, ceil(1.1) = 2 ) | cos // Calculates the cosine | cosh // Calculates the hyperbolic cosine | exp // Calculates the exponential | exponent // Calculates the exponent of a floating point value | floor // Calculates the floor of a value ( floor(-1.1) = -2, floor(1.1) = 1 ) | int // Calculates the C style integer value ( int(-1.6) = -1, int(1.6) = 1 ) | log // Calculates logarithms | log10 // Calculates base-10 logarithms | mantissa // Calculates the mantissa of a floating point value | round // Calculates the nearest integer value ( round(-1.6) = -2, round(1.1) = 1 ) | sin // Calculate sines | sinh // Calculate hyperbolic sines | sq // Calculates the square | sqrt // Calculates the square root | tan // Calculates the tangent | tanh // Calculates the hyperbolic tangent | string // User defined one arg function, evaluated by the evalfunction() callback function2: max // Returns the larger of two values | min // Returns the smaller of two values | atan2 // Calculates the arctangent of arg0/arg1 | pow // Calculates a raised at the power of b | rand // Calculates a pseudo random value (arg0 <= randomValue < arg1) | string // User defined two args function, evaluated by the evalfunction() callback number: [0-9]+ // Unsigned decimal integer | "0x"[0-9a-fA-F]+ // Unsigned hexadecimal integer | "0"[0-7]+ // Unsigned octal integer | [0-9]*.[0-9]+ // Unsigned floating point value | [0-9]*.[0-9]+[eE]-?[0-9]*.[0-9]+ // Unsigned floating point value with signed exponent constant: e // 2.7182818284590452353602874713527 | pi // 3.1415926535897932384626433832795 string: [^ 0-9 /\*-+=<>&|\^!%~\(\)\.,\"][^ \t\n/\*-+=<>&|\^!%~\(\)\.,\"]* // Labels ($foo, #foo01, _001) | \"[]+\" // All kind of labels between double quotes "123456" "foo.foo[12]" Operator precedence: 0 - unary operator (-, ~, !) 1 - *, /, 2 - +, -, 3 - <<, >>, <-, -> 4 - <, <=, >, >= 5 - ==, != 6 - & 7 - | 8 - ^ 9 - && 10 - || 11 - ^^ Definition at line 586 of file eval_num_expr.cpp. References _ExprPtr, MustBeEnd, TReturnState, and uint32. Referenced by evalExpression(), and NLGEORGES::CMyEvalNumExpr::evalValue(). { // Init the ptr _ExprPtr = expression; TToken nextToken; TReturnState error = evalExpression (result, nextToken, userData); if (error == NoError) { // The end ? if (nextToken == End) return NoError; else { if (errorIndex) *errorIndex = _ExprPtr - expression; return MustBeEnd; } } else { if (errorIndex) *errorIndex = _ExprPtr - expression; return error; } }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::evalFunction (  const char *  funcName, double  arg0, double  arg1, double &  result )  [protected, virtual]

Definition at line 1197 of file eval_num_expr.cpp. References arg1, and UnkownFunction. { return UnkownFunction; }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::evalFunction (  const char *  funcName, double  arg0, double &  result )  [protected, virtual]

Eval a user defined function. Default implementation returns UnkownFunction. The user can parse the function name and fill the result double and return NoError, UnkownFunction or FunctionError. To convert double argu in boolean argu, use (round (value) != 0.0) ? true : false Parameters: funcName  is the name of the function to evaluate. arg0  is the first parameter passed to the function. arg1  is the second parameter passed to the function. result  is the result to fill if the value has been succesfully parsed. Returns: UnkownFunction if the function doesn't exist, FunctionError if the function evaluation failed, NoError if it has been parsed. Definition at line 1190 of file eval_num_expr.cpp. References UnkownFunction. Referenced by evalExpression(). { return UnkownFunction; }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::evalValue (  const char *  value, double &  result, uint32  userData )  [protected, virtual]

Overridable functions. Eval a user defined value. Default implementation returns UnkownValue. The user can parse the value and fill the result double and return NoError, UnkownValue or ValueError. Parameters: value  is the value to parse. result  is the result to fill if the value has been succesfully parsed. userData  is a user data used by user eval function. Returns: UnkownValue if the value is not known, ValueError is the value evaluation failed or NoError if it has been parsed. Reimplemented in NLGEORGES::CMyEvalNumExpr. Definition at line 1183 of file eval_num_expr.cpp. References uint32, UnkownValue, and value. Referenced by evalExpression(), and NLGEORGES::CMyEvalNumExpr::evalValue(). { return UnkownValue; }

const char * NLMISC::CEvalNumExpr::getErrorString (  TReturnState  state  )  const

Get error string. Definition at line 1289 of file eval_num_expr.cpp. References _ErrorString. { return _ErrorString[state]; }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::getNextToken (  TToken &  token  )  [private]

Internal functions Get the next token. Definition at line 96 of file eval_num_expr.cpp. References _ExprPtr, _InternalStlString, _InternalString, _InternalStringPtr, _OperatorArray, _ReservedWord, _ReservedWordFound, _ReservedWordToken, _StringChar, And, Close, Coma, Equal, ExtOperator, Inferior, InferiorEqual, InternalStringLen, LogicalAnd, LogicalOr, LogicalXor, Minus, MustBeDoubleQuote, Not, NotEqual, NotOperator, Number, NumberSyntaxError, Open, Or, readDecimal(), ReservedWordCount, sint, size, SLeftShift, SRightShift, Superior, SuperiorEqual, TReservedWord, TReturnState, uint, uint8, ULeftShift, UnkownOperator, URightShift, and Xor. Referenced by evalExpression(). { // Get the current char uint8 currentChar = *_ExprPtr; // Skip space while ((currentChar!=0) && (currentChar<=0x20)) { _ExprPtr++; currentChar = *_ExprPtr; } // Can be an operator ? if (currentChar <= 128) { // Get the operator _Op = _OperatorArray[currentChar]; // Is an operator ? if (_Op != NotOperator) { // It is an operator token = Operator; // Is a 2 characters operator ? if (_Op != ExtOperator) { // Return next character _ExprPtr++; return NoError; } else { // Have a second character ? char secondChar = *(_ExprPtr+1); // What kind of 1st character switch (currentChar) { case '!': if (secondChar == '=') { _Op = NotEqual; _ExprPtr+=2; return NoError; } else { _Op = Not; _ExprPtr++; return NoError; } case '&': if (secondChar == '&') { _Op = LogicalAnd; _ExprPtr+=2; return NoError; } else { _Op = And; _ExprPtr+=1; return NoError; } case '-': if (secondChar == '>') { _Op = SRightShift; _ExprPtr+=2; return NoError; } else { _Op = Minus; _ExprPtr++; return NoError; } case '<': if (secondChar == '<') { _Op = ULeftShift; _ExprPtr+=2; return NoError; } else if (secondChar == '=') { _Op = InferiorEqual; _ExprPtr+=2; return NoError; } else if (secondChar == '-') { _Op = SLeftShift; _ExprPtr+=2; return NoError; } else { _Op = Inferior; _ExprPtr+=1; return NoError; } case '=': if (secondChar == '=') { _Op = Equal; _ExprPtr+=2; return NoError; } case '>': if (secondChar == '>') { _Op = URightShift; _ExprPtr+=2; return NoError; } else if (secondChar == '=') { _Op = SuperiorEqual; _ExprPtr+=2; return NoError; } else { _Op = Superior; _ExprPtr+=1; return NoError; } case '^': if (secondChar == '^') { _Op = LogicalXor; _ExprPtr+=2; return NoError; } else { _Op = Xor; _ExprPtr+=1; return NoError; } case '|': if (secondChar == '|') { _Op = LogicalOr; _ExprPtr+=2; return NoError; } else { _Op = Or; _ExprPtr+=1; return NoError; } } // Can't found the operator return UnkownOperator; } } // Is End, '(', ')', '.' ? else if (currentChar == 0) { token = End; return NoError; } else if (currentChar == '(') { _ExprPtr++; token = Open; return NoError; } else if (currentChar == ')') { _ExprPtr++; token = Close; return NoError; } else if (currentChar == ',') { _ExprPtr++; token = Coma; return NoError; } // Is a number ? else if ((currentChar >= '0') && (currentChar <= '9') || (currentChar == '.')) { // This is a number token = Number; // Have a second character ? char secondChar = *(_ExprPtr+1); // Is an hexadecimal value ? if ((currentChar == '0') && (secondChar == 'x')) { // Go to the number _ExprPtr +=2; currentChar = *_ExprPtr; // Registered values register double regValue = 0; if ((currentChar >= '0') && (currentChar <= '9')) { regValue += (currentChar - '0'); } else if ((currentChar >= 'a') && (currentChar <= 'f')) { regValue += (currentChar - 'a' + 10); } else if ((currentChar >= 'A') && (currentChar <= 'F')) { regValue += (currentChar - 'A' + 10); } else { // Number syntax error return NumberSyntaxError; } _ExprPtr++; currentChar = *_ExprPtr; // For each values while (1) { if ((currentChar >= '0') && (currentChar <= '9')) { regValue *= 16; regValue += (currentChar - '0'); } else if ((currentChar >= 'a') && (currentChar <= 'f')) { regValue *= 16; regValue += (currentChar - 'a' + 10); } else if ((currentChar >= 'A') && (currentChar <= 'F')) { regValue *= 16; regValue += (currentChar - 'A' + 10); } else { // Stop break; } // Next char _ExprPtr++; currentChar = *_ExprPtr; } // Store value _Value = regValue; // Number ok return NoError; } // Is an octal value ? else if ((currentChar == '0') && (secondChar >= '0') && (secondChar <= '9')) { // Go to the number _ExprPtr ++; currentChar = *_ExprPtr; // Registered values register double regValue = 0; // Check octal number if (currentChar > '7') return NumberSyntaxError; // Read the first value regValue += (currentChar - '0'); _ExprPtr++; currentChar = *_ExprPtr; // For each values while ((currentChar >= '0') && (currentChar <= '9')) { // Check octal number if (currentChar > '7') return NumberSyntaxError; regValue *= 8; regValue += (currentChar - '0'); // Next char _ExprPtr++; currentChar = *_ExprPtr; } // Store value _Value = regValue; // Number ok return NoError; } // It is a decimal value else { // Read value TReturnState state = readDecimal (_Value); if (state == NoError) { // Exponent ? currentChar = *_ExprPtr; if ( (currentChar == 'e') || (currentChar == 'E') ) { // Next char _ExprPtr++; // Minus ? bool negative = false; if (*_ExprPtr == '-') { negative = true; _ExprPtr++; } // Read value double exponent; state = readDecimal (exponent); if (state == NoError) { // Negative value ? if (negative) exponent = -exponent; // Raise 10 at the power of _Value *= pow (10.0, exponent); } else { return state; } } // Number ok return NoError; } else { return state; } } } // Is a string ? else if (currentChar == '"') { // Look for the end of the string _ExprPtr++; currentChar = *_ExprPtr; const char *start = _ExprPtr; while ( (currentChar != 0) && (currentChar != '"') ) { _ExprPtr++; currentChar = *_ExprPtr; } // End reached ? if (currentChar == 0) return MustBeDoubleQuote; // This is a user string, copy the string uint size = _ExprPtr - start; if (size >= (InternalStringLen-1)) { _InternalStlString.resize (size); uint i; for (i=0; i<size; i++) _InternalStlString[i] = start[i]; _InternalStringPtr = _InternalStlString.c_str (); } else { memcpy (_InternalString, start, size); _InternalString[size] = 0; _InternalStringPtr = _InternalString; } // Token _ExprPtr++; token = String; return NoError; } } // Read a string const char *start = _ExprPtr; while ( (currentChar >= 128) || _StringChar[currentChar] ) { _ExprPtr++; currentChar = *_ExprPtr; } // Is pi ? if (((_ExprPtr - start) == 2) && (start[0] == 'p') && (start[1] == 'i')) { token = Number; _Value = 3.1415926535897932384626433832795; return NoError; } // Is e ? else if (((_ExprPtr - start) == 1) && (start[0] == 'e')) { token = Number; _Value = 2.7182818284590452353602874713527; return NoError; } // This is a user string, copy the string uint size = _ExprPtr - start; if (size >= (InternalStringLen-1)) { _InternalStlString.resize (size); uint i; for (i=0; i<size; i++) _InternalStlString[i] = start[i]; _InternalStringPtr = _InternalStlString.c_str (); } else { memcpy (_InternalString, start, size); _InternalString[size] = 0; _InternalStringPtr = _InternalString; } // Search for a reserved word ? uint begin = 0; uint end = ReservedWordCount-1; sint result = strcmp (_InternalStringPtr, _ReservedWord[begin]); if ( result >= 0 ) { // The first is the good ? if ( result == 0 ) { end = begin; } result = strcmp (_InternalStringPtr, _ReservedWord[end]); if (result <= 0) { // The last is the good ? if ( result == 0 ) { begin = end; } // While there is a middle.. while ((end - begin) > 1) { uint middle = begin + (end - begin) / 2; result = strcmp (_InternalStringPtr, _ReservedWord[middle]); if (result == 0) { begin = middle; end = middle; break; } else if (result < 0) { end = middle; } else { begin = middle; } } } // Found ? if (end == begin) { // Return the token _ReservedWordFound = (TReservedWord)begin; token = _ReservedWordToken[begin]; // Ok return NoError; } } // Token token = String; return NoError; }

bool NLMISC::CEvalNumExpr::internalCheck (   )

Definition at line 1127 of file eval_num_expr.cpp. References _ReservedWord, nlstop, ReservedWordCount, and uint. { for (uint i=0; i<ReservedWordCount-1; i++) if (strcmp (_ReservedWord[i], _ReservedWord[i+1]) >= 0) { nlstop; return false; } return true; }

CEvalNumExpr::TReturnState NLMISC::CEvalNumExpr::readDecimal (  double &  value  )  [private]

Read a decimal double. Definition at line 37 of file eval_num_expr.cpp. References _ExprPtr, NumberSyntaxError, readIntegerNumberDecimal(), and value. Referenced by getNextToken(). { // Read first integer value readIntegerNumberDecimal (value); // Dot ? char currentChar = *_ExprPtr; if (currentChar == '.') { // Next char _ExprPtr++; currentChar = *_ExprPtr; if (currentChar < '0' || currentChar > '9') return NumberSyntaxError; // Read the decimal part const char *start = _ExprPtr; double fract; readIntegerNumberDecimal (fract); fract /= (double)pow (10 ,(_ExprPtr-start)); value += fract; } return NoError; }

void NLMISC::CEvalNumExpr::readIntegerNumberDecimal (  double &  value  )  [private]

Read an integer. Definition at line 65 of file eval_num_expr.cpp. References _ExprPtr, and value. Referenced by readDecimal(). { // Registered values register double regValue = 0; // Read the first value char currentChar = *_ExprPtr; if ((currentChar >= '0') && (currentChar <= '9')) { regValue += (currentChar - '0'); _ExprPtr++; currentChar = *_ExprPtr; // For each values while ((currentChar >= '0') && (currentChar <= '9')) { regValue *= 10; regValue += (currentChar - '0'); // Next char _ExprPtr++; currentChar = *_ExprPtr; } } // Store value value = regValue; }

---

Field Documentation

const char * NLMISC::CEvalNumExpr::_ErrorString [static, private]

Initial value: { "No error", "Unkown value", "Error during user defined value evaluation", "Unkown function", "Error during user defined function evaluation", "Syntax error in a number expression", "Unkown operator", "Should be a open parentesis", "Should be a close parentesis", "Should be a coma character", "Should be an expression", "Should not be an unary operator", "Should be the end of the expression", "Should be a double quote", "Divid by zero", } Definition at line 1268 of file eval_num_expr.cpp. Referenced by getErrorString().

const char* NLMISC::CEvalNumExpr::_ExprPtr [private]

Definition at line 297 of file eval_num_expr.h. Referenced by evalExpression(), getNextToken(), readDecimal(), and readIntegerNumberDecimal().

std::string NLMISC::CEvalNumExpr::_InternalStlString [private]

Definition at line 318 of file eval_num_expr.h. Referenced by getNextToken().

char NLMISC::CEvalNumExpr::_InternalString[InternalStringLen] [private]

Current string. Definition at line 317 of file eval_num_expr.h. Referenced by getNextToken().

const char* NLMISC::CEvalNumExpr::_InternalStringPtr [private]

Definition at line 319 of file eval_num_expr.h. Referenced by evalExpression(), and getNextToken().

TOperator NLMISC::CEvalNumExpr::_Op [private]

Current operator. Definition at line 325 of file eval_num_expr.h.

const CEvalNumExpr::TOperator NLMISC::CEvalNumExpr::_OperatorArray [static, private]

Initial value: { NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, ExtOperator, NotOperator, NotOperator, NotOperator, Remainder, ExtOperator, NotOperator, NotOperator, NotOperator, Mul, Plus, NotOperator, ExtOperator, NotOperator, Div, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, ExtOperator, ExtOperator, ExtOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, ExtOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, NotOperator, ExtOperator, NotOperator, Tilde, NotOperator, } Definition at line 1155 of file eval_num_expr.cpp. Referenced by getNextToken().

const int NLMISC::CEvalNumExpr::_OperatorPrecedence [static, private]

Initial value: { 0, 0, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 0xffffffff, 20, } Definition at line 1296 of file eval_num_expr.cpp. Referenced by evalExpression().

const char * NLMISC::CEvalNumExpr::_ReservedWord [static, private]

Initial value: { "abs", "acos", "asin", "atan", "atan2", "ceil", "cos", "cosh", "exp", "exponent", "floor", "int", "log", "log10", "mantissa", "max", "min", "pow", "rand", "round", "sin", "sinh", "sq", "sqrt", "tan", "tanh", } Definition at line 1204 of file eval_num_expr.cpp. Referenced by getNextToken(), and internalCheck().

TReservedWord NLMISC::CEvalNumExpr::_ReservedWordFound [private]

Reserved word. Definition at line 314 of file eval_num_expr.h. Referenced by evalExpression(), and getNextToken().

const CEvalNumExpr::TToken NLMISC::CEvalNumExpr::_ReservedWordToken [static, private]

Initial value: { Function1, Function1, Function1, Function1, Function2, Function1, Function1, Function1, Function1, Function1, Function1, Function1, Function1, Function1, Function1, Function2, Function2, Function2, Function2, Function1, Function1, Function1, Function1, Function1, Function1, Function1, } Static values Char to operator array. Definition at line 1236 of file eval_num_expr.cpp. Referenced by getNextToken().

TReturnState NLMISC::CEvalNumExpr::_State [private]

Members. Definition at line 296 of file eval_num_expr.h.

const bool NLMISC::CEvalNumExpr::_StringChar [static, private]

Initial value: { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, false, false, true, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, true, true, true, true, true, false, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, } Definition at line 1169 of file eval_num_expr.cpp. Referenced by getNextToken().

double NLMISC::CEvalNumExpr::_Value [private]

Current value. Definition at line 322 of file eval_num_expr.h.

---

The documentation for this class was generated from the following files:

• eval_num_expr.h
• eval_num_expr.cpp

---