GNU C字符串程处理函数

memccpy()：从src中复制字符到dest中，直到遇到某个值c（c也被拷贝过去）或者复制了n个字符后停止。

void * __memccpy (dest, src, c, n) void *dest; const void *src; int c; size_t n; { register const char *s = src; register char *d = dest; register const char x = c; register size_t i = n; while (i-- > 0) if ((*d++ = *s++) == x) return d; return NULL; }

 

 

memcpy()内存拷贝，会完整的复制n个字节,不会因为遇到字符串结束'/0'而结束。

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; /* Copy from the beginning to the end. */ /* If there not too few bytes to copy, use word copy. */ if (len >= OP_T_THRES) { /* Copy just a few bytes to make DSTP aligned. */ len -= (-dstp) % OPSIZ; BYTE_COPY_FWD (dstp, srcp, (-dstp) % OPSIZ); /* Copy whole pages from SRCP to DSTP by virtual address manipulation, as much as possible. */ PAGE_COPY_FWD_MAYBE (dstp, srcp, len, len); /* Copy from SRCP to DSTP taking advantage of the known alignment of DSTP. Number of bytes remaining is put in the third argument, i.e. in LEN. This number may vary from machine to machine. */ WORD_COPY_FWD (dstp, srcp, len, len); /* Fall out and copy the tail. */ } /* There are just a few bytes to copy. Use byte memory operations. */ BYTE_COPY_FWD (dstp, srcp, len); return dstpp; }

 

strcat()字符串连接，把src连到dest后。dest后的'/0'合被清除，src后的'/0'会被复制到新dest最后。

char * strcat (dest, src) char *dest; const char *src; { char *s1 = dest; const char *s2 = src; reg_char c; /* Find the end of the string. */ do c = *s1++; while (c != '/0'); /* Make S1 point before the next character, so we can increment it while memory is read (wins on pipelined cpus). */ s1 -= 2; do { c = *s2++; *++s1 = c; } while (c != '/0'); return dest; }

 

strcmp()字符串拷贝，比较字符串p1,p2，如果相同返回0,如果不同返回p1与p2不等的第一对字符的差值。

int strcmp (p1, p2) const char *p1; const char *p2; { register const unsigned char *s1 = (const unsigned char *) p1; register const unsigned char *s2 = (const unsigned char *) p2; unsigned reg_char c1, c2; do { c1 = (unsigned char) *s1++; c2 = (unsigned char) *s2++; if (c1 == '/0') return c1 - c2; } while (c1 == c2); return c1 - c2; }

 

strcpy():拷贝字符串，直到遇到src指向的第一个'/0'位置为止。

char * strcpy (dest, src) char *dest; const char *src; { reg_char c; char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src); const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1; size_t n; do { c = *s++; s[off] = c; } while (c != '/0'); n = s - src; (void) CHECK_BOUNDS_HIGH (src + n); (void) CHECK_BOUNDS_HIGH (dest + n); return dest; }

 

strncpy():从s2中复制n个字符到s1中，注意，如果strlen(s2)<n,则遇到s2中第一个'/0'后，会补齐n-strlen(s2)个'/0',如果strlen(s2)>=n,会复制n个字符到s1中，并在最后添加'/0'。

char * STRNCPY (char *s1, const char *s2, size_t n) { reg_char c; char *s = s1; --s1; if (n >= 4) { size_t n4 = n >> 2; for (;;) { c = *s2++; *++s1 = c; if (c == '/0') 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; } n = n - (s1 - s) - 1; if (n == 0) return s; goto zero_fill; } last_chars: n &= 3; if (n == 0) return s; do { c = *s2++; *++s1 = c; if (--n == 0) return s; } while (c != '/0'); zero_fill: do *++s1 = '/0'; while (--n > 0); return s; }

 

strstr()从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)。

char * STRSTR (const char *haystack_start, const char *needle_start) { const char *haystack = haystack_start; const char *needle = needle_start; size_t needle_len; /* Length of NEEDLE. */ size_t haystack_len; /* Known minimum length of HAYSTACK. */ bool ok = true; /* True if NEEDLE is prefix of HAYSTACK. */ /* Determine length of NEEDLE, and in the process, make sure HAYSTACK is at least as long (no point processing all of a long NEEDLE if HAYSTACK is too short). */ while (*haystack && *needle) ok &= *haystack++ == *needle++; if (*needle) return NULL; if (ok) return (char *) haystack_start; /* Reduce the size of haystack using strchr, since it has a smaller linear coefficient than the Two-Way algorithm. */ needle_len = needle - needle_start; haystack = strchr (haystack_start + 1, *needle_start); if (!haystack || __builtin_expect (needle_len == 1, 0)) return (char *) haystack; needle -= needle_len; haystack_len = (haystack > haystack_start + needle_len ? 1 : needle_len + haystack_start - haystack); /* Perform the search. Abstract memory is considered to be an array of 'unsigned char' values, not an array of 'char' values. See ISO C 99 section 6.2.6.1. */ if (needle_len < LONG_NEEDLE_THRESHOLD) return two_way_short_needle ((const unsigned char *) haystack, haystack_len, (const unsigned char *) needle, needle_len); return two_way_long_needle ((const unsigned char *) haystack, haystack_len, (const unsigned char *) needle, needle_len); }  

 

待续。。。