sunday 字符串匹配算法的实现(支持二进制匹配)

之前在解析multi-part formdata协议的http请求包时, 用字符串匹配的方式寻找包体中的 boundary标记.  这就涉及到了字符串匹配算法,  然后就选择了sunday算法.

sunday是我所知到目前最快的单模式字符串匹配算法了, 由于请求包体中可能含有二进制, 所以把sunday算法改造成了支持二进制串匹配的.

sunday算法的原理不多说,网上一搜一大把, 下面贴下我的实现:

/*
 * @desc    : Sunday String pattern matching algorithm (also support binary buf pattern match)
 * @author  : nemozhang
 *
 */
#ifndef __SUNDAY_H_20111203__
#define __SUNDAY_H_20111203__

#include <stdio.h>
#include <vector>

#ifndef u_char
#define u_char unsigned char
#endif

class SundayAlgo
{
public:
        enum
        {   
                JUMP_TABLE_LEN                          = 256    // 跳转表大小
        };  

        enum
        {
                MATCH_RULE_STEP_ONE_CHAR        = 0,    // 匹配上时, 跳过一个字符长度继续匹配
                MATCH_RULE_STEP_ONE_PATTEN      = 1,    // 匹配上时, 跳过一个模式串长度继续匹配
        };

public:

        SundayAlgo():
                _jump_table_inited(false), 
                _pat_start(0),
                _pat_end(0),
                _match_rule(MATCH_RULE_STEP_ONE_CHAR)
        {}  

public:
        // 源串     [text_start, text_end)
        // 模式串   [pat_start, pat_end)
        // @return -1 没找到， else 目标相对于起始串的偏移
        int Search(const char *text_start, const char *text_end)
        {   
                if (text_start >= text_end)
                {   
                        return -1; 
                }   

                if (!_jump_table_inited)
                {   
                        return -1; 
                }   

                int text_len = text_end - text_start;
                int pat_len = _pat_end - _pat_start;

                for (int i=0; i<text_len-pat_len+1; )
                {   
                        bool finded = true;
                        // 从后往前匹配
                        for (int j=0; j<pat_len; ++j)
                        {   
                                // 匹配不上, 跳
                                if (text_start[i+pat_len-j-1] != _pat_start[pat_len-j-1])
                                {   
                                        //printf("i:%d, j:%d\n", i, j);
                                        //printf("text:%d [%c], pat:%d [%c] \n", i+pat_len-j-1, text_start[i+pat_len-j-1],  pat_len-j-1, _pat_start[pat_len-j-1]);
                                        //printf("i:%d [%c], j:%d [%c] \n", i, text_start[i],  j, _pat_start[j]);
                                        u_char next_c = (u_char)text_start[i + pat_len];
                                        //printf("next c:%d, [%c], jmp:%d\n", i+pat_len, next_c, _jump_table[next_c]);

                                        i += _jump_table[next_c];

                                        finded = false;
                                        break;
                                }   
                        }   

                        if (finded)
                        {   
                                // 匹配上了 
                                return i;
                        }
                }

                return -1;
        }

        // 将每一个匹配项的偏移存于pos_vec
        void Search(const char *text_start, const char *text_end, std::vector<int> &pos_vec)
        {
                int pos = 0;

                const char *text_start_new = (const char*)text_start;

                int pat_len = _pat_end - _pat_start;

                while(pos != -1)
                {
                        pos = Search(text_start_new, text_end);

                        if (pos != -1)
                        {
                                pos_vec.push_back(pos + text_start_new - text_start);

                                if (MATCH_RULE_STEP_ONE_CHAR == _match_rule)
                                {
                                        text_start_new += (1 + pos);
                                }
                                else
                                {
                                        text_start_new += (pat_len + pos);
                                }

                        }
                        else
                        {
                                break;
                        }
                }
        }

        // 设置模式串
        // [pat_start, pat_end) 不含pat_end.
        void SetPatten(const char* pat_start, const char* pat_end)
        {
                _pat_start = pat_start;
                _pat_end = pat_end;
                PreCompute(pat_start, pat_end);
        }

        // 设置匹配策略
        // 假设文本串为 "aaaaaa", 模式串为 "aaa"
        // 如果rule:MATCH_RULE_STEP_ONE_CHAR, 则会产生 4次匹配
        // 如果rule:MATCH_RULE_STEP_ONE_PATTERN, 则会产生 2次匹配
        void SetMatchRule(int rule)
        {
                _match_rule = rule;
        }

private:
        // 生成跳转表
        void PreCompute(const char* pat_start, const char* pat_end)
        {
                if (pat_start >= pat_end)
                {
                        return;
                }

                int pat_len = pat_end - pat_start ;

                // 初始化
                for (int i=0; i<JUMP_TABLE_LEN; ++i)
                {
                        _jump_table[i] = pat_len + 1; // pat长度+1
                }

                const char* p = pat_start;
                for (; p!=pat_end; ++p)
                {
                        _jump_table[(u_char)(*p)] = pat_end - p;
                }

                _jump_table_inited = true;
        }

private:
        u_char  _jump_table[JUMP_TABLE_LEN];
        bool    _jump_table_inited;

        const char    *_pat_start;
        const char    *_pat_end;

        int             _match_rule;
};

#endif

测试用例:

// by nemozhang

#include <gtest/gtest.h>
#include "sunday.h"
#include <unistd.h>

using namespace std;


TEST(autorun_SundayAlgo, test_ascii_str) {

    const char *text = "sunhello world !\n taday is sunday, i feel good now.\nthis is a text for sunday algo test program.day, sunhow,dslasun.sdslsunday" ;
    const char *pat = "sunday";

    int text_len = strlen(text);
    int pat_len = strlen(pat);

    SundayAlgo sunday;
    const char * pat_start = (const char*)pat;
    const char * pat_end = pat_start + pat_len;
    sunday.SetPatten(pat_start, pat_end);

    vector<int> pos_vec;

    sunday.Search(text, text + text_len, pos_vec);

    printf("hit times : %d\n", pos_vec.size());
    for (size_t i=0; i<pos_vec.size(); ++i)
    {
        printf("the %u time : %d\n", i, pos_vec[i]);
        for (int j=pos_vec[i]; j<pos_vec[i]+pat_len+5; ++j)
        {
            if (j >= text_len)
            {
                break;
            }
            printf("%c",text[j]);
        }
        printf("\n");
    }

}

TEST(autorun_SundayAlgo, test_binary_str) {

        u_char text[] = {1,2,255,253,0,255,0,253,0,3,4,5,6,7,8,9,0,0,1,2,3,4,0,0,1,2,0,4,5,0,9,6,4,2,0,0,0,0,0,0,3,2,1,1,2,3,4,5,6,7,0,3,4,6,55,4,2,3,4,234,12,111,255,253,0,255,253,0,255,253,0};
        //u_char pat[] = {255,253,0};
        u_char pat[] = {0,0,0};

        int text_len = sizeof(text);
        int pat_len = sizeof(pat);

        SundayAlgo sunday;
        const char * pat_start = (const char*)pat;
        const char * pat_end = pat_start + pat_len;
        sunday.SetPatten(pat_start, pat_end);

        vector<int> pos_vec;

        sunday.SetMatchRule(SundayAlgo::MATCH_RULE_STEP_ONE_PATTEN);
        sunday.Search((const char*)text, (const char*)text + text_len, pos_vec);

        printf("\n");
        printf("\n");
        printf("hit times : %d\n", pos_vec.size());
        for (size_t i=0; i<pos_vec.size(); ++i)
        {
                printf("the %u time : %d\n", i, pos_vec[i]);
                for (int j=pos_vec[i]; j<pos_vec[i]+pat_len+5; ++j)
                {
                        if (j >= text_len)
                        {
                                break;
                        }
                        printf("%d,",text[j]);
                }
                printf("\n");
        }

}

输出如下:
nemo@vm04_sles10:[unittest]$ ./sunday_unittest 
Running main() from gtest_main.cc
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from autorun_SundayAlgo
[ RUN      ] autorun_SundayAlgo.test_ascii_str
hit times : 3
the 0 time : 27
sunday, i f
the 1 time : 71
sunday algo
the 2 time : 120
sunday
[       OK ] autorun_SundayAlgo.test_ascii_str (0 ms)
[ RUN      ] autorun_SundayAlgo.test_binary_str




hit times : 2
the 0 time : 34
0,0,0,0,0,0,3,2,
the 1 time : 37
0,0,0,3,2,1,1,2,
[       OK ] autorun_SundayAlgo.test_binary_str (0 ms)
[----------] 2 tests from autorun_SundayAlgo (0 ms total)


[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (0 ms total)
[  PASSED  ] 2 tests.