if ( szToken[0] != '.' ) // set the options
					goto ProcessLine_syntax;
			break;


			case TRACEV_CMD :
			if (pCTmmon->CmdTraceV( (unsigned char *)szToken ) != CMD_STATUS_OK)
				goto ProcessLine_syntax;
			break;

			case TRACEV_PROCESS :
			if (pCTmmon->CmdTraceV( (unsigned char *)szToken ) == CMD_STATUS_COMPLETE)
			{
				pCTmmon->wState = CMD_WAIT;
			}
			else
				goto ProcessLine_syntax;
			break;

			case	TRACEP_CMD :
			if (pCTmmon->CmdTraceP( (unsigned char *)szToken ) != CMD_STATUS_OK)
			{
				// Write in trace edit box
				traceIndex=0;
				if(pCTmmon->m_traceBuffer && pCTmmon->m_PrintableLength > 0)
				{
					DisplayTrace(pCTmmon->m_traceBuffer, pCTmmon->m_PrintableLength);
					pCTmmon->m_traceBuffer[traceIndex]=0;
					pTraceView->SetWindowText(pCTmmon->m_traceBuffer);
					if(traceIndex != 0 && pTraceView->GetWindowTextLength() == 0)
					{
						pCTmmon->m_traceBuffer[20000]=0;
						pTraceView->SetWindowText(pCTmmon->m_traceBuffer);
					}

					delete (pCTmmon->m_traceBuffer);
					pCTmmon->m_traceBuffer = NULL;
				}
			goto ProcessLine_syntax;
			}
			break;


			case	TRACEP_FILENAME :
			{
				CMD_STATUS_CODE	cmd_code =
					pCTmmon->CmdTraceP( (unsigned char *)szToken );
				if (cmd_code  == CMD_STATUS_OK)
				{
					break;
				}
				else if (cmd_code  == CMD_STATUS_COMPLETE)
				{
					if (pCTmmon->fTraceIntoFile == False)
					{
						// Write in trace edit box
						traceIndex=0;
						DisplayTrace(pCTmmon->m_traceBuffer, pCTmmon->m_PrintableLength);
						pCTmmon->m_traceBuffer[traceIndex]=0;
						pTraceView->SetWindowText(pCTmmon->m_traceBuffer);
						if(traceIndex != 0 && pTraceView->GetWindowTextLength() == 0)
						{
							pCTmmon->m_traceBuffer[20000]=0;
							pTraceView->SetWindowText(pCTmmon->m_traceBuffer);
						}

						delete (pCTmmon->m_traceBuffer);
						pCTmmon->m_traceBuffer = NULL;
					}
					pCTmmon->wState = CMD_WAIT;
				}
				else
				{
					goto ProcessLine_syntax;
				}
			break;
			}

			//
			//	load executeable file command 
			//
			case LD_CMD :
			if (pCTmmon->CmdEXELoad( (unsigned char *)szToken ) != CMD_STATUS_OK)
				goto ProcessLine_syntax;
			break;

			case LD_FILENAME :
			if (pCTmmon->CmdEXELoad( (unsigned char *)szToken ) != CMD_STATUS_OK)
				goto ProcessLine_syntax;
			pCTmmon->CmdLDParam.dwIdxArgStr =  0;
			pCTmmon->CmdLDParam.dwCountArg = 0;

			// name of the executeable is argv[0]
			strcpy ( 
				&pCTmmon->CmdLDParam.ArgumentBuffer[pCTmmon->CmdLDParam.dwIdxArgStr],
				szToken );
			pCTmmon->CmdLDParam.ArgumentPtr[pCTmmon->CmdLDParam.dwCountArg] = 
					&pCTmmon->CmdLDParam.ArgumentBuffer[pCTmmon->CmdLDParam.dwIdxArgStr];
			pCTmmon->CmdLDParam.dwIdxArgStr += ( strlen ( szToken ) + 1) ;
			pCTmmon->CmdLDParam.dwCountArg++;
			break;

			case LD_PROCESS:
			if ( pCTmmon->CmdEXELoad( (unsigned char *)szToken ) == CMD_STATUS_COMPLETE )
			{
				pCTmmon->ProgramState = PROG_STATE_LOADED;
			}
			//  we have to set *dwArgv to point to our argument vector.
			pCTmmon->wState = CMD_WAIT;
			break;

			//
			//	run executeable file command 
			//
			case GO_CMD :
			if (pCTmmon->CmdEXERun( (unsigned char *)szToken ) != CMD_STATUS_OK)
				goto ProcessLine_syntax;
			break;

			case GO_ARGS:
			if (pCTmmon->CmdEXERun( (unsigned char *)szToken ) == CMD_STATUS_COMPLETE)
				goto ProcessLine_syntax;
//			pCTmmon->wState = CMD_WAIT;
			break;


			//
			//	stop executeable file command 
			//
			case ST_CMD :
			if (pCTmmon->CmdEXEStop( (unsigned char *)szToken ) != CMD_STATUS_OK)
				goto ProcessLine_syntax;
			break;

			case ST_PROCESS:
			if (pCTmmon->CmdEXEStop( (unsigned char *)szToken ) != CMD_STATUS_COMPLETE)
				goto ProcessLine_syntax;
			pCTmmon->wState = CMD_WAIT;
			break;

			case DSP_CMD :
				if (pCTmmon->CmdDSP( (unsigned char *)szToken ) != CMD_STATUS_OK)
					goto ProcessLine_syntax;
				break;

			case DSP_NUMBER :
				if (pCTmmon->CmdDSP( (unsigned char *)szToken ) != CMD_STATUS_OK)
					goto ProcessLine_syntax;
				break;

			case DSP_PROCESS :
				if (pCTmmon->CmdDSP( (unsigned char *)szToken ) != CMD_STATUS_COMPLETE)
					goto ProcessLine_syntax;
				pCTmmon->wState = CMD_WAIT;
				break;
		
		}
	}
	return TRUE;


ProcessLine_syntax :
	pCTmmon->wState = CMD_WAIT;
	return FALSE;	
}

BOOL ctc_main (CTmgmonDlg* pTmgmonDlg,char* verstr)
{
	// required for processing arguments
	DWORD	dwWaitTimeOut = 0;
	DWORD	dwWindowLines = 0;
	WORD wCount = 0 ;

	tmmanVersion		Version;

	sprintf ( verstr, 
		"TriMedia Monitor - (c)Philips Semiconductors Version [%d.%d.%d]\n[%s %s]",
		verGetFileMajorVersion (),
		verGetFileMinorVersion (),
		verGetFileBuildVersion (),__DATE__, __TIME__);


	//initize the parser data structre
	cTmmon.wState = CMD_WAIT;
	cTmmon.fTraceIntoFile = FALSE;

	cTmmon.ProgramState = PROG_STATE_NOTINIT;

	if ( dwWaitTimeOut == 0 )
		dwWaitTimeOut = 100;

	Version.Major = verGetFileMajorVersion();
	Version.Minor = verGetFileMinorVersion();

	if ( ( tmmanNegotiateVersion (  
		constTMManDefault,
		&Version ) ) != statusSuccess )
	{
		AfxMessageBox("ERROR : Obsolete version of TMGMon.exe : Terminating ... " );
		return FALSE;
	}

	if ( ( Version.Major  < verGetFileMajorVersion() ) ||
		( Version.Minor  < verGetFileMinorVersion()) )
	{
		AfxMessageBox("ERROR : Obsolete version of TMMan32.dll : Terminating ... " );
		return FALSE;
	}

	if(!cTmmon.Initial())
		return FALSE;

	cTmmon.ShowProcessorInfo(pTmgmonDlg);

	return TRUE;
}


char *ctcGetDownloaderErrorString ( DWORD Code )
{
   return TMDwnLdr_get_last_error(Code);
}

void ctc_exit(void)
{
	CTmmon *pcTmmon = &cTmmon;
	UInt32	DSPStatus;

	tmmanDSPGetStatus ( pcTmmon->m_CurrentDSPHandle, &DSPStatus );

	if ( DSPStatus == constTMManDSPStatusRunning )
		tmmanDSPStop( pcTmmon->m_CurrentDSPHandle );

	pcTmmon->Exit();
}

void ctc_loadfile(char *filename,char *arguments)
{
    CWaitCursor wait;	// display wait cursor

	CTmmon *pcTmmon = &cTmmon;
	strcpy(pcTmmon->szInputString,"LOAD ");
	strcat(pcTmmon->szInputString,filename);
	strcat(pcTmmon->szInputString," .");
	ProcessLine(pcTmmon);
}

void ctc_stop(void)
{
	CTmmon *pcTmmon = &cTmmon;
	strcpy(pcTmmon->szInputString,"STOP ");
	strcat(pcTmmon->szInputString," .");
	ProcessLine(pcTmmon);
}

void ctc_go(char *filename,char *arguments)
{
	CTmmon *pcTmmon = &cTmmon;

	// load file
	strcpy(pcTmmon->szInputString,"LOAD ");
	strcat(pcTmmon->szInputString,filename);
	strcat(pcTmmon->szInputString," .");
	if( ProcessLine(pcTmmon) )
	{
		// run
		strcpy(pcTmmon->szInputString,"RUN ");
		strcat(pcTmmon->szInputString,arguments);
		strcat(pcTmmon->szInputString," .");
		ProcessLine(pcTmmon);
	}
}

ctc_mem(HWND hwnd,DWORD PhyAddress,int dumptype,BOOL start)
{
	DWORD LinearAdr,Size;
	static int memtype=0;

	UINT wDataSize;
	if(dumptype == 0)
		wDataSize = 1;
	else if(dumptype == 1)
		wDataSize = 2;
	else if(dumptype == 2)
		wDataSize = 4;
	else
		return FALSE;

	if(start)
	{
		if (cTmmon.halValidateAddress ( wDataSize,
											PhyAddress,
											&LinearAdr,
											&Size,
											&memtype)
						== CMD_STATUS_INADEQUATE)

		if(memtype == 0)
			return FALSE;
	}
	if(memtype == 2)		// MMIO
	{
		dumptype=2;
		PhyAddress &= 0xffffffffc;
	}
	ViewMem(hwnd,PhyAddress,(PVOID)LinearAdr,Size,dumptype,memtype,start);
	return TRUE;
}

void ctc_debug(char *str)
{
	CTmmon *pcTmmon = &cTmmon;
	strcpy(pcTmmon->szInputString,str);
	ProcessLine(pcTmmon);
}

void ctc_redirect(char *str)
{
	CTmmon *pcTmmon = &cTmmon;
	strcpy(pcTmmon->szInputString,str);
	ProcessLine(pcTmmon);
}

void ctc_trace(CEdit * pEdit,char *str)
{
    CWaitCursor wait;	// display wait cursor

	CTmmon *pcTmmon = &cTmmon;

	traceEdit=TRUE;
	strcpy(pcTmmon->szInputString,str);
	pTraceView=pEdit;
	pTraceView->SetWindowText("");

	ProcessLine(pcTmmon);

	traceEdit=FALSE;
}

DisplayTrace(PVOID pBuffer, DWORD dwLength)
{
	CTmmon *pcTmmon = &cTmmon;
	DWORD i;
	PBYTE pByte;

	traceBuffer=new char[dwLength + 10];

	if (traceBuffer == NULL)
		return 0;

	memcpy(traceBuffer, pBuffer, dwLength);

	pByte = (PBYTE)traceBuffer;

	for(i=0;i<dwLength;i++)
	{
		if(traceIndex >= 64000)
			break;
		if(*pByte == '\n')
		{
			if(traceIndex > 0)
				if(pcTmmon->m_traceBuffer[traceIndex-1] != '\r')
					pcTmmon->m_traceBuffer[traceIndex++]='\r';
		}
		pcTmmon->m_traceBuffer[traceIndex++]=*pByte;
		pByte++;
	}

	delete traceBuffer;

	return 1;
}

void ctc_newcard(void)
{
	CTmmon* pcTmmon = &cTmmon;
}

BOOL ctc_change_dsp(CTmgmonDlg* pTmgmonDlg, DWORD dwDSPNumber)
{
	CHAR	szTemp[80];
	CTmmon *pcTmmon = &cTmmon;

	strcpy(pcTmmon->szInputString,"DSP ");
	sprintf(szTemp,"%x",dwDSPNumber);		// To be changed to variable
	strcat(pcTmmon->szInputString,szTemp);
	strcat(pcTmmon->szInputString," .");
	return ProcessLine(pcTmmon);
}