From 63c5e353d745684ecca182e9969da104798faa0d Mon Sep 17 00:00:00 2001 From: Birunthan Mohanathas Date: Sat, 22 Dec 2012 12:23:36 +0200 Subject: [PATCH] Cosmetics --- Library/MathParser.cpp | 396 ++++++++++++++++++++++------------------- 1 file changed, 216 insertions(+), 180 deletions(-) diff --git a/Library/MathParser.cpp b/Library/MathParser.cpp index 99f12bf1..5aa969ce 100644 --- a/Library/MathParser.cpp +++ b/Library/MathParser.cpp @@ -25,65 +25,66 @@ static const double M_E = 2.7182818284590452354; static const double M_PI = 3.14159265358979323846; -typedef double (*OneArgProc)(double arg); -typedef const WCHAR* (*MultiArgProc)(int paramcnt, double* args, double* result); +typedef double (*SingleArgFunction)(double arg); +typedef const WCHAR* (*MultiArgFunction)(int paramcnt, double* args, double* result); -enum OperationType +enum class Operator : uint8_t { - OP_SHL, - OP_SHR, - OP_POW, - OP_LOGIC_NEQ, - OP_LOGIC_GEQ, - OP_LOGIC_LEQ, - OP_LOGIC_AND, - OP_LOGIC_OR, - OP_OBR, - OP_ADD, - OP_SUB, - OP_MUL, - OP_DIV, - OP_MOD, - OP_UNK, - OP_XOR, - OP_NOT, - OP_AND, - OP_OR, - OP_EQU, - OP_GREATER, - OP_SMALLER, - OP_LOGIC, - OP_LOGIC_SEP, - OP_CBR, - OP_COMMA, - OP_FUNC_ONEARG, // Special - OP_FUNC_MULTIARG // Special + ShiftLeft, + ShiftRight, + Power, + NotEqual, + GreatorOrEqual, + LessOrEqual, + LogicalAND, + LogicalOR, + OpeningBracket, + Addition, + Subtraction, + Multiplication, + Division, + Modulo, + UNK, + BitwiseXOR, + BitwiseNOT, + BitwiseAND, + BitwiseOR, + Equal, + Greater, + Less, + Conditional, + ConditionalSeparator, + ClosingBracket, + Comma, + SingleArgFunction, + MultiArgFunction, + Invalid // Must be last. }; -enum CharType +enum class CharType { - CH_UNKNOWN = 0x00, - CH_LETTER = 0x01, - CH_DIGIT = 0x02, - CH_SEPARAT = 0x04, - CH_SYMBOL = 0x08, - CH_MINUS = 0x10, - CH_FINAL = 0x7F + Unknown = 0x00, + Letter = 0x01, + Digit = 0x02, + Separator = 0x04, + Symbol = 0x08, + MinusSymbol = 0x10, + Final = 0x7F }; -enum MathTokenType +enum class Token { - TOK_ERROR, - TOK_NONE, - TOK_FINAL, - TOK_FLOAT, - TOK_SYMBOL, - TOK_NAME + Error, + None, + Final, + Float, + Symbol, + Name }; struct Operation { - BYTE type; + Operator type; BYTE funcIndex; char prevTop; }; @@ -91,7 +92,7 @@ struct Operation struct Function { WCHAR* name; - OneArgProc proc; + SingleArgFunction proc; BYTE length; }; @@ -117,7 +118,7 @@ static Function g_Functions[] = { L"trunc", &trunc, 5 }, { L"floor", &floor, 5 }, { L"ceil", &ceil, 4 }, - { L"round", (OneArgProc)&round, 5 }, + { L"round", (SingleArgFunction)&round, 5 }, { L"asin", &asin, 4 }, { L"acos", &acos, 4 }, { L"rad", &rad, 3 }, @@ -133,44 +134,44 @@ static const int FUNC_E = 19; static const int FUNC_PI = 20; static const BYTE FUNC_INVALID = UCHAR_MAX; -static const Operation g_BrOp = { OP_OBR, 0, 0}; -static const Operation g_NegOp = { OP_FUNC_ONEARG, 18, 0 }; +static const Operation g_BrOp = { Operator::OpeningBracket, 0, 0}; +static const Operation g_NegOp = { Operator::SingleArgFunction, 18, 0 }; -static const BYTE g_OpPriorities[OP_FUNC_MULTIARG + 1] = +static const BYTE g_OpPriorities[Operator::Invalid] = { - 5, // OP_SHL - 5, // OP_SHR - 5, // OP_POW - 2, // OP_LOGIC_NEQ - 2, // OP_LOGIC_GEQ - 2, // OP_LOGIC_LEQ - 2, // OP_LOGIC_AND - 2, // OP_LOGIC_OR - 0, // OP_OBR - 3, // OP_ADD - 3, // OP_SUB - 4, // OP_MUL - 4, // OP_DIV - 4, // OP_MOD - 4, // OP_UNK - 5, // OP_XOR - 5, // OP_NOT - 5, // OP_AND - 5, // OP_OR - 2, // OP_EQU - 2, // OP_GREATER - 2, // OP_SMALLER - 1, // OP_LOGIC - 2, // OP_LOGIC_SEP - 0, // OP_CBR - 2, // OP_COMMA - 6, // OP_FUNC_ONEARG - 6 // OP_FUNC_MULTIARG + 5, // Operator::ShiftLeft + 5, // Operator::ShiftRight + 5, // Operator::Power + 2, // Operator::NotEqual + 2, // Operator::GreatorOrEqual + 2, // Operator::LessOrEqual + 2, // Operator::LogicalAND + 2, // Operator::LogicalOR + 0, // Operator::OpeningBracket + 3, // Operator::Addition + 3, // Operator::Subtraction + 4, // Operator::Multiplication + 4, // Operator::Division + 4, // Operator::Modulo + 4, // Operator::UNK + 5, // Operator::BitwiseXOR + 5, // Operator::BitwiseNOT + 5, // Operator::BitwiseAND + 5, // Operator::BitwiseOR + 2, // Operator::Equal + 2, // Operator::Greater + 2, // Operator::Less + 1, // Operator::Conditional + 2, // Operator::ConditionalSeparator + 0, // Operator::ClosingBracket + 2, // Operator::Comma + 6, // Operator::SingleArgFunction + 6 // Operator::MultiArgFunction }; static CharType GetCharType(WCHAR ch); static BYTE GetFunctionIndex(const WCHAR* str, BYTE len); -static int FindSymbol(const WCHAR* str); +static Operator GetOperator(const WCHAR* str); struct Parser { @@ -180,7 +181,7 @@ struct Parser char valTop; int obrDist; - Parser() : opTop(0), valTop(-1), obrDist(2) { opStack[0].type = OP_OBR; } + Parser() : opTop(0), valTop(-1), obrDist(2) { opStack[0].type = Operator::OpeningBracket; } }; static const WCHAR* CalcToObr(Parser& parser); @@ -193,13 +194,13 @@ struct Lexer size_t nameLen; double extValue; int intValue; - MathTokenType prevToken; + Token prevToken; CharType charType; - Lexer(const WCHAR* str) : string(str), name(), nameLen(), extValue(), intValue(), prevToken(TOK_NONE), charType(GetCharType(*str)) {} + Lexer(const WCHAR* str) : string(str), name(), nameLen(), extValue(), intValue(), prevToken(Token::None), charType(GetCharType(*str)) {} }; -static MathTokenType GetNextToken(Lexer& lexer); +static Token GetNextToken(Lexer& lexer); const WCHAR* eBrackets = L"Unmatched brackets"; const WCHAR* eSyntax = L"Syntax error"; @@ -263,14 +264,14 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* return eInternal; } - MathTokenType token = GetNextToken(lexer); + Token token = GetNextToken(lexer); --parser.obrDist; switch (token) { - case TOK_ERROR: + case Token::Error: return eSyntax; - case TOK_FINAL: + case Token::Final: if ((error = CalcToObr(parser)) != NULL) { return error; @@ -287,31 +288,31 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* } break; - case TOK_FLOAT: + case Token::Float: parser.valStack[++parser.valTop] = lexer.extValue; break; - case TOK_SYMBOL: + case Token::Symbol: switch (lexer.intValue) { - case OP_OBR: + case Operator::OpeningBracket: { parser.opStack[++parser.opTop] = g_BrOp; parser.obrDist = 2; } break; - case OP_CBR: + case Operator::ClosingBracket: { if ((error = CalcToObr(parser)) != NULL) return error; } break; - case OP_COMMA: + case Operator::Comma: { if ((error = CalcToObr(parser)) != NULL) return error; - if (parser.opStack[parser.opTop].type == OP_FUNC_MULTIARG) + if (parser.opStack[parser.opTop].type == Operator::MultiArgFunction) { parser.opStack[++parser.opTop] = g_BrOp; parser.obrDist = 2; @@ -326,10 +327,10 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* default: { Operation op; - op.type = (OperationType)lexer.intValue; + op.type = (Operator)lexer.intValue; switch (op.type) { - case OP_ADD: + case Operator::Addition: if (parser.obrDist >= 1) { // Goto next token @@ -337,7 +338,7 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* } break; - case OP_SUB: + case Operator::Subtraction: if (parser.obrDist >= 1) { parser.opStack[++parser.opTop] = g_NegOp; @@ -347,13 +348,13 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* } break; - case OP_LOGIC: - case OP_LOGIC_SEP: + case Operator::Conditional: + case Operator::ConditionalSeparator: parser.obrDist = 2; break; } - while (g_OpPriorities[op.type] <= g_OpPriorities[parser.opStack[parser.opTop].type]) + while (g_OpPriorities[(int)op.type] <= g_OpPriorities[(int)parser.opStack[parser.opTop].type]) { if ((error = Calc(parser)) != NULL) return error; } @@ -363,7 +364,7 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* } break; - case TOK_NAME: + case Token::Name: { Operation op; if (lexer.nameLen <= FUNC_MAX_LEN && @@ -380,13 +381,13 @@ const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* break; case FUNC_ROUND: - op.type = OP_FUNC_MULTIARG; + op.type = Operator::MultiArgFunction; op.prevTop = parser.valTop; parser.opStack[++parser.opTop] = op; break; default: // Internal function - op.type = OP_FUNC_ONEARG; + op.type = Operator::SingleArgFunction; parser.opStack[++parser.opTop] = op; break; } @@ -419,16 +420,16 @@ static const WCHAR* Calc(Parser& parser) Operation op = parser.opStack[parser.opTop--]; // Multi-argument function - if (op.type == OP_LOGIC) + if (op.type == Operator::Conditional) { return NULL; } - else if (op.type == OP_FUNC_MULTIARG) + else if (op.type == Operator::MultiArgFunction) { int paramcnt = parser.valTop - op.prevTop; parser.valTop = op.prevTop; - const WCHAR* error = (*(MultiArgProc)g_Functions[op.funcIndex].proc)(paramcnt, &parser.valStack[parser.valTop + 1], &res); + const WCHAR* error = (*(MultiArgFunction)g_Functions[op.funcIndex].proc)(paramcnt, &parser.valStack[parser.valTop + 1], &res); if (error) return error; parser.valStack[++parser.valTop] = res; @@ -443,13 +444,13 @@ static const WCHAR* Calc(Parser& parser) double right = parser.valStack[parser.valTop--]; // One arg operations - if (op.type == OP_NOT) + if (op.type == Operator::BitwiseNOT) { res = (double)(~((long long)right)); } - else if (op.type == OP_FUNC_ONEARG) + else if (op.type == Operator::SingleArgFunction) { - res = (*(OneArgProc)g_Functions[op.funcIndex].proc)(right); + res = (*(SingleArgFunction)g_Functions[op.funcIndex].proc)(right); } else { @@ -462,51 +463,51 @@ static const WCHAR* Calc(Parser& parser) double left = parser.valStack[parser.valTop--]; switch (op.type) { - case OP_SHL: + case Operator::ShiftLeft: res = (double)((long long)left << (long long)right); break; - case OP_SHR: + case Operator::ShiftRight: res = (double)((long long)left >> (long long)right); break; - case OP_POW: + case Operator::Power: res = pow(left, right); break; - case OP_LOGIC_NEQ: + case Operator::NotEqual: res = left != right; break; - case OP_LOGIC_GEQ: + case Operator::GreatorOrEqual: res = left >= right; break; - case OP_LOGIC_LEQ: + case Operator::LessOrEqual: res = left <= right; break; - case OP_LOGIC_AND: + case Operator::LogicalAND: res = left && right; break; - case OP_LOGIC_OR: + case Operator::LogicalOR: res = left || right; break; - case OP_ADD: + case Operator::Addition: res = left + right; break; - case OP_SUB: + case Operator::Subtraction: res = left - right; break; - case OP_MUL: + case Operator::Multiplication: res = left* right; break; - case OP_DIV: + case Operator::Division: if (right == 0.0) { return eInfinity; @@ -517,11 +518,11 @@ static const WCHAR* Calc(Parser& parser) } break; - case OP_MOD: + case Operator::Modulo: res = fmod(left, right); break; - case OP_UNK: + case Operator::UNK: if (left <= 0) { res = 0.0; @@ -536,34 +537,34 @@ static const WCHAR* Calc(Parser& parser) } break; - case OP_XOR: + case Operator::BitwiseXOR: res = (double)((long long)left ^ (long long)right); break; - case OP_AND: + case Operator::BitwiseAND: res = (double)((long long)left & (long long)right); break; - case OP_OR: + case Operator::BitwiseOR: res = (double)((long long)left | (long long)right); break; - case OP_EQU: + case Operator::Equal: res = left == right; break; - case OP_GREATER: + case Operator::Greater: res = left > right; break; - case OP_SMALLER: + case Operator::Less: res = left < right; break; - case OP_LOGIC_SEP: + case Operator::ConditionalSeparator: { // Needs three arguments - if (parser.opTop < 0 || parser.opStack[parser.opTop--].type != OP_LOGIC) + if (parser.opTop < 0 || parser.opStack[parser.opTop--].type != Operator::Conditional) { return eLogicErr; } @@ -582,7 +583,7 @@ static const WCHAR* Calc(Parser& parser) static const WCHAR* CalcToObr(Parser& parser) { - while (parser.opStack[parser.opTop].type != OP_OBR) + while (parser.opStack[parser.opTop].type != Operator::OpeningBracket) { const WCHAR* error = Calc(parser); if (error) return error; @@ -591,44 +592,44 @@ static const WCHAR* CalcToObr(Parser& parser) return NULL; } -MathTokenType GetNextToken(Lexer& lexer) +Token GetNextToken(Lexer& lexer) { - MathTokenType result = TOK_ERROR; + Token result = Token::Error; - while (lexer.charType == CH_SEPARAT) + while (lexer.charType == CharType::Separator) { lexer.charType = GetCharType(*++lexer.string); } - if (lexer.charType == CH_MINUS) + if (lexer.charType == CharType::MinusSymbol) { // If the - sign follows a symbol, it is treated as a (negative) number. - lexer.charType = (lexer.prevToken == TOK_SYMBOL) ? CH_DIGIT : CH_SYMBOL; + lexer.charType = (lexer.prevToken == Token::Symbol) ? CharType::Digit : CharType::Symbol; } switch (lexer.charType) { - case CH_FINAL: + case CharType::Final: { - result = TOK_FINAL; + result = Token::Final; } break; - case CH_LETTER: + case CharType::Letter: { lexer.name = lexer.string; do { lexer.charType = GetCharType(*++lexer.string); } - while (lexer.charType <= CH_DIGIT); + while (lexer.charType <= CharType::Digit); lexer.nameLen = lexer.string - lexer.name; - result = TOK_NAME; + result = Token::Name; } break; - case CH_DIGIT: + case CharType::Digit: { WCHAR* newString; if (lexer.string[0] == L'0') @@ -660,7 +661,7 @@ MathTokenType GetNextToken(Lexer& lexer) lexer.string = newString; lexer.charType = GetCharType(*lexer.string); lexer.extValue = lexer.intValue; - result = TOK_FLOAT; + result = Token::Float; } break; } @@ -672,21 +673,21 @@ MathTokenType GetNextToken(Lexer& lexer) { lexer.string = newString; lexer.charType = GetCharType(*lexer.string); - result = TOK_FLOAT; + result = Token::Float; } } break; - case CH_SYMBOL: + case CharType::Symbol: { - int sym = FindSymbol(lexer.string); - if (sym >= 0) + Operator oper = GetOperator(lexer.string); + if (oper != Operator::Invalid) { - lexer.string += (sym <= OP_LOGIC_OR) ? 2 : 1; + lexer.string += ((int)oper <= (int)Operator::LogicalOR) ? 2 : 1; lexer.charType = GetCharType(*lexer.string); - lexer.intValue = sym; - result = TOK_SYMBOL; + lexer.intValue = (int)oper; + result = Token::Symbol; } } break; @@ -702,18 +703,18 @@ CharType GetCharType(WCHAR ch) switch (ch) { case L'\0': - return CH_FINAL; + return CharType::Final; case L' ': case L'\t': case L'\n': - return CH_SEPARAT; + return CharType::Separator; case L'_': - return CH_LETTER; + return CharType::Letter; case L'-': - return CH_MINUS; + return CharType::MinusSymbol; case L'+': case L'/': @@ -731,19 +732,19 @@ CharType GetCharType(WCHAR ch) case L'=': case L'&': case L'|': - return CH_SYMBOL; + return CharType::Symbol; } - if (iswalpha(ch)) return CH_LETTER; - if (iswdigit(ch)) return CH_DIGIT; + if (iswalpha(ch)) return CharType::Letter; + if (iswdigit(ch)) return CharType::Digit; - return CH_UNKNOWN; + return CharType::Unknown; } bool MathParser::IsDelimiter(WCHAR ch) { CharType type = GetCharType(ch); - return type == CH_SYMBOL || type == CH_SEPARAT; + return type == CharType::Symbol || type == CharType::Separator; } BYTE GetFunctionIndex(const WCHAR* str, BYTE len) @@ -761,31 +762,66 @@ BYTE GetFunctionIndex(const WCHAR* str, BYTE len) return FUNC_INVALID; } -int FindSymbol(const WCHAR* str) +Operator GetOperator(const WCHAR* str) { switch (str[0]) { - case L'(': return OP_OBR; - case L'+': return OP_ADD; - case L'-': return OP_SUB; - case L'*': return (str[1] == L'*') ? OP_POW : OP_MUL; - case L'/': return OP_DIV; - case L'%': return OP_MOD; - case L'$': return OP_UNK; - case L'^': return OP_XOR; - case L'~': return OP_NOT; - case L'&': return (str[1] == L'&') ? OP_LOGIC_AND : OP_AND; - case L'|': return (str[1] == L'|') ? OP_LOGIC_OR : OP_OR; - case L'=': return OP_EQU; - case L'>': return (str[1] == L'>') ? OP_SHR : (str[1] == L'=') ? OP_LOGIC_GEQ : OP_GREATER; - case L'<': return (str[1] == L'>') ? OP_LOGIC_NEQ : (str[1] == L'<') ? OP_SHL : (str[1] == L'=') ? OP_LOGIC_LEQ : OP_SMALLER; - case L'?': return OP_LOGIC; - case L':': return OP_LOGIC_SEP; - case L')': return OP_CBR; - case L',': return OP_COMMA; + case L'(': + return Operator::OpeningBracket; + + case L'+': + return Operator::Addition; + + case L'-': + return Operator::Subtraction; + + case L'*': + return (str[1] == L'*') ? Operator::Power : Operator::Multiplication; + + case L'/': + return Operator::Division; + + case L'%': + return Operator::Modulo; + + case L'$': + return Operator::UNK; + + case L'^': + return Operator::BitwiseXOR; + + case L'~': + return Operator::BitwiseNOT; + + case L'&': + return (str[1] == L'&') ? Operator::LogicalAND : Operator::BitwiseAND; + + case L'|': + return (str[1] == L'|') ? Operator::LogicalOR : Operator::BitwiseOR; + + case L'=': + return Operator::Equal; + + case L'>': + return (str[1] == L'>') ? Operator::ShiftRight : (str[1] == L'=') ? Operator::GreatorOrEqual : Operator::Greater; + + case L'<': + return (str[1] == L'>') ? Operator::NotEqual : (str[1] == L'<') ? Operator::ShiftLeft : (str[1] == L'=') ? Operator::LessOrEqual : Operator::Less; + + case L'?': + return Operator::Conditional; + + case L':': + return Operator::ConditionalSeparator; + + case L')': + return Operator::ClosingBracket; + + case L',': + return Operator::Comma; } - return -1; + return Operator::Invalid; } // -----------------------------------------------------------------------------------------------