匹配时添加了一个当前索引项

nancy.liao

2025-05-26 77a92c3204b95eaf2870605718b9099ab6ece56a

 libscpi/src/externinterface.cpp

@@ -8,7 +8,12 @@
#include <sstream>

CPatternResult* g_pattern_results = new (std::nothrow) CPatternResult();

int g_pattern_count = 0;

//static std::vector<std::string_view> currentCommandGroup;

static int currentIndex;

class Segment {
public:
@@ -82,52 +87,45 @@
    }

    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++)
                                   const std::vector<Segment>& vecSegment) {
        size_t currentIndex = 0;
        for (const auto& segment : vecSegment)
        {
            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 (currentIndex >= stringList.size())
            {
                if (stringList.size() == vecSegment.size())
                return false;
            }
            if (segment.is_required)
            {
                bool matched = false;
                for (const auto& option : segment.options)
                {
                    auto vecTempSegments = currentSegment.options;
                    for (const auto& option : vecTempSegments)
                    if (stringList[currentIndex] == option)
                    {
                        if (stringList[currentIndex] != option)
                        {
                            return false;
                        } else {
                            currentIndex += 1;
                        }
                        matched = true;
                        break;
                    }
                }
                if (!matched)
                {
                    return false;
                }
                currentIndex++;
            }
            else {
                currentIndex += 1;
            else if (segment.is_variable)
            {
                // 可变参数：直接跳过
                currentIndex++;
            } else
            {

                if (segment.options.empty() || stringList[currentIndex] != segment.options[0]) {
                    return false;
                }
                currentIndex++;
            }
        }
        return true;
        return currentIndex == stringList.size();
    }

    static std::vector<Segment> extract_all_segments(const std::string& pattern)
@@ -228,8 +226,12 @@
    }
};

char* currentPattern()
{
    return g_pattern_results[currentIndex].commandData;
}
// 全局管理函数实现
void add_pattern_to_global(const std::vector<Segment>& segments)
void add_pattern_to_global(const char* pattern, const std::vector<Segment>& segments)
{
    // 重新分配内存
    CPatternResult* new_results = new CPatternResult[g_pattern_count + 1];
@@ -244,7 +246,6 @@
    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];
@@ -288,14 +289,23 @@

int get_pattern_count() { return g_pattern_count; }


void clearCurrentGroup()
{
    currentIndex = -1;
    //currentCommandGroup.clear();
}
void parse_pattern_global(const char* pattern)
{
    auto segments = PatternParser::extract_all_segments(pattern);
    add_pattern_to_global(segments);
    add_pattern_to_global(pattern,segments);
}

void setCurrentIndex(int index)
{
    currentIndex = index;
}

//pattern_index  匹配组的下标
int match_segments_global(const char* input, int pattern_index)
{
    if (pattern_index < 0 || pattern_index >= g_pattern_count)
@@ -339,9 +349,4 @@
    }

    return PatternParser::match_all_segments(inputList, segments) ? 1 : 0;
}

CPatternResult *GetInstance()
{
    return g_pattern_results;
}