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

8、特定区域的字符串比较和转换strcoll,strxfrm,wcscoll,wcsxfrm：strcoll使用当前的区域设置来比较字符串，strxfrm使用当前的区域设置来转换字符串。当前区域设置由LL_COLLATE宏指定。它们均调用带有区域设置参数的内部版本strcoll_l和strxfrm_l来完成实际的工作。

/* strcoll.c：strcoll函数的实现 */
#include <string.h>
#ifndef STRING_TYPE
# define STRING_TYPE char
# define STRCOLL strcoll
# define STRCOLL_L __strcoll_l
# define USE_HIDDEN_DEF
#endif
#include "../locale/localeinfo.h"
int
STRCOLL (s1, s2)
const STRING_TYPE *s1;
const STRING_TYPE *s2;
{
return STRCOLL_L (s1, s2, _NL_CURRENT_LOCALE);
}
#ifdef USE_HIDDEN_DEF
libc_hidden_def (STRCOLL)
#endif

/* strxfrm.c：strxfrm函数的实现  */
#include <string.h>
#include <locale/localeinfo.h>
#ifndef STRING_TYPE
# define STRING_TYPE char
# define STRXFRM strxfrm
# define STRXFRM_L __strxfrm_l
#endif
size_t
STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n)
{
return STRXFRM_L (dest, src, n, _NL_CURRENT_LOCALE);
}

9、错误消息报告strerror：获取错误码errnum的字符串描述，在下一次调用strerror之前这个字符串存储空间不能修改，对这个空间进行写操作会导致未定义的行为。若获取没有成功，则使用errno全局变量（或全局宏）中的错误码来获取错误消息。

/* strerror.c：strerror函数的实现  */
#include <libintl.h> /* 有很多内部接口 */
#include <stdio.h>
#include <string.h>
#include <errno.h>   /* errno中保存了程序的错误码 */
/* 返回错误码errnum的字符串描述，在下一次调用strerror之前这个字符串存储
空间不能修改，对这个空间进行写操作会导致未定义的行为 */
libc_freeres_ptr (static char *buf); /* 存放字符串描述的全局空间 */
char *
strerror (errnum)
int errnum;
{
char *ret = __strerror_r (errnum, NULL, 0); /* 根据错误码获取错误消息 */
int saved_errno;
if (__builtin_expect (ret != NULL, 1)) /* 若错误消息获取成功，则返回它 */
return ret;
/* 否则获取errno中保存的程序错误码，用缓冲区buf来存储它的字符串描述 */
saved_errno = errno;
if (buf == NULL)
buf = malloc (1024);  /* buf是一个全局缓冲区 */
__set_errno (saved_errno); /* 设置错误码 */
if (buf == NULL)
return _("Unknown error");
return __strerror_r (errnum, buf, 1024); /* 获取错误码对应的错误消息并返回 */
}

10、内存块复制memcpy,memmove,wmemcpy,wmemmove：memcpy从SRC中复制N个字节的内容到DEST中，memmove从SRC中复制N个字节的内容到DEST中，保证对重叠字符串（即SRC与DEST共用存储空间）有正确的行为。这两个函数的实现使用了memcopy.h和pagecopy.h中定义的内部接口，有按字节方式复制BYTE_COPY_FWD，按字方式复制WORD_COPY_FWD（一个字为unsigned long型）、按页方式复制PAGE_COPY_FWD_MAYBE，这些接口都是以宏的形式提供的。

/* memcopy.h -- 在内存复制函数中使用的一些定义  */
/* 内存函数的复制策略是：
1、复制字节，直到目标指针被对齐。
2、在展开的循环中复制字。如果源指针和目标指针不是用
同一种方式对齐，则使用字内存操作，但在写之前要对两个读取的字进行移位和合并
3、复制剩下的几个字节
在至少有10个寄存器用来给GCC使用的处理器上，这是非常快速的，并且能在一条指令中使用
reg+const来访问内存  */
#include <sys/cdefs.h>
#include <endian.h>
/* 在本文件中定义的宏有：
BYTE_COPY_FWD(dst_beg_ptr, src_beg_ptr, nbytes_to_copy)
BYTE_COPY_BWD(dst_end_ptr, src_end_ptr, nbytes_to_copy)
WORD_COPY_FWD(dst_beg_ptr, src_beg_ptr, nbytes_remaining, nbytes_to_copy)
WORD_COPY_BWD(dst_end_ptr, src_end_ptr, nbytes_remaining, nbytes_to_copy)
MERGE(old_word, sh_1, new_word, sh_2)
*/
/* 用于对齐的内存操作类型，正常时它应该是能一次装载和存储的最大类型 */
#define	op_t	unsigned long int
#define OPSIZ	(sizeof(op_t))
/* 用于未对齐的操作类型 */
typedef unsigned char byte;
/* 用于在寄存器中存储字节的优化类型 */
#define	reg_char	char
/* 对两个字的合并操作 */
#if __BYTE_ORDER == __LITTLE_ENDIAN  /* 小端字节序：w0在低端，w1在高端 */
#define MERGE(w0, sh_1, w1, sh_2) (((w0) >> (sh_1)) | ((w1) << (sh_2)))
#endif
#if __BYTE_ORDER == __BIG_ENDIAN  /* 大端字节序：w0在高端，w1在低端 */
#define MERGE(w0, sh_1, w1, sh_2) (((w0) << (sh_1)) | ((w1) >> (sh_2)))
#endif
/* 向前复制：从SRC_BP中精确地复制NBTYES个字节到DST_BP中，无需对指针的对齐作任何假设  */
#define BYTE_COPY_FWD(dst_bp, src_bp, nbytes)				      /
do									      /
{									      /
size_t __nbytes = (nbytes);					      /
while (__nbytes > 0)						      /
{								      /
byte __x = ((byte *) src_bp)[0];				      /
src_bp += 1;							      /
__nbytes -= 1;						      /
((byte *) dst_bp)[0] = __x;					      /
dst_bp += 1;							      /
}								      /
} while (0)
/* 向后复制：从SRC_END_PTR中精确地复制NBTYTES_TO_COPY个字节到DST＿END＿PTR中，
复制从指针前面的字节右端开始，并且向着更小的地址方向前进。无需对指针的对齐作任何假设 */
#define BYTE_COPY_BWD(dst_ep, src_ep, nbytes)				      /
do									      /
{									      /
size_t __nbytes = (nbytes);					      /
while (__nbytes > 0)						      /
{								      /
byte __x;							      /
src_ep -= 1;							      /
__x = ((byte *) src_ep)[0];					      /
dst_ep -= 1;							      /
__nbytes -= 1;						      /
((byte *) dst_ep)[0] = __x;					      /
}								      /
} while (0)
/* 向前复制：从SRC_BP中复制最多NBYTES个字节到DST＿BP中，假设DST_BP对齐到OPSIZ的倍数。
如果不是所有的字节都能顺利的复制，剩下的字节数保存到NBYTES_LEFT中，否则存入0 */
extern void _wordcopy_fwd_aligned (long int, long int, size_t) __THROW;
extern void _wordcopy_fwd_dest_aligned (long int, long int, size_t) __THROW;
#define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)		      /
do									      /
{									      /
if (src_bp % OPSIZ == 0)						      /
_wordcopy_fwd_aligned (dst_bp, src_bp, (nbytes) / OPSIZ);	      /
else								      /
_wordcopy_fwd_dest_aligned (dst_bp, src_bp, (nbytes) / OPSIZ);	      /
src_bp += (nbytes) & -OPSIZ;					      /
dst_bp += (nbytes) & -OPSIZ;					      /
(nbytes_left) = (nbytes) % OPSIZ;					      /
} while (0)
/* 向后复制：从SRC_END_PTR中复制最多NBYTES_TO_COPY个字节到DST＿END_PTR中，复制
从指针前面的字（为op_t类型）的右端开始，并且向着更小的地址方向前进。可以利用DST_END_PTR
已经对齐到OPSIZ的倍数。如果不是所有的字节都能顺利的复制，剩下的字节数保存到
NBYTES_REMAINING中，否则存入0 */
extern void _wordcopy_bwd_aligned (long int, long int, size_t) __THROW;
extern void _wordcopy_bwd_dest_aligned (long int, long int, size_t) __THROW;
#define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes)		      /
do									      /
{									      /
if (src_ep % OPSIZ == 0)						      /
_wordcopy_bwd_aligned (dst_ep, src_ep, (nbytes) / OPSIZ);	      /
else								      /
_wordcopy_bwd_dest_aligned (dst_ep, src_ep, (nbytes) / OPSIZ);	      /
src_ep -= (nbytes) & -OPSIZ;					      /
dst_ep -= (nbytes) & -OPSIZ;					      /
(nbytes_left) = (nbytes) % OPSIZ;					      /
} while (0)
/* 进入展开循环的门槛值  */
#define	OP_T_THRES	16

/* pagecopy.h -- 按页方式来复制的宏；用在memcpy和memmove中  */
/* 本文件中定义的宏：
PAGE_COPY_FWD_MAYBE (dstp, srcp, nbytes_left, nbytes)
由WORD_COPY_FWD以及其他的函数来调用，指针至少要是字对齐的。这将会检查虚页复制是否能
执行、是否应该执行、以及如果能执行的话则执行它
依赖于系统的pagecopy.h文件应该定义以下宏，然后包含本文件：
PAGE_COPY_THRESHOLD
-- 值得使用按页复制策略的最小字节数
PAGE_SIZE
-- 页的大小
PAGE_COPY_FWD (dstp, srcp, nbytes_left, nbytes)
-- 执行虚页复制操作的宏。指针要对齐到PAGE_SIZE个字节的边界上
*/
#if PAGE_COPY_THRESHOLD
#include <assert.h>
#define PAGE_COPY_FWD_MAYBE(dstp, srcp, nbytes_left, nbytes)		      /
do									      /
{									      /
if ((nbytes) >= PAGE_COPY_THRESHOLD &&				      /
PAGE_OFFSET ((dstp) - (srcp)) == 0) 				      /
{								      /
/* 要复制的字节数超过内核用于复制虚拟页的VM操作的门槛值，且源地址	      /
和目标地址有同样的对齐方式 */    /
size_t nbytes_before = PAGE_OFFSET (-(dstp));			      /
if (nbytes_before != 0)					      /
{								      /
/* 首先复制第一页前面的各个字  */     /
WORD_COPY_FWD (dstp, srcp, nbytes_left, nbytes_before);	      /
assert (nbytes_left == 0);				      /
nbytes -= nbytes_before;					      /
}								      /
PAGE_COPY_FWD (dstp, srcp, nbytes_left, nbytes);		      /
}								      /
} while (0)
/* 页大小总是2的幂，这样我们就可以避免模除法运算  */
#define PAGE_OFFSET(n)	((n) & (PAGE_SIZE - 1))
#else
#define PAGE_COPY_FWD_MAYBE(dstp, srcp, nbytes_left, nbytes)
#endif

/* memcpy.c：memcpy函数的实现  */
#include <string.h>
#include <memcopy.h>  /* 包含了字节复制函数BYTE_COPY_FWD和字复制函数WORD_COPY_FWD */
#include <pagecopy.h>  /* 包含内存页复制函数PAGE_COPY_FWD_MAYBE */
#undef memcpy
/* 从src中复制len个字节的内容到dst中  */
void *
memcpy (dstpp, srcpp, len)
void *dstpp;
const void *srcpp;
size_t len;
{
unsigned long int dstp = (long int) dstpp;
unsigned long int srcp = (long int) srcpp;
/* 从开始复制到末尾 */
/* 如果len足够长，使用字复制方式（一个字为long类型，一般占4个字节） */
if (len >= OP_T_THRES)
{
/* 复制开头的几个字节，以使dstp对齐到字的边界 */
len -= (-dstp) % OPSIZ;
BYTE_COPY_FWD (dstp, srcp, (-dstp) % OPSIZ); /* 字节复制方式 */
/* 通过虚拟地址操作，从srcp中复制尽可能多的页到dstp中 */
PAGE_COPY_FWD_MAYBE (dstp, srcp, len, len); /* 页复制方式 */
/* 利用对齐的dstp，采用字复制方式从srcp复制到dstp。剩余的字节数放在第三个实参中，
例如放在len中。这个数字可能在不同的机器有不同的值 */
WORD_COPY_FWD (dstp, srcp, len, len);
/* 复制剩下的尾部几个字节 */
}
/* 还有剩下的几个字节，使用字节内存操作  */
BYTE_COPY_FWD (dstp, srcp, len);
return dstpp;
}
libc_hidden_builtin_def (memcpy)

/* memmove.c：memmove函数的实现 */
#include <string.h>
#include <memcopy.h>  /* 包含了字节复制函数BYTE_COPY_FWD和字复制函数WORD_COPY_FWD */
#include <pagecopy.h>  /* 包含内存页复制函数PAGE_COPY_FWD_MAYBE */
/* 所有这些都是为了在定义了一些东西后bcopy.c能包含本文件 */
#ifndef	a1
#define	a1	dest	/* 第一个实参是dest */
#define	a1const
#define	a2	src	    /* 第二个实参是src  */
#define	a2const	const
#undef memmove
#endif
#if	!defined(RETURN) || !defined(rettype)
#define	RETURN(s)	return (s)	/* 返回dest  */
#define	rettype		void *
#endif
/* 从SRC中复制LEN个字节的内容到DEST中，保证对重叠字符串（即SRC与DEST共用存储空间）有正确的行为 */
rettype
memmove (a1, a2, len)
a1const void *a1;
a2const void *a2;
size_t len;
{
unsigned long int dstp = (long int) dest;
unsigned long int srcp = (long int) src;
/* 这个测试使得向前复制代码一旦可能就能被使用，减少工作集 */
if (dstp - srcp >= len)	/* *Unsigned* compare!  */
{
/* 从开始复制到末尾 */
/* 如果len足够长，使用字复制方式（一个字为long类型，一般占4个字节） */
if (len >= OP_T_THRES)
{
/* 复制开头的几个字节，以使dstp对齐到字的边界 */
len -= (-dstp) % OPSIZ;
BYTE_COPY_FWD (dstp, srcp, (-dstp) % OPSIZ); /* 字节复制方式 */
/* 通过虚拟地址操作，从srcp中复制尽可能多的页到dstp中 */
PAGE_COPY_FWD_MAYBE (dstp, srcp, len, len); /* 页复制方式 */
/* 利用对齐的dstp，采用字复制方式从srcp复制到dstp。剩余的字节数放在第三个实参中，
例如放在len中。这个数字可能在不同的机器有不同的值 */
WORD_COPY_FWD (dstp, srcp, len, len);
/* 复制剩下的尾部几个字节 */
}
/* 还有剩下的几个字节，使用字节内存操作 */
BYTE_COPY_FWD (dstp, srcp, len);
}
else
{
/* 从开始复制到末尾  */
srcp += len;
dstp += len;
/* 如果len足够长，使用字复制方式（一个字为long类型，一般占4个字节） */
if (len >= OP_T_THRES)
{
/* 复制开头的几个字节，以使dstp对齐到字的边界 */
len -= dstp % OPSIZ;
BYTE_COPY_BWD (dstp, srcp, dstp % OPSIZ);
/* 利用对齐的dstp，采用字复制方式从srcp复制到dstp。剩余的字节数放在第三个实参中，
例如放在len中。这个数字可能在不同的机器有不同的值 */
WORD_COPY_BWD (dstp, srcp, len, len);
/* 复制剩下的尾部几个字节 */
}
/* 还有剩下的几个字节，使用字节内存操作 */
BYTE_COPY_BWD (dstp, srcp, len);
}
RETURN (dest);
}
#ifndef memmove
libc_hidden_builtin_def (memmove)
#endif

解释：
（1）memcopy.h中，宏op_t为字的类型，定义为unsigned long，OPSIZ为字的大小（32位平台中为4字节）。byte为字节的类型，定义为unsigned char。MERGE函数用于合并两个字，根据不同的机器字节序，一个字在高端，一个字在低端。字节复制和字复制都有两种方式，一种是向前复制，一种是向后复制。字复制时需要指针对齐到字的边界（即指针变量中的值为OPSIZ的倍数），复制操作使用了编译器内置的_wordcopy_fwd_aligned等函数。字节复制的接口中的代码是很直接的，用一个while循环一个字节一个字节地进行拷贝即可。宏OP_T_THRES定义了能进行字复制的最低门槛值。
（2）pagecopy.h中，要复制的字节数必须达到一定的门槛值PAGE_COPY_THRESHOLD（这个值在内核中定义），才会执行按页复制。PAGE_SIZE为页的大小，在内核中定义，PAGE_OFFSET(n)用于计算页的偏移。复制时先用WORD_COPY_FWD复制前面几个字节，这样就能让源地址和目标地址按页对齐，然后就可执行页复制。
（3）有了这些宏，memcpy和memmove函数的实现就比较简单了，直接用这些接口来进行复制操作，只不过要注意进行字复制或页复制时要复制开头的几个字节，以对齐到字或页的边界。最后尾部可能还剩下几个字节，用字节复制复制它们即可。
11、内存块中的字符搜索memchr,wmemchr：在内存块S的前N个字节中搜索C的第一次出现。算法实现与strlen及strchr类似。

/* memchr.c：memchr函数的实现 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#undef __ptr_t
/* 标准C++或标准C中通用指针为void*类型 */
#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
# define __ptr_t void *
#else /* 传统C中通用指针为char*类型 */
# define __ptr_t char *
#endif
#if defined _LIBC
# include <string.h>
# include <memcopy.h>
#else
# define reg_char char
#endif
#if HAVE_STDLIB_H || defined _LIBC
# include <stdlib.h>
#endif
#if HAVE_LIMITS_H || defined _LIBC
# include <limits.h>
#endif
#define LONG_MAX_32_BITS 2147483647
#ifndef LONG_MAX
#define LONG_MAX LONG_MAX_32_BITS
#endif
#include <sys/types.h>
#if HAVE_BP_SYM_H || defined _LIBC
#include <bp-sym.h>
#else
# define BP_SYM(sym) sym
#endif
#undef memchr
#undef __memchr
/* 在S的前N个字节中搜索C的第一次出现  */
__ptr_t
__memchr (s, c_in, n)
const __ptr_t s;
int c_in;
size_t n;
{
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;
n > 0 && ((unsigned long int) char_ptr
& (sizeof (longword) - 1)) != 0;
--n, ++char_ptr)
if (*char_ptr == c)   /* 若到达字符c处，则直接返回其指针 */
return (__ptr_t) char_ptr;
/* 所有这些说明性的注释使用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则提供洞，以便让进位陷进去  */
if (sizeof (longword) != 4 && sizeof (longword) != 8)
abort ();
#if LONG_MAX <= LONG_MAX_32_BITS
magic_bits = 0x7efefeff;
#else
magic_bits = ((unsigned long int) 0x7efefefe << 32) | 0xfefefeff;
#endif
/* 设置一个长整型字，其每个字节都是字符c */
charmask = c | (c << 8);
charmask |= charmask << 16;
#if LONG_MAX > LONG_MAX_32_BITS
charmask |= charmask << 32;
#endif
/* 这里我们不使用传统的对每个字符都进行测试的循环，而是一次测试一个long型字。技巧性的部分
是测试当前long型字的各个字节是否为0 */
while (n >= sizeof (longword))
{
/* longword中有一个字节为C，恰好等价于longword ^ charmask中有一个字节为0 */
longword = *longword_ptr++ ^ charmask;
/* 让longword加上魔数magic_bits  */
if ((((longword + magic_bits)
/* 设置那些通过加法而未改变的位 */
^ ~longword)
/* 只需看这些洞。如果任何的洞位都没有改变，最有可能的是有一个字节值为C或者到达终止符处(没找到C) */
& ~magic_bits) != 0)
{
/* 长整型字的哪个字节为C或0？如果都不是，则是一个非预期情况，继续搜索 */
const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);
if (cp[0] == c)
return (__ptr_t) cp;
if (cp[1] == c)
return (__ptr_t) &cp[1];
if (cp[2] == c)
return (__ptr_t) &cp[2];
if (cp[3] == c)
return (__ptr_t) &cp[3];
#if LONG_MAX > 2147483647      /* 如果long类型是8个字节，则还有4个字节需要判断 */
if (cp[4] == c)
return (__ptr_t) &cp[4];
if (cp[5] == c)
return (__ptr_t) &cp[5];
if (cp[6] == c)
return (__ptr_t) &cp[6];
if (cp[7] == c)
return (__ptr_t) &cp[7];
#endif
}
n -= sizeof (longword);
}
/* 循环完如果还剩下几个字节，则继承搜索这剩下的几个字节 */
char_ptr = (const unsigned char *) longword_ptr;
while (n-- > 0)
{
if (*char_ptr == c)
return (__ptr_t) char_ptr;
else
++char_ptr;
}
return 0;
}
#ifdef weak_alias
weak_alias (__memchr, BP_SYM (memchr))
#endif
libc_hidden_builtin_def (memchr)

12、内存块比较memcmp,wmemcmp：对两个内存块的前N个字节进行比较。比较也是使用字（unsigned long型）的比较方式，以加快搜索速度。采用的策略是先比较开头的几个字节，以使块指针对齐到字的边界，再用memcmp_common_alignment（两个内存块都对齐的情况）或memcmp_not_common_alignment（一个内存块对齐，而另一个没有对齐）按字进行快速的比较，最后对剩下的几个字节进行比较。代码就不再解剖了，涉及到大量的字操作，以及用MERGE进行字合并（这需要考虑到机器的字节序）。
13、内存块设置memset,wmemset：将内存块的前LEN个字节设置为字符C。也是采用字的方式来进行快速地写入。先设置了一个字cccc，其每个字节都是字符C。为了加快写入速度，每循环一次就写入8个cccc，最后对剩下的几个字节写入C。

/* memset.c：memset函数的实现  */
#include <string.h>
#include <memcopy.h>
#undef memset
/* 将内存块DST的前LEN个字节设置为字符C */
void *
memset (dstpp, c, len)
void *dstpp;
int c;
size_t len;
{
long int dstp = (long int) dstpp;
if (len >= 8)
{
size_t xlen;
op_t cccc;

/* 设置一个长整型字，其每个字节都是字符c */
cccc = (unsigned char) c;
cccc |= cccc << 8;
cccc |= cccc << 16;
if (OPSIZ > 4)
/* 移位操作分两步，以避免当long为32位时出现警告 */
cccc |= (cccc << 16) << 16;
/* 把dstp对齐到字的边界，开头的几个字节要设置为C，在这个对齐循环中无需
测试LEN是否等于0 */
while (dstp % OPSIZ != 0)
{
((byte *) dstp)[0] = c;
dstp += 1;
len -= 1;
}
/* 每次迭代中写8个op_t型的字，直到剩下不到8个字为止 */
xlen = len / (OPSIZ * 8); /* 计算迭代次数 */
while (xlen > 0)
{
((op_t *) dstp)[0] = cccc;
((op_t *) dstp)[1] = cccc;
((op_t *) dstp)[2] = cccc;
((op_t *) dstp)[3] = cccc;
((op_t *) dstp)[4] = cccc;
((op_t *) dstp)[5] = cccc;
((op_t *) dstp)[6] = cccc;
((op_t *) dstp)[7] = cccc;
dstp += 8 * OPSIZ;
xlen -= 1;
}
len %= OPSIZ * 8; /* 计算剩下的字节数 */
/* 每次迭代写1个字，直到剩下不到OPSIZ个字节为止 */
xlen = len / OPSIZ;  /* 计算迭代次数 */
while (xlen > 0)
{
((op_t *) dstp)[0] = cccc;
dstp += OPSIZ;
xlen -= 1;
}
len %= OPSIZ;
}
/* 写入最后剩下的几个字节 */
while (len > 0)
{
((byte *) dstp)[0] = c;
dstp += 1;
len -= 1;
}
return dstpp;
}
libc_hidden_builtin_def (memset)