#include "Parser.h"
#include <algorithm>
#include <stdexcept>
#include <s
stream>
#include <io
stream>
#include"SingleNode.h"
#include"Context.h"
#include"IfNode.h"
#include"ThenNode.h"
#include"WhenNode.h"
#include"AndNode.h"
#include"NotNode.h"
#include"OrNode.h"
using namespace std;
unique_ptr<
ExpressionNode> Parser
::parse(const string& expr) {
string cleaned = trim(expr.substr(expr.find('(') + 1, expr.rfind(')') - expr.find('(') - 1));
return parse
Expression(cleaned);
}
unique_ptr<
ExpressionNode> Parser
::parseSingleNode(const string& expr) {
if (expr.find("THEN(")
!= 0 && expr.find("IF(")
!= 0 &&
expr.find("WHEN(")
!= 0 && expr.find("AND(")
!= 0 &&
expr.find("OR(")
!= 0 && expr.find("NOT(")
!= 0) {
return make_unique<SingleNode>(expr);
}
return parse
Expression(expr);
}
unique_ptr<
ExpressionNode> Parser
::parseIf
Expression(const string& expr) {
size_t comma1 = findMatchingBracket(expr, 0);
string conditionStr = trim(expr.substr(0, comma1));
size_t comma2 = findMatchingBracket(expr, comma1 + 1);
string thenPart = trim(expr.substr(comma1 + 1, comma2 - comma1 - 1));
string elsePart = trim(expr.substr(comma2 + 1));
auto conditionNode = parseLogical
Expression(conditionStr);
auto thenNode = parse
Expression(thenPart);
unique_ptr<
ExpressionNode> elseNode =
nullptr;
if (!elsePart.empty()) {
elseNode = parse
Expression(elsePart);
}
return make_unique<IfNode>(
move(conditionNode),
move(thenNode),
move(elseNode)
);
}
unique_ptr<
ExpressionNode> Parser
::parseThen
Expression(const string& expr) {
vector<unique_ptr<
ExpressionNode>> children;
size_t pos = 0;
while (pos < expr.size()) {
size_t end = findMatchingBracket(expr, pos);
string item = expr.substr(pos, end - pos);
children.push_back(parse
Expression(trim(item)));
pos = (end == string
::npos) ? expr.size()
: end + 1;
}
return make_unique<ThenNode>(move(children));
}
unique_ptr<
ExpressionNode> Parser
::parseWhen
Expression(const string& expr) {
vector<unique_ptr<
ExpressionNode>> children;
auto parts = splitComponents(expr);
for (const auto& part
: parts) {
children.push_back(parse
Expression(trim(part)));
}
return make_unique<WhenNode>(move(children));
}
vector<string> Parser
::splitComponents(const string& expr) {
vector<string> parts;
int bracketCount = 0;
size_t start = 0;
for (size_t i = 0; i < expr.size(); ++i) {
char c = expr[i];
if (c == '(') {
bracketCount++;
}
else if (c == ')') {
bracketCount--;
}
else if (c == ',' && bracketCount == 0) {
string part = expr.substr(start, i - start);
parts.push_back(trim(part));
start = i + 1;
}
}
if (start < expr.size()) {
string lastPart = expr.substr(start);
parts.push_back(trim(lastPart));
}
return parts;
}
unique_ptr<
ExpressionNode> Parser
::parse
Expression(const string& expr) {
try {
string trimmed = trim(expr);
if (trimmed.empty()) {
throw runtime_error("Empty
expression");
}
if (startsWith(trimmed, "THEN(")) {
return parseThen
Expression(trimmed.substr(5, trimmed.size() - 6));
}
if (startsWith(trimmed, "IF(")) {
return parseIf
Expression(trimmed.substr(3, trimmed.size() - 4));
}
if (startsWith(trimmed, "WHEN(") || startsWith(trimmed, "PAR(")) {
return parseWhen
Expression(trimmed.substr(5, trimmed.size() - 6));
}
if (startsWith(trimmed, "AND(")) {
return parseAnd
Expression(trimmed.substr(4, trimmed.size() - 5));
}
if (startsWith(trimmed, "OR(")) {
return parseOr
Expression(trimmed.substr(3, trimmed.size() - 4));
}
if (startsWith(trimmed, "NOT(")) {
return parseNot
Expression(trimmed.substr(4, trimmed.size() - 5));
}
return parseSingleNode(trimmed);
}
catch (const exception& e) {
cerr << "Parse EL error
: " << e.what() << endl;
throw;
}
}
// 新增逻辑表达式解析方法
unique_ptr<
ExpressionNode> Parser
::parseLogical
Expression(const string& expr) {
string trimmed = trim(expr);
if (startsWith(trimmed, "AND(")) {
return parseAnd
Expression(trimmed.substr(4, trimmed.size() - 5));
}
if (startsWith(trimmed, "OR(")) {
return parseOr
Expression(trimmed.substr(3, trimmed.size() - 4));
}
if (startsWith(trimmed, "NOT(")) {
return parseNot
Expression(trimmed.substr(4, trimmed.size() - 5));
}
return parseSingleNode(trimmed);
}
unique_ptr<
ExpressionNode> Parser
::parseAnd
Expression(const string& expr) {
auto parts = splitComponents(expr);
vector<unique_ptr<
ExpressionNode>> children;
for (const auto& part
: parts) {
children.push_back(parseLogical
Expression(trim(part)));
}
return make_unique<AndNode>(move(children));
}
unique_ptr<
ExpressionNode> Parser
::parseOr
Expression(const string& expr) {
auto parts = splitComponents(expr);
vector<unique_ptr<
ExpressionNode>> children;
for (const auto& part
: parts) {
children.push_back(parseLogical
Expression(trim(part)));
}
return make_unique<OrNode>(move(children));
}
unique_ptr<
ExpressionNode> Parser
::parseNot
Expression(const string& expr) {
// 确保NOT表达式只有一个参数
auto parts = splitComponents(expr);
if (parts.size()
!= 1) {
throw runtime_error("NOT
expression requires exactly one argument");
}
return make_unique<NotNode>(parseLogical
Expression(trim(parts[0])));
}
// 辅助函数
bool Parser
::startsWith(const string& str, const string& prefix) {
return str.compare(0, prefix.length(), prefix) == 0;
}
size_t Parser
::findMatchingBracket(const string& expr, size_t start) {
int balance = 0;
for (size_t i = start; i < expr.size(); ++i) {
if (expr[i] == '(') balance++;
else if (expr[i] == ')') balance--;
else if (expr[i] == ',' && balance == 0) {
return i;
}
}
return string
::npos;
}
string Parser
::trim(const string& s) {
size_t start = s.find_first_not_of(" \t\n\r");
size_t end = s.find_last_not_of(" \t\n\r");
return (start == string
::npos) ? ""
: s.substr(start, end - start + 1);
}报错
本文探讨了FFmpeg在使用过程中出现的空指针异常问题，并详细分析了导致此问题的原因，包括文件不存在或流为空等情况。通过阅读本文，读者可以了解到如何排查和解决此类错误。
扫一扫
1605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
