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