tmcrt.c

wince host 和 target PCI驱动程序

#endif
   if ( Command == _O_BINARY)
	{
		return _setmode( Handle, Command );
	}
	else
	{
		return ((DWORD)~0);
	}
}

DWORD	IsattyFunc ( DWORD Handle )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

#ifdef USE_TRACE
   ODS("[IsattyFunc|Handle:%x]", Handle );
#endif
	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];
		
		if ( ( EncodedHandle->StdType == kLevel2StdinHandle ) || 
			( EncodedHandle->StdType == kLevel2StdoutHandle ) ||
			( EncodedHandle->StdType == kLevel2StderrHandle ) )
		{
			return 1;
		}
	}

	return _isatty ( Handle );
}

DWORD	LseekFunc (  DWORD Handle, DWORD Offset, DWORD Origin )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

#ifdef USE_TRACE
   ODS("[LseekFunc|Handle:%x|Offset:%x|Origin:%x]", Handle, Offset, Origin );
#endif

	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];
		
		if ( ( EncodedHandle->StdType == kLevel2StdinHandle ) || 
			( EncodedHandle->StdType == kLevel2StdoutHandle ) ||
			( EncodedHandle->StdType == kLevel2StderrHandle ) )
		{
			return (0xffffffff);
		}
	}

	return _lseek ( Handle, Offset, Origin );
}

DWORD	OpenFunc (  PCHAR PathName, DWORD Flags, DWORD Mode )
{
#ifdef USE_TRACE
   ODS("[OpenFunc|PathName:%s|Flags:%x|Mode:%x]", PathName, Flags, Mode );
#endif

	return _open ( PathName, Flags,Mode );
}

DWORD	CloseFunc (  DWORD Handle  )
{
#ifdef USE_TRACE
   ODS("[CloseFunc|Handle:%x]", Handle );
#endif

	return _close ( Handle );
}

Bool	cruntimeInit ( void )
{
	UInt32 Idx;

	for ( Idx = 0 ; Idx < MAXIMUM_DSPS ; Idx++ )
	{
		GlobalContext[Idx] = NULL;
	}

	if ( TM1IF_init(
		(RPCServ_OpenFunc) OpenFunc,
		(RPCServ_OpenDllFunc) OpenDLLFunc,
		(RPCServ_CloseFunc) CloseFunc,
		(RPCServ_ReadFunc) ReadFunc,
		(RPCServ_WriteFunc) WriteFunc,
		(RPCServ_SeekFunc) LseekFunc,
		(RPCServ_IsattyFunc) IsattyFunc,
		(RPCServ_FstatFunc) FstatFunc,
		(RPCServ_FcntlFunc) FcntlFunc,
		(RPCServ_StatFunc) StatFunc,
		(RPCServ_ExitFunc) ExitCodeFunc,
		LittleEndian /* no big endian support yet */) != True )
	{
		return False;
	}


	if ( TM1IF_start_serving() == TM1IF_Serving_Failed )
	{
		TM1IF_term( );
		return False;
	}

}

void cruntimeExit ( void )
{
	TM1IF_term( );	
}

UInt32	cruntimeCreate( 
	UInt32	DSPNumber,
	UInt32	ArgumentCount,
	UInt8*	ArgumentVector[],
	CRunTimeParameterBlock* Parameters,
	UInt32* CRTHandlePointer )
{
	DWORD	Written;
	UInt32	PathIdx;
	PTMCRT_CONTEXT pCRT;
	DWORD	ServerStatus;
        TMMAN_DSP_CAPS          Caps;

	CHAR	Key[0x10]; // HARDCODED max 16 bytes for key number

	CHAR	Path[TMSTD_PATH_LENGTH];
	TMCRT_STD_HANDLE	EncodedStdInHandle, EncodedStdOutHandle, EncodedStdErrHandle;

	if ( ( pCRT = malloc ( sizeof ( TMCRT_CONTEXT ) ) ) == NULL )
	{
		goto	cruntimeCreateExit1;
	}

	GlobalContext[Parameters->VirtualNodeNumber] =  pCRT;
	pCRT->OptionBitmap = Parameters->OptionBitmap;
	pCRT->DSPNumber = DSPNumber;
	pCRT->StdInHandle = (HANDLE)Parameters->StdInHandle;
	pCRT->StdOutHandle = (HANDLE)Parameters->StdOutHandle;
	pCRT->StdErrHandle = (HANDLE)Parameters->StdErrHandle;
	pCRT->VirtualNodeNumber = Parameters->VirtualNodeNumber;
	pCRT->ArgumentCount = ArgumentCount;
	pCRT->ArgumentVector = ArgumentVector;
	pCRT->SynchObject = (HANDLE)Parameters->SynchronizationObject;

	pCRT->fServerLoaded = FALSE;
	pCRT->fTargetExited = FALSE;	
	pCRT->ExitCode = ~0;

	if ( tmDSPOpen ( pCRT->DSPNumber , &pCRT->DSPHandle ) != TMOK )
	{
		goto cruntimeCreateExit2;
	}

	if (  pCRT->OptionBitmap & constCRunTimeFlagsAllocConsole )
	{
		AllocConsole();
		
		SetConsoleTitle("TriMedia Console");

		// check for the windows size only we are allocating a new console.
		if (  pCRT->OptionBitmap & constCRunTimeFlagsUseWindowSize )
		{
			COORD	Coord;
			Coord.Y = (WORD)Parameters->WindowSize;
			Coord.X = 80;
			SetConsoleScreenBufferSize ( GetStdHandle(STD_OUTPUT_HANDLE), Coord );

		}

		pCRT->StdInHandle = GetStdHandle(STD_INPUT_HANDLE);
		pCRT->StdOutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
		pCRT->StdErrHandle = GetStdHandle(STD_ERROR_HANDLE);

	}


	
	if ( ( pCRT->ExitObject = 
		CreateEvent (NULL, TRUE, FALSE, NULL ) ) == NULL )
	{
		goto	cruntimeCreateExit3;
	}


	if ( tmDSPGetCaps ( pCRT->DSPHandle, &Caps ) != TMOK )
	{
		goto cruntimeCreateExit2;
	}

	// make the stdin , stdout and stderr handles.
	// totally screwed up, but can't help it.

	EncodedStdInHandle.Magic  =  
		EncodedStdOutHandle.Magic  = 
		EncodedStdErrHandle.Magic  =  TMCRT_MAGIC_PATTERN;

	EncodedStdInHandle.StdType  = kLevel2StdinHandle;
	EncodedStdOutHandle.StdType  = kLevel2StdoutHandle;
	EncodedStdErrHandle.StdType  =  kLevel2StderrHandle;

	EncodedStdInHandle.DSPNumber  =
		EncodedStdOutHandle.DSPNumber  = 
		EncodedStdErrHandle.DSPNumber  =  pCRT->VirtualNodeNumber;

	if (!TM1IF_add_node_info(
		pCRT->VirtualNodeNumber, 
		pCRT->ArgumentCount, 
		pCRT->ArgumentVector, 
		*(PDWORD)&EncodedStdInHandle, 
		*(PDWORD)&EncodedStdOutHandle, 
		*(PDWORD)&EncodedStdErrHandle, 
		Caps.SDRAM.dwLinear - Caps.SDRAM.dwPhysical, 
		Caps.SDRAM.dwPhysical, 
		Caps.SDRAM.dwPhysical + Caps.SDRAM.dwSize, 
		(void*)pCRT->DSPNumber )) 
	{
		goto	cruntimeCreateExit4;
	}


	pCRT->fServerLoaded = TRUE;

	for ( PathIdx = 0; PathIdx < MAX_PATH_INDEX ; PathIdx++ )
	{
		sprintf ( Key, "%u", PathIdx );

		GetPrivateProfileString (
			"DLLPath", Key, "DEFAULT", Path, TMSTD_PATH_LENGTH, "tmman.ini" );

		if( _stricmp ( Path, "DEFAULT" ) == 0 )
			break;

		OpenDll_add_dll_path ( Path );
	}

	*CRTHandlePointer = (UInt32)pCRT;

	return True;
/*
cruntimeCreateExit5:


*/
cruntimeCreateExit4:
	CloseHandle ( pCRT->ExitObject  );

cruntimeCreateExit3:
	if (  pCRT->OptionBitmap & constCRunTimeFlagsAllocConsole )
	{
		FreeConsole();
	}
	tmDSPClose ( pCRT->DSPHandle );

cruntimeCreateExit2:
	free ( pCRT );

cruntimeCreateExit1:
	return False;
}

UInt32	cruntimeDestroy ( 
	UInt32	CRTHandle )
{
	PTMCRT_CONTEXT pCRT	= (PTMCRT_CONTEXT)CRTHandle;
   UInt32   ExitCode;

	/*	
		RPCServ should have created thread by now so we block here on our global event 
		to be signalled 
	*/
	fExitProcess = TRUE;

	SetEvent ( pCRT->ExitObject );

	CloseHandle ( pCRT->ExitObject  );



	ExitCode = pCRT->ExitCode;

	if (  pCRT->OptionBitmap & constCRunTimeFlagsAllocConsole )
	{
		FreeConsole();
	}

	TM1IF_remove_node_info( pCRT->VirtualNodeNumber );

	tmDSPClose ( pCRT->DSPHandle );

	GlobalContext[pCRT->VirtualNodeNumber] = NULL;

	free ( pCRT );

   return ExitCode;

}

/*
	StripCR

	Unix is a brain dead OS, it cannot undestrand input string terminated with CRLF.
	And of course trimedia will blindly follow what Unix does.
	So we have to strip all CR in the input that is being read from 
	StdIn. This function does that and accordingly reduces the lenth of the 
	string that is read in.
*/
VOID	StripCR ( PCHAR pBuffer, DWORD *BytesRead )
{
	DWORD Idx, InnerIdx;
	DWORD OrigLength = *BytesRead;

	for ( Idx = 0; Idx < *BytesRead ; Idx++ )
	{
		if  ( ( pBuffer[Idx] == '\r' ) && ( pBuffer[Idx + 1]  == '\n' ) )
		{
			(*BytesRead)--;
			for ( InnerIdx =  Idx ;  InnerIdx < *BytesRead ; InnerIdx++ )
			{
				pBuffer[InnerIdx] = pBuffer[InnerIdx+1];
			}
		}
	}
}


UInt32	crtPrintf ( HANDLE FileHandle, UInt8* Format, ...)
{
	DWORD	BytesWritten;
	UInt8	Buffer[1024];
	DWORD	ItemsWritten;
	va_list	ArgumentList;


	va_start ( ArgumentList, Format ); 
	ItemsWritten = vsprintf ( Buffer, Format, ArgumentList );
	va_end ( ArgumentList );

	WriteFile ( FileHandle, Buffer, strlen ( Buffer ), &BytesWritten, NULL );
	return ItemsWritten;
}

UInt32 ODS( 
	UInt8* FormatString, 
	... )
{
	UInt32	Items;
	UInt8	Buffer[1024];
	
	va_list	Arguments;

	va_start ( Arguments, FormatString );

	Items = vsprintf ( Buffer,  FormatString, Arguments );

	va_end ( Arguments );

	OutputDebugString ( Buffer ); 

	return Items;
}