一份开源的BM算法

mstring.h

/*
** Copyright (C) 1998-2002 Martin Roesch <roesch@sourcefire.com>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

/* $Id: mstring.h,v 1.5 2003/10/20 15:03:20 chrisgreen Exp $ */

#ifndef __MSTRING_H__
#define __MSTRING_H__

/*  I N C L U D E S  ******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>




/*  P R O T O T Y P E S  *************************************************/
class BMSearch
{
public:
    BMSearch()
    {
        skip = NULL;
        shift = NULL;
    }
    ~BMSearch();
    int Match(const char* pBuf, int nBufLen, const char* ptrn, int nLen, bool bOneTimeFlag);
private:
    int mSearch(const char *buf, int blen, const char *ptrn, int plen, int *skip, int *shift, bool bOneTimeFlag);
    int *make_skip(const char *ptrn, int plen);
    int *make_shift(const char *ptrn, int plen);

    int* skip;
    int* shift;

};


#endif  /* __MSTRING_H__ */

mstring.cpp

#include <stdafx.h>
#include "mstring.h"
BMSearch::~BMSearch()
{
    if (skip)
    {
        free(skip);
        skip = NULL;
    }
    if (shift)
    {
        free(shift);
        shift = NULL;
    }
}
int BMSearch::Match(const char* pBuf, int nBufLen, const char* ptrn, int nLen, bool bOneTimeFlag)
{
    if (skip)
    {
        free(skip);
        skip = NULL;
    }
    if (shift)
    {
        free(shift);
        shift = NULL;
    }

    if (NULL == pBuf || 
        NULL == ptrn || 
        nBufLen <=0 ||
        nLen <= 0
        )
    {
        return 0;
    }

    skip = make_skip(ptrn, nLen);
    shift = make_shift(ptrn, nLen);

    if (NULL == skip || NULL == shift)
        return 0;

    return mSearch(pBuf, nBufLen, ptrn, nLen, skip, shift, bOneTimeFlag);


}
/****************************************************************
 *
 *  Function: make_skip(char *, int)
 *
 *  Purpose: Create a Boyer-Moore skip table for a given pattern
 *
 *  Parameters:
 *      ptrn => pattern
 *      plen => length of the data in the pattern buffer
 *
 *  Returns:
 *      int * - the skip table
 *
 ****************************************************************/
int * BMSearch::make_skip(const char *ptrn, int plen)
{
    int *skip = (int *) malloc(256 * sizeof(int));
    int *sptr = &skip[256];

    if (skip == NULL)
        return NULL;

    while(sptr-- != skip)
        *sptr = plen + 1;

    while(plen != 0)
        skip[(unsigned char) *ptrn++] = plen--;

    return skip;
}



/****************************************************************
 *
 *  Function: make_shift(char *, int)
 *
 *  Purpose: Create a Boyer-Moore shift table for a given pattern
 *
 *  Parameters:
 *      ptrn => pattern
 *      plen => length of the data in the pattern buffer
 *
 *  Returns:
 *      int * - the shift table
 *
 ****************************************************************/
int *BMSearch::make_shift(const char *ptrn, int plen)
{
    int *shift = (int *) malloc(plen * sizeof(int));
    int *sptr = shift + plen - 1;
    const char *pptr = ptrn + plen - 1;
    char c;

    if (shift == NULL)
        return NULL;

     c = ptrn[plen - 1];

    *sptr = 1;

    while(sptr-- != shift)
    {
        const char *p1 = ptrn + plen - 2, *p2, *p3;

        do
        {
            while(p1 >= ptrn && *p1-- != c);

            p2 = ptrn + plen - 2;
            p3 = p1;

            while(p3 >= ptrn && *p3-- == *p2-- && p2 >= pptr);
        }
        while(p3 >= ptrn && p2 >= pptr);

        *sptr = static_cast<int>(shift + plen - sptr + p2 - p3);

        pptr--;
    }

    return shift;
}



/****************************************************************
 *
 *  Function: mSearch(char *, int, char *, int)
 *
 *  Purpose: Determines if a string contains a (non-regex)
 *           substring.
 *
 *  Parameters:
 *      buf => data buffer we want to find the data in
 *      blen => data buffer length
 *      ptrn => pattern to find
 *      plen => length of the data in the pattern buffer
 *      skip => the B-M skip array
 *      shift => the B-M shift array
 *
 *  Returns:
 *      Integer value, 1 on success (str constains substr), 0 on
 *      failure (substr not in str)
 *
 ****************************************************************/
int BMSearch::mSearch(const char *buf, int blen, const char *ptrn, int plen, int *skip, int *shift, bool bOneTimeFlag)
{
    int b_idx = plen;
    int nCount = 0;
    bool bContinue = false;

    if(0 == blen || 0 == plen)
        return 1;

    while(b_idx <= blen)
    {
        int p_idx = plen, skip_stride, shift_stride;

        while(buf[--b_idx] == ptrn[--p_idx])
        {
            if(b_idx < 0)
                return 0;

            if(p_idx == 0)
            {    
                if (bOneTimeFlag)
                    return 1;
                else
                {
                    nCount++;
                    bContinue = true;
                    break;
                }
            }
        }

        if (bContinue)
        {
            b_idx += 2*plen;
            bContinue = false;
        }
        else
        {
            skip_stride = skip[(unsigned char) buf[b_idx]];
            shift_stride = shift[p_idx];

            b_idx += (skip_stride > shift_stride) ? skip_stride : shift_stride;
        }
    }

    return nCount;
}