lib_str.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

*
*   			len_max 		Maximum number of characters to search (see Notes #2e & #3).
*
*   			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.
*
*   				(e) 'len_max' number of characters searched.
*   					(1) 'len_max' number of characters does NOT include terminating NULL character.
*
*   			(3) Ideally, the 'len_max' parameter would be the last parameter in this function's
*   				paramter list for consistency with all other custom string library functions.
*   				However, the 'len_max' parameter is ordered to comply with the standard library
*   				function's parameter list.
*********************************************************************************************************
*/

CPU_CHAR * Str_Char_N(CPU_CHAR *pstr, CPU_SIZE_T   len_max, CPU_CHAR	 srch_char)
{
	CPU_CHAR	*pstr_next;
	CPU_SIZE_T   len_srch;


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

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


	pstr_next = pstr;
	pstr_next++;
	len_srch = 0;
	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); ...      */
		   (len_srch < (CPU_SIZE_T) len_max))
	{
		/* ... or max nbr chars srch'd (see Note #2e).          */
		pstr++;
		pstr_next++;
		len_srch++;
	}


	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_Last()
*
* Description : Search string for last occurrence of specific character.
*
* Argument(s) : pstr			Pointer to string (see Note #1).
*
*   			srch_char   	Search character.
*
* Return(s)   : Pointer to last 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.
*   					(3) NULL address boundary handled in Str_Len().
*
*   				(c) String searched from end to beginning.
*   					(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_Last(CPU_CHAR *pstr, CPU_CHAR   srch_char)
{
	CPU_CHAR	*pstr_next;
	CPU_SIZE_T   str_len;


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


	pstr_next = pstr;
	str_len = Str_Len(pstr);
	pstr_next += str_len;
	while ((pstr_next != pstr) &&   							/* Srch str from end until beg (see Note #2c) ...   	*/
		   (*pstr_next != srch_char))
	{
		/* ... until srch char found   (see Note #2d).  		*/
		pstr_next--;
	}


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

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


/*$PAGE*/
/*
*********************************************************************************************************
*   										  Str_Str()
*
* Description : Search string for first occurence of a specific search string.
*
* Argument(s) : pstr			Pointer to  	  string (see Note #1).
*
*   			psrch_str   	Pointer to search string (see Note #1).
*
* Return(s)   : Pointer to first occurrence of search string in string, if any.
*
*   			Pointer to NULL,										otherwise.
*
* Caller(s)   : various.
*
* Note(s)     : (1) String buffers NOT modified.
*
*   			(2) String search terminates when :
*
*   				(a) String pointer passed a NULL pointer.
*   					(1) No string search performed; NULL pointer returned.
*
*   				(b) Search string length greater than string length.
*   					(1) No string search performed; NULL pointer returned.
*
*   				(c) Search string length equal to zero.
*   					(1) NULL search string at end of string returned.
*
*   				(d) Entire string has been searched.
*   					(1) Maximum size of the search is defined as the subtraction of the
*   						search string length from the string length.
*   					(2) Search string not found; NULL pointer returned.
*
*   				(e) Search string found.
*   					(1) Search string found according to Str_Cmp_N() return value.
*   					(2) Return pointer to first occurrence of search string in string.
*********************************************************************************************************
*/

CPU_CHAR * Str_Str(CPU_CHAR *pstr, CPU_CHAR *psrch_str)
{
	CPU_SIZE_T    str_len;
	CPU_SIZE_T    srch_str_len;
	CPU_SIZE_T    srch_len;
	CPU_SIZE_T    srch_ix;
	CPU_BOOLEAN   srch_done;
	CPU_INT16S    srch_cmp = 0;
	CPU_CHAR	 *pstr_srch_ix = 0;

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


	str_len = Str_Len(pstr);
	srch_str_len = Str_Len(psrch_str);
	if (srch_str_len > str_len)
	{
		/* If srch str len > str len, rtn NULL  (see Note #2b). */
		return ((CPU_CHAR *) 0);
	}
	if (srch_str_len == 0)
	{
		/* If srch str len = 0, srch str equal NULL str; ...	*/
		pstr_srch_ix = (CPU_CHAR *) (pstr + str_len);   		 /* ... rtn ptr to NULL str found in str (see Note #2c). */
		return (pstr_srch_ix);
	}

	srch_len = str_len - srch_str_len;  					   /* Determine srch len (see Note #2d1).   			   */
	srch_ix = 0;
	srch_done = DEF_NO;
	while ((srch_done == DEF_NO) && (srch_ix <= srch_len))
	{
		pstr_srch_ix = (CPU_CHAR *) (pstr + srch_ix);
		srch_cmp = Str_Cmp_N(pstr_srch_ix, psrch_str, srch_str_len);
		srch_done = (srch_cmp == 0) ? DEF_YES : DEF_NO;
		srch_ix++;
	}


	if (srch_cmp != 0)
	{
		/* If srch str NOT found, rtn NULL  (see Note #2d). 	*/
		return ((CPU_CHAR *) 0);
	}

	return (pstr_srch_ix);  									/* Rtn ptr to srch str found in str (see Note #2e). 	*/
}


/*$PAGE*/
/*
*********************************************************************************************************
*   										Str_FmtNbr_32()
*
* Description : Format number into a multi-digit character string.
*
* Argument(s) : nbr 			Number  						to format (see Note #1).
*
*   			nbr_dig 		Number of integer   	 digits to format (see Note #2).
*
*   			nbr_dp  		Number of decimal point  digits to format.
*
*   			lead_zeros  	Prepend leading zeros    option (DEF_YES/DEF_NO) [see Note #3].
*
*   			nul 			NULL-character terminate option (DEF_YES/DEF_NO) [see Note #4].
*
*   			pstr_fmt		Pointer to character array to return formatted number string (see Note #5).
*
* Return(s)   : Pointer to formatted string, if NO errors (see Note #6).
*
*   			Pointer to NULL,			 otherwise.
*
* Caller(s)   : various.
*
* Note(s)     : (1) (a) The maximum accuracy for 32-bit floating-point numbers :
*
*
*   							  Maximum Accuracy  		  log [Internal-Base ^ (Number-Internal-Base-Digits)]
*   						32-bit Floating-point Number  =  -----------------------------------------------------
*   																		  log [External-Base]
*
*   														  log [2 ^ 24]
*   													  =  --------------
*   															log [10]
*
*   													  <  7.225  Base-10 Digits
*
*   							where
*   									Internal-Base   				Internal number base of floating-
*   																		point numbers (i.e.  2)
*   									External-Base   				External number base of floating-
*   																		point numbers (i.e. 10)
*   									Number-Internal-Base-Digits 	Number of internal number base
*   																		significant digits (i.e. 24)
*
*   				(b) Some compilers' floating-point routines MAY further reduce the maximum accuracy.
*
*   				(c) If the total number of digits to format ('nbr_dig + nbr_dp') is greater than the 
*   					maximum accuracy; digits following the first, significantly-accurate digits will
*   					be inaccurate.
*
*   			(2) (a) If the number of digits to format ('nbr_dig') is less than the number of significant
*   					integer digits of the number to format ('nbr'); then the most-significant digits of
*   					the formatted number will be truncated.
*
*   						Example :
*
*   							nbr 	 = 23456.789
*   							nbr_dig  = 3
*   							nbr_dp   = 2
*
*   							pstr_fmt = "456.78"
*
*   				(b) If number to format ('nbr') is negative but the most-significant digits of the
*   					formatted number are truncated (see Note #2a); the negative sign still prefixes
*   					the truncated formatted number.
*
*   						Example :
*
*   							nbr 	 = -23456.789
*   							nbr_dig  =  3
*   							nbr_dp   =  2
*
*   							pstr_fmt = "-456.78"
*
*   			(3) (a) Leading zeros option prepends leading '0's prior to the first non-zero digit.
*   					The number of leading zeros is such that the total number integer digits is
*   					equal to the requested number of integer digits to format ('nbr_dig').
*
*   				(b) (1) If leading zeros option DISABLED,   					 ...
*   					(2) ... number of digits to format is non-zero, 			 ...
*   					(3) ... & the integer value of the number to format is zero; ...
*   					(4) ... then one digit of '0' value is formatted.
*
*   						This is NOT a leading zero; but a single integer digit of '0' value.
*
*   			(4) (a) NULL-character terminate option DISABLED prevents overwriting previous character
*   					array formatting.
*
*   				(b) WARNING: Unless 'pstr_fmt' character array is pre-/post-terminated, NULL-character
*   					terminate option DISABLED will cause character string run-on.
*$PAGE*
*   			(5) (a) Format buffer size NOT validated; buffer overruns MUST be prevented by caller.
*
*   				(b) To prevent character buffer overrun :
*
*   						Character array size MUST be  >=  ('nbr_dig'		 +
*   														   'nbr_dp' 		 +
*   														   1 negative sign   +
*   														   1 decimal point   +
*   														   1 'NUL' terminator)  characters
*
*   			(6) String format terminates when :
*
*   				(a) Format string pointer is passed a NULL pointer.
*   					(1) No string format performed; NULL pointer returned.
*
*   				(b) Number successfully formatted into character string array.
*********************************************************************************************************
*/

#if (LIB_STR_CFG_FP_EN == DEF_ENABLED)
CPU_CHAR * Str_FmtNbr_32(CPU_FP32      nbr, CPU_INT08U    nbr_dig, CPU_INT08U    nbr_dp, CPU_BOOLEAN   lead_zeros, CPU_BOOLEAN   nul, CPU_CHAR *pstr_fmt)
{
	CPU_CHAR	*pstr;
	CPU_INT08U   i;
	CPU_INT32U   dig_nbr;
	CPU_INT32U   dig_val;
	CPU_FP32	 dig_exp;
	CPU_FP32	 dp_exp;

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


	pstr = pstr_fmt;

	if (nbr < 0.0)
	{
		/* If nbr neg,  		   ...  						*/
		if ((nbr_dig > 0) ||									 /* ... &  at least one dig ... 						 */
			(nbr_dp > 0))
		{
			/* ... or at least one dp; ...  						*/
			nbr = -nbr; 								   /* ... negate nbr &  	  ...   					   */
			*pstr++ = '-';  								   /* ... prefix with neg sign (see Note #2b).  		   */
		}
	}

	if (nbr_dig > 0)
	{
		dig_exp = 1.0;
		for (i = 1; i < nbr_dig; i++)
		{
			dig_exp *= 10.0;
		}
		for (i = nbr_dig; i > 0; i--)
		{
			/* Fmt str for desired nbr digs.						*/
			dig_nbr = (CPU_INT32U) (nbr / dig_exp);
			if ((dig_nbr > 0) ||								/* If dig nbr > 0,  							... 	*/
				(nbr_dig == 1) ||   							 /* ... OR exactly 1 dig to fmt,				 ...	 */
				(i == 1) || 							   /* ... OR on one's  dig to fmt,                 ...     */
				(lead_zeros == DEF_YES))
			{
				/* ... OR lead zeros opt ENABLED (see Note #3), ... 	*/
				/* ... calc & fmt dig val.  							*/
				dig_val = (CPU_INT32U) (dig_nbr % 10);
				*pstr++ = (CPU_CHAR) (dig_val + '0');
			}
			dig_exp /= 10.0;									/* Shift to next least-significant dig. 				*/
		}
	}

	if (nbr_dp > 0)
	{
		*pstr++ = '.';  										 /* Append dp prior to dp conversion.   				 */
		dp_exp = 10.0;
		for (i = 0; i < nbr_dp; i++)
		{
			/* Fmt str for desired nbr dp.  						*/
			dig_nbr = (CPU_INT32U) (nbr * dp_exp);
			dig_val = (CPU_INT32U) (dig_nbr % 10);
			*pstr++ = (CPU_CHAR) (dig_val + '0');
			dp_exp *= 10.0; 								  /* Shift to next least-significant dp.				  */
		}
	}

	if (nul != DEF_NO)
	{
		/* If NOT DISABLED, append NULL char (see Note #4). 	*/
		*pstr = (CPU_CHAR) 0;
	}


	return (pstr_fmt);
}
#endif