#include "scpi/externinterface.h"
|
#include <vector>
|
#include <string>
|
#include <algorithm>
|
#include <cstring>
|
|
// 全局变量定义
|
CPatternResult* g_pattern_results = nullptr;
|
int g_pattern_count = 0;
|
|
class Segment {
|
public:
|
bool is_required = false;
|
bool is_variable = false;
|
bool is_nested = false;
|
int variableSize = 0;
|
std::vector<std::string> options;
|
};
|
|
class PatternParser
|
{
|
private:
|
//清除空格
|
static void trim_whitespace(std::string& str)
|
{
|
auto not_space = [](int ch) { return !std::isspace(ch); };
|
str.erase(str.begin(), std::find_if(str.begin(), str.end(), not_space));
|
str.erase(std::find_if(str.rbegin(), str.rend(), not_space).base(), str.end());
|
}
|
//拆分可选参数
|
static std::vector<std::string> split_options(const std::string& input)
|
{
|
std::vector<std::string> result;
|
size_t start = 0;
|
size_t end = input.find('|');
|
|
while (end != std::string::npos)
|
{
|
std::string token = input.substr(start, end - start);
|
trim_whitespace(token);
|
if (!token.empty()) result.push_back(token);
|
start = end + 1;
|
end = input.find('|', start);
|
}
|
|
std::string last_token = input.substr(start);
|
trim_whitespace(last_token);
|
last_token = remove_colon(last_token);
|
if (!last_token.empty()) result.push_back(last_token);
|
return result;
|
}
|
|
//删掉可能携带的:分割符
|
static std::string remove_colon(const std::string& input)
|
{
|
std::string result;
|
for (char ch : input)
|
{
|
if (ch != ':') {
|
result += ch;
|
}
|
}
|
return result;
|
}
|
|
public:
|
static std::vector<std::string> parse_input_data(const std::string& input)
|
{
|
std::vector<std::string> result;
|
size_t start = 0;
|
size_t end = input.find(':');
|
|
while (end != std::string::npos)
|
{
|
result.push_back(input.substr(start, end - start));
|
start = end + 1;
|
end = input.find(':', start);
|
}
|
|
result.push_back(input.substr(start));
|
return result;
|
}
|
|
static bool match_all_segments(const std::vector<std::string>& stringList,
|
const std::vector<Segment>& vecSegment)
|
{
|
int currentIndex = 0;
|
for (size_t i = 0; i < vecSegment.size(); i++)
|
{
|
auto currentSegment = vecSegment[i];
|
|
if (currentSegment.is_required) {
|
for (const auto& option : currentSegment.options)
|
{
|
//当索引index超过输入参数的词组大小 则表示命令不匹配
|
if(currentIndex >= stringList.size())
|
{
|
return false;
|
}
|
if (stringList[currentIndex] != option)
|
{
|
return false;
|
} else {
|
currentIndex += 1;
|
}
|
break;
|
}
|
}
|
else if (currentSegment.is_variable)
|
{
|
if (stringList.size() == vecSegment.size())
|
{
|
auto vecTempSegments = currentSegment.options;
|
for (const auto& option : vecTempSegments)
|
{
|
if (stringList[currentIndex] != option)
|
{
|
return false;
|
} else {
|
currentIndex += 1;
|
}
|
break;
|
}
|
}
|
}
|
else {
|
currentIndex += 1;
|
}
|
}
|
return true;
|
}
|
|
static std::vector<Segment> extract_all_segments(const std::string& pattern)
|
{
|
std::vector<Segment> segments;
|
size_t pos = 0;
|
const size_t len = pattern.length();
|
|
while (pos < len)
|
{
|
while (pos < len && std::isspace(pattern[pos])) ++pos;
|
if (pos >= len) break;
|
|
if (pattern[pos] == '<')
|
{
|
size_t end_pos = pattern.find('>', pos);
|
if (end_pos == std::string::npos) break;
|
|
std::string content = pattern.substr(pos + 1, end_pos - pos - 1);
|
trim_whitespace(content);
|
|
Segment segment;
|
segment.is_variable = false;
|
segment.options = split_options(content);
|
|
if (content.find(':') != std::string::npos)
|
{
|
segment.is_required = true;
|
} else
|
{
|
segment.is_required = false;
|
}
|
|
segments.push_back(segment);
|
pos = end_pos + 1;
|
}
|
else if (pattern[pos] == '[')
|
{
|
size_t end_pos = pattern.find(']', pos);
|
if (end_pos == std::string::npos) break;
|
|
std::string content = pattern.substr(pos + 1, end_pos - pos - 1);
|
trim_whitespace(content);
|
|
Segment segment;
|
segment.variableSize += 1;
|
segment.is_required = false;
|
segment.is_variable = true;
|
segment.options = split_options(content);
|
|
segments.push_back(segment);
|
pos = end_pos + 1;
|
}
|
else
|
{
|
size_t next_lt = pattern.find('<', pos);
|
size_t next_lb = pattern.find('[', pos);
|
size_t next_special = std::min(next_lt, next_lb);
|
|
std::string content;
|
if (next_special != std::string::npos)
|
{
|
content = pattern.substr(pos, next_special - pos);
|
} else
|
{
|
content = pattern.substr(pos);
|
}
|
trim_whitespace(content);
|
|
if (!content.empty())
|
{
|
size_t start = 0;
|
size_t end = content.find(':');
|
while (end != std::string::npos)
|
{
|
std::string token = content.substr(start, end - start);
|
trim_whitespace(token);
|
|
if (!token.empty())
|
{
|
Segment segment;
|
segment.is_required = true;
|
segment.is_variable = false;
|
segment.options.push_back(token);
|
segments.push_back(segment);
|
}
|
start = end + 1;
|
end = content.find(':', start);
|
}
|
std::string last_token = content.substr(start);
|
trim_whitespace(last_token);
|
if (!last_token.empty())
|
{
|
Segment segment;
|
segment.is_required = true;
|
segment.is_variable = false;
|
segment.options.push_back(last_token);
|
segments.push_back(segment);
|
}
|
}
|
pos = (next_special != std::string::npos) ? next_special : len;
|
}
|
}
|
return segments;
|
}
|
};
|
|
// 全局管理函数实现
|
void add_pattern_to_global(const std::vector<Segment>& segments)
|
{
|
// 重新分配内存
|
CPatternResult* new_results = new CPatternResult[g_pattern_count + 1];
|
|
// 复制旧数据
|
for (int i = 0; i < g_pattern_count; ++i)
|
{
|
new_results[i] = g_pattern_results[i];
|
}
|
|
// 添加新数据
|
CPatternResult& new_item = new_results[g_pattern_count];
|
new_item.segments_count = static_cast<int>(segments.size());
|
new_item.segments = new CSegment[segments.size()];
|
|
for (size_t i = 0; i < segments.size(); ++i)
|
{
|
const auto& seg = segments[i];
|
new_item.segments[i].is_required = seg.is_required;
|
new_item.segments[i].is_variable = seg.is_variable;
|
new_item.segments[i].is_nested = seg.is_nested;
|
new_item.segments[i].variableSize = seg.variableSize;
|
|
new_item.segments[i].options_count = static_cast<int>(seg.options.size());
|
new_item.segments[i].options = new char*[seg.options.size()];
|
|
for (size_t j = 0; j < seg.options.size(); ++j)
|
{
|
new_item.segments[i].options[j] = strdup(seg.options[j].c_str());
|
}
|
}
|
|
// 释放旧内存并更新指针
|
delete[] g_pattern_results;
|
g_pattern_results = new_results;
|
g_pattern_count++;
|
}
|
|
void clear_global_patterns() {
|
for (int i = 0; i < g_pattern_count; ++i)
|
{
|
for (int j = 0; j < g_pattern_results[i].segments_count; ++j)
|
{
|
for (int k = 0; k < g_pattern_results[i].segments[j].options_count; ++k)
|
{
|
free(g_pattern_results[i].segments[j].options[k]);
|
}
|
delete[] g_pattern_results[i].segments[j].options;
|
}
|
delete[] g_pattern_results[i].segments;
|
}
|
delete[] g_pattern_results;
|
g_pattern_results = nullptr;
|
g_pattern_count = 0;
|
}
|
|
int get_pattern_count() { return g_pattern_count; }
|
|
|
void parse_pattern_global(const char* pattern)
|
{
|
auto segments = PatternParser::extract_all_segments(pattern);
|
add_pattern_to_global(segments);
|
}
|
|
|
int match_segments_global(const char* input, int pattern_index)
|
{
|
if (pattern_index < 0 || pattern_index >= g_pattern_count)
|
{
|
return 0;
|
}
|
|
|
std::string inputStr(input);
|
inputStr.erase(std::remove(inputStr.begin(), inputStr.end(), '\n'), inputStr.end());
|
|
std::vector<std::string> inputList;
|
size_t start = 0;
|
size_t end = inputStr.find(':');
|
|
while (end != std::string::npos)
|
{
|
inputList.push_back(inputStr.substr(start, end - start));
|
start = end + 1;
|
end = inputStr.find(':', start);
|
}
|
inputList.push_back(inputStr.substr(start));
|
|
std::vector<Segment> segments;
|
CPatternResult& pattern = g_pattern_results[pattern_index];
|
|
for (int i = 0; i < pattern.segments_count; ++i)
|
{
|
Segment seg;
|
seg.is_required = pattern.segments[i].is_required;
|
seg.is_variable = pattern.segments[i].is_variable;
|
seg.is_nested = pattern.segments[i].is_nested;
|
seg.variableSize = pattern.segments[i].variableSize;
|
|
for (int j = 0; j < pattern.segments[i].options_count; ++j)
|
{
|
seg.options.push_back(pattern.segments[i].options[j]);
|
}
|
|
segments.push_back(seg);
|
}
|
|
return PatternParser::match_all_segments(inputList, segments) ? 1 : 0;
|
}
|
