#include "Usart.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include "modbus.h"
#include "Rcc_Nvic_Systick.h"
#include "global_param.h"
//Êý¾Ý·¢ËͶÓÁбäÁ¿
EUART_Frame m_EUART_TxFrames[EUART_TX_FRM_SIZE];	//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐ	
volatile int8_t m_EUART_TxFrm_Tail = 0;					//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐβָÕë
volatile int8_t m_EUART_TxFrm_Head = 0;					//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐÍ·Ö¸Õë
volatile int8_t m_EUART_TxFrm_FreeFrmLen = 0;			//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐÊ£ÓàÖ¡Êý
//DMAÊý¾Ý½ÓÊÕ»º´æ
uint8_t m_EUART_DMA_RXBuf[EUART_RX_BUF_SIZE];			//DMAÊý¾Ý½ÓÊÕ»º´æ
volatile int32_t m_EUART_DMA_RXPtr = 0;					//µ±Ç°Êý¾ÝµØÖ·
int16_t DMA_rxtemp = 0,DMA_rxtemp2 = 0;															//µ±Ç°Êý¾ÝµØÖ·»º´æ
u16 datadelaycount = 0;													//Ê£Óà1λÊý¾ÝÑÓʱµÈ´ý´¦Àí
//±êÖ¾±äÁ¿
volatile uint8_t m_bEUARTPushingFrms = 0;				//ÕýÔÚÍù·¢ËͶÓÁдæÊý¾Ý
volatile uint8_t m_bEUARTCheckingSend = 0;				//ÕýÔÚÈ·ÈÏÊý¾Ý·¢ËÍ
volatile uint8_t m_bEUARTCheckingRec = 0;				//ÕýÔÚÈ·ÈϽÓÊÕÊý¾Ý
volatile uint8_t m_bEUARTTxEn = 0;						//ʹÄÜ·¢ËÍ

void (*Usart1ParseDataCallback)(uint8_t);
void Usart1InitVariables(void)
{	
	m_EUART_TxFrm_FreeFrmLen = EUART_TX_FRM_SIZE-1;
}
 HIDO_DataStruct stPosState[4];
HIDO_INT32 GPS_ParseGGA(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{

    if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%p,%*,%p,%*,%p,%*,%*,%p,%*,%*,%*,%*,%**",
			&stPosState[0], &stPosState[1], &stPosState[2], &stPosState[3]) != 15)
    {
        return HIDO_ERR;
    }

    //l_u8PosState = atoi((HIDO_CHAR *)stPosState.m_pData);

    return HIDO_OK;
}
//UART DMAµÄÅäÖÃ
void UART_DMAConfiguration(void)
{
	DMA_InitTypeDef DMA_InitStructure;

	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	
	//UARTµÄDMAÊý¾Ý½ÓÊÕ³õʼ»¯
	DMA_DeInit(EUART_RX_DMA_CH);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)( &(EXT_UART->DR));			//ÍâÉèÊý¾Ý¼Ä´æÆ÷
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)m_EUART_DMA_RXBuf;				//Êý¾ÝBuf
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;							//ÍâÉè×÷Ô´Í·
	DMA_InitStructure.DMA_BufferSize = EUART_RX_BUF_SIZE;						//Buf´óС
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;			//ÍâÉèµØÖ·²»Ôö¼Ó
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;						//ÄÚ´æµØÖ·Ôö¼Ó
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;		//×Ö½Ú
	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;				//×Ö½Ú£¨×¢ÒâÓëÉÏÒ»¸ö±äÁ¿Ãû³Æ²»Í¬£¡£¡£©
	DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;								//Ñ­»·Ä£Ê½
	DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;						//ÓÅÏȼ¶
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;								//·ÇÄÚ´æµ½ÄÚ´æ
	DMA_Init(EUART_RX_DMA_CH, &DMA_InitStructure);
	USART_DMACmd(EXT_UART, USART_DMAReq_Rx, ENABLE);							
	DMA_Cmd(EUART_RX_DMA_CH, ENABLE);			
	
#ifdef EXUART_USE_TXDMA
	//UARTµÄDMAÊý¾Ý·¢Ëͳõʼ»¯
	DMA_DeInit(EUART_TX_DMA_CH);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&(EXT_UART->DR));			//ÍâÉèÊý¾Ý¼Ä´æÆ÷
	DMA_InitStructure.DMA_MemoryBaseAddr = 0;									//Êý¾ÝBuf
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;							//ÍâÉè×÷Ä¿±ê
	DMA_InitStructure.DMA_BufferSize = 0;										//Buf´óС
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;			//ÍâÉèµØÖ·¼Ä´æÆ÷²»µÝÔö
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;						//ÄÚ´æµØÖ·µÝÔö
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;		//ÍâÉè×Ö½ÚΪµ¥Î»
	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;				//ÄÚ´æ×Ö½ÚΪµ¥Î»£¨×¢ÒâÓëÉÏÒ»¸ö±äÁ¿Ãû³Æ²»Í¬£¡£¡£©
	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;								//ÆÕͨģʽ
	DMA_InitStructure.DMA_Priority = DMA_Priority_High;							//ÓÅÏȼ¶
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;								//·ÇÄÚ´æµ½ÄÚ´æ
	DMA_Init(EUART_TX_DMA_CH, &DMA_InitStructure);

//	DMA_ITConfig(EUART_TX_DMA_CH, DMA_IT_TC, ENABLE);							//DMA´«ÊäÍê³ÉÖжÏ
	USART_DMACmd(EXT_UART,USART_DMAReq_Tx,ENABLE);								//ÍâÉèʹÄÜDMA  // */
#endif						
}

void Uart1_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	USART_ClockInitTypeDef USART_ClockInitStructure;
	
	/* Enable GPIO clock */
    RCC_APB2PeriphClockCmd(EU_RCC_GPIO | RCC_APB2Periph_AFIO, ENABLE);
	/* Enable USART clock */
    RCC_APB2PeriphClockCmd(EXT_UART_RCC, ENABLE);
	
	Usart1InitVariables();
	
	//³õʼ»¯¹Ü½Å
	GPIO_InitStructure.GPIO_Pin = EU_RX_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;							//RxÉÏÀ­ÊäÈë
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(EU_RX_GPIO, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = EU_TX_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;							//TxÍÆÍ츴ÓÃÊä³ö GPIO_Mode_AF_PP
	GPIO_Init(EU_TX_GPIO, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = EU_485_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;							//TxÍÆÍ츴ÓÃÊä³ö GPIO_Mode_AF_PP
	GPIO_Init(EU_485_GPIO, &GPIO_InitStructure);
	OUT485_DISABLE;
#ifdef UART_GPIO_REMAP_ENABLE
	GPIO_PinRemapConfig(UART_GPIO_REMAP, ENABLE);
#endif
	
	USART_DeInit(EXT_UART);
	USART_InitStructure.USART_BaudRate = EXUART_BAUD_RADE;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
		
	USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
	
	USART_ClockInit(EXT_UART, &USART_ClockInitStructure);
	USART_Init(EXT_UART, &USART_InitStructure);
//	USART_ITConfig(EXT_UART, USART_IT_RXNE, ENABLE);//??????,????? ??????????
	// Enable the USARTx 
	USART_Cmd(EXT_UART, ENABLE); 
	//DMAÅäÖã¨Ðë·Åµ½UART³õʼ»¯Ö®ºó£©
	UART_DMAConfiguration();
	
}
u8 overrun_flag=0,receiveingdata_flag,gpsdataready_flag,waitggaend_flag,ggaend_idx;
u8 RTCMdata[2000];
u32 lastusartdata_timer;
u16 rtcm_i,gps_packlen;
u16 t1,t2,t3,t4;
extern volatile uint32_t time32_incr;
void UART_CheckReceive(void)
{
	int32_t DMACnt = 0;
	int32_t MaxDataLen = EUART_RX_BUF_SIZE;	
	
	//Èç¹ûÕýÔÚÍù·¢ËͶÓÁÐÖÐÌí¼ÓÊý¾Ý£¬Í˳ö
	if(m_bEUARTPushingFrms)
		return;
	//ÅжÏÊÇ·ñÕýÔÚCheck
	if(m_bEUARTCheckingRec)
		return;
	m_bEUARTCheckingRec = 1;
	if(EUART_RX_DMA_CH->CNDTR == 0)
	{
		m_bEUARTCheckingRec = 0;
		return;
	}
	if(time32_incr-lastusartdata_timer>300&&receiveingdata_flag)
	{
		gpsdataready_flag = 1;
		receiveingdata_flag = 0;
		gps_packlen = rtcm_i;
		rtcm_i = 0;
		t1++;
		waitggaend_flag = 1;
		if(g_com_map[DEV_ROLE])
		{
			UWBSendOnePackData(RTCMdata,gps_packlen);
			gpsdataready_flag = 0;
		}
	}
	DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
	while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
	{
		receiveingdata_flag = 1;
		lastusartdata_timer = time32_incr;
		//Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
		RTCMdata[rtcm_i++] = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
//		if(waitggaend_flag&&m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]=='*')
//		{
//			waitggaend_flag = 0;
//			ggaend_idx = rtcm_i;
//		}
		//delay_us(10);
		m_EUART_DMA_RXPtr++;
		if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
		{
			m_EUART_DMA_RXPtr = 0;
		}
		DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
		MaxDataLen--;
	}
	m_bEUARTCheckingRec = 0;	
}

#ifndef EXUART_USE_TXDMA							
//²éѯ·½Ê½·¢ËÍÊý¾Ý
void UART_CheckSend(void)
{
	static int32_t s_count = 0;
//	uint32_t temp32 = 0;

	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTCheckingSend = 1;

	//Åж϶ÓÁÐÊÇ·ñΪ¿ÕÒÔ¼°DMAÊÇ·ñ¿ÕÏÐ
	if ((EXT_UART->SR & USART_FLAG_TXE) == (uint16_t)RESET)	//Éϴη¢ËÍδÍê³É
	{
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)					//¶ÓÁÐΪ¿Õ
	{
		if((EXT_UART->SR & USART_FLAG_TC) != (uint16_t)RESET)	 	//·¢ËÍÍê±Ï
		{
			if(m_bEUARTTxEn)
			{
				OUT485_DISABLE;
				m_bEUARTTxEn = 0;
				t3++;
//				temp32 = GPIOC->CRH;			//C10Ðü¿ÕÊäÈë
//				temp32 &= ~(0x00000000F<<8);		
//				temp32 |= (0x000000004<<8);
//				GPIOC->CRH = temp32;// */
			}
		}
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	if(!m_bEUARTTxEn)
	{
		m_bEUARTTxEn = 1;
		 OUT485_ENABLE;
		t4++;
		#ifdef BAUDRATE_19200
		delay_us(500);
		#else
		delay_us(10);
		#endif
//		temp32 = GPIOC->CRH;			//C10¸´ÓÃÍÆÍìÊä³ö
//		temp32 &= ~(0x00000000F<<8);
//		temp32 |= (0x000000009<<8);
//		GPIOC->CRH = temp32;// */
	}
	
	//·¢ËÍÒ»¸ö×Ö½ÚÊý¾Ý
	EXT_UART->DR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf[s_count];		
	s_count++;
	if(s_count >= m_EUART_TxFrames[m_EUART_TxFrm_Tail].len)		//Ò»Ö¡Êý¾Ý·¢ËÍÍê±Ï
	{
		s_count = 0;
		m_EUART_TxFrm_Tail++;
		if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
			m_EUART_TxFrm_Tail = 0;
		m_EUART_TxFrm_FreeFrmLen++;
	}
	m_bEUARTCheckingSend = 0;
 }		   // */

#else
 /*
//¼ì²éÊÇ·ñÊý¾ÝÖ¡ÐèÒª·¢ËÍ
void UART_CheckSend(void)
{
	//ÅжÏÊÇ·ñÕýÔÚCheck
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTCheckingSend = 1;

	//ÅжÏDMAͨµÀÊÇ·ñÕýÔÚ¹¤×÷
	if((EUART_TX_DMA_CH->CCR & 0x01) != 0)	//ͨµÀÕýÔÚ¹¤×÷
	{
		if((EUART_DMA->ISR & EUART_TX_DMA_IT_TC) == (uint32_t)RESET) 	//´«ÊäδÍê³É
		{
			m_bEUARTCheckingSend = 0;
			return;
		}
		else
		{
			EUART_DMA->IFCR = EUART_TX_DMA_IT_TC;				//Çå³ý±êÖ¾£¨×¢Òâ¼Ä´æÆ÷ºÍ±êÖ¾Ãû³Æ£©
			EUART_TX_DMA_CH->CCR &= ~((uint32_t)0x01);	//½ûÓÃDMA
		}
	}
	
	//Åж϶ÓÁÐÊÇ·ñΪ¿Õ
	if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)
	{
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	//¿ªÆôÒ»´ÎÊý¾Ý·¢ËÍ
	EUART_TX_DMA_CH->CMAR = (uint32_t)m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf;	//Òª·¢Ë͵ÄÄÚ´æµØÖ· 
	EUART_TX_DMA_CH->CNDTR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].len;		//Òª·¢Ë͵Ä×Ö½ÚÊý
	EUART_TX_DMA_CH->CCR |= 0x01;											//¿ªÆôÒ»´ÎDMA  
	m_EUART_TxFrm_Tail++;
	if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
		m_EUART_TxFrm_Tail = 0;	
	m_EUART_TxFrm_FreeFrmLen++;
	m_bEUARTCheckingSend = 0;	 
}					// */	
#endif


//½«Ò»Ö¡Êý¾ÝѹÈë·¢ËͶÓÁÐ
void UART_PushFrame(uint8_t* pdata, int32_t data_len)
{
//	uint8_t temp8 = 0;
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTPushingFrms = 1;
	
	if(data_len > EUART_TX_FRMBUF_SIZE || m_EUART_TxFrm_FreeFrmLen <= 0)		//Ö¡³¤¶È³¬·¶Î§»ò»º´æÒÑÂú
	{
		m_bEUARTPushingFrms = 0;
		return;
	}

	//½«Òª·¢Ë͵ÄÊý¾Ý֡ѹÈë¶ÓÁÐ
	m_EUART_TxFrames[m_EUART_TxFrm_Head].len = data_len;
	memcpy((uint8_t*)m_EUART_TxFrames[m_EUART_TxFrm_Head].buf, (uint8_t*)pdata, data_len);
	m_EUART_TxFrm_Head++;
	if(m_EUART_TxFrm_Head == EUART_TX_FRM_SIZE)
		m_EUART_TxFrm_Head = 0;
	m_EUART_TxFrm_FreeFrmLen--;
	m_bEUARTPushingFrms = 0;	
}

//½«×îÐÂÒ»Ö¡Êý¾ÝPop³ö¶ÓÁÐ
void UART_PopFrame(void)
{
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	if(m_EUART_TxFrm_FreeFrmLen >= EUART_TX_FRM_SIZE-1)
		return;
	m_EUART_TxFrm_Head--;
	if(m_EUART_TxFrm_Head < 0)
		m_EUART_TxFrm_Head = EUART_TX_FRM_SIZE-1;
	m_EUART_TxFrm_FreeFrmLen++;
}
void USART_putc(char c)
{
	//while(!(USART2->SR & 0x00000040));
	//USART_SendData(USART2,c);
	/* e.g. write a character to the USART */
	USART_SendData(USART1, c);

	/* Loop until the end of transmission */
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)	;
}
void USART_puts(uint8_t *s,uint8_t len)
{
	int i;
	for(i=0; i<len; i++)
	{
		USART_putc(s[i]);
	}
}
int fputc(int ch, FILE *f)
{
	
	USART_SendData(USART1, (unsigned char) ch);// USART1 ???? USART2 ?
	while (!(USART1->SR & USART_FLAG_TXE));
	return (ch);
}

HIDO_UINT32 HIDO_UtilParseFormat(HIDO_UINT8 *_pu8Src, HIDO_UINT32 _u32SrcLen, const HIDO_CHAR *_pcFmt, ...)
{
    va_list sArgPtr = { NULL };
    int nParseNum = 0;
    HIDO_CHAR cSign = ' ';
    HIDO_BOOL bReturn = HIDO_FALSE;

    if((NULL == _pu8Src) || (NULL == _pcFmt))
    {
        return 0;
    }

    va_start(sArgPtr, _pcFmt);

    while ((*_pcFmt) != '\0')
    {
        if(0 == _u32SrcLen)
        {
            if(!(('%' == *_pcFmt) && ('e' == *(_pcFmt + 1))))
            {
                break;
            }
        }

        if ((*_pcFmt) == '%')
        {
            _pcFmt++;
            cSign = *(_pcFmt++);

            switch (cSign)
            {
            case '*':
            {
                while (_u32SrcLen)
                {
                    if (*_pu8Src != *_pcFmt)
                    {
                        _pu8Src++;
                        _u32SrcLen--;
                    }
                    else
                    {
                        break;
                    }
                }

                nParseNum++;

                break;
            }
            case 'd':
            {
                HIDO_BOOL bNeg = HIDO_FALSE;
                HIDO_BOOL bBeg = HIDO_FALSE;

                HIDO_UINT32 nResult = 0;
                int *pInt = NULL;
                HIDO_CHAR c = ' ';

                pInt = va_arg(sArgPtr, INT32_PTR);

                while (_u32SrcLen)
                {
                    c = *_pu8Src;

                    if ((HIDO_FALSE == bBeg) && c == '-')
                    {
                        bNeg = HIDO_TRUE;
                        bBeg = HIDO_TRUE;
                    }
                    else if ((c >= '0') && (c <= '9'))
                    {
                        bBeg = HIDO_TRUE;
                        nResult = nResult * 10 + (c - '0');
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if (HIDO_TRUE == bNeg)
                {
                    nResult = (~nResult) + 1;
                }

                if (NULL != pInt)
                {
                    *pInt = nResult;
                }

                nParseNum++;

                break;
            }
            case 'x':
            {
                HIDO_UINT32 nResult = 0;
                HIDO_UINT32 *pUint = NULL;
                HIDO_CHAR c;

                pUint = va_arg(sArgPtr, UINT32_PTR);

                while (_u32SrcLen)
                {
                    c = *_pu8Src;

                    if ((c >= '0') && (c <= '9'))
                    {
                        nResult = (nResult << 4) + (c - '0');
                    }
                    else if ((c >= 'a') && (c <= 'f'))
                    {
                        nResult = (nResult << 4) + (c - 'a' + 0x0A);
                    }
                    else if ((c >= 'A') && (c <= 'F'))
                    {
                        nResult = (nResult << 4) + (c - 'A' + 0x0A);
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if (NULL != pUint)
                {
                    *pUint = nResult;
                }

                nParseNum++;

                break;
            }
            case 'p':
            {
                HIDO_DataStruct *pDptr = va_arg(sArgPtr, DATA_PTR);
                HIDO_UINT8 *pStart = NULL;
                HIDO_UINT32 nCount = 0;

                pStart = _pu8Src;

                while (_u32SrcLen)
                {
                    if (*_pu8Src != *_pcFmt)
                    {
                        nCount++;
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if(NULL != pDptr)
                {
                    pDptr->m_pData = pStart;
                    pDptr->m_u32Len = nCount;
                }

                nParseNum++;

                break;
            }
            case 'e':
            {
                HIDO_UINT8 **ppPtr = va_arg(sArgPtr, U8_PTR_PTR);

                if (ppPtr)
                {
                    *ppPtr = _pu8Src;
                }

                nParseNum++;
                bReturn = HIDO_TRUE;

                break;
            }
            default:
            {
                bReturn = HIDO_TRUE;
                nParseNum = 0;

                break;
            }
            }

            if(HIDO_TRUE == bReturn)
            {
                break;
            }
        }
        else if (*_pu8Src == *_pcFmt)
        {
            _pu8Src++;
            _pcFmt++;
            _u32SrcLen--;
        }
        else
        {
            nParseNum = 0;

            break;
        }
    }

    va_end(sArgPtr);

    return nParseNum;
}