qbytearraymatcher.cpp File Reference

#include "qbytearraymatcher.h"
#include <limits.h>

Go to the source code of this file.

Macros
#define	REHASH(a)

Functions
static int	bm_find (const uchar *cc, int l, int index, const uchar *puc, uint pl, const uchar *skiptable)
static void	bm_init_skiptable (const uchar *cc, int len, uchar *skiptable)
static int	findChar (const char *str, int len, char ch, int from)
int	qFindByteArray (const char *haystack0, int haystackLen, int from, const char *needle, int needleLen)
static int	qFindByteArrayBoyerMoore (const char *haystack, int haystackLen, int haystackOffset, const char *needle, int needleLen)

Macro Definition Documentation

REHASH

#define REHASH

(

a

)

Value:

if (sl_minus_1 < sizeof(uint) * CHAR_BIT) \
        hashHaystack -= (a) << sl_minus_1; \
    hashHaystack <<= 1

Definition at line 268 of file qbytearraymatcher.cpp.

Referenced by qFindByteArray().

Function Documentation

bm_find()

static int bm_find ( const uchar *  cc, int  l, int  index, const uchar *  puc, uint  pl, const uchar *  skiptable  )

inlinestatic

Definition at line 57 of file qbytearraymatcher.cpp.

Referenced by QByteArrayMatcher::indexIn(), and qFindByteArrayBoyerMoore().

{
    if (pl == 0)
        return index > l ? -1 : index;
    const uint pl_minus_one = pl - 1;

    register const uchar *current = cc + index + pl_minus_one;
    const uchar *end = cc + l;
    while (current < end) {
        uint skip = skiptable[*current];
        if (!skip) {
            // possible match
            while (skip < pl) {
                if (*(current - skip) != puc[pl_minus_one - skip])
                    break;
                skip++;
            }
            if (skip > pl_minus_one) // we have a match
                return (current - cc) - skip + 1;

            // in case we don't have a match we are a bit inefficient as we only skip by one
            // when we have the non matching char in the string.
            if (skiptable[*(current - skip)] == pl)
                skip = pl - skip;
            else
                skip = 1;
        }
        if (current > end - skip)
            break;
        current += skip;
    }
    return -1; // not found
}

bm_init_skiptable()

static void bm_init_skiptable ( const uchar *  cc, int  len, uchar *  skiptable  )

inlinestatic

Definition at line 48 of file qbytearraymatcher.cpp.

Referenced by QByteArrayMatcher::QByteArrayMatcher(), qFindByteArrayBoyerMoore(), and QByteArrayMatcher::setPattern().

{
    int l = qMin(len, 255);
    memset(skiptable, l, 256*sizeof(uchar));
    cc += len - l;
    while (l--)
        skiptable[*cc++] = l;
}

findChar()

static int findChar ( const char *  str, int  len, char  ch, int  from  )

static

Definition at line 238 of file qbytearraymatcher.cpp.

Referenced by qFindByteArray().

{
    const uchar *s = (const uchar *)str;
    uchar c = (uchar)ch;
    if (from < 0)
        from = qMax(from + len, 0);
    if (from < len) {
        const uchar *n = s + from - 1;
        const uchar *e = s + len;
        while (++n != e)
            if (*n == c)
                return  n - s;
    }
    return -1;
}

qFindByteArray()

int qFindByteArray	(	const char *	haystack0,
		int	haystackLen,
		int	from,
		const char *	needle,
		int	needleLen
	)

Warning

This function is not part of the public interface.

Definition at line 275 of file qbytearraymatcher.cpp.

Referenced by QByteArray::indexOf().

{
    const int l = haystackLen;
    const int sl = needleLen;
    if (from < 0)
        from += l;
    if (uint(sl + from) > (uint)l)
        return -1;
    if (!sl)
        return from;
    if (!l)
        return -1;

    if (sl == 1)
        return findChar(haystack0, haystackLen, needle[0], from);

    /*
      We use the Boyer-Moore algorithm in cases where the overhead
      for the skip table should pay off, otherwise we use a simple
      hash function.
    */
    if (l > 500 && sl > 5)
        return qFindByteArrayBoyerMoore(haystack0, haystackLen, from,
                                        needle, needleLen);

    /*
      We use some hashing for efficiency's sake. Instead of
      comparing strings, we compare the hash value of str with that
      of a part of this QString. Only if that matches, we call memcmp().
    */
    const char *haystack = haystack0 + from;
    const char *end = haystack0 + (l - sl);
    const uint sl_minus_1 = sl - 1;
    uint hashNeedle = 0, hashHaystack = 0;
    int idx;
    for (idx = 0; idx < sl; ++idx) {
        hashNeedle = ((hashNeedle<<1) + needle[idx]);
        hashHaystack = ((hashHaystack<<1) + haystack[idx]);
    }
    hashHaystack -= *(haystack + sl_minus_1);

    while (haystack <= end) {
        hashHaystack += *(haystack + sl_minus_1);
        if (hashHaystack == hashNeedle && *needle == *haystack
             && memcmp(needle, haystack, sl) == 0)
            return haystack - haystack0;

        REHASH(*haystack);
        ++haystack;
    }
    return -1;
}

qFindByteArrayBoyerMoore()

static int qFindByteArrayBoyerMoore ( const char *  haystack, int  haystackLen, int  haystackOffset, const char *  needle, int  needleLen  )

static

Warning

This function is not part of the public interface.

Definition at line 256 of file qbytearraymatcher.cpp.

Referenced by qFindByteArray().

{
    uchar skiptable[256];
    bm_init_skiptable((const uchar *)needle, needleLen, skiptable);
    if (haystackOffset < 0)
        haystackOffset = 0;
    return bm_find((const uchar *)haystack, haystackLen, haystackOffset,
                   (const uchar *)needle, needleLen, skiptable);
}