/*
###############################################################################
Wiznet.
5F Simmtech Bldg., 228-3, Nonhyun-dong, Kangnam-gu,  
Seoul, Korea

(c) Copyright 2002, Wiznet, Seoul, Korea


File Name : UTIL.C

Version : 1.0

Created : 2001/10/05

Description : It's implemented with useful functions, these functions are several converting and referring to String.
              Almost functions in this are offered by Keil Compiler.
              If you want not to use, Include that Library.
  
Modified History 
		Modified : 2002/03/15             
		Description : 
		Modified : 2002/10/20
		Description : Version Up (V2.0)
		              Add ITOA()
			      Add ValidATOI()
			      Add CmpStr()
			      Add StrTrim()
			      Add FindLast()
			      Add StrNChr()

###############################################################################
*/



/*
###############################################################################
Include Part
###############################################################################
*/

#include "reg51.h"
#include "util.h"
#include "serial.h"


/*
###############################################################################
Define Part
###############################################################################
*/




/*
###############################################################################
Grobal Variable Definition Part
###############################################################################
*/



/*
###############################################################################
Local  Variable Definition Part
###############################################################################
*/



/*
###############################################################################
Function Implementation Part
###############################################################################
*/

/*
Description   :  Convert Hex(0-F) to Character
Argument      :  c -  Hex( 0x00'~0x0F)to convert into character (INPUT)
Note          :  
*/
UCHAR D2C(char c)
{
	if( c >= 0 && c <= 9)
		return '0' + c;
	if( c >= 10 && c <= 15)
		return 'A' + c - 10;
	return c;	
}

/*
Description   :  Convert Character into Hex
Argument      :  c - character( '0'~'F') to convert into Hex(INPUT)

Note          :  
*/
char C2D(UCHAR c)
{
	if( c >= '0' && c <= '9')
		return c - '0';
	if( c >= 'a' && c <= 'f')
		return 10 + c -'a';
	if( c >= 'A' && c <= 'F')
		return 10 + c -'A';
	return c;
}

/*
Description   :  Convert Character string into integer number.
Argument      :  str - Source string (INPUT)
                 base - Base of value; must be in the range 2 ~ 16
Return Value  :  Value of Number to be converted 
Note          :  
*/
UINT ATOI(UCHAR* str,char base)
{
        UINT num = 0;
        while (*str !=0)
                num = num * base + C2D(*str++);
	return num;
}	


/*
###############################################################################
Unused Function Implementation Part
###############################################################################
*/

#ifndef __UTIL_UNUSED
/*
Description   :   Find beginning of character in string  
Argument      :  src - source string (INPUT)
                 tag -  Character to find in source string (INPUT)
Note          :  
*/
UCHAR * FindFirstStr(UCHAR *src,UCHAR * tag)
{
	UINT i;
	UCHAR * tsrc = src;
	
FIND:
	if((tsrc = FindFirst(tsrc,tag[0])) !=0)
	{
		for(i=1; tag[i] != '\0' ; i++)
		{
			if(*(tsrc+i) == '\0') return 0;
			if( *(tag + i) != *(tsrc+ i) )
			{
				tsrc++;
				goto FIND;
			}
		}
		return tsrc;		
	}
	return 0;
}


/*
Description   :  Cascade 'tag' in the end of 'str' string.
Argument      :  str - source string  (INPUT, OUTPUT)
Note          :  
*/
void MemCat(UCHAR* str, UCHAR* tag)
{
	while(*str !='\0') str++;
	while(*tag !='\0') *str++ = *tag++;
	*str='\0';
}

/*
Description   :  Find last location of character in string  
Argument      :  src - source string (INPUT)
                   c -  Character to find in source string (INPUT)
Note          :  Version 2.0
*/
UCHAR * FindLast(UCHAR * src,char c)
{
	
	UCHAR * ret = 0;
	while(*src != '\0')
	{
		if(*src == c) ret = src;
		src++;
	}
	return ret;
}

/*
Description   :  Get count 'c' character in str
Argument      :  src - Source string (INPUT)
                 c - character to be found 
Return Value  :  Count
Note          :  Version 2.0
*/
int StrNChr(char* src, char c)
{
	int ret = 0;
	while(*src != '\0')
		if(*src++ == c) ret++;
	return ret;	
}

/*
Description   :  Convert Decimal Number into string.
Argument      :  str - pointer to string to be returned  
                 base - Base of value; must be in the range 2 ~ 16
Return Value  :  pointer to string
Note          :  Version 2.0
*/
char* ITOA(u_int value,char* str,char base)
{
	char c;
	char* tstr = str;
	char* ret = str;
	if(value == 0) *str++='0';
	while(value > 0)
	{
		*str++ = D2C(value%base);
		value /= base;
	}
	*str-- ='\0';
	while(tstr < str )
	{
		c = *tstr;
		*tstr++ = *str;	
		*str-- = c;
	}
	return ret;
}
/*
Description   :  Convert Character string to (hexa-)decimal.
Argument      :  str - Source string (INPUT)
                 base - Base of value; must be in the range 2 ~ 16 
		 ret - Value of Number to be converted
Return Value  :  Verify digit character in str, 
		 Verify success : 1
                        fail    : -1
Note          :  Version 2.0
*/
char ValidATOI(char* str, int base, int* ret)
{
	char c;
	char* tstr = str;
	if(str == 0 || *str == '\0') return -1;
	while(*tstr != '\0')
	{
		c = C2D(*tstr);
		if( c >= 0 && c < base) tstr++;
		else    return -1;
	}
	
	*ret = ATOI(str,base);
	return 1;
}


/*
Description   :  Cut out whitespace in src
Argument      :  src - Source string (INPUT)
Return Value  :  Trimed string
Note          :  Version 2.0
*/
void StrTrim(char* src)
{
	int size = StrLen(src);
	char c;
	while(size > 0)
	{
		c = *(src+size);
		if( c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\b')
			*(src+size) = 0;
		else break;
		size--;
	}
}

/*
Description   :  Compare source string to destination source
Argument      :  str - Source string (INPUT)
                 dst - destination string
Return Value  :  src > dst : 1
		 src = dst : 0
                 src < dst : -1
Note          :  Version 2.0
*/
int CmpStr(char* src, char* dst)
{
	while(*src != '\0')
	{
		if(*src > *dst)	return 1;
		else if(*src < *dst)	return -1;
		src++;
		dst++;
	}
	if(*dst != '\0') return 1;
	return 0;
}

/*
Description   :  Replace with assigned character in Character String 
Argument      :  src - character string to replace specific-character(INPUT, OUTPUT)
                 s - Character to be placed  
		 d - replacement character
Return Value  :  
Note          :  
*/
void ReplaceAll(UCHAR * src,char s,char d)
{
	while(*src != '\0')
	{
                if(*src == s)	*src = d;
		src++;
	}
}

/*
Description   : Turncate character string by Delimeter
Argument      :  src - character string to be Tokenize (INPUT)
	         sep - Delimeter character  (INPUT)
                 tok - Copy string in front of Delimeter with character string Pointer to be assigned.(OUTPUT)

Return Value  :Pointer to assign beginning of tag in original string Delimeter
Note          :  Version 2.0
*/
UCHAR * StrTok(UCHAR* src,char sep,UCHAR* tok)
{
	UCHAR * tsrc;
	if((tsrc = FindFirst(src,sep)) != 0)
	{
		while(src != tsrc)	*tok++ = *src++;
		*tok = '\0';
	}
	else
	{
		MemCopy(tok,src);
		return 0 ;
	}
	while(*src == sep)src++;
	if(*src == '\0')
	{
		return 0;
	}
	return src;
}


/*
Description   :  Copy src string to dst.
Argument      :  src -Source string (INPUT)
                 dst -  Taget string (OUTPUT)
Return Value  :  Length of copied string
Note          :  
*/
UINT MemCopy(UCHAR *dst,UCHAR * src)
{
	UINT i=0;
	while(*src !=0) *dst++ = *src++, i++;
	*dst = '\0';
	return i;
}

/*
Description   :  Find first location of character in string  
Argument      :  src - source string (INPUT)
                   c -  Character to find in source string (INPUT)
Note          :  
*/
UCHAR * FindFirst(UCHAR * src,char c)
{
	
	while(*src != '\0')
	{
		if(*src == c) 	return src;
		src++;
	}
	return 0;
}


/*
Description   :  Convert small letter to capital letter in string  
Argument      :  src -  source string (INPUT)
Return Value  :  
Note          :  
*/
void MakeUpper(UCHAR* src)
{
	while(*src != '\0')
	{
		if(*src >= 'a' && *src <= 'z')	*src = *src + 'A' - 'a';
		src++;
	}
}

/*
Description   : Find  out Length of string
Return Value  :  Length of source string
Note          :  
*/
UINT StrLen(UCHAR* str)
{
	UINT i = 0;
	while(*str++ != '\0') i++;
	return i;
}


#endif