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

pattern: Fixed many code inconsistencies and bugs

Browse Source
This commit is contained in:
WerWolv 2022-01-31 14:37:12 +01:00
parent 8f8f3c5415
commit 61fc479c79
22 changed files with 303 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -31,7 +31,6 @@ add_subdirectory(main)
add_custom_target(imhex ALL DEPENDS main)
# Add unit tests
enable_testing()
add_subdirectory(tests EXCLUDE_FROM_ALL)
# Configure packaging

11
lib/libimhex/include/hex/helpers/concepts.hpp
View File

@ -159,3 +159,14 @@ namespace hex {
concept has_size = sizeof(T) == Size;
}
namespace hex {
template<typename T>
class Cloneable {
public:
[[nodiscard]] virtual T* clone() const = 0;
};
}

103
lib/libimhex/include/hex/pattern_language/ast_node.hpp
View File

@ -3,6 +3,7 @@
#include <hex/pattern_language/token.hpp>
#include <hex/pattern_language/evaluator.hpp>
#include <hex/pattern_language/pattern_data.hpp>
#include <hex/helpers/concepts.hpp>
#include <algorithm>
#include <bit>
@ -18,14 +19,7 @@ namespace hex::pl {
class PatternData;
class Evaluator;
class ASTNode;
class Clonable {
public:
[[nodiscard]] virtual ASTNode *clone() const = 0;
};
class ASTNode : public Clonable {
class ASTNode : public Cloneable<ASTNode> {
public:
constexpr ASTNode() = default;
@ -42,7 +36,7 @@ namespace hex::pl {
[[nodiscard]] virtual std::vector<PatternData *> createPatterns(Evaluator *evaluator) const { return {}; }
using FunctionResult = std::optional<Token::Literal>;
virtual FunctionResult execute(Evaluator *evaluator) const { evaluator->getConsole().abortEvaluation("cannot execute non-function statement", this); }
virtual FunctionResult execute(Evaluator *evaluator) const { LogConsole::abortEvaluation("cannot execute non-function statement", this); }
private:
u32 m_lineNumber = 1;
@ -86,8 +80,12 @@ namespace hex::pl {
}
Attributable(const Attributable &other) {
for (auto &attribute : other.m_attributes)
this->m_attributes.push_back(static_cast<ASTNodeAttribute *>(attribute->clone()));
for (auto &attribute : other.m_attributes) {
if (auto node = dynamic_cast<ASTNodeAttribute*>(attribute->clone()))
this->m_attributes.push_back(node);
else
delete node;
}
}
public:
@ -203,17 +201,17 @@ namespace hex::pl {
[this](double left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](char left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](bool left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](std::string left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](const std::string &left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, u128 right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, i128 right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, double right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, char right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, bool right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, std::string right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, PatternData *right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, const std::string &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](PatternData *const &left, PatternData *const &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](auto &&left, std::string right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](std::string left, auto &&right) -> ASTNode * {
[this](auto &&left, const std::string &right) -> ASTNode * { LogConsole::abortEvaluation("invalid operand used in mathematical expression", this); },
[this](const std::string &left, auto &&right) -> ASTNode * {
switch (this->getOperator()) {
case Token::Operator::Star:
{
@ -226,7 +224,7 @@ namespace hex::pl {
LogConsole::abortEvaluation("invalid operand used in mathematical expression", this);
}
},
[this](std::string left, std::string right) -> ASTNode * {
[this](const std::string &left, const std::string &right) -> ASTNode * {
switch (this->getOperator()) {
case Token::Operator::Plus:
return new ASTNodeLiteral(left + right);
@ -246,7 +244,7 @@ namespace hex::pl {
LogConsole::abortEvaluation("invalid operand used in mathematical expression", this);
}
},
[this](std::string left, char right) -> ASTNode * {
[this](const std::string &left, char right) -> ASTNode * {
switch (this->getOperator()) {
case Token::Operator::Plus:
return new ASTNodeLiteral(left + right);
@ -254,7 +252,7 @@ namespace hex::pl {
LogConsole::abortEvaluation("invalid operand used in mathematical expression", this);
}
},
[this](char left, std::string right) -> ASTNode * {
[this](char left, const std::string &right) -> ASTNode * {
switch (this->getOperator()) {
case Token::Operator::Plus:
return new ASTNodeLiteral(left + right);
@ -361,7 +359,7 @@ namespace hex::pl {
};
auto condition = std::visit(overloaded {
[this](std::string value) -> bool { return !value.empty(); },
[](const std::string &value) -> bool { return !value.empty(); },
[this](PatternData *const &) -> bool { LogConsole::abortEvaluation("cannot cast custom type to bool", this); },
[](auto &&value) -> bool { return bool(value); } },
first->getValue());
@ -456,8 +454,12 @@ namespace hex::pl {
auto type = this->m_type->evaluate(evaluator);
if (auto attributable = dynamic_cast<Attributable *>(type)) {
for (auto &attribute : this->getAttributes())
attributable->addAttribute(static_cast<ASTNodeAttribute *>(attribute->clone()));
for (auto &attribute : this->getAttributes()) {
if (auto node = dynamic_cast<ASTNodeAttribute*>(attribute->clone()))
attributable->addAttribute(node);
else
delete node;
}
}
return type;
@ -489,7 +491,7 @@ namespace hex::pl {
class ASTNodeCast : public ASTNode {
public:
ASTNodeCast(ASTNode *value, ASTNode *type) : m_value(value), m_type(type) { }
ASTNodeCast(const ASTNodeCast &other) {
ASTNodeCast(const ASTNodeCast &other) : ASTNode(other) {
this->m_value = other.m_value->clone();
this->m_type = other.m_type->clone();
}
@ -623,7 +625,7 @@ namespace hex::pl {
auto parameterPack = evaluator->getScope(0).parameterPack;
u32 startVariableCount = variables.size();
ON_SCOPE_EXIT {
i64 stackSize = evaluator->getStack().size();
ssize_t stackSize = evaluator->getStack().size();
for (u32 i = startVariableCount; i < variables.size(); i++) {
stackSize--;
delete variables[i];
@ -671,7 +673,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete literal; };
return std::visit(overloaded {
[](std::string value) -> bool { return !value.empty(); },
[](const std::string &value) -> bool { return !value.empty(); },
[this](PatternData *const &) -> bool { LogConsole::abortEvaluation("cannot cast custom type to bool", this); },
[](auto &&value) -> bool { return value != 0; } },
literal->getValue());
@ -784,6 +786,9 @@ namespace hex::pl {
this->m_placementOffset = other.m_placementOffset->clone();
else
this->m_placementOffset = nullptr;
this->m_inVariable = other.m_inVariable;
this->m_outVariable = other.m_outVariable;
}
~ASTNodeVariableDecl() override {
@ -808,7 +813,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete offset; };
evaluator->dataOffset() = std::visit(overloaded {
[this](std::string) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](const std::string &) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](PatternData *const &) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a custom type", this); },
[](auto &&offset) -> u64 { return offset; } },
offset->getValue());
@ -833,7 +838,7 @@ namespace hex::pl {
ASTNode *m_type;
ASTNode *m_placementOffset;
bool m_inVariable, m_outVariable;
bool m_inVariable = false, m_outVariable = false;
};
class ASTNodeArrayVariableDecl : public ASTNode,
@ -872,7 +877,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete offset; };
evaluator->dataOffset() = std::visit(overloaded {
[this](std::string) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](const std::string &) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](PatternData *const &) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a custom type", this); },
[](auto &&offset) -> u64 { return offset; } },
offset->getValue());
@ -930,7 +935,7 @@ namespace hex::pl {
if (auto literal = dynamic_cast<ASTNodeLiteral *>(sizeNode)) {
entryCount = std::visit(overloaded {
[this](std::string) -> u128 { LogConsole::abortEvaluation("cannot use string to index array", this); },
[this](const std::string &) -> u128 { LogConsole::abortEvaluation("cannot use string to index array", this); },
[this](PatternData *) -> u128 { LogConsole::abortEvaluation("cannot use custom type to index array", this); },
[](auto &&size) -> u128 { return size; } },
literal->getValue());
@ -1029,7 +1034,7 @@ namespace hex::pl {
if (auto literal = dynamic_cast<ASTNodeLiteral *>(sizeNode)) {
auto entryCount = std::visit(overloaded {
[this](std::string) -> u128 { LogConsole::abortEvaluation("cannot use string to index array", this); },
[this](const std::string &) -> u128 { LogConsole::abortEvaluation("cannot use string to index array", this); },
[this](PatternData *) -> u128 { LogConsole::abortEvaluation("cannot use custom type to index array", this); },
[](auto &&size) -> u128 { return size; } },
literal->getValue());
@ -1176,7 +1181,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete offset; };
evaluator->dataOffset() = std::visit(overloaded {
[this](std::string) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](const std::string &) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a string", this); },
[this](PatternData *) -> u64 { LogConsole::abortEvaluation("placement offset cannot be a custom type", this); },
[](auto &&offset) -> u64 { return u64(offset); } },
offset->getValue());
@ -1499,7 +1504,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete literal; };
u8 bitSize = std::visit(overloaded {
[this](std::string) -> u8 { LogConsole::abortEvaluation("bitfield field size cannot be a string", this); },
[this](const std::string &) -> u8 { LogConsole::abortEvaluation("bitfield field size cannot be a string", this); },
[this](PatternData *) -> u8 { LogConsole::abortEvaluation("bitfield field size cannot be a custom type", this); },
[](auto &&offset) -> u8 { return static_cast<u8>(offset); } },
dynamic_cast<ASTNodeLiteral *>(literal)->getValue());
@ -1531,13 +1536,13 @@ namespace hex::pl {
class ASTNodeParameterPack : public ASTNode {
public:
ASTNodeParameterPack(const std::vector<Token::Literal> &values) : m_values(values) {}
explicit ASTNodeParameterPack(std::vector<Token::Literal> values) : m_values(std::move(values)) {}
[[nodiscard]] ASTNode *clone() const override {
return new ASTNodeParameterPack(*this);
}
const std::vector<Token::Literal> &getValues() const {
[[nodiscard]] const std::vector<Token::Literal> &getValues() const {
return this->m_values;
}
@ -1622,7 +1627,7 @@ namespace hex::pl {
std::visit(overloaded {
[&](char assignmentValue) { if (assignmentValue != 0x00) value = std::string({ assignmentValue }); },
[&](std::string assignmentValue) { value = assignmentValue; },
[&](const std::string &assignmentValue) { value = assignmentValue; },
[&, this](PatternData *const &assignmentValue) {
if (!dynamic_cast<PatternDataString *>(assignmentValue) && !dynamic_cast<PatternDataCharacter *>(assignmentValue))
LogConsole::abortEvaluation(hex::format("cannot assign '{}' to string", pattern->getTypeName()), this);
@ -1646,7 +1651,7 @@ namespace hex::pl {
literal = pattern->clone();
}
if (auto transformFunc = pattern->getTransformFunction(); transformFunc.has_value() && pattern->getEvaluator() != nullptr) {
if (auto transformFunc = pattern->getTransformFunction(); transformFunc.has_value()) {
auto result = transformFunc->func(evaluator, { literal });
if (!result.has_value())
@ -1730,8 +1735,8 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete index; };
std::visit(overloaded {
[](std::string) { throw std::string("cannot use string to index array"); },
[](PatternData *const &) { throw std::string("cannot use custom type to index array"); },
[this](const std::string &) { LogConsole::abortEvaluation("cannot use string to index array", this); },
[this](PatternData *const &) { LogConsole::abortEvaluation("cannot use custom type to index array", this); },
[&, this](auto &&index) {
if (auto dynamicArrayPattern = dynamic_cast<PatternDataDynamicArray *>(currPattern)) {
if (index >= searchScope.size() || index < 0)
@ -1825,7 +1830,7 @@ namespace hex::pl {
public:
explicit ASTNodeScopeResolution(ASTNode *type, std::string name) : ASTNode(), m_type(type), m_name(std::move(name)) { }
ASTNodeScopeResolution(const ASTNodeScopeResolution &other) {
ASTNodeScopeResolution(const ASTNodeScopeResolution &other) : ASTNode(other) {
this->m_type = other.m_type->clone();
this->m_name = other.m_name;
}
@ -1904,14 +1909,6 @@ namespace hex::pl {
return this->m_condition;
}
[[nodiscard]] const std::vector<ASTNode *> &getTrueBody() const {
return this->m_trueBody;
}
[[nodiscard]] const std::vector<ASTNode *> &getFalseBody() const {
return this->m_falseBody;
}
FunctionResult execute(Evaluator *evaluator) const override {
auto &body = evaluateCondition(evaluator) ? this->m_trueBody : this->m_falseBody;
@ -1948,7 +1945,7 @@ namespace hex::pl {
ON_SCOPE_EXIT { delete literal; };
return std::visit(overloaded {
[](std::string value) -> bool { return !value.empty(); },
[](const std::string &value) -> bool { return !value.empty(); },
[this](PatternData *const &) -> bool { LogConsole::abortEvaluation("cannot cast custom type to bool", this); },
[](auto &&value) -> bool { return value != 0; } },
literal->getValue());
@ -2308,9 +2305,9 @@ namespace hex::pl {
if (ctx->getCurrentControlFlowStatement() != ControlFlowStatement::None) {
switch (ctx->getCurrentControlFlowStatement()) {
case ControlFlowStatement::Break:
ctx->getConsole().abortEvaluation("break statement not within a loop", statement);
LogConsole::abortEvaluation("break statement not within a loop", statement);
case ControlFlowStatement::Continue:
ctx->getConsole().abortEvaluation("continue statement not within a loop", statement);
LogConsole::abortEvaluation("continue statement not within a loop", statement);
default:
break;
}
@ -2336,13 +2333,15 @@ namespace hex::pl {
class ASTNodeCompoundStatement : public ASTNode {
public:
ASTNodeCompoundStatement(std::vector<ASTNode *> statements, bool newScope = false) : m_statements(std::move(statements)), m_newScope(newScope) {
explicit ASTNodeCompoundStatement(std::vector<ASTNode *> statements, bool newScope = false) : m_statements(std::move(statements)), m_newScope(newScope) {
}
ASTNodeCompoundStatement(const ASTNodeCompoundStatement &other) : ASTNode(other) {
for (const auto &statement : other.m_statements) {
this->m_statements.push_back(statement->clone());
}
this->m_newScope = other.m_newScope;
}
[[nodiscard]] ASTNode *clone() const override {
@ -2410,7 +2409,7 @@ namespace hex::pl {
public:
std::vector<ASTNode *> m_statements;
bool m_newScope;
bool m_newScope = false;
};
};

27
lib/libimhex/include/hex/pattern_language/error.hpp Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <hex.hpp>
#include <stdexcept>
#include <string>
namespace hex::pl {
class PatternLanguageError : public std::exception {
public:
PatternLanguageError(u32 lineNumber, std::string message) : m_lineNumber(lineNumber), m_message(std::move(message)) { }
[[nodiscard]] const char *what() const noexcept override {
return this->m_message.c_str();
}
[[nodiscard]] u32 getLineNumber() const {
return this->m_lineNumber;
}
private:
u32 m_lineNumber;
std::string m_message;
};
}

10
lib/libimhex/include/hex/pattern_language/lexer.hpp
View File

@ -12,18 +12,16 @@ namespace hex::pl {
class Lexer {
public:
using LexerError = std::pair<u32, std::string>;
Lexer() = default;
std::optional<std::vector<Token>> lex(const std::string &code);
const std::optional<LexerError> &getError() { return this->m_error; }
const std::optional<PatternLanguageError> &getError() { return this->m_error; }
private:
std::optional<LexerError> m_error;
std::optional<PatternLanguageError> m_error;
[[noreturn]] void throwLexerError(const std::string &error, u32 lineNumber) const {
throw LexerError(lineNumber, "Lexer: " + error);
[[noreturn]] static void throwLexerError(const std::string &error, u32 lineNumber) {
throw PatternLanguageError(lineNumber, "Lexer: " + error);
}
};

10
lib/libimhex/include/hex/pattern_language/log_console.hpp
View File

@ -8,6 +8,8 @@
#include <utility>
#include <vector>
#include <hex/pattern_language/error.hpp>
namespace hex::pl {
class ASTNode;
@ -23,8 +25,6 @@ namespace hex::pl {
[[nodiscard]] const auto &getLog() const { return this->m_consoleLog; }
using EvaluateError = std::pair<u32, std::string>;
void log(Level level, const std::string &message);
[[noreturn]] static void abortEvaluation(const std::string &message);
@ -33,13 +33,13 @@ namespace hex::pl {
void clear();
void setHardError(const EvaluateError &error) { this->m_lastHardError = error; }
void setHardError(const PatternLanguageError &error) { this->m_lastHardError = error; }
[[nodiscard]] const std::optional<EvaluateError> &getLastHardError() { return this->m_lastHardError; };
[[nodiscard]] const std::optional<PatternLanguageError> &getLastHardError() { return this->m_lastHardError; };
private:
std::vector<std::pair<Level, std::string>> m_consoleLog;
std::optional<EvaluateError> m_lastHardError;
std::optional<PatternLanguageError> m_lastHardError;
};
}

12
lib/libimhex/include/hex/pattern_language/parser.hpp
View File

@ -3,6 +3,7 @@
#include <hex.hpp>
#include <hex/helpers/utils.hpp>
#include <hex/pattern_language/error.hpp>
#include <hex/pattern_language/token.hpp>
#include <hex/pattern_language/ast_node.hpp>
@ -16,16 +17,15 @@ namespace hex::pl {
class Parser {
public:
using TokenIter = std::vector<Token>::const_iterator;
using ParseError = std::pair<u32, std::string>;
Parser() = default;
~Parser() = default;
std::optional<std::vector<ASTNode *>> parse(const std::vector<Token> &tokens);
const std::optional<ParseError> &getError() { return this->m_error; }
const std::optional<PatternLanguageError> &getError() { return this->m_error; }
private:
std::optional<ParseError> m_error;
std::optional<PatternLanguageError> m_error;
TokenIter m_curr;
TokenIter m_originalPosition, m_partOriginalPosition;
@ -47,7 +47,7 @@ namespace hex::pl {
auto value = std::get_if<T>(&this->m_curr[index].value);
if (value == nullptr)
throwParseError("failed to decode token. Invalid type.", getLineNumber(index));
throwParserError("failed to decode token. Invalid type.", getLineNumber(index));
return *value;
}
@ -143,8 +143,8 @@ namespace hex::pl {
return program;
}
[[noreturn]] void throwParseError(const std::string &error, i32 token = -1) const {
throw ParseError(this->m_curr[token].lineNumber, "Parser: " + error);
[[noreturn]] void throwParserError(const std::string &error, i32 token = -1) const {
throw PatternLanguageError(this->m_curr[token].lineNumber, "Parser: " + error);
}
/* Token consuming */

92
lib/libimhex/include/hex/pattern_language/pattern_data.hpp
View File

@ -73,11 +73,16 @@ namespace hex::pl {
PatternCreationLimiter::s_evaluator->patternDestroyed();
}
[[nodiscard]]
static Evaluator *getEvaluator() {
return PatternCreationLimiter::s_evaluator;
}
public:
static Evaluator *s_evaluator;
};
class PatternData : public PatternCreationLimiter {
class PatternData : public PatternCreationLimiter, public Cloneable<PatternData> {
public:
PatternData(u64 offset, size_t size, u32 color = 0)
: PatternCreationLimiter(), m_offset(offset), m_size(size), m_color(color) {
@ -95,9 +100,7 @@ namespace hex::pl {
PatternData(const PatternData &other) = default;
virtual ~PatternData() = default;
virtual PatternData *clone() = 0;
~PatternData() override = default;
[[nodiscard]] u64 getOffset() const { return this->m_offset; }
virtual void setOffset(u64 offset) { this->m_offset = offset; }
@ -122,8 +125,8 @@ namespace hex::pl {
[[nodiscard]] bool hasOverriddenColor() const { return this->m_manualColor; }
[[nodiscard]] std::endian getEndian() const {
if (this->getEvaluator() == nullptr) return std::endian::native;
else return this->m_endian.value_or(this->getEvaluator()->getDefaultEndian());
if (PatternData::getEvaluator() == nullptr) return std::endian::native;
else return this->m_endian.value_or(PatternData::getEvaluator()->getDefaultEndian());
}
virtual void setEndian(std::endian endian) { this->m_endian = endian; }
[[nodiscard]] bool hasOverriddenEndian() const { return this->m_endian.has_value(); }
@ -131,8 +134,6 @@ namespace hex::pl {
[[nodiscard]] std::string getDisplayName() const { return this->m_displayName.value_or(this->m_variableName); }
void setDisplayName(const std::string &name) { this->m_displayName = name; }
[[nodiscard]] Evaluator *getEvaluator() const { return PatternCreationLimiter::s_evaluator; }
[[nodiscard]] const auto &getTransformFunction() const { return this->m_transformFunction; }
void setTransformFunction(const ContentRegistry::PatternLanguage::Function &function) { this->m_transformFunction = function; }
[[nodiscard]] const auto &getFormatterFunction() const { return this->m_formatterFunction; }
@ -154,7 +155,7 @@ namespace hex::pl {
for (u64 i = 0; i < this->getSize(); i++)
highlight.insert({ this->getOffset() + i, this->getColor() });
this->getEvaluator()->handleAbort();
PatternData::getEvaluator()->handleAbort();
}
virtual void sort(ImGuiTableSortSpecs *sortSpecs, prv::Provider *provider) { }
@ -255,7 +256,7 @@ namespace hex::pl {
return value;
else {
try {
auto result = this->m_formatterFunction->func(this->getEvaluator(), { literal });
auto result = this->m_formatterFunction->func(PatternData::getEvaluator(), { literal });
if (result.has_value()) {
if (auto displayValue = std::get_if<std::string>(&result.value()); displayValue != nullptr)
@ -265,8 +266,8 @@ namespace hex::pl {
} else {
return "???";
}
} catch (LogConsole::EvaluateError &error) {
return "Error: " + error.second;
} catch (PatternLanguageError &error) {
return "Error: "s + error.what();
}
}
}
@ -307,10 +308,10 @@ namespace hex::pl {
bool m_hidden = false;
private:
u64 m_offset;
size_t m_size;
u64 m_offset = 0x00;
size_t m_size = 0x00;
u32 m_color;
u32 m_color = 0x00;
std::optional<std::string> m_displayName;
std::string m_variableName;
std::optional<std::string> m_comment;
@ -327,7 +328,8 @@ namespace hex::pl {
public:
PatternDataPadding(u64 offset, size_t size) : PatternData(offset, size, 0xFF000000) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataPadding(*this);
}
@ -355,7 +357,8 @@ namespace hex::pl {
delete this->m_pointedAt;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataPointer(*this);
}
@ -476,7 +479,8 @@ namespace hex::pl {
PatternDataUnsigned(u64 offset, size_t size, u32 color = 0)
: PatternData(offset, size, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataUnsigned(*this);
}
@ -513,7 +517,8 @@ namespace hex::pl {
PatternDataSigned(u64 offset, size_t size, u32 color = 0)
: PatternData(offset, size, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataSigned(*this);
}
@ -551,7 +556,8 @@ namespace hex::pl {
PatternDataFloat(u64 offset, size_t size, u32 color = 0)
: PatternData(offset, size, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataFloat(*this);
}
@ -590,7 +596,8 @@ namespace hex::pl {
explicit PatternDataBoolean(u64 offset, u32 color = 0)
: PatternData(offset, 1, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataBoolean(*this);
}
@ -618,7 +625,8 @@ namespace hex::pl {
explicit PatternDataCharacter(u64 offset, u32 color = 0)
: PatternData(offset, 1, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataCharacter(*this);
}
@ -641,7 +649,8 @@ namespace hex::pl {
explicit PatternDataCharacter16(u64 offset, u32 color = 0)
: PatternData(offset, 2, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataCharacter16(*this);
}
@ -674,7 +683,8 @@ namespace hex::pl {
PatternDataString(u64 offset, size_t size, u32 color = 0)
: PatternData(offset, size, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataString(*this);
}
@ -714,7 +724,8 @@ namespace hex::pl {
PatternDataString16(u64 offset, size_t size, u32 color = 0)
: PatternData(offset, size, color) { }
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataString16(*this);
}
@ -780,7 +791,8 @@ namespace hex::pl {
delete entry;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataDynamicArray(*this);
}
@ -893,7 +905,7 @@ namespace hex::pl {
[[nodiscard]] const PatternData *getPattern(u64 offset) const override {
if (this->isHidden()) return nullptr;
auto iter = std::find_if(this->m_entries.begin(), this->m_entries.end(), [this, offset](PatternData *pattern) {
auto iter = std::find_if(this->m_entries.begin(), this->m_entries.end(), [offset](PatternData *pattern) {
return offset >= pattern->getOffset() && offset < (pattern->getOffset() + pattern->getSize());
});
@ -932,7 +944,8 @@ namespace hex::pl {
delete this->m_highlightTemplate;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataStaticArray(*this);
}
@ -1067,9 +1080,9 @@ namespace hex::pl {
}
private:
PatternData *m_template;
mutable PatternData *m_highlightTemplate;
size_t m_entryCount;
PatternData *m_template = nullptr;
mutable PatternData *m_highlightTemplate = nullptr;
size_t m_entryCount = 0;
u64 m_displayEnd = 50;
};
@ -1091,7 +1104,8 @@ namespace hex::pl {
delete member;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataStruct(*this);
}
@ -1238,7 +1252,8 @@ namespace hex::pl {
delete member;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataUnion(*this);
}
@ -1375,7 +1390,8 @@ namespace hex::pl {
: PatternData(offset, size, color) {
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataEnum(*this);
}
@ -1398,7 +1414,7 @@ namespace hex::pl {
return false;
},
[](std::string) { return false; },
[](std::string&) { return false; },
[](PatternData *) { return false; } },
entryValueLiteral);
if (matches)
@ -1470,7 +1486,8 @@ namespace hex::pl {
: m_bitOffset(bitOffset), m_bitSize(bitSize), m_bitField(bitField), PatternData(offset, 0, color) {
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataBitfieldField(*this);
}
@ -1549,7 +1566,8 @@ namespace hex::pl {
delete field;
}
PatternData *clone() override {
[[nodiscard]]
PatternData *clone() const override {
return new PatternDataBitfield(*this);
}

4
lib/libimhex/include/hex/pattern_language/pattern_language.hpp
View File

@ -40,7 +40,7 @@ namespace hex::pl {
void abort();
[[nodiscard]] const std::vector<std::pair<LogConsole::Level, std::string>> &getConsoleLog();
[[nodiscard]] const std::optional<std::pair<u32, std::string>> &getError();
[[nodiscard]] const std::optional<PatternLanguageError> &getError();
[[nodiscard]] std::map<std::string, Token::Literal> getOutVariables() const;
[[nodiscard]] u32 getCreatedPatternCount();
@ -58,7 +58,7 @@ namespace hex::pl {
std::vector<ASTNode *> m_currAST;
std::optional<std::pair<u32, std::string>> m_currError;
std::optional<PatternLanguageError> m_currError;
};
}

14
lib/libimhex/include/hex/pattern_language/preprocessor.hpp
View File

@ -11,24 +11,24 @@
#include <hex/helpers/paths.hpp>
#include <hex/pattern_language/error.hpp>
namespace hex::pl {
class Preprocessor {
public:
Preprocessor();
Preprocessor() = default;
std::optional<std::string> preprocess(const std::string &code, bool initialRun = true);
void addPragmaHandler(const std::string &pragmaType, const std::function<bool(const std::string &)> &function);
void addDefaultPragmaHandlers();
const std::pair<u32, std::string> &getError() { return this->m_error; }
const std::optional<PatternLanguageError> &getError() { return this->m_error; }
private:
using PreprocessorError = std::pair<u32, std::string>;
[[noreturn]] void throwPreprocessorError(const std::string &error, u32 lineNumber) const {
throw PreprocessorError(lineNumber, "Preprocessor: " + error);
[[noreturn]] static void throwPreprocessorError(const std::string &error, u32 lineNumber) {
throw PatternLanguageError(lineNumber, "Preprocessor: " + error);
}
std::unordered_map<std::string, std::function<bool(std::string)>> m_pragmaHandlers;
@ -38,7 +38,7 @@ namespace hex::pl {
std::set<fs::path> m_onceIncludedFiles;
std::pair<u32, std::string> m_error;
std::optional<PatternLanguageError> m_error;
};
}

41
lib/libimhex/include/hex/pattern_language/token.hpp
View File

@ -7,6 +7,7 @@
#include <variant>
#include <hex/helpers/utils.hpp>
#include <hex/pattern_language/log_console.hpp>
namespace hex::pl {
@ -156,48 +157,48 @@ namespace hex::pl {
static u128 literalToUnsigned(const pl::Token::Literal &literal) {
return std::visit(overloaded {
[](std::string) -> u128 { throw std::string("expected integral type, got string"); },
[](PatternData *) -> u128 { throw std::string("expected integral type, got custom type"); },
[](auto &&value) -> u128 { return value; } },
[](const std::string &) -> u128 { LogConsole::abortEvaluation("expected integral type, got string"); },
[](PatternData *) -> u128 { LogConsole::abortEvaluation("expected integral type, got custom type"); },
[](auto &&result) -> u128 { return result; } },
literal);
}
static i128 literalToSigned(const pl::Token::Literal &literal) {
return std::visit(overloaded {
[](std::string) -> i128 { throw std::string("expected integral type, got string"); },
[](PatternData *) -> i128 { throw std::string("expected integral type, got custom type"); },
[](auto &&value) -> i128 { return value; } },
[](const std::string &) -> i128 { LogConsole::abortEvaluation("expected integral type, got string"); },
[](PatternData *) -> i128 { LogConsole::abortEvaluation("expected integral type, got custom type"); },
[](auto &&result) -> i128 { return result; } },
literal);
}
static double literalToFloatingPoint(const pl::Token::Literal &literal) {
return std::visit(overloaded {
[](std::string) -> double { throw std::string("expected integral type, got string"); },
[](PatternData *) -> double { throw std::string("expected integral type, got custom type"); },
[](auto &&value) -> double { return value; } },
[](const std::string &) -> double { LogConsole::abortEvaluation("expected integral type, got string"); },
[](PatternData *) -> double { LogConsole::abortEvaluation("expected integral type, got custom type"); },
[](auto &&result) -> double { return result; } },
literal);
}
static bool literalToBoolean(const pl::Token::Literal &literal) {
return std::visit(overloaded {
[](std::string) -> bool { throw std::string("expected integral type, got string"); },
[](PatternData *) -> bool { throw std::string("expected integral type, got custom type"); },
[](auto &&value) -> bool { return value != 0; } },
[](const std::string &) -> bool { LogConsole::abortEvaluation("expected integral type, got string"); },
[](PatternData *) -> bool { LogConsole::abortEvaluation("expected integral type, got custom type"); },
[](auto &&result) -> bool { return result != 0; } },
literal);
}
static std::string literalToString(const pl::Token::Literal &literal, bool cast) {
if (!cast && std::get_if<std::string>(&literal) == nullptr)
throw std::string("expected string type, got integral");
LogConsole::abortEvaluation("expected string type, got integral");
return std::visit(overloaded {
[](std::string value) -> std::string { return value; },
[](u128 value) -> std::string { return std::to_string(u64(value)); },
[](i128 value) -> std::string { return std::to_string(i64(value)); },
[](bool value) -> std::string { return value ? "true" : "false"; },
[](char value) -> std::string { return std::string() + value; },
[](PatternData *) -> std::string { throw std::string("expected integral type, got custom type"); },
[](auto &&value) -> std::string { return std::to_string(value); } },
[](std::string result) -> std::string { return result; },
[](u128 result) -> std::string { return hex::to_string(result); },
[](i128 result) -> std::string { return hex::to_string(result); },
[](bool result) -> std::string { return result ? "true" : "false"; },
[](char result) -> std::string { return { 1, result }; },
[](PatternData *) -> std::string { LogConsole::abortEvaluation("expected integral type, got custom type"); },
[](auto &&result) -> std::string { return std::to_string(result); } },
literal);
}

15
lib/libimhex/include/hex/pattern_language/validator.hpp
View File

@ -2,28 +2,29 @@
#include <hex.hpp>
#include <optional>
#include <string>
#include <vector>
#include <hex/pattern_language/error.hpp>
namespace hex::pl {
class ASTNode;
class Validator {
public:
Validator();
Validator() = default;
bool validate(const std::vector<ASTNode *> &ast);
const std::pair<u32, std::string> &getError() { return this->m_error; }
const std::optional<PatternLanguageError> &getError() { return this->m_error; }
private:
std::pair<u32, std::string> m_error;
std::optional<PatternLanguageError> m_error;
using ValidatorError = std::pair<u32, std::string>;
[[noreturn]] void throwValidateError(std::string_view error, u32 lineNumber) const {
throw ValidatorError(lineNumber, error);
[[noreturn]] static void throwValidatorError(const std::string &error, u32 lineNumber) {
throw PatternLanguageError(lineNumber, "Validator: " + error);
}
};

6
lib/libimhex/source/pattern_language/evaluator.cpp
View File

@ -206,10 +206,10 @@ namespace hex::pl {
}
popScope();
} catch (const LogConsole::EvaluateError &error) {
this->m_console.log(LogConsole::Level::Error, error.second);
} catch (PatternLanguageError &error) {
this->m_console.log(LogConsole::Level::Error, error.what());
if (error.first != 0)
if (error.getLineNumber() != 0)
this->m_console.setHardError(error);
for (auto &pattern : patterns)

15
lib/libimhex/source/pattern_language/lexer.cpp
View File

@ -10,7 +10,7 @@ namespace hex::pl {
#define TOKEN(type, value) Token::Type::type, Token::type::value, lineNumber
#define VALUE_TOKEN(type, value) Token::Type::type, value, lineNumber
std::string matchTillInvalid(const char *characters, std::function<bool(char)> predicate) {
std::string matchTillInvalid(const char *characters, const std::function<bool(char)> &predicate) {
std::string ret;
while (*characters != 0x00) {
@ -403,14 +403,14 @@ namespace hex::pl {
tokens.emplace_back(TOKEN(Operator, SizeOf));
offset += 6;
} else if (c == '\'') {
auto character = getCharacterLiteral(code.substr(offset));
auto lexedCharacter = getCharacterLiteral(code.substr(offset));
if (!character.has_value())
if (!lexedCharacter.has_value())
throwLexerError("invalid character literal", lineNumber);
auto [c, charSize] = character.value();
auto [character, charSize] = lexedCharacter.value();
tokens.emplace_back(VALUE_TOKEN(Integer, Token::Literal(c)));
tokens.emplace_back(VALUE_TOKEN(Integer, Token::Literal(character)));
offset += charSize;
} else if (c == '\"') {
auto string = getStringLiteral(code.substr(offset));
@ -530,9 +530,10 @@ namespace hex::pl {
}
tokens.emplace_back(TOKEN(Separator, EndOfProgram));
} catch (LexerError &e) {
} catch (PatternLanguageError &e) {
this->m_error = e;
return {};
return std::nullopt;
}

4
lib/libimhex/source/pattern_language/log_console.cpp
View File

@ -9,14 +9,14 @@ namespace hex::pl {
}
[[noreturn]] void LogConsole::abortEvaluation(const std::string &message) {
throw EvaluateError(0, message);
throw PatternLanguageError(0, message);
}
[[noreturn]] void LogConsole::abortEvaluation(const std::string &message, const ASTNode *node) {
if (node == nullptr)
abortEvaluation(message);
else
throw EvaluateError(node->getLineNumber(), message);
throw PatternLanguageError(node->getLineNumber(), message);
}
void LogConsole::clear() {

142
lib/libimhex/source/pattern_language/parser.cpp
View File

@ -20,7 +20,7 @@ namespace hex::pl {
std::string functionName = parseNamespaceResolution();
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETOPEN)))
throwParseError("expected '(' after function name");
throwParserError("expected '(' after function name");
std::vector<ASTNode *> params;
auto paramCleanup = SCOPE_GUARD {
@ -32,11 +32,11 @@ namespace hex::pl {
params.push_back(parseMathematicalExpression());
if (MATCHES(sequence(SEPARATOR_COMMA, SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("unexpected ',' at end of function parameter list", -1);
throwParserError("unexpected ',' at end of function parameter list", -1);
else if (MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
break;
else if (!MATCHES(sequence(SEPARATOR_COMMA)))
throwParseError("missing ',' between parameters", -1);
throwParserError("missing ',' between parameters", -1);
}
paramCleanup.release();
@ -76,7 +76,7 @@ namespace hex::pl {
continue;
} else {
if (!this->m_types.contains(typeName))
throwParseError(hex::format("cannot access scope of invalid type '{}'", typeName), -1);
throwParserError(hex::format("cannot access scope of invalid type '{}'", typeName), -1);
return create(new ASTNodeScopeResolution(this->m_types[typeName]->clone(), getValue<Token::Identifier>(-1).get()));
}
@ -84,7 +84,7 @@ namespace hex::pl {
break;
}
throwParseError("failed to parse scope resolution. Expected 'TypeName::Identifier'");
throwParserError("failed to parse scope resolution. Expected 'TypeName::Identifier'");
}
ASTNode *Parser::parseRValue() {
@ -104,14 +104,14 @@ namespace hex::pl {
if (MATCHES(sequence(SEPARATOR_SQUAREBRACKETOPEN))) {
path.push_back(parseMathematicalExpression());
if (!MATCHES(sequence(SEPARATOR_SQUAREBRACKETCLOSE)))
throwParseError("expected closing ']' at end of array indexing");
throwParserError("expected closing ']' at end of array indexing");
}
if (MATCHES(sequence(SEPARATOR_DOT))) {
if (MATCHES(oneOf(IDENTIFIER, KEYWORD_PARENT)))
return this->parseRValue(path);
else
throwParseError("expected member name or 'parent' keyword", -1);
throwParserError("expected member name or 'parent' keyword", -1);
} else
return create(new ASTNodeRValue(path));
}
@ -126,7 +126,7 @@ namespace hex::pl {
auto node = this->parseMathematicalExpression();
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE))) {
delete node;
throwParseError("expected closing parenthesis");
throwParserError("expected closing parenthesis");
}
return node;
} else if (MATCHES(sequence(IDENTIFIER))) {
@ -159,17 +159,17 @@ namespace hex::pl {
result = new ASTNodeLiteral(u128(Token::getTypeSize(type)));
} else {
throwParseError("expected rvalue identifier or built-in type");
throwParserError("expected rvalue identifier or built-in type");
}
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE))) {
delete result;
throwParseError("expected closing parenthesis");
throwParserError("expected closing parenthesis");
}
return result;
} else
throwParseError("expected value or parenthesis");
throwParserError("expected value or parenthesis");
}
ASTNode *Parser::parseCastExpression() {
@ -178,10 +178,10 @@ namespace hex::pl {
auto builtinType = dynamic_cast<ASTNodeBuiltinType *>(type->getType());
if (builtinType == nullptr)
throwParseError("invalid type used for pointer size", -1);
throwParserError("invalid type used for pointer size", -1);
if (!peek(SEPARATOR_ROUNDBRACKETOPEN))
throwParseError("expected '(' before cast expression", -1);
throwParserError("expected '(' before cast expression", -1);
auto node = parseFactor();
@ -382,7 +382,7 @@ namespace hex::pl {
auto second = this->parseBooleanOr();
if (!MATCHES(sequence(OPERATOR_INHERIT)))
throwParseError("expected ':' in ternary expression");
throwParserError("expected ':' in ternary expression");
auto third = this->parseBooleanOr();
node = create(new ASTNodeTernaryExpression(node, second, third, Token::Operator::TernaryConditional));
@ -401,11 +401,11 @@ namespace hex::pl {
// [[ <Identifier[( (parseStringLiteral) )], ...> ]]
void Parser::parseAttribute(Attributable *currNode) {
if (currNode == nullptr)
throwParseError("tried to apply attribute to invalid statement");
throwParserError("tried to apply attribute to invalid statement");
do {
if (!MATCHES(sequence(IDENTIFIER)))
throwParseError("expected attribute expression");
throwParserError("expected attribute expression");
auto attribute = getValue<Token::Identifier>(-1).get();
@ -414,7 +414,7 @@ namespace hex::pl {
auto string = std::get_if<std::string>(&value);
if (string == nullptr)
throwParseError("expected string attribute argument");
throwParserError("expected string attribute argument");
currNode->addAttribute(create(new ASTNodeAttribute(attribute, *string)));
} else
@ -423,7 +423,7 @@ namespace hex::pl {
} while (MATCHES(sequence(SEPARATOR_COMMA)));
if (!MATCHES(sequence(SEPARATOR_SQUAREBRACKETCLOSE, SEPARATOR_SQUAREBRACKETCLOSE)))
throwParseError("unfinished attribute. Expected ']]'");
throwParserError("unfinished attribute. Expected ']]'");
}
/* Functions */
@ -441,7 +441,7 @@ namespace hex::pl {
parameterPack = getValue<Token::Identifier>(-1).get();
if (MATCHES(sequence(SEPARATOR_COMMA)))
throwParseError("parameter pack can only appear at end of parameter list");
throwParserError("parameter pack can only appear at end of parameter list");
break;
} else {
@ -461,10 +461,10 @@ namespace hex::pl {
}
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("expected closing ')' after parameter list");
throwParserError("expected closing ')' after parameter list");
if (!MATCHES(sequence(SEPARATOR_CURLYBRACKETOPEN)))
throwParseError("expected opening '{' after function definition");
throwParserError("expected opening '{' after function definition");
// Parse function body
@ -496,7 +496,7 @@ namespace hex::pl {
statement = create(new ASTNodeCompoundStatement({ statement, create(new ASTNodeAssignment(identifier, expression)) }));
}
} else
throwParseError("invalid variable declaration");
throwParserError("invalid variable declaration");
return statement;
}
@ -539,11 +539,11 @@ namespace hex::pl {
} else if (peek(KEYWORD_BE) || peek(KEYWORD_LE) || peek(VALUETYPE_ANY)) {
statement = parseFunctionVariableDecl();
} else
throwParseError("invalid sequence", 0);
throwParserError("invalid sequence", 0);
if (needsSemicolon && !MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION))) {
delete statement;
throwParseError("missing ';' at end of expression", -1);
throwParserError("missing ';' at end of expression", -1);
}
// Consume superfluous semicolons
@ -576,7 +576,7 @@ namespace hex::pl {
else if (peek(KEYWORD_CONTINUE, -1))
type = ControlFlowStatement::Continue;
else
throwParseError("invalid control flow statement. Expected 'return', 'break' or 'continue'");
throwParserError("invalid control flow statement. Expected 'return', 'break' or 'continue'");
if (peek(SEPARATOR_ENDOFEXPRESSION))
return create(new ASTNodeControlFlowStatement(type, nullptr));
@ -618,7 +618,7 @@ namespace hex::pl {
};
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("expected closing ')' after statement head");
throwParserError("expected closing ')' after statement head");
trueBody = parseStatementBody();
@ -641,7 +641,7 @@ namespace hex::pl {
};
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("expected closing ')' after statement head");
throwParserError("expected closing ')' after statement head");
body = parseStatementBody();
@ -655,16 +655,16 @@ namespace hex::pl {
auto variableCleanup = SCOPE_GUARD { delete variable; };
if (!MATCHES(sequence(SEPARATOR_COMMA)))
throwParseError("expected ',' after for loop variable declaration");
throwParserError("expected ',' after for loop variable declaration");
auto condition = parseMathematicalExpression();
auto conditionCleanup = SCOPE_GUARD { delete condition; };
if (!MATCHES(sequence(SEPARATOR_COMMA)))
throwParseError("expected ',' after for loop condition");
throwParserError("expected ',' after for loop condition");
if (!MATCHES(sequence(IDENTIFIER, OPERATOR_ASSIGNMENT)))
throwParseError("expected for loop variable assignment");
throwParserError("expected for loop variable assignment");
auto postExpression = parseFunctionVariableAssignment(getValue<Token::Identifier>(-2).get());
auto postExpressionCleanup = SCOPE_GUARD { delete postExpression; };
@ -677,7 +677,7 @@ namespace hex::pl {
};
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("expected closing ')' after statement head");
throwParserError("expected closing ')' after statement head");
body = parseStatementBody();
@ -711,7 +711,7 @@ namespace hex::pl {
} else if (MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE))) {
trueBody.push_back(parseMember());
} else
throwParseError("expected body of conditional statement");
throwParserError("expected body of conditional statement");
if (MATCHES(sequence(KEYWORD_ELSE, SEPARATOR_CURLYBRACKETOPEN))) {
while (!MATCHES(sequence(SEPARATOR_CURLYBRACKETCLOSE))) {
@ -735,7 +735,7 @@ namespace hex::pl {
};
if (!MATCHES(sequence(SEPARATOR_ROUNDBRACKETCLOSE)))
throwParseError("expected closing ')' after while head");
throwParserError("expected closing ')' after while head");
cleanup.release();
@ -761,18 +761,18 @@ namespace hex::pl {
else if (this->m_types.contains(getNamespacePrefixedName(typeName)))
return create(new ASTNodeTypeDecl({}, this->m_types[getNamespacePrefixedName(typeName)]->clone(), endian));
else
throwParseError(hex::format("unknown type '{}'", typeName));
throwParserError(hex::format("unknown type '{}'", typeName));
} else if (MATCHES(sequence(VALUETYPE_ANY))) { // Builtin type
auto type = getValue<Token::ValueType>(-1);
if (!allowFunctionTypes) {
if (type == Token::ValueType::String)
throwParseError("cannot use 'str' in this context. Use a character array instead");
throwParserError("cannot use 'str' in this context. Use a character array instead");
else if (type == Token::ValueType::Auto)
throwParseError("cannot use 'auto' in this context");
throwParserError("cannot use 'auto' in this context");
}
return create(new ASTNodeTypeDecl({}, new ASTNodeBuiltinType(type), endian));
} else throwParseError("failed to parse type. Expected identifier or builtin type");
} else throwParserError("failed to parse type. Expected identifier or builtin type");
}
// using Identifier = (parseType)
@ -780,10 +780,10 @@ namespace hex::pl {
auto name = parseNamespaceResolution();
if (!MATCHES(sequence(OPERATOR_ASSIGNMENT)))
throwParseError("expected '=' after type name of using declaration");
throwParserError("expected '=' after type name of using declaration");
auto *type = dynamic_cast<ASTNodeTypeDecl *>(parseType());
if (type == nullptr) throwParseError("invalid type used in variable declaration", -1);
if (type == nullptr) throwParserError("invalid type used in variable declaration", -1);
return addType(name, type, type->getEndian());
}
@ -794,7 +794,7 @@ namespace hex::pl {
if (!MATCHES(sequence(SEPARATOR_SQUAREBRACKETCLOSE))) {
delete size;
throwParseError("expected closing ']' at end of array declaration", -1);
throwParserError("expected closing ']' at end of array declaration", -1);
}
return create(new ASTNodeArrayVariableDecl({}, new ASTNodeTypeDecl({}, new ASTNodeBuiltinType(Token::ValueType::Padding)), size));
@ -835,7 +835,7 @@ namespace hex::pl {
size = parseMathematicalExpression();
if (!MATCHES(sequence(SEPARATOR_SQUAREBRACKETCLOSE)))
throwParseError("expected closing ']' at end of array declaration", -1);
throwParserError("expected closing ']' at end of array declaration", -1);
}
sizeCleanup.release();
@ -853,7 +853,7 @@ namespace hex::pl {
auto builtinType = dynamic_cast<ASTNodeBuiltinType *>(sizeType->getType());
if (builtinType == nullptr || !Token::isUnsigned(builtinType->getType()))
throwParseError("invalid type used for pointer size", -1);
throwParserError("invalid type used for pointer size", -1);
}
return create(new ASTNodePointerVariableDecl(name, type, sizeType));
@ -893,14 +893,14 @@ namespace hex::pl {
else if (MATCHES(sequence(OPERATOR_STAR, IDENTIFIER, OPERATOR_INHERIT)))
member = parseMemberPointerVariable(type);
else
throwParseError("invalid variable declaration");
throwParserError("invalid variable declaration");
}
} else if (MATCHES(sequence(VALUETYPE_PADDING, SEPARATOR_SQUAREBRACKETOPEN)))
member = parsePadding();
else if (MATCHES(sequence(KEYWORD_IF, SEPARATOR_ROUNDBRACKETOPEN)))
return parseConditional();
else if (MATCHES(sequence(SEPARATOR_ENDOFPROGRAM)))
throwParseError("unexpected end of program", -2);
throwParserError("unexpected end of program", -2);
else if (MATCHES(sequence(KEYWORD_BREAK)))
member = new ASTNodeControlFlowStatement(ControlFlowStatement::Break, nullptr);
else if (MATCHES(sequence(KEYWORD_CONTINUE)))
@ -910,13 +910,13 @@ namespace hex::pl {
else if (MATCHES(oneOf(OPERATOR_DOLLAR) && oneOf(OPERATOR_PLUS, OPERATOR_MINUS, OPERATOR_STAR, OPERATOR_SLASH, OPERATOR_PERCENT, OPERATOR_SHIFTLEFT, OPERATOR_SHIFTRIGHT, OPERATOR_BITOR, OPERATOR_BITAND, OPERATOR_BITXOR) && sequence(OPERATOR_ASSIGNMENT)))
member = parseFunctionVariableCompoundAssignment("$");
else
throwParseError("invalid struct member", 0);
throwParserError("invalid struct member", 0);
if (MATCHES(sequence(SEPARATOR_SQUAREBRACKETOPEN, SEPARATOR_SQUAREBRACKETOPEN)))
parseAttribute(dynamic_cast<Attributable *>(member));
if (!MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
throwParseError("missing ';' at end of expression", -1);
throwParserError("missing ';' at end of expression", -1);
// Consume superfluous semicolons
while (MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
@ -942,17 +942,17 @@ namespace hex::pl {
do {
auto inheritedTypeName = getValue<Token::Identifier>(-1).get();
if (!this->m_types.contains(inheritedTypeName))
throwParseError(hex::format("cannot inherit from unknown type '{}'", inheritedTypeName), -1);
throwParserError(hex::format("cannot inherit from unknown type '{}'", inheritedTypeName), -1);
structNode->addInheritance(this->m_types[inheritedTypeName]->clone());
} while (MATCHES(sequence(SEPARATOR_COMMA, IDENTIFIER)));
} else if (MATCHES(sequence(OPERATOR_INHERIT, VALUETYPE_ANY))) {
throwParseError("cannot inherit from builtin type");
throwParserError("cannot inherit from builtin type");
}
if (!MATCHES(sequence(SEPARATOR_CURLYBRACKETOPEN)))
throwParseError("expected '{' after struct definition", -1);
throwParserError("expected '{' after struct definition", -1);
while (!MATCHES(sequence(SEPARATOR_CURLYBRACKETCLOSE))) {
structNode->addMember(parseMember());
@ -988,7 +988,7 @@ namespace hex::pl {
auto typeName = getValue<Token::Identifier>(-2).get();
auto underlyingType = parseType();
if (underlyingType->getEndian().has_value()) throwParseError("underlying type may not have an endian specification", -2);
if (underlyingType->getEndian().has_value()) throwParserError("underlying type may not have an endian specification", -2);
const auto enumNode = create(new ASTNodeEnum(underlyingType));
const auto typeDecl = addType(typeName, enumNode);
@ -998,7 +998,7 @@ namespace hex::pl {
};
if (!MATCHES(sequence(SEPARATOR_CURLYBRACKETOPEN)))
throwParseError("expected '{' after enum definition", -1);
throwParserError("expected '{' after enum definition", -1);
ASTNode *lastEntry = nullptr;
while (!MATCHES(sequence(SEPARATOR_CURLYBRACKETCLOSE))) {
@ -1018,15 +1018,15 @@ namespace hex::pl {
enumNode->addEntry(name, valueExpr);
} else if (MATCHES(sequence(SEPARATOR_ENDOFPROGRAM)))
throwParseError("unexpected end of program", -2);
throwParserError("unexpected end of program", -2);
else
throwParseError("invalid enum entry", -1);
throwParserError("invalid enum entry", -1);
if (!MATCHES(sequence(SEPARATOR_COMMA))) {
if (MATCHES(sequence(SEPARATOR_CURLYBRACKETCLOSE)))
break;
else
throwParseError("missing ',' between enum entries", -1);
throwParserError("missing ',' between enum entries", -1);
}
}
@ -1054,12 +1054,12 @@ namespace hex::pl {
} else if (MATCHES(sequence(VALUETYPE_PADDING, OPERATOR_INHERIT))) {
bitfieldNode->addEntry("padding", parseMathematicalExpression());
} else if (MATCHES(sequence(SEPARATOR_ENDOFPROGRAM)))
throwParseError("unexpected end of program", -2);
throwParserError("unexpected end of program", -2);
else
throwParseError("invalid bitfield member", 0);
throwParserError("invalid bitfield member", 0);
if (!MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
throwParseError("missing ';' at end of expression", -1);
throwParserError("missing ';' at end of expression", -1);
// Consume superfluous semicolons
while (MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
@ -1104,11 +1104,11 @@ namespace hex::pl {
size = parseMathematicalExpression();
if (!MATCHES(sequence(SEPARATOR_SQUAREBRACKETCLOSE)))
throwParseError("expected closing ']' at end of array declaration", -1);
throwParserError("expected closing ']' at end of array declaration", -1);
}
if (!MATCHES(sequence(OPERATOR_AT)))
throwParseError("expected placement instruction", -1);
throwParserError("expected placement instruction", -1);
auto placementOffset = parseMathematicalExpression();
@ -1128,11 +1128,11 @@ namespace hex::pl {
auto builtinType = dynamic_cast<ASTNodeBuiltinType *>(sizeType->getType());
if (builtinType == nullptr || !Token::isUnsigned(builtinType->getType()))
throwParseError("invalid type used for pointer size", -1);
throwParserError("invalid type used for pointer size", -1);
}
if (!MATCHES(sequence(OPERATOR_AT)))
throwParseError("expected placement instruction", -1);
throwParserError("expected placement instruction", -1);
auto placementOffset = parseMathematicalExpression();
@ -1145,7 +1145,7 @@ namespace hex::pl {
std::vector<ASTNode *> statements;
if (!MATCHES(sequence(IDENTIFIER)))
throwParseError("expected namespace identifier");
throwParserError("expected namespace identifier");
this->m_currNamespace.push_back(this->m_currNamespace.back());
@ -1159,7 +1159,7 @@ namespace hex::pl {
}
if (!MATCHES(sequence(SEPARATOR_CURLYBRACKETOPEN)))
throwParseError("expected '{' at start of namespace");
throwParserError("expected '{' at start of namespace");
while (!MATCHES(sequence(SEPARATOR_CURLYBRACKETCLOSE))) {
auto newStatements = parseStatements();
@ -1181,7 +1181,7 @@ namespace hex::pl {
return parseVariablePlacement(type);
else if (MATCHES(sequence(OPERATOR_STAR, IDENTIFIER, OPERATOR_INHERIT)))
return parsePointerVariablePlacement(type);
else throwParseError("invalid sequence", 0);
else throwParserError("invalid sequence", 0);
}
/* Program */
@ -1221,13 +1221,13 @@ namespace hex::pl {
statement = parseFunctionDefinition();
else if (MATCHES(sequence(KEYWORD_NAMESPACE)))
return parseNamespace();
else throwParseError("invalid sequence", 0);
else throwParserError("invalid sequence", 0);
if (MATCHES(sequence(SEPARATOR_SQUAREBRACKETOPEN, SEPARATOR_SQUAREBRACKETOPEN)))
parseAttribute(dynamic_cast<Attributable *>(statement));
if (!MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
throwParseError("missing ';' at end of expression", -1);
throwParserError("missing ';' at end of expression", -1);
// Consume superfluous semicolons
while (MATCHES(sequence(SEPARATOR_ENDOFEXPRESSION)))
@ -1242,7 +1242,7 @@ namespace hex::pl {
auto typeName = getNamespacePrefixedName(name);
if (this->m_types.contains(typeName))
throwParseError(hex::format("redefinition of type '{}'", typeName));
throwParserError(hex::format("redefinition of type '{}'", typeName));
auto typeDecl = create(new ASTNodeTypeDecl(typeName, node, endian));
this->m_types.insert({ typeName, typeDecl });
@ -1263,14 +1263,14 @@ namespace hex::pl {
auto program = parseTillToken(SEPARATOR_ENDOFPROGRAM);
if (program.empty() || this->m_curr != tokens.end())
throwParseError("program is empty!", -1);
throwParserError("program is empty!", -1);
return program;
} catch (ParseError &e) {
} catch (PatternLanguageError &e) {
this->m_error = e;
}
return {};
return std::nullopt;
}
}
}

13
lib/libimhex/source/pattern_language/pattern_language.cpp
View File

@ -10,8 +10,6 @@
#include <hex/pattern_language/validator.hpp>
#include <hex/pattern_language/evaluator.hpp>
#include <unistd.h>
namespace hex::pl {
class PatternData;
@ -113,6 +111,15 @@ namespace hex::pl {
return std::nullopt;
}
if (!this->m_validator->validate(*ast)) {
this->m_currError = this->m_validator->getError();
for (auto &node : *ast)
delete node;
return std::nullopt;
}
return ast;
}
@ -172,7 +179,7 @@ namespace hex::pl {
return this->m_evaluator->getConsole().getLog();
}
const std::optional<std::pair<u32, std::string>> &PatternLanguage::getError() {
const std::optional<PatternLanguageError> &PatternLanguage::getError() {
return this->m_currError;
}

6
lib/libimhex/source/pattern_language/preprocessor.cpp
View File

@ -8,9 +8,6 @@
namespace hex::pl {
Preprocessor::Preprocessor() {
}
std::optional<std::string> Preprocessor::preprocess(const std::string &code, bool initialRun) {
u32 offset = 0;
u32 lineNumber = 1;
@ -220,8 +217,9 @@ namespace hex::pl {
throwPreprocessorError(hex::format("no #pragma handler registered for type {0}", type.c_str()), pragmaLine);
}
}
} catch (PreprocessorError &e) {
} catch (PatternLanguageError &e) {
this->m_error = e;
return std::nullopt;
}

13
lib/libimhex/source/pattern_language/validator.cpp
View File

@ -9,9 +9,6 @@
namespace hex::pl {
Validator::Validator() {
}
bool Validator::validate(const std::vector<ASTNode *> &ast) {
std::unordered_set<std::string> identifiers;
@ -19,16 +16,16 @@ namespace hex::pl {
for (const auto &node : ast) {
if (node == nullptr)
throwValidateError("nullptr in AST. This is a bug!", 1);
throwValidatorError("nullptr in AST. This is a bug!", 1);
if (auto variableDeclNode = dynamic_cast<ASTNodeVariableDecl *>(node); variableDeclNode != nullptr) {
if (!identifiers.insert(variableDeclNode->getName().data()).second)
throwValidateError(hex::format("redefinition of identifier '{0}'", variableDeclNode->getName().data()), variableDeclNode->getLineNumber());
throwValidatorError(hex::format("redefinition of identifier '{0}'", variableDeclNode->getName().data()), variableDeclNode->getLineNumber());
this->validate({ variableDeclNode->getType() });
} else if (auto typeDeclNode = dynamic_cast<ASTNodeTypeDecl *>(node); typeDeclNode != nullptr) {
if (!identifiers.insert(typeDeclNode->getName().data()).second)
throwValidateError(hex::format("redefinition of identifier '{0}'", typeDeclNode->getName().data()), typeDeclNode->getLineNumber());
throwValidatorError(hex::format("redefinition of identifier '{0}'", typeDeclNode->getName().data()), typeDeclNode->getLineNumber());
this->validate({ typeDeclNode->getType() });
} else if (auto structNode = dynamic_cast<ASTNodeStruct *>(node); structNode != nullptr) {
@ -39,12 +36,12 @@ namespace hex::pl {
std::unordered_set<std::string> enumIdentifiers;
for (auto &[name, value] : enumNode->getEntries()) {
if (!enumIdentifiers.insert(name).second)
throwValidateError(hex::format("redefinition of enum constant '{0}'", name.c_str()), value->getLineNumber());
throwValidatorError(hex::format("redefinition of enum constant '{0}'", name.c_str()), value->getLineNumber());
}
}
}
} catch (ValidatorError &e) {
} catch (PatternLanguageError &e) {
this->m_error = e;
return false;
}

6
plugins/builtin/source/content/views/view_pattern_editor.cpp
View File

@ -9,9 +9,6 @@
#include <hex/helpers/file.hpp>
#include <hex/helpers/magic.hpp>
#include <hex/helpers/literals.hpp>
#include <nlohmann/json.hpp>
namespace hex::plugin::builtin {
@ -640,7 +637,8 @@ namespace hex::plugin::builtin {
auto error = this->m_evaluatorRuntime->getError();
if (error.has_value()) {
this->m_textEditor.SetErrorMarkers({ error.value() });
TextEditor::ErrorMarkers errorMarkers = { { error->getLineNumber(), error->what() } };
this->m_textEditor.SetErrorMarkers(errorMarkers);
}
this->m_console = this->m_evaluatorRuntime->getConsoleLog();

2
tests/CMakeLists.txt
View File

@ -1,5 +1,7 @@
project(unit_tests)
enable_testing()
add_custom_target(unit_tests)
add_subdirectory(common)

2
tests/pattern_language/source/main.cpp
View File

@ -63,7 +63,7 @@ int test(int argc, char **argv) {
hex::log::fatal("Error during compilation!");
if (auto error = language.getError(); error.has_value())
hex::log::info("Compile error: {} : {}", error->first, error->second);
hex::log::info("Compile error: {} : {}", error->getLineNumber(), error->what());
for (auto &[level, message] : language.getConsoleLog())
hex::log::info("Evaluate error: {}", message);