tools.c

名厂车载GPS通信终端

		}
		if(s2[j]=='\0')
		{
		return (s1+i);
		}
		if(++tail>=maxsize) tail=0;
		clr_watchdog();
		}
		return ( ( char * )0 );
}*/

/*void String2Bcd(LPBYTE dst,LPBYTE src,WORD dstlen,WORD srclen,UCHAR keychar)
{
WORD i;
if(srclen>dstlen*2)
{
for(i=0;i<dstlen;i++)
{
dst[i]=src[2*i]-0x30;
dst[i]<<=4;
dst[i]|=(src[2*i+1]-0x30);
}
}
else
{
if(srclen%2==0)
{
for(i=0;i<srclen/2;i++)
{
dst[i]=src[2*i]-0x30;
dst[i]<<=4;
dst[i]|=(src[2*i+1]-0x30);
}
for(i=srclen/2;i<dstlen;i++)
{
dst[i]=(keychar<<4);
dst[i]|=keychar;
}
}
else
{
for(i=0;i<(srclen-1)/2;i++)
{
dst[i]=src[2*i]-0x30;
dst[i]<<=4;
dst[i]|=(src[2*i+1]-0x30);
}
dst[(srclen-1)/2]=src[srclen-1]-0x30;
dst[(srclen-1)/2]<<=4;
dst[(srclen-1)/2]|=keychar;
for(i=(srclen-1)/2+1;i<dstlen;i++)
{
dst[i]=(keychar<<4);
dst[i]|=keychar;
}
}
}
}*/

/*WORD Bcd2String(LPBYTE dst,LPBYTE src,WORD srclen,UCHAR endchar)
{
WORD i;
UCHAR a,b;
for(i=0;i<srclen*2;i++)
{
a=(src[i]>>4);
if(a!=endchar)
{
dst[2*i]=0x30+a;
}
else
{
return 2*i;
}
b=src[i]&0x0f;
if(b!=endchar)
{
dst[2*i+1]=0x30+b;
}
else
{
return 2*i+1;
}
}
return srclen*2;
}*/

//填充拷贝
void _MemFillCpy(LPBYTE dst,LPBYTE src,UCHAR keychar,WORD dstlen,WORD srclen)
{
	if(dstlen>srclen)
	{
		_Memset(dst+srclen,keychar,dstlen-srclen);
	}
	_Memcpy(dst,src,srclen);
}
//
/*void _MemFillChg(LPBYTE src,UCHAR dstkeychar,UCHAR srckeychar,WORD srclen)
{
while(src[srclen-1]==srckeychar)
{
src[srclen-1]=dstkeychar;
srclen--;
}
}*/
//字符串比较
/*UCHAR  _Memicmp(LPBYTE p,LPBYTE buf,WORD  len)
{
WORD  i;
UCHAR	value=0;
for(i=0;i<len;i++)
{
if(p[i]!=buf[i])
{
value= 1;
break;
}
}
return value;
}*/

/*WORD _MemFind(LPBYTE pSrc,LPBYTE pDst,WORD Srclen)
{
WORD i;
WORD Dstlen;  //bylrx

  Dstlen = _stringlen(pDst); //bylrx
  if(Srclen<Dstlen) return 0xffff;
  
	for(i=0;i<Srclen-Dstlen+1;i++)//bylrx
	{
	if(_Memicmp(pSrc+i,pDst,Dstlen)==0)
	{
	return i;
	}
	}
	return 0xffff;
}*/

WORD  _Memcpy(LPBYTE p,LPBYTE buf,WORD len)
{
	WORD i=0;
	for(i=0;i<len;i++)
	{
		p[i] = buf[i];
	}
	return i;
}

/*WORD _Memcat(LPBYTE p,LPBYTE buf,WORD start,WORD len)
{
WORD i;

  for(i=0;i<len;i++)
  {
		p[start+i]=buf[i];
		}
		return i;
}*/

/*WORD  _Strcpy(LPBYTE p,LPBYTE buf)
{
WORD  i = 0;
while(buf[i]!=0x00)
{
p[i]=buf[i];
i++;
}
p[i]=0;
return i;
}*/

WORD _Strlen(LPBYTE p,uint lenlimit)
{
	//	WORD i=0;
	//	while(p[i]!=0){i++;}
	WORD i;
	for(i=0; i<lenlimit; i++) if(p[i]==0 || p[i]=='F') break;
	return i;
}


WORD _StrlenForKey(LPBYTE p,UCHAR keychar,WORD maxlength)
{
	WORD i=0;
	while((p[i]!=keychar)&&(i<maxlength)){i++;}
	return i;
}

void _Memset(LPBYTE p,UCHAR value,WORD size)
{
	WORD i=0;
	for(i=0;i<size;i++)
	{
		p[i]= value;	 	
	}
}

UCHAR IntToStr(DWORD inCount,LPBYTE outchar)
{
	UCHAR len;
	UCHAR i;
	UCHAR str;
	if(inCount==0){outchar[0]='0';return 1;}
	
	len=0;
	while(inCount!=0)
	{
		outchar[len]=(UCHAR)(inCount%10)+0x30;
		inCount/=10;
		len++;
	}
	for(i=0;i<len/2;i++)
	{
		str=outchar[i];
		outchar[i]=outchar[len-1-i];
		outchar[len-1-i]=str;
	}
	return (len);
}

/*DWORD StrToInt(LPBYTE src,UCHAR len,UCHAR base)
{
DWORD result=0;
UCHAR i;
for(i=0;i<len;i++)
{
result+=(DWORD)(src[i]-0x30)*base;
result<<=8;
}
return(result);
}*/
//
uint WideCharToMultiByte(
						 LPBYTE  lpWideCharStr,
						 uint      cchWideChar,
						 LPBYTE   lpMultiByteStr,
						 uint      cchMultiByte
						 )
{
	uint len=0,i=0;
	LPBYTE aaa;
	
	while(len<cchMultiByte)
	{
		if(i<cchWideChar)
		{
			if(lpWideCharStr[i]==0)
			{
				*lpMultiByteStr++=lpWideCharStr[i+1];
				len++;
			}
			else
			{
				aaa=UnicodeToGBCode(lpWideCharStr+i);
				*lpMultiByteStr++=*aaa;
				*lpMultiByteStr++=*(aaa+1);
				len=len+2;
			}
			i=i+2;
		}
		else
		{
			break;
		}
	}
	return len;
}
uint MultiByteToWideChar(
						 LPBYTE   lpMultiByteStr,
						 uint      cchMultiByte,
						 LPBYTE   lpWideCharStr,
						 uint      cchWideChar)//gb转unicode
{
	uint len=0,i=0;
	LPBYTE aaa;
	
	while(len<cchWideChar)
	{
		if(i<cchMultiByte)
		{
			if(IsGBCode(lpMultiByteStr+i)==TRUE)
			{
				aaa=GBCodeToUnicode(lpMultiByteStr+i);
				*lpWideCharStr++=*aaa;
				*lpWideCharStr++=*(aaa+1);
				i=i+2;
			}
			else
			{
				*lpWideCharStr++=0;
				*lpWideCharStr++=lpMultiByteStr[i];
				i++;
			}
			len=len+2;
		}
		else
		{
			break;
		}
	}
	return len;
}

/************************************************************************
*  Function name   : GBCodeToUnicode
*  Description     : Map GB2312 code to Unicode.
*                  :
*  Parameters      : gbCode   - The GB code.
*  Returns         : The mapped Unicode.  NULL if error.
*  Author          : Richard Shen
* ----------------------------------------------------------------------
*  Date     By       Description
* ----------------------------------------------------------------------
*  09Oct00  RCS      Created.
************************************************************************/
LPBYTE GBCodeToUnicode(LPBYTE gbCode)
{
	const unsigned char  *mapped = 0;
	unsigned int         i;
	
	LPBYTE gb2uTable;
	
	Change_Bank(GB2UNICODEADDR-FALSH_OFFER_ADDR);
	gb2uTable=(LPBYTE)GB2UNICODEADDR;
	
	if ((*(gbCode + 1) >= 0xa1) && (*(gbCode + 1) <= 0xfe))
	{
		if ((*gbCode >= 0xa1) && (*gbCode <= 0xa9))
		{
			i      = ((*gbCode - 0xa1) * 94 + (*(gbCode + 1) - 0xa1)) * 2;
			mapped = &gb2uTable[i];
		} /* end of if */
		else
			if ((*gbCode >= 0xb0) && (*gbCode <= 0xf7))
			{
				i      = ((*gbCode - 0xb0 + 9) * 94 + (*(gbCode + 1) - 0xa1)) * 2;
				mapped = &gb2uTable[i];
			} /* end of if */
	} /* end of if */
	
	return mapped;
} // GBCodeToUnicode()

  /************************************************************************
  *  Function name   : UnicodeToGBCode
  *  Description     : Map Unicode to GB2312 code.
  *                  :
  *  Parameters      : unicode  - The Unicode.
  *  Returns         : The mapped GBCode.  NULL if error.
  *  Author          : Richard Shen
  * ----------------------------------------------------------------------
  *  Date     By       Description
  * ----------------------------------------------------------------------
  *  09Oct00  RCS      Created.
************************************************************************/
LPBYTE UnicodeToGBCode(LPBYTE unicode)
{
	DWORD   i;
	LPBYTE u2gbTable;
	
	Change_Bank(UNICODE2GBADDR-FALSH_OFFER_ADDR);
	u2gbTable=(LPBYTE)UNICODE2GBADDR;
	i=unicode[0];
	i<<=8;
	i+=unicode[1];
	i*=2;
	
	return &u2gbTable[i];
} // UnicodeToGBCode()

  /************************************************************************
  *  Function name   : IsGBCode
  *  Description     : Check whether it is a valid GB2312 code.
  *                  :
  *  Parameters      : gbCode   - The code (2 bytes).
  *  Returns         : TRUE     - Is GB code.
  *                  : FALSE    - Non GB code.
  *  Author          : Richard Shen
  * ----------------------------------------------------------------------
  *  Date     By       Description
  * ----------------------------------------------------------------------
  *  20Oct00  RCS      Created.
************************************************************************/
BOOL IsGBCode(LPBYTE gbCode)
{
	BOOL  answer = FALSE;
	
	if ((*(gbCode + 1) >= 0xa1) && (*(gbCode + 1) <= 0xfe))
	{
		if ((*gbCode >= 0xa1) && (*gbCode <= 0xa9))
			answer = TRUE;
		else
			if ((*gbCode >= 0xb0) && (*gbCode <= 0xf7))
				answer = TRUE;
    } /* end of if */
	
	return answer;
}

/*BOOL IsAscii(LPBYTE psrc,WORD len)
{
while(len)
{
if(psrc[--len]>0x7f)
{
return FALSE;
}
}
return TRUE;
}*/