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;
}



评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值