cutil-string.c

Linux环境下常用功能的实现

#include "cutil.h"

static unsigned char byte_to_hex[] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','A', 'B', 'C', 'D', 'E', 'F'};

/**
 * cutil_string_to_hex
 * @pszInput:	要求转换的字符串
 * @nLen: 要求转换的长度
 * @pnOutLen: 转换后的长度
 *
 * 将字符串编码转变为HEX的编码
 * 
 * Returns: 成功操作返回转换后的报文
 */
char *cutil_string_to_hex(const char *pszInput, int nLen, int *pnOutLen)
{
	int iStrPos,iHexStrPos;
	unsigned char c;
	char *pstruStr = (char *)calloc(nLen * 2 + 1, sizeof(char));

	memset(pstruStr, 0, sizeof(pstruStr));
	for (iStrPos = 0 , iHexStrPos = 0 ; iStrPos < nLen; 
		iStrPos ++,iHexStrPos += 2)
	{
		c = (unsigned char )pszInput[iStrPos];
		pstruStr[iHexStrPos] = byte_to_hex[c >> 4];
		pstruStr[iHexStrPos + 1] = byte_to_hex[c & 0x0F];
	}
	if(pnOutLen)
		*pnOutLen = iHexStrPos;
	return pstruStr;
}

/**
 * cutil_string_from_hex
 * @pszInput: 要求转换的字符串
 * @pnOutLen: 转换后的长度
 * 
 * 将字符串HEX编码转变字符串
 * 
 * Returns: 成功操作返回转换后的报文
 */
char *cutil_string_from_hex(const char *pszInput, int *pnOutLen)
{
	int iStrPos,iHexStrPos;
	unsigned char c;
	int nLen = strlen(pszInput);
	char *pszOut = (char *)calloc(nLen / 2, sizeof(char));

	memset(pszOut, 0, sizeof(pszOut));
	for (iHexStrPos = 0 , iStrPos = 0 ; iHexStrPos < nLen ; 
		iHexStrPos += 2,iStrPos ++)
	{
		c =(unsigned char) pszInput[iHexStrPos];
		pszOut[iStrPos] = (isdigit(c) ? c - '0' 
			: ((('a' <= c && c <= 'f') ? c - 'a' : c - 'A')) + 10) << 4;
		c = pszInput[iHexStrPos + 1];
		pszOut[iStrPos] |= isdigit(c) ? c - '0' 
			: ((('a' <= c && c <= 'f') ? c - 'a' : c - 'A') + 10);
	}
	if(pnOutLen)
		*pnOutLen = iStrPos;
	return pszOut;
}

/**
 * cutil_string_to_lower
 * @pszInputString: 要转变的字符串
 *
 * 将字符串转为小写(会修改源串)
 *
 * Returns: 转换后的字符串
 */
char * cutil_string_to_lower(char *pszInput)
{
	int i;

	for(i = 0; pszInput[i] != 0; i ++)
		pszInput[i] = tolower(pszInput[i]);
		
	return pszInput;
}

/**
 * cutil_string_to_upper
 * @pszInputString: 要转变的字符串
 *
 * 将字符串转为大写写(会修改源串)
 *
 * Returns: 转换后的字符串
 */
char * cutil_string_to_upper(char *pszInput)
{
	int i;

	for(i = 0; pszInput[i] != 0; i ++)
		pszInput[i] = toupper(pszInput[i]);
		
	return pszInput;
}

/**
 * cutil_string_trim_left
 * @pszInputString: 要转变的字符串
 *
 * 除去前面的空格(会修改源串)
 *
 * Returns: 转换后的字符串
 */
char *cutil_string_trim_left(char * pszInputString)
{
	int i;
	int nStringLen;

	if(pszInputString == NULL)
		return NULL;

	nStringLen = strlen(pszInputString);
	for (i = 0; (i < nStringLen) && isspace(pszInputString [i]); i ++);
		
	memcpy(pszInputString , pszInputString + i, nStringLen - i + 1);
	return pszInputString;
}

/**
 * cutil_string_trim_right
 * @pszInputString: 要转变的字符串
 *
 * 除去后面的空格(会修改源串)
 * 
 * Returns: 转换后的字符串
 */
char * cutil_string_trim_right(char *pszInputString)
{
	int i;
	
	if(pszInputString == NULL)
		return(NULL);

	for( i = strlen(pszInputString) -1 ; (i >= 0) 
		&& isspace(pszInputString [i]); i --)
	{
		pszInputString[i] = '\0';
	}
	
	return(pszInputString);
}

/**
 * cutil_string_trim_space
 * @pszInputString: 要转变的字符串
 *
 * 除去前后的空格(会修改源串)
 *
 * Returns: 转换后的字符串
 */
char * cutil_string_trim_space(char *pszInputString)
{
	return(cutil_string_trim_left(cutil_string_trim_right(pszInputString)));
}

/**
 * cutil_string_divide
 * @pszInputString:	待分割的字符串
 * @pszDivide:	字符的分割标志
 * @pszSeperateStr:	保存分割好的字符串
 * @nSeperateNum: 	指针数组的最大大小
 *
 *  将字符串分割为几个小的字符串(会修改源串)
 *
 *  Returns: 成功分割好的个数失败-1
 */
int cutil_string_divide(char * pszInputString, char *pszDivide, 
	char * pszSeperateStr[], int nSeperateNum)
{
	int i;
	char * pszTemp = NULL;
	char * pszBreak = NULL;
	
	if((pszInputString == NULL) || (pszDivide == NULL) || (strlen(pszInputString) == 0)
		|| (strlen(pszDivide) == 0))
		return -1;
				
	pszTemp = pszInputString;	
	for(i = 0; i < nSeperateNum; i ++)
	{
		pszBreak = strstr(pszTemp, pszDivide);
		pszSeperateStr[i] = pszTemp;
		if(pszBreak == NULL)
			break;
		*pszBreak = '\0';
		pszTemp = pszBreak + strlen(pszDivide);
	}
	return i + 1;
}