C标准库源码解剖(5)：字符串处理函数string.h和wchar.h(续)

3、字符串复制strcpy,strncpy,wcscpy,wcsncpy：将字符串src（或其前n个字符）复制到dest中，覆盖dest的内容。实现中先检查指针是否越界，计算指针dest到src的偏移，然后开始做复制操作，复制到dest的开始位置处，以覆盖dest的内容。对strncpy，也采用了每4个字符作为一组来进行复制的方法，以加快复制速度。

/* strcpy.c：strcpy函数的实现 */
#include <stddef.h>   /* 用到了ptrdiff_t */
#include <string.h>
#include <memcopy.h>
#include <bp-checks.h>  /* 定义了CHECK_BOUNDS_LOW和CHECK_BOUNDS_HIGH */
#undef strcpy
/* 将SRC复制到DEST中，覆盖DEST原先的内容 */
char *
strcpy (dest, src)
char *dest;
const char *src;
{
reg_char c;
/* 检查指针src的值是否 >= low，返回原来的指针值 */
char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src);
/* 计算出目的地dest到s的偏移 */
const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1;
size_t n;
do
{
c = *s++;   /* 把src中每个字符复制到目的地，覆盖了dest中的内容 */
s[off] = c;
}
while (c != '/0');
n = s - src;
(void) CHECK_BOUNDS_HIGH (src + n); /* 检查指针src+n的值是否 < high，返回原来的指针值 */
(void) CHECK_BOUNDS_HIGH (dest + n);
return dest;
}
libc_hidden_builtin_def (strcpy)

/* strncpy.c：strncpy函数的实现  */
#include <string.h>
#include <memcopy.h>
#undef strncpy
/* 将s2的前n个字符复制到s1中，覆盖s1原先的内容，若s2不中n个字符，
则填充null字符，直到写入n个字符 */
char *
strncpy (s1, s2, n)
char *s1;
const char *s2;
size_t n;
{
reg_char c;
char *s = s1;
--s1; /* 指向首字符的前一个字符 */
if (n >= 4)     /* 做复制操作，每4个字符作为一组来进行复制 */
{
size_t n4 = n >> 2; /* 让n除以4，计算出循环次数 */
for (;;)   /* 每次循环都复制4个字符，总共复制了4*n4个字符 */
{
c = *s2++;
*++s1 = c;
if (c == '/0') /* s2不足n个字符时，复制完毕，退出循环 */
break;
c = *s2++;
*++s1 = c;
if (c == '/0')
break;
c = *s2++;
*++s1 = c;
if (c == '/0')
break;
c = *s2++;
*++s1 = c;
if (c == '/0')
break;
if (--n4 == 0)
goto last_chars; /* 循环终止，要对剩下的几个字符（不超过3个）进行复制 */
}
n = n - (s1 - s) - 1;
if (n == 0)  /* 若s1恰好到达s的终止符的前一个字符处 */
return s;  /* 说明s与s2长度相等，均为n，复制操作恰好用s2覆盖了s，终止符没有覆盖，直接返回s */
goto zero_fill; /* 否则s1没有到达s的末尾，说明s2不足n个字符，需要在s1末尾填充null字符，直到写入n个字符 */
}
last_chars:
n &= 3; /* 求出n除以4的余数 */
if (n == 0)  /* 余数为0说明没有剩余的未复制的字符，直接返回s */
return s;
do   /* 对剩下的几个字符（最多3个）进行复制 */
{
c = *s2++;
*++s1 = c;
if (--n == 0)
return s;
}
while (c != '/0');
zero_fill:
do
*++s1 = '/0';  /* 在s1末尾填充null字符，直到写入n个字符 */
while (--n > 0);
return s;
}
libc_hidden_builtin_def (strncpy)

4、字符串求长strlen,wcslen：返回str中终止符'/0'之前的字符个数。这里通过把指针移到终止符处，然后计算该指针与开始处指针的差值来获取字符串的长度。为了加快移动速度，实现中把const char*型指针char_ptr转换成了unsigned long*型指针longword_ptr，这样一次就可以移动4个字节。算法关键是要辨别出longword_ptr指向的值（有4个字节）中有一个字节为0（它表示字符'/0'），这说明指针到达了终止符'/0'处，要停止移动，并转换回const char*型指针，计算指针之间的差值。

/* strlen.c：strlen函数的实现 */
#include <string.h>
#include <stdlib.h>  /* 用到abort()函数 */
#undef strlen
/* 返回以null终止的字符串str的长度。通过一次测试4个字节来迅速的扫描到null终止符 */
size_t
strlen (str)
const char *str;
{
const char *char_ptr;
const unsigned long int *longword_ptr;
unsigned long int longword, magic_bits, himagic, lomagic;
/* 通过一次读取一个字符来处理开头的几个字符，直到char_ptr中的值对齐到一个long型字的边界，
即直到char_ptr中的值是long的字节数（通常为4）的倍数 */
for (char_ptr = str; ((unsigned long int) char_ptr
& (sizeof (longword) - 1)) != 0;
++char_ptr)
if (*char_ptr == '/0') /* 若到达null终止符，则直接返回长度 */
return char_ptr - str;
/* 所有这些说明性的注释使用4字节的long型字，但本算法同样也可以应用于8字节的long型字 */

longword_ptr = (unsigned long int *) char_ptr;
/* magic_bits的第8,16,24,31位为0，称这些位为“洞”。注意每个字节的左边有一个洞，
在最后的位置上也有一个洞。
bits:  01111110 11111110 11111110 11111111
比特1确保进位能传播到后面的比特0上，比特0则提供洞，以便让进位陷进去  */
magic_bits = 0x7efefeffL;
himagic = 0x80808080L;  /* 高位魔数，即第7,15,23,31位上为1 */
lomagic = 0x01010101L;  /* 低位魔数，即第0,8,16,24位上为1 */
if (sizeof (longword) > 4) /*  64位的平台上 */
{
/* 魔数的64位版本 */
/* 移位操作分两步，以避免当long为32位时出现警告 */
/* 位数的第8,16,24,32,40,48,56,63位上为0 */
magic_bits = ((0x7efefefeL << 16) << 16) | 0xfefefeffL;
himagic = ((himagic << 16) << 16) | himagic; /* 第7,15,23,31,39,47,55,63位上为1 */
lomagic = ((lomagic << 16) << 16) | lomagic; /* 第0,8,16,24,32,40,48,56位上为0 */
}
if (sizeof (longword) > 8) /* long类型大于8字节则终止程序 */
abort ();
/* 这里我们不使用传统的对每个字符都进行测试的循环，而是一次测试一个long型字。技巧性的部分
是测试当前long型字的各个字节是否为0 */
for (;;)
{
longword = *longword_ptr++;
if (
#if 0
/* 让longword加上魔数magic_bits  */
(((longword + magic_bits)
/* 设置那些通过加法而未改变的位 */
^ ~longword)

/* 只需看这些洞。如果任何的洞位都没有改变，最有可能的是有一个字节值为0 */
& ~magic_bits)
#else
((longword - lomagic) & himagic)
#endif
!= 0)
{
/* 长整型字的哪个字节为0？如果都不为0，则是一个非预期情况，继续搜索 */
const char *cp = (const char *) (longword_ptr - 1);
if (cp[0] == 0)
return cp - str;
if (cp[1] == 0)
return cp - str + 1;
if (cp[2] == 0)
return cp - str + 2;
if (cp[3] == 0)
return cp - str + 3;
if (sizeof (longword) > 4) /* 如果long类型是8个字节，则还有4个字节需要判断 */
{
if (cp[4] == 0)
return cp - str + 4;
if (cp[5] == 0)
return cp - str + 5;
if (cp[6] == 0)
return cp - str + 6;
if (cp[7] == 0)
return cp - str + 7;
}
}
}
}
libc_hidden_builtin_def (strlen)

解释：
（1）先移动char_ptr，使其值对齐到长整型字的边界，即移动到使char_ptr中的值是4的倍数为止。在对齐过程中若到达了终止符处，则直接返回与开始处的指针str的差值。
（2）对longword_ptr指针进行移动时，指针指向的值为longword。为了判断指针是否到达终止符，算法实现使用了两个魔数lomagic和himagic，lomagic各个字节的最低位为1，其余位均为0；himagic各个字节的最高位为1，其余位均为0。看表达式(longword - lomagic) & himagic，若longword中有一个字节为00000000，则减00000001时要向高字节借一位，得到11111111或11111110（当借了一位给更低的字节时），与10000000做“与”运算后变成10000000，这时表达式的结果必定不为0。可见，只有在表达式结果不等于0时，longword中才有可能有终止符。因此，在移动过程中，一旦表达式结果不等于0，只要逐一检查一下每个字节，看哪个为0，这时就到达终止符，计算指针差值并返回。若都不为0，则继续移动。
（3）也可以只用一个魔数magic_bits来实现，即代码中用#if 0注释掉的那部分，它可以达到同样的效果。看表达式((longword + magic_bits) ^ ~longword) & ~magic_bits，最后的“与”运算会使结果的其他位清零，只留下那4个洞位，因此我们只要看longword的洞位的变化即可。若longword中有一个字节为0，则做加法后它不可能向高字节（即左侧字节）进位，左侧字节的洞位没有改变（因为magic_bits的对应洞位为0，加上0而又没有低字节的进位，因此不会改变）。做异或运算后，必定使这个洞位变成1，因此表达式的结果必定不为0。可见，这跟（2）用两个魔数实现的效果是一样的。
5、字符搜索strchr,strrchr,wcschr,wcsrchr：在字符串s中查找字符c的第一次（或最后一次）出现，若没找到则返回NULL指针。算法实现与strlen类似，只不过在strlen是搜索到终止符'/0'为止，这里是搜索到字符c为止。

/* strchr.c：strchr函数的实现  */
#include <string.h>
#include <memcopy.h>  /* 非标准头文件，要用到reg_char类型 */
#include <stdlib.h>   /* 要用到abort() */
#undef strchr
/* 在S中查找C的第一次出现，如果没有找到，则返回NULL指针  */
char *
strchr (s, c_in)
const char *s;
int c_in;
{
const unsigned char *char_ptr;
const unsigned long int *longword_ptr;
unsigned long int longword, magic_bits, charmask;
unsigned reg_char c;
c = (unsigned char) c_in;
/* 通过一次读取一个字符来处理开头的几个字符，直到char_ptr中的值对齐到一个long型字的边界，
即直到char_ptr中的值是long的字节数（通常为4）的倍数 */
for (char_ptr = (const unsigned char *) s;
((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0;
++char_ptr)
if (*char_ptr == c)     /* 若到达字符c处，则直接返回其指针 */
return (void *) char_ptr;
else if (*char_ptr == '/0')  /* 没找到c则返回NULL */
return NULL;
/* 所有这些说明性的注释使用4字节的long型字，但本算法同样也可以应用于8字节的long型字 */
longword_ptr = (unsigned long int *) char_ptr;
/* magic_bits的第8,16,24,31位为0，称这些位为“洞”。注意每个字节的左边有一个洞，
在最后的位置上也有一个洞。
bits:  01111110 11111110 11111110 11111111
比特1确保进位能传播到后面的比特0上，比特0则提供洞，以便让进位陷进去  */
switch (sizeof (longword))
{
case 4: magic_bits = 0x7efefeffL; break;
case 8: magic_bits = ((0x7efefefeL << 16) << 16) | 0xfefefeffL; break;
default:
abort ();
}
/* 设置一个长整型字，其每个字节都是字符c */
charmask = c | (c << 8);
charmask |= charmask << 16;
if (sizeof (longword) > 4)
/* 移位操作分两步，以避免当long为32位时出现警告 */
charmask |= (charmask << 16) << 16;
if (sizeof (longword) > 8)
abort ();  /* long类型大于8字节则终止程序 */
/* 这里我们不使用传统的对每个字符都进行测试的循环，而是一次测试一个long型字。技巧性的部分
是测试当前long型字的各个字节是否为0 */
for (;;)
{
longword = *longword_ptr++;
/* 让longword加上魔数magic_bits  */
if ((((longword + magic_bits)
/* 设置那些通过加法而未改变的位 */
^ ~longword)
/* 只需看这些洞。如果任何的洞位都没有改变，最有可能的是有一个字节值为0 */
& ~magic_bits) != 0 ||
/* 捕捉到值为0的字节后，测试字中是否含有字符c  */
((((longword ^ charmask) + magic_bits) ^ ~(longword ^ charmask))
& ~magic_bits) != 0)
{
/* 长整型字的哪个字节为C或0？如果都不是，则是一个非预期情况，继续搜索 */
const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);
if (*cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (sizeof (longword) > 4) /* 如果long类型是8个字节，则还有4个字节需要判断 */
{
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
if (*++cp == c)
return (char *) cp;
else if (*cp == '/0')
return NULL;
}
}
}
return NULL;
}
#ifdef weak_alias
#undef index
weak_alias (strchr, index)
#endif
libc_hidden_builtin_def (strchr)

/* strrchr.c：strrchr函数的实现 */
#include <string.h>
#undef strrchr
/* 在S中查找C的最后一次出现  */
char *
strrchr (const char *s, int c)
{
register const char *found, *p;
c = (unsigned char) c;
/* 因为strchr非常地快，我们直接使用它来实现strrchr */
if (c == '/0')
return strchr (s, '/0');
found = NULL;
while ((p = strchr (s, c)) != NULL)
{
found = p;
s = p + 1;
}
return (char *) found;
}
#ifdef weak_alias
#undef rindex
weak_alias (strrchr, rindex)
#endif
libc_hidden_builtin_def (strrchr)

解释：
（1）算法中，有可能搜索到字符c，也有可能搜索到终止符（当字符串中没有c时）。对于搜索到终止符，与strlen中一样，对于搜索到字符c，要判断longword中是否有一个字节为c，看表达式(((longword ^ charmask) + magic_bits) ^ ~(longword ^ charmask)) & ~magic_bits，长整型字charmask的每个字节都是字符c。strlen的对应表达式中的longword换成了这里的longword ^ charmask，而这里的longword中有一个字节为c，恰好等价于longword ^ charmask中有一个字节为0，因此具体的分析过程是一样的。
（2）strrchr的实现直接使用strchr。用strchr不停地向前搜索，直到搜索到最后一个c为止。
6、子串的无顺序匹配strspn,strcspn,strpbrk,wcsspn,wcscspn,wcspbrk：strspn和strcspn在s的开头查找一个最长子串，使其所有字符都在accept中（或都不在reject中），返回这个子串的长度。strspn的实现中直接对s中开头的每个字符搜索accept，看其是否在accept中。strcspn的实现则使用了strchr来查找字符。strpbrk在s中搜索第一个出现在accept中的字符，返回其指针。

/* strspn.c：strspn函数的实现 */
#include <string.h>
#undef strspn
/* 返回S中的第一个子串长度，这个子串的所有字符都在ACCEPT中  */
size_t
strspn (s, accept)
const char *s;
const char *accept;
{
const char *p;
const char *a;
size_t count = 0;
for (p = s; *p != '/0'; ++p) /* 对s开头的各个字符，搜索accept */
{
for (a = accept; *a != '/0'; ++a)
if (*p == *a)  /* 若该字符在accept中，则子串长度加1 */
break;
if (*a == '/0') /* 若在accept中没有找到该字符，则子串匹配结束，直接返回count */
return count;
else
++count;
}
return count;
}
libc_hidden_builtin_def (strspn)

/* strcspn.c：strcspn函数的实现 */
#if HAVE_CONFIG_H
# include <config.h>
#endif
#if defined _LIBC || HAVE_STRING_H
# include <string.h>
#else
# include <strings.h>
# ifndef strchr
#  define strchr index
# endif
#endif
#undef strcspn
/* 返回S中的第一个子串长度，这个子串的所有字符都不在REJECT中  */
size_t
strcspn (s, reject)
const char *s;
const char *reject;
{
size_t count = 0;
while (*s != '/0')  /* 对s开头的各个字符，搜索reject */
if (strchr (reject, *s++) == NULL) /* 若不在reject，则子串长度加1 */
++count;
else
return count;
return count;
}
libc_hidden_builtin_def (strcspn)

/* strpbrk.c：strpbrk函数的实现  */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#if defined _LIBC || defined HAVE_CONFIG_H
# include <string.h>
#endif
#undef strpbrk
/* 在s中搜索第一个出现在accept中的字符，返回其指针 */
char *
strpbrk (s, accept)
const char *s;
const char *accept;
{
while (*s != '/0') /* 对s开头的各个字符，看其是否在accept中 */
{
const char *a = accept;
while (*a != '/0')
if (*a++ == *s) /* 若在accept，则返回，否则继承向前搜索 */
return (char *) s;
++s;
}
return NULL;
}
libc_hidden_builtin_def (strpbrk)

7、模式匹配及字符串解析strstr,strtok,wcsstr,wcstok：strstr(src,sub)在src中搜索子串sub，返回其第一次出现的位置。strtok(str,set)用set中的字符作为分隔符把str分解为多个标号。
strstr的实现用了最新的二路模式匹配算法，可以达到最好的效率。由于算法比较复杂，涉及到很多内部函数，这里就不解剖了，我们平时一般使用KMP算法来进行模式匹配，这个效率也已经非常不错了。strtok实现如下：

/* strok.c：strok函数的实现  */
#include <string.h>
static char *olds; /* 下一记号的开始处，若到达字符串末尾，则olds指向终止符'/0' */
#undef strtok
/* 用DELIM中的字符作为分隔符把S解析成多个记号，返回当前的记号。如果S为NULL，
则strtok从即下一记号的开始处开始解析。例如：
char s[] = "-abc-=-def";
x = strtok(s, "-");		// x = "abc"
x = strtok(NULL, "-=");		// x = "def"
x = strtok(NULL, "=");		// x = NULL
// s = "abc/0=-def/0"
*/
char *
strtok (s, delim)
char *s;
const char *delim;
{
char *token;
if (s == NULL) /* s指定为NULL，则使用olds */
s = olds;
/* 从s开始搜索分隔符，跳过分隔符，让s移动到记号开始处  */
s += strspn (s, delim);
if (*s == '/0') /* 若s到达字符串末尾，则返回NULL表示记号解析过程完毕 */
{
olds = s;
return NULL;
}
/* 找到当前记号的末尾处（即下一分隔符处）  */
token = s; /* token指向记号的首个字符 */
s = strpbrk (token, delim); /* 从token开始找到下一分隔符，让s指向它 */
if (s == NULL) /* 如果到达的是字符串末尾，说明当前记号是最后一个记号 */
/* 从token开始，找到终止符，并赋给olds，表示记号解析结束  */
olds = __rawmemchr (token, '/0');
else  /* 否则s指向了下一分隔符 */
{
/* 把分隔符替换成'/0'，以解析出当前记号，让OLDS指向下一记号的开始处  */
*s = '/0';
olds = s + 1;
}
return token;
}

算法先用strspn函数使s路过分隔符，移到当前记号的开始处；接着让token指向当前记号开始处，s移到下一个分隔符处（通过strpbrk函数）；然后把这个分隔符替换成终止符'/0'，以解析出当前记号，olds指向下一记号的开始处。下一次解析时，若指定s为NULL，则从olds处开始新的解析。