Redis源码分析（二十三）——通用工具算法util

通用工具类算法是一些常见的辅助处理算法。在此主要分析正则表达式的匹配原理，以及字符串与长整型之间的相互转换。 

正则表达式的匹配原理：

通过这次分析，才算正真懂了正则表达式匹配的原理和具体的处理过程，也算是一大收获。

函数stringmatchlen：

支持glob-style的通配符格式,如*表示任意一个或多个字符,?表示任意字符,[abc]表示方括号中任意一个字母。
将给定字符串与给定模式匹配，匹配返回1，否则返回0

int stringmatchlen(const char *pattern, int patternLen,
        const char *string, int stringLen, int nocase)
{
    while(patternLen) {
        switch(pattern[0]) {
        case '*':  //模式的当前字符为*， 则只需要模式中连续*以后的部分与给定string的某后部分匹配即可
            while (pattern[1] == '*') {
                pattern++;
                patternLen--;
            }
            if (patternLen == 1)  //到此，说明模式全为*， 当然匹配
                return 1; /* match */
            while(stringLen) {   //模式前部分全为*， 则只需后部分与string 的某后部分匹配即可，
			                      //依次往后查找string中的该“某后部分”，直到匹配，或者到尾部
                if (stringmatchlen(pattern+1, patternLen-1,
                            string, stringLen, nocase))
                    return 1; /* match */
                string++;
                stringLen--;
            }
            return 0; /* no match */
            break;
        case '?':    //模式的当前字符为？ ，则直接跳过string的当前字符，从下一字符开始判断
            if (stringLen == 0)
                return 0; /* no match */
            string++;
            stringLen--;
            break;
        case '[':   //模式的当前字符为[  ，范围，需要根据下一字符确定是为为 ^
        {
            int not, match;

            pattern++;
            patternLen--;
            not = pattern[0] == '^';
            if (not) {
                pattern++;
                patternLen--;
            }
            match = 0;
            while(1) {
                if (pattern[0] == '\\') {
                    pattern++;
                    patternLen--;
                    if (pattern[0] == string[0])
                        match = 1;
                } else if (pattern[0] == ']') { //[]里面为空
                    break;
                } else if (patternLen == 0) {
                    pattern--;
                    patternLen++;
                    break;
                } else if (pattern[1] == '-' && patternLen >= 3) {//如[1-8]:即1到8中的任意一个字符 ，只要string当前字符在此范围内
                    int start = pattern[0];
                    int end = pattern[2];
                    int c = string[0];
                    if (start > end) {
                        int t = start;
                        start = end;
                        end = t;
                    }
                    if (nocase) {
                        start = tolower(start);
                        end = tolower(end);
                        c = tolower(c);
                    }
                    pattern += 2;
                    patternLen -= 2;
                    if (c >= start && c <= end)
                        match = 1;
                } else {
                    if (!nocase) {
                        if (pattern[0] == string[0])
                            match = 1;
                    } else {
                        if (tolower((int)pattern[0]) == tolower((int)string[0]))
                            match = 1;
                    }
                }
                pattern++;
                patternLen--;
            }
            if (not)
                match = !match;
            if (!match)
                return 0; /* no match */
            string++;
            stringLen--;
            break;
        }
        case '\\':
            if (patternLen >= 2) {
                pattern++;
                patternLen--;
            }
            /* fall through */
        default: // 如果没有正则表达式的关键字符，则直接比较 
            if (!nocase) {
                if (pattern[0] != string[0])
                    return 0; /* no match */
            } else {
                if (tolower((int)pattern[0]) != tolower((int)string[0]))
                    return 0; /* no match */
            }
            string++;
            stringLen--;
            break;
        }
        pattern++;
        patternLen--;
        if (stringLen == 0) {
            while(*pattern == '*') {
                pattern++;
                patternLen--;
            }
            break;
        }
    }
    if (patternLen == 0 && stringLen == 0)//完全匹配
        return 1;
    return 0;
}

字符串与长整型之间的相互转换：

 数值转换为字符串：    注意作者的具体做法，值得深思与学习！

 我们一般的做法是 每次除以10 取余，再将余数转换为对应的字符，如此从低位到高位逐位处理。
 在这作者提供了更好的做法： 由于longlong类型是很长的数值，因此每次除以10，逐位处理需要进行很多次，所以采取除以100，每次处理两位，如此一来节约了一半的时间； 另外，作者将所有的两位数00 到99，所对应的字符全部先存放到一个字符串表中，后面只需要直接查表取出对应的字符即可，而不需要每次都去转换。   这再次大大的提高了效率啊！

int ll2string(char* dst, size_t dstlen, long long svalue) {
//00到99的数字对应的字符串， 直接查表，而不是每次都将整数转换为字符串
    static const char digits[201] =
        "0001020304050607080910111213141516171819"
        "2021222324252627282930313233343536373839"
        "4041424344454647484950515253545556575859"
        "6061626364656667686970717273747576777879"
        "8081828384858687888990919293949596979899";
    int negative;
    unsigned long long value;
    uint32_t next;

    /* The main loop works with 64bit unsigned integers for simplicity, so
     * we convert the number here and remember if it is negative. */
	 //把负数转换为正数处理，加上一位的符号
    if (svalue < 0) {
        if (svalue != LLONG_MIN) {
            value = -svalue;
        } else {
            value = ((unsigned long long) LLONG_MAX)+1;
        }
        negative = 1;
    } else {
        value = svalue;
        negative = 0;
    }

    /* Check length. */
    uint32_t const length = digits10(value)+negative;
    if (length >= dstlen) return 0;//由于在字符串中末尾需要包含‘\0’，因此所需的字符串的长度至少要比ll长度大1

    /* Null term. */
    next = length;
    dst[next] = '\0';
    next--;   
    while (value >= 100) {   //由于每次都是处理的除以100的余数，即ll的低两位,因此从字符串的末尾向前开始填充
        int const i = (value % 100) * 2;
        value /= 100;
        dst[next] = digits[i + 1];//直接查表，取得对应的字符
        dst[next - 1] = digits[i];
        next -= 2;
    }

    /* Handle last 1-2 digits. */
    if (value < 10) {
        dst[next] = '0' + (uint32_t) value;
    } else {
        int i = (uint32_t) value * 2;
        dst[next] = digits[i + 1];
        dst[next - 1] = digits[i];
    }

    /* Add sign. */
	//若为负数，在字符串开头加上负号标志
    if (negative) dst[0] = '-';
    return length;
}

字符串转换为longlong:

 //字符串转换为longlong:从字符串的第一位开始逐位取出，（第一位为longlong的最高位）。每次将ll值乘以10，然后将新取出的低位作为各位数加到ll值上
int string2ll(const char *s, size_t slen, long long *value) {
    const char *p = s;
    size_t plen = 0;
    int negative = 0;
    unsigned long long v;

    if (plen == slen)
        return 0;

    /* Special case: first and only digit is 0. */
    if (slen == 1 && p[0] == '0') {
        if (value != NULL) *value = 0;
        return 1;
    }

    if (p[0] == '-') {
        negative = 1;
        p++; plen++;

        /* Abort on only a negative sign. */
        if (plen == slen)
            return 0;
    }

    /* First digit should be 1-9, otherwise the string should just be 0. */
    if (p[0] >= '1' && p[0] <= '9') {
        v = p[0]-'0';
        p++; plen++;
    } else if (p[0] == '0' && slen == 1) {
        *value = 0;
        return 1;
    } else {
        return 0;
    }

    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
        if (v > (ULLONG_MAX / 10)) /* Overflow. */
            return 0;
        v *= 10;

        if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */
            return 0;
        v += p[0]-'0';

        p++; plen++;
    }

    /* Return if not all bytes were used. */
    if (plen < slen)
        return 0;

    if (negative) {
        if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
            return 0;
        if (value != NULL) *value = -v;
    } else {
        if (v > LLONG_MAX) /* Overflow. */
            return 0;
        if (value != NULL) *value = v;
    }
    return 1;
}