atrespparser.cpp

MTK平台COM口通讯的源代码。很底层的。可以学习一下。

			wi = 0;
			readIndex++;
			while(respDataBuf[readIndex]!=')')
			{
				ptr[wi++] = respDataBuf[readIndex++];
			}

			ptr[wi]='\0';
			if(IsNumber(ptr))
				elem.int_range_end = atoi(ptr);
			else
				return false;

			break;

		case '\0':
			return false;
			break;

		case '(':
			GetList(ptr, wi, elemLocal);
			break;

		default:
			ptr[wi++] = respDataBuf[readIndex];
			break;

		}
		readIndex++;
	}
	ptr[wi]='\0';

	
	if(sizeof(ptr)!=0)
		GetParam(ptr, elem, stag);


	return true;
}




// This function would fill the respDataBuf
bool ATRespParser::GetOneCrLf()
{
	unsigned char ch;
	int		state = 0;


	while (!stopEvent)
	{
		if( Raw_Buffer != NULL
		&& stopEvent == false
		&&	Raw_Buffer->CheckOut(ch)==true)
		{
			FillBufferByState( ch, state);
			if(m_waitGtAndSpace)
			{
				if(CheckIfGetGtandSpace())
				{
					::SetEvent(m_hWaitGtAndSpace);
					m_waitGtAndSpace = false;
					state = 0;
				}
			}
		}
		else
		{
			return false;
		}
	}

	return true;
}


bool ATRespParser::GetParam(char *ptr, ATParamElem& elem, bool isString)
{

	ATParamElem elemLocal;

	if(isString)
	{
		elemLocal.type = AT_STRING;
		elemLocal.str_value = ptr;
	}
	else
	{
		if(strlen(ptr)==0)
			elemLocal.type = AT_OMIT;

		
		if(IsNumber(ptr))
		{
			elemLocal.type = AT_INTEGER;
			elemLocal.int_value = atoi(ptr);
		}
		else
		{
			elemLocal.type = AT_STRING;
			elemLocal.str_value = ptr;
		}
	}

	elem.paramLst.push_back(elemLocal);


	return true;
}


HANDLE ATRespParser::GetParserEvent()
{
	return m_hParserEvt;
}


bool ATRespParser::GetParam(char *ptr, ATParamLst& lst, bool isString)
{

	ATParamElem elem;

	if(isString)
	{
		elem.type = AT_STRING;
		elem.str_value = ptr;
	}
	else
	{
		if(strlen(ptr)==0)
		{
			elem.type = AT_OMIT;

		}
		else
		{
			if(IsNumber(ptr))
			{
				elem.type = AT_INTEGER;
				elem.int_value = atoi(ptr);
			}
			else
			{
				elem.type = AT_STRING;
				elem.str_value = ptr;
			}
		}
	}
	lst.eleLst.push_back(elem);


	return true;
}

bool ATRespParser:: GetPdu(char *buf, const int maxLen)
{
    int wi = 0;
	unsigned char ch;
	unsigned char ch2;

	while(1)
	{
		Raw_Buffer->CheckOut(ch);

		if(ch == cr)
		{
			Raw_Buffer->CheckOut(ch2);
			if (ch2 == lf)
			{
				buf[wi] = '\0';
				return true;
			}
			else
				return false;
		}
		else
		{
			if(wi < maxLen)
				buf[wi++] = ch;
		}
		
	}
}


void ATRespParser::GetResult(ATResult& rt)
{
	rt = result;
}


bool ATRespParser::GetString(char *ptr, int& wi, ATParamLst& lst)
{
	
	ATParamElem  elem;

	readIndex++; // Skip "

	wi = 0;

	while(respDataBuf[readIndex]!='"')
	{
		switch(respDataBuf[readIndex])
		{
		case '\0':
			return false;

			break;

		default:
			ptr[wi++] = respDataBuf[readIndex++];
			break;
		}
	}


	ptr[wi]='\0';
	elem.type = AT_STRING;
	elem.str_value = ptr;
	lst.eleLst.push_back(elem);


	while(respDataBuf[readIndex]!='\0'
	&& respDataBuf[readIndex]!=',')
	{
		readIndex++;
	}
	
	if(respDataBuf[readIndex]==',')
		readIndex++;

	if(respDataBuf[readIndex]=='\0')
		readIndex--;

	return true;
}


HANDLE ATRespParser::GetWaitGtAndSpaceEvent()
{
	return m_hWaitGtAndSpace;
}


bool ATRespParser::GetStringToBuf(char *ptr, int& wi, const int size)
{
	wi = 0;

	readIndex++; // Skip one "

	while(respDataBuf[readIndex]!='"')
	{
		switch(respDataBuf[readIndex])
		{
		case '\0':
			return false;

			break;

		default:
			ptr[wi++] = respDataBuf[readIndex++];
			break;
		}

		if(readIndex>=size)
			return false;
	}

	ptr[wi]='\0';

	return true;
}



bool ATRespParser::GetString(char *ptr, int& wi, ATParamElem& elem)
{
	ATParamElem  elemLocal;

	readIndex++; // Skip "

	wi = 0;

	while(respDataBuf[readIndex]!='"')
	{
		switch(respDataBuf[readIndex])
		{
		case '\0':
			return false;

			break;

		default:
			ptr[wi++] = respDataBuf[readIndex++];
			break;
		}
	}


	ptr[wi]='\0';
	elemLocal.type = AT_STRING;
	elemLocal.str_value = ptr;
	

	while(respDataBuf[readIndex]!='\0'
	&& respDataBuf[readIndex]!=')'
	&& respDataBuf[readIndex]!=',')
	{
		readIndex++;
	}
	
	if(respDataBuf[readIndex]==',')
		readIndex++;

	if(respDataBuf[readIndex]=='\0'
	|| respDataBuf[readIndex]==')')
		readIndex--;

	return true;
}


bool ATRespParser::IsNumber(char *ptr)
{
	int len = strlen(ptr);

	for(int i =0; i<len; i++)
	{
		if( (*(ptr+i) < '0')
		||  (*(ptr+i) > '9')
		)
		{
			return false;
		}
	}
	return true;
}


bool ATRespParser::IsUnsolicited(string cmd, ATParamLst& lst)
{
    ATParamElem elem;

	if( cmd == "RING" )
	{
		return true;
	}

	if(lst.eleLst.size()==0)
		return false;

	if(lst.eleLst[0].type != AT_STRING)
		return false;

	// Then handled unsolicited command is listed here
	// This should take care of all the unsolicited command
	// listed in spec.
	if(
	   lst.eleLst[0].str_value == "RING"
	|| lst.eleLst[0].str_value == "NO CARRIER"
	|| lst.eleLst[0].str_value == "+CMT"
	|| lst.eleLst[0].str_value == "+CBM"
	|| lst.eleLst[0].str_value == "+CDS"
	|| lst.eleLst[0].str_value == "+CMTI"
	|| lst.eleLst[0].str_value == "+CBMI"
	|| lst.eleLst[0].str_value == "+CDSI"
	|| lst.eleLst[0].str_value == "+CLIP"
	|| lst.eleLst[0].str_value == "+EADC"
	|| lst.eleLst[0].str_value == "+GPIOS"
	|| lst.eleLst[0].str_value == "+EKPDS"
	|| lst.eleLst[0].str_value == "+BATS"
	)
		return true;

	else
		return false;

	
}


bool ATRespParser::SetCrByte(char _cr)
{
	cr = _cr;
	return true;
}

void ATRespParser::SetExpectString(string command)
{
	result.expectedCommand=command;
}

bool ATRespParser::SetLfByte( char _lf)
{
	lf = _lf;
	return true;
}

void ATRespParser::SetWaitGtAndSpace(bool flag)
{
	m_waitGtAndSpace = flag;
}


void ATRespParser::SetPduFlag(bool flag)
{
	pduFlag = flag;
}

bool ATRespParser::SkipComma( char *ptr, int& ri, const int size)
{
	while(ri < size && *(ptr+ri)!=',')
		ri++;

	if (ri == size)
	{
		ri--;
		return false;
	}
	else
		return true;
}

DWORD WINAPI ATRespParser::ThreadFunc()
{


	if(Raw_Buffer == NULL)
		return -1;

	int i=0;


	while(stopEvent==false
	&& Raw_Buffer != NULL
	)
	{
		AnalyingBuffer();
	}
	return 0;	
}


bool ATRespParser::UnsolicitedGetPdu(char *buf, const int bufLen, ATParamLst& lst)
{

	ATParamElem elem;

	if(lst.eleLst[0].str_value == "+CMT"
	|| lst.eleLst[0].str_value == "+CBM"
	|| lst.eleLst[0].str_value == "+CDS")
	{
		// Get pdu data to buffer
		GetPdu(buf, bufLen);

		// Set up elem
		elem.type = AT_STRING;
		elem.str_value = buf;

		// Push to the elem to elemlst
		lst.eleLst.push_back(elem);
	}

	return true;
}

void  ATRespParser::StopThread()
{
	if( GetHandle()==NULL ) 
	{
		return;
	}

	stopEvent = true;

	WaitForExit();
}


void ATRespParser::Sync()
{
	DWORD state;

	::SetEvent(m_hWriteEvt);
	state = ::WaitForSingleObject(m_hParserEvt, INFINITE);
	::ResetEvent(m_hParserEvt);
	CleanResult(result);
}

bool ATRespParser::StartParsing(	ACircularBuf<unsigned char> *raw_data, 
									unSolicitedCallback cb)
{


	if (raw_data==NULL)
		return false;

	m_hWriteEvt = NULL;
	m_hWriteEvt = ::CreateEvent(NULL, TRUE, FALSE, NULL);
	
	m_hParserEvt = NULL;
	m_hParserEvt = ::CreateEvent(NULL, TRUE, FALSE, NULL);

	m_hStopEvt   = NULL;
	m_hStopEvt   = ::CreateEvent(NULL, FALSE, FALSE, NULL);

	m_hWaitGtAndSpace = NULL;
	m_hWaitGtAndSpace = ::CreateEvent(NULL, FALSE, FALSE, NULL);

	Raw_Buffer = raw_data;


	if(cb == NULL)
		return false;

	// Config the call back function
	m_usc_cb = cb;

	if( StartThread()==false )
	{
		Raw_Buffer = NULL;
		return false;
	}
	return true;
}


bool ATRespParser::StartThread()
{
	m_hThread = (HANDLE)_beginthreadex(
					NULL, 
					0, 
					(PBEGINTHREADEX_THREADFUNC)ATRespParser::HelpThreadFunc, 
					(LPVOID) this, 
					0, 
					(PBEGINTHREADEX_THREADID) &m_ThreadId
				);

	if( m_hThread )
		return true;
	else
		return false;
}


bool ATRespParser::StopParsing()
{
	StopThread();

	Raw_Buffer = NULL;

	::CloseHandle(m_hWriteEvt);
	m_hWriteEvt = NULL;

	::CloseHandle(m_hParserEvt);
	m_hParserEvt = NULL;

	::CloseHandle(m_hStopEvt);
	m_hStopEvt = NULL;

	::CloseHandle(m_hWaitGtAndSpace);
	m_hWaitGtAndSpace = NULL;
	
	return true;
}

void ATRespParser::WaitForExit()
{
	if( m_hThread==NULL )
        return;
	WaitForSingleObject(m_hThread, INFINITE);
	CloseHandle(m_hThread);
    m_hThread=NULL;
}