C 某些库函数中字符串处理函数的具体实现

其中包括：strcpy(char *, char *),strncpy();strcat();strncat();strcmp();strncmp();strchr();strrchr();strlen();

strdup();strspn();strpbrk();strtok(); memset();memcpy();memmove();memcmp();memscan();strstr();

_strupr_();_strlen_();_strsplit_();_hex2dec_();_str2hex_();_str2dec_();

 

 /*=========================================================================
   工程名称：C语言

 组成文件：string_lib.c
 功能描述：常用C库函数的C实现
 程序分析：
 维护记录：

 =========================================================================*/

 char * ___strtok = NULL;


 char * strcpy(char * dest,const char *src)
 {
     char *tmp = dest;

     while ((*dest++ = *src++) != '\0')
         /* nothing */;
     return tmp;
 }



 char * strncpy(char * dest,const char *src,size_t count)
 {
     char *tmp = dest;

     while (count-- && (*dest++ = *src++) != '\0')
         /* nothing */;

     return tmp;
 }



 char * strcat(char * dest, const char * src)
 {
     char *tmp = dest;

     while (*dest)
         dest++;
     while ((*dest++ = *src++) != '\0')
         ;
     return tmp;
 }



 char * strncat(char *dest, const char *src, size_t count)
 {
     char *tmp = dest;

     if (count)
     {
         while (*dest)
             dest++;
         while ((*dest++ = *src++))
         {
             if (--count == 0)
             {
                 *dest = '\0';
                 break;
             }
         }
     }
     return tmp;
 }


 int strcmp(char *s1, char *s2)
 {
     while(*s1 && *s2)
     {
         if(*s1 - *s2)
             return (*s1 - *s2);
         s1++;
         s2++;
     }
     if(*s1 != 0)
         return 1;
     else
         return -1;
     return 0;
 }


 int strncmp(char *s1, char *s2, int len)
 {
     while(len--)
     {
         if(*s1 && *s2)
         {
             if(*s1 - *s2)
                 return (*s1 - *s2);
             s1++;
             s2++;
         }
         else
         {
             if(*s1 || *s2)
                 return(*s1? *s1: *s2);
         }
     }
     return 0;
 }


 char * strchr(const char * s, int c)
 {
     for(; *s != (char) c; ++s)
         if (*s == '\0')
             return NULL;
     return (char *) s;
 }


 char * strrchr(const char * s, int c)
 {
        const char *p = s + strlen(s);
        do
        {
                 if (*p == (char)c)
             return (char *)p;
        }
        while (--p >= s);
        return NULL;
 }


 size_t strlen(const char * s)
 {
     const char *sc;

     for (sc = s; *sc != '\0'; ++sc)
         /* nothing */;
     return sc - s;
 }


 char * strdup(const char *s)
 {
     char *new;

     if ( (s == NULL) || ((new = malloc (strlen(s) + 1)) == NULL) )
      {
         return NULL;
     }

     strcpy (new, s);
     return new;
 }


 size_t strspn(const char *s, const char *accept)
 {
     const char *p;
     const char *a;
     size_t count = 0;

     for (p = s; *p != '\0'; ++p)
     {
         for (a = accept; *a != '\0'; ++a)
         {
             if (*p == *a)
                 break;
         }
         if (*a == '\0')
             return count;

         ++count;
     }

     return count;
 }


 char * strpbrk(const char * cs,const char * ct)
 {
     const char *sc1,*sc2;

     for( sc1 = cs; *sc1 != '\0'; ++sc1)
     {
         for( sc2 = ct; *sc2 != '\0'; ++sc2)
         {
             if (*sc1 == *sc2)
                 return (char *) sc1;
         }
     }
     return NULL;
 }


 char * strtok(char * s,const char * ct)
 {
     char *sbegin, *send;

     sbegin  = s ? s : ___strtok;
     if (!sbegin)
     {
         return NULL;
     }
     sbegin += strspn(sbegin,ct);
     if (*sbegin == '\0')
     {
         ___strtok = NULL;
         return( NULL );
     }
     send = strpbrk( sbegin, ct);
     if (send && *send != '\0')
         *send++ = '\0';
     ___strtok = send;
     return (sbegin);
 }


 void * memset(void * s,char c,size_t count)
 {
     char *xs = (char *) s;

     while (count--)
         *xs++ = c;

     return s;
 }


 void * memcpy(void * dest,const void *src,size_t count)
 {
     char *tmp = (char *) dest, *s = (char *) src;

     while (count--)
         *tmp++ = *s++;

     return dest;
 }


 void * memmove(void * dest,const void *src,size_t count)
 {
     char *tmp, *s;

     if (dest <= src)
     {
         tmp = (char *) dest;
         s = (char *) src;
         while (count--)
             *tmp++ = *s++;
     }
     else
     {
         tmp = (char *) dest + count;
         s = (char *) src + count;
         while (count--)
             *--tmp = *--s;
     }

     return dest;
 }


 int memcmp(const void * cs,const void * ct,size_t count)
 {
     const unsigned char *su1, *su2;
     signed char res = 0;

     for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
         if ((res = *su1 - *su2) != 0)
             break;
     return res;
 }


 /*
  * find the first occurrence of byte 'c', or 1 past the area if none
  */
 void * memscan(void * addr, int c, size_t size)
 {
     unsigned char * p = (unsigned char *) addr;

     while (size) {
         if (*p == c)
             return (void *) p;
         p++;
         size--;
     }
     return (void *) p;
 }


 char * strstr(const char * s1,const char * s2)
 {
     int l1, l2;

     l2 = strlen(s2);
     if (!l2)
         return (char *) s1;
     l1 = strlen(s1);
     while (l1 >= l2)
     {
         l1--;
         if (!memcmp(s1,s2,l2))
             return (char *) s1;
         s1++;
     }
     return NULL;
 }

 //=============================================================
 // 语法格式：    char *_strupr_(char *Str)
 // 实现功能：    将字符串转换为全大写
 // 参数：      Str -   输入字符串首地址
 // 返回值：     输出字符串首地址
 // 注意:      该程序将直接修改原始字符串
 //=============================================================
 char *_strupr_(char *Str)
 {
     char *cp;
     cp = Str;
     while (*cp != 0)
     {
         if (*cp >= 'a' && *cp <= 'z' )
         {
             *cp -=  'a' - 'A';
         }
         cp++;
     }
     return Str;
 }

 //=============================================================
 // 语法格式：    int _strlen_(char *s)
 // 实现功能：    求取字符串长度
 // 参数：      s   -   输入字符串首地址
 // 返回值：     字符串长度
 //=============================================================
 int _strlen_(char *s)
 {
     int i = 0;
     while(*s)
     {
         i++;
         s++;
     }
     return i;
 }


 //=============================================================
 // 语法格式：    int _strsplit_(char *sour, char *splstr, char *dest[])
 // 实现功能：    字符串分割
 // 参数：      sour    -   原始字符串首地址
 //              splstr  -   分割字符串
 //              dest[]  -   分割之后的每个字符串的首地址
 // 返回值：     分割之后的字符串数量
 //=============================================================
 int _strsplit_(char *sour, char *splstr, char *dest[])
 {
     int i = 0;
     int len;
     char *cp;
     if(*splstr == 0)
         return 0;

     cp = sour;

     dest[i] = cp;
     len = _strlen_(splstr);
     while(*sour)
     {
         if(*sour == *splstr)
         {
             if(_strncmp_(sour, splstr, _strlen_(splstr)) == 0)
             {
                 i++;
                 sour += len - 1;
                 *cp++ = 0;
                 dest[i] = cp;
             }
         }
         else cp++;
        sour++;
     }
     return (i + 1);
 }

 //=============================================================
 // 语法格式：    unsigned int _hex2dec_(unsigned int Binary)
 // 实现功能：    二进制转BCD码(仅转换输入数据的低16bit)
 // 参数：      Binary  -   输入数据
 // 返回值：     BCD码
 //=============================================================
 unsigned int _hex2dec_(unsigned int Binary)
 {
     unsigned int ulRet = 0;
     Binary &= 0xffff;
     while(Binary >= 10000)
     {
         ulRet += 10000;
         Binary -= 10000;
     }
     while(Binary >= 1000)
     {
         ulRet += 0x1000;
         Binary -= 1000;
     }
     while(Binary >= 100)
     {
         ulRet += 0x0100;
         Binary -= 100;
     }
     while(Binary >= 10)
     {
         ulRet += 0x0010;
         Binary -= 10;
     }
     ulRet += Binary;
     return (ulRet);
 }

 //=============================================================
 // 语法格式：    int _str2hex_(char *s)
 // 实现功能：    将一个字符串转换为十六进制数据
 // 参数：      s   -   输入字符串
 // 返回值：     字符串代表的十六进制数据
 //=============================================================
 int _str2hex_(char *s)
 {
     int Ret = 0;
     s = _strupr_(s);
     if((s[0] != '0') || (s[1] != 'X'))
         return 0;
     s += 2;
     while(*s)
     {
         Ret <<= 4;
         if((*s >= '0') && (*s <= '9'))
             Ret += ((int)*s - '0');
         else if((*s >= 'A') && (*s <= 'Z'))
             Ret += ((int)*s - 'A' + 0x0a);
         else
             return 0;
         s++;
     }
     return Ret;
 }

 //=============================================================
 // 语法格式：    int _str2dec_(char *s)
 // 实现功能：    将一个字符串转换为十进制数据
 // 参数：      s   -   输入字符串
 // 返回值：     字符串代表的十进制数据
 //=============================================================
 int _str2dec_(char *s)
 {
     int Ret, Flag = 0;
     Ret = 0;
     if(*s == '-')
     {
         Flag = 1;
         s++;
     }
     while(*s)
     {
         if((*s < '0') || (*s > '9'))
             return 0;
         Ret = Ret * 10 + (int)(*s - '0');
         s++;
     }
     if(Flag)
         Ret *= -1;
     return Ret;
 }