lib_str.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

*   						beyond or including the NULL address; destination string buffer properly
*   						terminated with NULL character.
*
*   				(d) Concatenation string's terminating NULL character found.
*   					(1) Entire concatenation string appended to destination string.
*
*   				(e) 'len_max' number of characters concatenated.
*   					(1) 'len_max' number of characters does NOT include the terminating NULL character.
*
*   						See also Note #1a.
*********************************************************************************************************
*/
/*$PAGE*/
CPU_CHAR * Str_Cat_N(CPU_CHAR *pdest, CPU_CHAR *pstr_cat, CPU_SIZE_T   len_max)
{
	CPU_CHAR	*pstr;
	CPU_CHAR	*pstr_next;
	CPU_SIZE_T   len_cat;

	/* Rtn NULL if str ptr(s) NULL     (see Note #2a).  	*/
	if (pdest == (CPU_CHAR *) 0)
	{
		return  ((CPU_CHAR *) 0);
	}
	if (pstr_cat == (CPU_CHAR *) 0)
	{
		return  ((CPU_CHAR *) 0);
	}

	if (len_max == (CPU_SIZE_T) 0)
	{
		/* Rtn NULL if cat len equals zero (see Note #2e).  	*/
		return  ((CPU_CHAR *) 0);
	}


	pstr = pdest;
	while ((pstr != (CPU_CHAR *) 0) &&  						 /* Adv to end of cur dest str until NULL ptr ...   	 */
		   (*pstr != (CPU_CHAR) 0))
	{
		/* ... or NULL char found.. 							*/
		pstr++;
	}
	if (pstr == (CPU_CHAR *) 0)
	{
		/* If NULL str overrun, rtn NULL (see Note #2b).		*/
		return ((CPU_CHAR *) 0);
	}

	pstr_next = pstr;
	pstr_next++;
	len_cat = 0;

	while ((pstr_next != (CPU_CHAR *) 0) && 					 /* Cat str until NULL ptr(s)  (see Note #2c)  ...  	 */
		   (pstr_cat != (CPU_CHAR *) 0) && (*pstr_cat != (CPU_CHAR) 0) &&   				   /* ... or NULL char found	 (see Note #2d); ...	   */
		   (len_cat < (CPU_SIZE_T) len_max))
	{
		/* ... or max nbr chars cat'd (see Note #2d).           */
		*pstr = *pstr_cat;
		pstr++;
		pstr_next++;
		pstr_cat++;
		len_cat++;
	}

	*pstr = (CPU_CHAR) 0;   									  /* Append NULL char (see Note #2c2).  				  */


	return (pdest);
}


/*$PAGE*/
/*
*********************************************************************************************************
*   										   Str_Cmp()
*
* Description : Determine if two strings are identical.
*
* Argument(s) : p1_str  	Pointer to first  string (see Note #1).
*
*   			p2_str  	Pointer to second string (see Note #1).
*
* Return(s)   : 0,  			if strings are identical			 (see Notes #2a, #2e, & #2f).
*
*   			Negative value, if 'p1_str' is less    than 'p2_str' (see Notes #2b, #2g, & #2d).
*
*   			Positive value, if 'p1_str' is greater than 'p2_str' (see Notes #2c, #2h, & #2d).
*
* Caller(s)   : various.
*
* Note(s)     : (1) String buffers NOT modified.
*
*   			(2) String comparison terminates when :
*
*   				(a) BOTH string pointer(s) are passed NULL pointers.
*   					(1) NULL strings identical; return 0.
*
*   				(b) 'p1_str' passed a NULL pointer.
*   					(1) Return negative value of character pointed to by 'p2_str'.
*
*   				(c) 'p2_str' passed a NULL pointer.
*   					(1) Return positive value of character pointed to by 'p1_str'.
*
*   				(d) Non-matching characters found.
*   					(1) Return signed-integer difference of the character pointed to by 'p2_str'
*   						from the character pointed to by 'p1_str'.
*
*   				(e) Terminating NULL character found in both strings.
*   					(1) Strings identical; return 0.
*   					(2) Only one NULL character test required in conditional since previous condition
*   						tested character equality.
*
*   				(f) BOTH strings point to NULL.
*   					(1) Strings overlap with NULL address.
*   					(2) Strings identical up to but NOT beyond or including the NULL address; return 0.
*
*   				(g) 'p1_str_next' points to NULL.
*   					(1) 'p1_str' overlaps with NULL address.
*   					(2) Strings compared up to but NOT beyond or including the NULL address.
*   					(3) Return  negative value of character pointed to by 'p2_str_next'.
*
*   				(h) 'p2_str_next' points to NULL.
*   					(1) 'p2_str' overlaps with NULL address.
*   					(2) Strings compared up to but NOT beyond or including the NULL address.
*   					(3) Return  positive value of character pointed to by 'p1_str_next'.
*
*   			(3) Since 16-bit signed arithmetic is performed to calculate a non-identical comparison
*   				return value, 'CPU_CHAR' native data type size MUST be 8-bit.
*********************************************************************************************************
*/
/*$PAGE*/
CPU_INT16S Str_Cmp(CPU_CHAR *p1_str, CPU_CHAR *p2_str)
{
	CPU_CHAR	*p1_str_next;
	CPU_CHAR	*p2_str_next;
	CPU_INT16S   cmp_val;


	if (p1_str == (CPU_CHAR *) 0)
	{
		if (p2_str == (CPU_CHAR *) 0)
		{
			return ((CPU_INT16S) 0);							 /* If BOTH str ptrs NULL, rtn 0 (see Note #2a).		 */
		}
		cmp_val = (CPU_INT16S) 0 - (CPU_INT16S) (*p2_str);
		return (cmp_val);   									/* If p1_str NULL, rtn neg p2_str val (see Note #2b).   */
	}
	if (p2_str == (CPU_CHAR *) 0)
	{
		cmp_val = (CPU_INT16S) (*p1_str);
		return (cmp_val);   									/* If p2_str NULL, rtn pos p1_str val (see Note #2c).   */
	}


	p1_str_next = p1_str;
	p2_str_next = p2_str;
	p1_str_next++;
	p2_str_next++;
	while ((*p1_str == *p2_str) &&  				  /* Cmp strs until non-matching char (see Note #2d) ..   */
		   (*p1_str != (CPU_CHAR) 0) && 				   /* .. or NULL char(s)			   (see Note #2e) ..   */
		   (p1_str_next != (CPU_CHAR *) 0) &&   				 /* .. or NULL ptr(s) found (see Notes #2f, #2g, & #2h). */
		   (p2_str_next != (CPU_CHAR *) 0))
	{
		p1_str_next++;
		p2_str_next++;
		p1_str++;
		p2_str++;
	}


	if (*p1_str != *p2_str)
	{
		/* If strs NOT identical, ...   				*/
		cmp_val = (CPU_INT16S) (*p1_str) - (CPU_INT16S) (*p2_str);  	 /* ... calc & rtn char diff  (see Note #2d1).   */
	}
	else if (*p1_str == (CPU_CHAR) 0)
	{
		/* If NULL char(s) found, ...   				*/
		cmp_val = 0;												   /* ... strs identical; rtn 0 (see Note #2e).    */
	}
	else
	{
		if (p1_str_next == (CPU_CHAR *) 0)
		{
			if (p2_str_next == (CPU_CHAR *) 0)
			{
				/* If BOTH next str ptrs NULL, ...  			*/
				cmp_val = (CPU_INT16S) 0;   							 /* ... rtn 0   				(see Note #2f).  */
			}
			else
			{
				/* If p1_str_next NULL, ... 					*/
				cmp_val = (CPU_INT16S) 0 - (CPU_INT16S) (*p2_str_next);   /* ... rtn neg p2_str_next val (see Note #2g).  */
			}
		}
		else
		{
			/* If p2_str_next NULL, ... 					*/
			cmp_val = (CPU_INT16S) (*p1_str_next);  					 /* ... rtn pos p1_str_next val (see Note #2h).  */
		}
	}


	return (cmp_val);
}


/*$PAGE*/
/*
*********************************************************************************************************
*   										  Str_Cmp_N()
*
* Description : Determine if two strings are identical for up to a maximum number of characters.
*
* Argument(s) : p1_str  	Pointer to first  string (see Note #1).
*
*   			p2_str  	Pointer to second string (see Note #1).
*
*   			len_max 	Maximum number of characters to compare  (see Notes #2i & #2j).
*
* Return(s)   : 0,  			if strings are identical			 (see Notes #2a, #2e, #2f, #2i, & #2j).
*
*   			Negative value, if 'p1_str' is less    than 'p2_str' (see Notes #2b, #2g, & #2d).
*
*   			Positive value, if 'p1_str' is greater than 'p2_str' (see Notes #2c, #2h, & #2d).
*
* Caller(s)   : various.
*
* Note(s)     : (1) String buffers NOT modified.
*
*   			(2) String comparison terminates when :
*
*   				(a) BOTH string pointer(s) are passed NULL pointers.
*   					(1) NULL strings identical; return 0.
*
*   				(b) 'p1_str' passed a NULL pointer.
*   					(1) Return negative value of character pointed to by 'p2_str'.
*
*   				(c) 'p2_str' passed a NULL pointer.
*   					(1) Return positive value of character pointed to by 'p1_str'.
*
*   				(d) Non-matching characters found.
*   					(1) Return signed-integer difference of the character pointed to by 'p2_str'
*   						from the character pointed to by 'p1_str'.
*
*   				(e) Terminating NULL character found in both strings.
*   					(1) Strings identical; return 0.
*   					(2) Only one NULL character test required in conditional since previous condition
*   						tested character equality.
*
*   				(f) BOTH strings point to NULL.
*   					(1) Strings overlap with NULL address.
*   					(2) Strings identical up to but NOT beyond or including the NULL address; return 0.
*
*   				(g) 'p1_str_next' points to NULL.
*   					(1) 'p1_str' overlaps with NULL address.
*   					(2) Strings compared up to but NOT beyond or including the NULL address.
*   					(3) Return  negative value of character pointed to by 'p2_str_next'.
*
*   				(h) 'p2_str_next' points to NULL.
*   					(1) 'p2_str' overlaps with NULL address.
*   					(2) Strings compared up to but NOT beyond or including the NULL address.
*   					(3) Return  positive value of character pointed to by 'p1_str_next'.
*
*   				(i) 'len_max' passed a zero length.
*   					(1) Zero-length strings identical; return 0.
*
*   				(j) First 'len_max' number of characters identical.
*   					(1) Strings identical; return 0.
*
*   			(3) Since 16-bit signed arithmetic is performed to calculate a non-identical comparison
*   				return value, 'CPU_CHAR' native data type size MUST be 8-bit.
*********************************************************************************************************
*/
/*$PAGE*/
CPU_INT16S Str_Cmp_N(CPU_CHAR *p1_str, CPU_CHAR *p2_str, CPU_SIZE_T   len_max)
{
	CPU_CHAR	*p1_str_next;
	CPU_CHAR	*p2_str_next;
	CPU_INT16S   cmp_val;
	CPU_SIZE_T   cmp_len;


	if (len_max == 0)
	{
		/* If cmp len equals zero, rtn 0	  (see Note #2i).   */
		return ((CPU_INT16S) 0);
	}

	if (p1_str == (CPU_CHAR *) 0)
	{
		if (p2_str == (CPU_CHAR *) 0)
		{
			return ((CPU_INT16S) 0);							 /* If BOTH str ptrs NULL,  rtn 0      (see Note #2a).   */
		}
		cmp_val = (CPU_INT16S) 0 - (CPU_INT16S) (*p2_str);
		return (cmp_val);   									/* If p1_str NULL, rtn neg p2_str val (see Note #2b).   */
	}
	if (p2_str == (CPU_CHAR *) 0)
	{
		cmp_val = (CPU_INT16S) (*p1_str);
		return (cmp_val);   									/* If p2_str NULL, rtn pos p1_str val (see Note #2c).   */
	}


	p1_str_next = p1_str;
	p2_str_next = p2_str;
	p1_str_next++;
	p2_str_next++;
	cmp_len = 0;
	while ((*p1_str == *p2_str) &&  				  /* Cmp strs until non-matching char (see Note #2d) ..   */
		   (*p1_str != (CPU_CHAR) 0) && 				   /* .. or NULL char(s)			   (see Note #2e) ..   */
		   (p1_str_next != (CPU_CHAR *) 0) &&   				 /* .. or NULL ptr(s) found (see Notes #2f, #2g, & #2h); */
		   (p2_str_next != (CPU_CHAR *) 0) && (cmp_len < (CPU_SIZE_T) len_max))
	{
		/* .. or len nbr chars cmp'd        (see Note #2j).     */
		p1_str_next++;
		p2_str_next++;
		p1_str++;
		p2_str++;
		cmp_len++;
	}


	if (cmp_len == len_max)
	{
		/* If strs     identical for len nbr of chars,  */
		return ((CPU_INT16S) 0);										 /* ... rtn 0 (see Note #2j).   				 */
	}

	if (*p1_str != *p2_str)
	{
		/* If strs NOT identical, ...   				*/
		cmp_val = (CPU_INT16S) (*p1_str) - (CPU_INT16S) (*p2_str);  	 /* ... calc & rtn char diff  (see Note #2d1).   */
	}
	else if (*p1_str == (CPU_CHAR) 0)
	{
		/* If NULL char(s) found, ...   				*/
		cmp_val = 0;												   /* ... strs identical; rtn 0 (see Note #2e).    */
	}
	else
	{
		if (p1_str_next == (CPU_CHAR *) 0)
		{
			if (p2_str_next == (CPU_CHAR *) 0)
			{
				/* If BOTH next str ptrs NULL, ...  			*/
				cmp_val = (CPU_INT16S) 0;   							 /* ... rtn 0   				(see Note #2f).  */
			}
			else
			{
				/* If p1_str_next NULL, ... 					*/
				cmp_val = (CPU_INT16S) 0 - (CPU_INT16S) (*p2_str_next);   /* ... rtn neg p2_str_next val (see Note #2g).  */
			}
		}
		else
		{
			/* If p2_str_next NULL, ... 					*/
			cmp_val = (CPU_INT16S) (*p1_str_next);  					 /* ... rtn pos p1_str_next val (see Note #2h).  */
		}
	}


	return (cmp_val);
}


/*$PAGE*/
/*
*********************************************************************************************************
*   										  Str_Char()
*
* Description : Search string for first occurrence of specific character.
*
* Argument(s) : pstr			Pointer to string (see Note #1).
*
*   			srch_char   	Search character.
*
* Return(s)   : Pointer to first occurrence of search character in string, if any.
*
*   			Pointer to NULL,										   otherwise.
*
* Caller(s)   : various.
*
* Note(s)     : (1) String buffer NOT modified.
*
*   			(2) String search terminates when :
*
*   				(a) String pointer passed a NULL pointer.
*   					(1) No string search performed; NULL pointer returned.
*
*   				(b) String pointer points to NULL.
*   					(1) String overlaps with NULL address.
*   					(2) String searched up to but NOT beyond or including the NULL address.
*
*   				(c) String's terminating NULL character found.
*   					(1) Search character NOT found in search string; NULL pointer returned.
*   					(2) Applicable ONLY IF search character is NOT the terminating NULL character.
*
*   				(d) Search character found.
*   					(1) Return pointer to first occurrence of search character in search string.
*********************************************************************************************************
*/

CPU_CHAR * Str_Char(CPU_CHAR *pstr, CPU_CHAR   srch_char)
{
	CPU_CHAR  *pstr_next;


	if (pstr == (CPU_CHAR *) 0)
	{
		/* Rtn NULL if srch str ptr NULL (see Note #2a).		*/
		return ((CPU_CHAR *) 0);
	}


	pstr_next = pstr;
	pstr_next++;
	while ((pstr_next != (CPU_CHAR *) 0) && 					 /* Srch str until NULL ptr(s) (see Note #2b) ...   	 */
		   (*pstr != (CPU_CHAR) 0) &&   				   /* ... or NULL char  		 (see Note #2c) ... 	   */
		   (*pstr != (CPU_CHAR) srch_char))
	{
		/* ... or srch char found     (see Note #2d).   		*/
		pstr++;
		pstr_next++;
	}


	if (*pstr != srch_char)
	{
		/* If srch char NOT found, str points to NULL; ...  	*/
		return ((CPU_CHAR *) 0);								 /* ... rtn NULL (see Notes #2b & #2c). 				 */
	}

	return (pstr);  											/* Else rtn ptr to found srch char (see Note #2d).  	*/
}


/*$PAGE*/
/*
*********************************************************************************************************
*   										 Str_Char_N()
*
* Description : Search string for first occurrence of specific character, up to a maximum number of characters.
*
* Argument(s) : pstr			Pointer to string (see Note #1).