tmmon.cpp

wince host 和 target PCI驱动程序

	PCMD_LOADRUN    pObject     =  (PCMD_LOADRUN)&CmdLoadRunContext;    

	strcpy ( (char *)(pObject->szExecutableFile), filename );
	// BEGIN APPLOAD



	// BEGIN APPLOAD
	if ( tmmanGetImageInfo (
		pObject->szExecutableFile,
		&ImageType,
		&ImageEndian ) != True )
	{
		sprintf ( (char *)szErrorString,
			"TMMon: ERROR  : Loading Executable [%s]: FAIL (File Not Found)", 
			pObject->szExecutableFile );
		MessageBox(AfxGetMainWnd()->m_hWnd,  (char *)szErrorString, "EXELoad", MB_OK );
		bReturn = FALSE;
		wState = CMD_WAIT;
		return bReturn;
	}

	if ( ImageType == TMObj_AppSegment ) 
	{

//		UInt32  IdxArg, Idx;
		Int8    TCSPath[constTMManPathLength];

		strcpy ( 
			(char*)pObject->szApplicationFile, 
			(char*)pObject->szExecutableFile );

		pObject->fDynamicApplicaiton = True;

		if ( tmmanGetTCSPath ( 
			TCSPath,
			constTMManPathLength ) != True )
		{
			sprintf ( (char*)pObject->szExecutableFile, "%s", "appshell.out" ); 
		}
		else
		{
			// TCS\lib\el\appshell.out
			sprintf ( (char*)pObject->szExecutableFile, "%s\\lib\\%s\\WinNT\\appshell.out",
				TCSPath, 
				( ImageEndian == LittleEndian ) ? "el" : "eb"  ); 
		}
	} 
	else
	{
		pObject->fDynamicApplicaiton = False;
	}

	// END APPLOAD

	if ( ( TMMANStatus = tmmanDSPLoad ( 
		m_CurrentDSPHandle,
		constTMManDefault, 
		pObject->szExecutableFile ) ) != statusSuccess )
	{
		sprintf ( (char *)szErrorString,
			"TMMon: ERROR  : Loading Executable [%s] : FAIL [%x](%s)", 
			pObject->szExecutableFile, 
			TMMANStatus, 
			tmmanGetErrorString(TMMANStatus) );
		MessageBox(AfxGetMainWnd()->m_hWnd,  (char *)szErrorString, "EXELoad", MB_OK );
		bReturn = FALSE;
	}

	wState = CMD_WAIT;

	return bReturn;
}

BOOL CTmmon::ExeRun(char *filename,char *arguments)
{
	CWaitCursor wait;   // display wait cursor
	BOOL bReturn = TRUE;
    HANDLE				StartEventHandle = NULL;

	if (!ExeLoad(filename,arguments))
		return FALSE;

	PCMD_LOADRUN    pObject     =  (PCMD_LOADRUN)&CmdLoadRunContext;    
//  char *pChar;

	wState = GO_ARGS;


/*
	// set file name
	pObject->dwIdxArgStr = 0;
	pChar = (char *)(&pObject->ArgumentBuffer[pObject->dwIdxArgStr]);
	strcpy ( 
		pChar,
		(char *)pObject->szExecutableFile );
	pObject->ArgumentPtr[pObject->dwCountArg] = 
			&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
	pObject->dwIdxArgStr = ( strlen ( (char *)(char *)pObject->szExecutableFile ) + 1) ;
	pObject->dwCountArg = 1; // executable file name only 
*/


	//
	pObject->dwIdxArgStr = 0;
	pObject->dwCountArg = 0;

	strcpy ( 
		(char *)&pObject->ArgumentBuffer[pObject->dwIdxArgStr],
		(char *)pObject->szExecutableFile );
	pObject->ArgumentPtr[pObject->dwCountArg] = 
			&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
	pObject->dwIdxArgStr += ( strlen ( (char *)pObject->szExecutableFile  ) + 1) ;
	pObject->dwCountArg += 1; // executable file name only 

	if ( pObject->fDynamicApplicaiton )
	{
		strcpy ( 
			(char *)&pObject->ArgumentBuffer[pObject->dwIdxArgStr],
			(char *)pObject->szApplicationFile );
		pObject->ArgumentPtr[pObject->dwCountArg] = 
				&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
		pObject->dwIdxArgStr += ( strlen ( (char *)pObject->szApplicationFile  ) + 1) ;
		pObject->dwCountArg += 1; // executable file name only 
	}

	//


	// set arguments
	// input buffer overflow is already checked by ReadInputLine
	unsigned char *p1, *p2;
	char *p3;
	p1 = p2 = &(pObject->ArgumentBuffer[pObject->dwIdxArgStr]);
	p3 = arguments;

	BOOL bProcess = TRUE;
	BOOL bGetArg = FALSE;

	char ch;

	while (bProcess)
	{
		ch = *p3;

		if( isspace(ch)  || ch == '\0' ) //|| ch == '.')
		{
			if( ch == '\0')
				bProcess = FALSE;
			if(bGetArg)
			{
				bGetArg = FALSE;
				if ( pObject->dwCountArg >= constTMManMaximumArgumentCount )
				{
					MessageBox(AfxGetMainWnd()->m_hWnd,  
						"TMMon: WARNING  : To Many Arguments : Ignoring Arguments",
						"ExeRun", MB_OK);
					return TRUE;
				}
				// get the argument
				pObject->ArgumentPtr[pObject->dwCountArg] = p1;
				pObject->dwCountArg++;
				*p2 = '\0';
				p2++;
				pObject->dwIdxArgStr += ( strlen ( (const char *)p1 ) + 1) ;
				p1 = p2;
			}

//          if( ch == '.')
//              bProcess = FALSE;
		}
		else if(isprint(ch))
		{
			if(!bGetArg)
			{
				bGetArg = TRUE;
				// get the argument
			}
			*p2 = ch;
			p2++;
		}

		// next char
		p3++;
	}

	UInt8   szErrorString[constTMManStringLength];
	// check for termination of argument list
	UInt32  TMMANStatus;
	UInt32  DSPStatus;

	TMMANStatus = tmmanDSPGetStatus ( m_CurrentDSPHandle, &DSPStatus );

	switch ( DSPStatus )
	{
		case constTMManDSPStatusReset :
        
			STARTUPINFO         StartupInformation;
			PROCESS_INFORMATION ProcessInformation;
			CHAR                szCommandString[1024];
//			CHAR                szTempString[80];
			UInt32              Idx;
			
			TCHAR				StartEventName[MAX_PATH];

			// spawn off tmrun here with the proper command line atguments.
			StartupInformation.cb               = sizeof (STARTUPINFO);
			StartupInformation.lpReserved       = 0;
			StartupInformation.lpDesktop        = NULL;
			StartupInformation.lpTitle          = NULL;
			StartupInformation.dwX              = 0;
			StartupInformation.dwY              = 0;
			StartupInformation.dwXSize          = 0;
			StartupInformation.dwYSize          = 0;
			StartupInformation.dwXCountChars    = 0;
			StartupInformation.dwYCountChars    = 0;
			StartupInformation.dwFillAttribute  = 0;
			StartupInformation.dwFlags          = 0; //STARTF_USESTDHANDLES;
			StartupInformation.wShowWindow      = 0;
			StartupInformation.cbReserved2      = 0;
			StartupInformation.lpReserved2      = 0;
			//StartupInformation.dwFlags          = STARTF_USESHOWWINDOW;//0; //STARTF_USESTDHANDLES;
			//StartupInformation.wShowWindow      = SW_SHOWMINIMIZED; //0;
			
			wsprintf ( szCommandString, 
				"tmrun -s -d%x ", 
				m_CurrentDSPNumber );

			/*
            if(m_TMRunWindowSize >= 25)
            {
			    sprintf ( szTempString, "-w%d ",  m_TMRunWindowSize );
    			strcat ( szCommandString, szTempString );
            }
			*/

			for ( Idx = 0 ; Idx < pObject->dwCountArg ; Idx ++ )
			{
				strcat ( szCommandString, " " );
				strcat ( szCommandString, (const char *)pObject->ArgumentPtr[Idx]);
			}

			OutputDebugString ( szCommandString );

						wsprintf ( 
							StartEventName, 
							TEXT("TMCRTStartEvent%d"), 
							m_CurrentDSPNumber );

						if ( NULL == ( StartEventHandle = CreateEvent ( 
							NULL,	//security attributes
							FALSE,	//manual reset
							FALSE,	//initial state
							StartEventName ) ) )
						{
							sprintf ( (char *)szErrorString,
								"TMMon: ERROR  : Creating C Run Time Synchronization Event : FAIL" );
            				MessageBox( AfxGetMainWnd()->m_hWnd,
					            (char *)szErrorString, "ExeRun", MB_OK );

						}

			if ( CreateProcess (NULL, //"tmrun.exe",
				szCommandString, // command line formed 
				NULL,
				NULL,
				TRUE,
				CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS,
				NULL,NULL,
				&StartupInformation,
				&ProcessInformation ) != TRUE )
			{
				sprintf ( (char *)szErrorString,
					"TMMon: ERROR  : Spawning C Run Time Server : FAIL" );
				MessageBox( AfxGetMainWnd()->m_hWnd,
					(char *)szErrorString, "ExeRun", MB_OK );
				bReturn = FALSE;
			}
			else            // Spawn successful
			{
				if ( StartEventHandle )
				{
					switch ( WaitForSingleObject (StartEventHandle, 10000 ) )
					{
						case WAIT_OBJECT_0 :
						// everything OK
						break;

						case WAIT_ABANDONED :
						case WAIT_TIMEOUT :
						sprintf ( (char *)szErrorString,
                                                        "TMMon: ERROR  : C Run Time Startup Synchronization : TIMEOUT" );
        				MessageBox( AfxGetMainWnd()->m_hWnd,
		        			(char *)szErrorString, "ExeRun", MB_OK );
        				bReturn = FALSE;
						break;
					}
					//Sleep( 3000 );	
				}
			}

			if ( StartEventHandle )
			{
				CloseHandle ( StartEventHandle );
			}

		tmmanDSPStart ( m_CurrentDSPHandle );
		break;

		case constTMManDSPStatusRunning :
		MessageBox(AfxGetMainWnd()->m_hWnd,  
			"TMMon: ERROR  : Program Already Running On TriMedia",
			"ExeRun", MB_OK);
		bReturn = FALSE;
		break;

		default :
		MessageBox(AfxGetMainWnd()->m_hWnd,  
			"TMMon: ERROR  : TriMedia in Unknown State",
			"ExeRun", MB_OK);
		bReturn = FALSE;
		break;
	}

	wState = CMD_WAIT;

	return bReturn;
}

BOOL CTmmon::ExeStop()
{
	BOOL bReturn = TRUE;

	UInt32  DSPStatus;

	wState = ST_PROCESS;

	tmmanDSPGetStatus ( m_CurrentDSPHandle, &DSPStatus );

	switch ( DSPStatus )
	{
		case constTMManDSPStatusReset :
		 MessageBox(AfxGetMainWnd()->m_hWnd,    
			"TMMon: WARNING  : No Program Running On TriMedia",
			"ExeStop", MB_OK);
		 bReturn = FALSE;
		 break;

		// fall through
		case constTMManDSPStatusRunning :
		tmmanDSPStop( m_CurrentDSPHandle );

		// stop the CRunTime Server if it is running
			// signal  the event that whacks tmrun
			HANDLE  hServerEvent;
			CHAR    szEventName[80];
			wsprintf( szEventName, "TMRunExitEvent%x", m_CurrentDSPNumber );

			if ( ( hServerEvent = OpenEvent ( EVENT_MODIFY_STATE, TRUE,
				szEventName ) ) != NULL )
			{
				SetEvent ( hServerEvent );
				CloseHandle (  hServerEvent );
			}

		break;
	}

	wState = CMD_WAIT;

	return bReturn;
}

BOOL CTmmon::ExeTraceP( char *filename )
{

	PCMD_TRACEP pObject = (PCMD_TRACEP) &CmdTracePContext;
	CMD_STATUS_CODE Status = CMD_STATUS_OK;
	UInt8*  pFirstHalfBuffer;
	UInt8*  pSecondHalfBuffer;
	UInt32  FirstHalfBufferSize;
	UInt32  SecondHalfBufferSize;


	wState = TRACEP_CMD;

	pObject->fTraceIntoFile = False;

	tmmanDebugDPBuffers ( 
		m_CurrentDSPHandle,
		&pFirstHalfBuffer, 
		&FirstHalfBufferSize, 
		&pSecondHalfBuffer, 
		&SecondHalfBufferSize );
				
	if(filename)        // copy to a file
	{
		pObject->fTraceIntoFile = True;
		strcpy ( (char *)(pObject->szTraceFileName), (char *)filename );

		HANDLE hFile;
		
		SYSTEMTIME  Time;
		UInt32  SizeOfMachineName;
		UInt8   szMachineName[MAX_COMPUTERNAME_LENGTH + 1];
		UInt8   szString[80];
		UInt32  BytesWritten;
		
		SizeOfMachineName = MAX_COMPUTERNAME_LENGTH + 1;
		pObject->fTraceIntoFile = False;
		fTraceIntoFile = TRUE;

		if ( ( hFile  = CreateFile ( (const char *)(pObject->szTraceFileName) , 
			GENERIC_READ | GENERIC_WRITE, 0,
			Null,
			CREATE_ALWAYS,
			FILE_ATTRIBUTE_NORMAL,
			Null ) ) == (HANDLE)-1 )
		{
			sprintf ( (char *)szString,
				"TMMon : ERROR [%x] : Creating Trace File [%s]",
				GetLastError(), pObject->szTraceFileName  );

			MessageBox( AfxGetMainWnd()->m_hWnd,   
				(const char *)szString, "Dump DP", MB_OK);
			return FALSE;
		}

		GetComputerName ( (char *)szMachineName, &SizeOfMachineName );
		GetLocalTime(&Time);
		sprintf ( (char *)szString,
			"TMMon:TraceFile:Machine[%s]:D[%02d.%02d.%04d]:T[%02d:%02d:%02d]\n",
			szMachineName, Time.wMonth,  Time.wDay, Time.wYear,
			Time.wHour, Time.wMinute, Time.wSecond );

		if ( WriteFile (  hFile,
			szString, strlen( (const char *)szString ),
			&BytesWritten, Null ) != True )
		{
			MessageBox(AfxGetMainWnd()->m_hWnd,
				"TMMon : ERROR : Writing Trace File Header",
				"TraceP", MB_OK);