Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2024-11-28 17:40:51 +01:00
Code Releases Wiki Activity

Added unary operators +, -, ~ and !

Browse Source
This commit is contained in:
WerWolv 2021-01-07 00:41:06 +01:00
parent acfd5aa02f
commit b30bb21646
5 changed files with 34 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/lang/parser.hpp
View File

@ -56,6 +56,7 @@ namespace hex::lang {
ASTNode* parseScopeResolution(std::vector<std::string> &path);
ASTNode* parseRValue(std::vector<std::string> &path);
ASTNode* parseFactor();
ASTNode* parseUnaryExpression();
ASTNode* parseMultiplicativeExpression();
ASTNode* parseAdditiveExpression();
ASTNode* parseShiftExpression();

6
include/lang/token.hpp
View File

@ -45,6 +45,7 @@ namespace hex::lang {
BitOr,
BitAnd,
BitXor,
BitNot,
BoolEquals,
BoolNotEquals,
BoolGreaterThan,
@ -53,7 +54,8 @@ namespace hex::lang {
BoolLessThanOrEquals,
BoolAnd,
BoolOr,
BoolXor
BoolXor,
BoolNot
};
enum class ValueType {
@ -204,6 +206,7 @@ namespace hex::lang {
#define OPERATOR_BITOR COMPONENT(Operator, BitOr)
#define OPERATOR_BITAND COMPONENT(Operator, BitAnd)
#define OPERATOR_BITXOR COMPONENT(Operator, BitXor)
#define OPERATOR_BITNOT COMPONENT(Operator, BitNot)
#define OPERATOR_BOOLEQUALS COMPONENT(Operator, BoolEquals)
#define OPERATOR_BOOLNOTEQUALS COMPONENT(Operator, BoolNotEquals)
#define OPERATOR_BOOLGREATERTHAN COMPONENT(Operator, BoolGreaterThan)
@ -213,6 +216,7 @@ namespace hex::lang {
#define OPERATOR_BOOLAND COMPONENT(Operator, BoolAnd)
#define OPERATOR_BOOLOR COMPONENT(Operator, BoolOr)
#define OPERATOR_BOOLXOR COMPONENT(Operator, BoolXor)
#define OPERATOR_BOOLNOT COMPONENT(Operator, BoolNot)
#define VALUETYPE_CUSTOMTYPE COMPONENT(ValueType, CustomType)
#define VALUETYPE_PADDING COMPONENT(ValueType, Padding)

8
source/lang/evaluator.cpp
View File

@ -123,6 +123,10 @@ namespace hex::lang {
return left ^ right;
}
FLOAT_BIT_OPERATION(bitNot) {
return ~right;
}
}
ASTNodeIntegerLiteral* Evaluator::evaluateOperator(ASTNodeIntegerLiteral *left, ASTNodeIntegerLiteral *right, Token::Operator op) {
@ -170,6 +174,8 @@ namespace hex::lang {
return new ASTNodeIntegerLiteral({ newType, bitXor(leftValue, rightValue) });
case Token::Operator::BitOr:
return new ASTNodeIntegerLiteral({ newType, bitOr(leftValue, rightValue) });
case Token::Operator::BitNot:
return new ASTNodeIntegerLiteral({ newType, bitNot(leftValue, rightValue) });
case Token::Operator::BoolEquals:
return new ASTNodeIntegerLiteral({ newType, leftValue == rightValue });
case Token::Operator::BoolNotEquals:
@ -188,6 +194,8 @@ namespace hex::lang {
return new ASTNodeIntegerLiteral({ newType, leftValue && !rightValue || !leftValue && rightValue });
case Token::Operator::BoolOr:
return new ASTNodeIntegerLiteral({ newType, leftValue || rightValue });
case Token::Operator::BoolNot:
return new ASTNodeIntegerLiteral({ newType, !rightValue });
default:
throwEvaluateError("invalid operator used in mathematical expression", left->getLineNumber());
}

6
source/lang/lexer.cpp
View File

@ -242,6 +242,9 @@ namespace hex::lang {
} else if (c == '<') {
tokens.emplace_back(TOKEN(Operator, BoolLessThan));
offset += 1;
} else if (c == '!') {
tokens.emplace_back(TOKEN(Operator, BoolNot));
offset += 1;
} else if (c == '|') {
tokens.emplace_back(TOKEN(Operator, BitOr));
offset += 1;
@ -251,6 +254,9 @@ namespace hex::lang {
} else if (c == '^') {
tokens.emplace_back(TOKEN(Operator, BitXor));
offset += 1;
} else if (c == '~') {
tokens.emplace_back(TOKEN(Operator, BitNot));
offset += 1;
} else if (c == '\'') {
offset += 1;

17
source/lang/parser.cpp
View File

@ -68,13 +68,24 @@ namespace hex::lang {
throwParseError("expected integer or parenthesis");
}
// (parseFactor) <*|/> (parseFactor)
// <+|-|!|~> (parseFactor)
ASTNode* Parser::parseUnaryExpression() {
if (MATCHES(sequence(OPERATOR_PLUS) || sequence(OPERATOR_MINUS) || sequence(OPERATOR_BOOLNOT) || sequence(OPERATOR_BITNOT))) {
auto op = getValue<Token::Operator>(-1);
return new ASTNodeNumericExpression(new ASTNodeIntegerLiteral({ Token::ValueType::Signed32Bit, 0}), this->parseFactor(), op);
}
return this->parseFactor();
}
// (parseUnaryExpression) <*|/> (parseUnaryExpression)
ASTNode* Parser::parseMultiplicativeExpression() {
auto node = this->parseFactor();
auto node = this->parseUnaryExpression();
while (MATCHES(variant(OPERATOR_STAR, OPERATOR_SLASH))) {
auto op = getValue<Token::Operator>(-1);
node = new ASTNodeNumericExpression(node, this->parseFactor(), op);
node = new ASTNodeNumericExpression(node, this->parseUnaryExpression(), op);
}
return node;