corelib.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, TLS_GETTHREADVALUE, &pfn, &cs ) )
	{
		retv = pfn( dwThreadId, dwTlsIndex );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PTLS_SETTHREADVALUE )( DWORD dwThreadId, DWORD dwTlsIndex, LPVOID lpvData );
BOOL WINAPI Tls_SetThreadValue( DWORD dwThreadId, DWORD dwTlsIndex, LPVOID lpvData )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_SETTHREADVALUE, 3 );
    cs.arg0 = (DWORD)dwThreadId;
    return (BOOL)CALL_SERVER( &cs, dwTlsIndex, lpvData );
#else

	PTLS_SETTHREADVALUE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, TLS_SETTHREADVALUE, &pfn, &cs ) )
	{
		retv = pfn( dwThreadId, dwTlsIndex, lpvData );
		API_Leave(  );
	}
	return retv;
#endif
}


// misc
//    SYS_WAITFORSINGLEOBJECT,
typedef DWORD ( WINAPI * PSYS_WAITFORSINGLEOBJECT )( HANDLE handle, DWORD dwMilliseconds );
DWORD WINAPI Sys_WaitForSingleObject( HANDLE handle, DWORD dwMilliseconds )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_WAITFORSINGLEOBJECT, 2 );
    cs.arg0 = (DWORD)handle;
    return (DWORD)CALL_SERVER( &cs, dwMilliseconds );
#else

	PSYS_WAITFORSINGLEOBJECT pfn;

	CALLSTACK cs;
	DWORD   retv = WAIT_FAILED;

	if( API_Enter( API_KERNEL, SYS_WAITFORSINGLEOBJECT, &pfn, &cs ) )
	{
		retv = pfn( handle, dwMilliseconds );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef DWORD ( WINAPI * PSYS_WAITFORMULTIPLEOBJECTS )( DWORD nCount, CONST HANDLE *lpHandles, BOOL fWaitAll, DWORD dwMilliseconds );
DWORD WINAPI Sys_WaitForMultipleObjects( DWORD nCount, CONST HANDLE *lpHandles, BOOL fWaitAll, DWORD dwMilliseconds )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_WAITFORMULTIPLEOBJECTS, 4 );
    cs.arg0 = (DWORD)nCount;
    return (DWORD)CALL_SERVER( &cs, lpHandles, fWaitAll, dwMilliseconds );
#else

	PSYS_WAITFORMULTIPLEOBJECTS pfn;

	CALLSTACK cs;
	DWORD   retv = WAIT_FAILED;

	if( API_Enter( API_KERNEL, SYS_WAITFORMULTIPLEOBJECTS, &pfn, &cs ) )
	{
		retv = pfn( nCount, lpHandles, fWaitAll, dwMilliseconds );
		API_Leave(  );
	}
	return retv;
#endif
}


//	SYS_ALLOCAPIHANDLE,
typedef HANDLE ( WINAPI * PSYS_ALLOCAPIHANDLE )( UINT uiAPIId, LPVOID lpvData, UINT objType );
HANDLE WINAPI Sys_AllocAPIHandle( UINT uiAPIId, LPVOID lpvData, UINT objType )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_ALLOCAPIHANDLE, 3 );
    cs.arg0 = (DWORD)uiAPIId;
    return (HANDLE)CALL_SERVER( &cs, lpvData, objType );
#else

	PSYS_ALLOCAPIHANDLE pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_KERNEL, SYS_ALLOCAPIHANDLE, &pfn, &cs ) )
	{
		retv = pfn( uiAPIId, lpvData, objType );
		API_Leave(  );
	}
	return retv;
#endif
}

//	SYS_CLOSEHANDLE,
typedef BOOL ( WINAPI * PSYS_CLOSEHANDLE )( HANDLE handle );
BOOL WINAPI Sys_CloseHandle( HANDLE handle )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_CLOSEHANDLE, 1 );
    cs.arg0 = (DWORD)handle ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PSYS_CLOSEHANDLE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_CLOSEHANDLE, &pfn, &cs ) )
	{
		retv = pfn( handle );
		API_Leave(  );
	}
	return retv;
#endif
}

//	SYS_SLEEP,
typedef VOID ( WINAPI * PSYS_SLEEP )( DWORD dwMilliseconds );
VOID WINAPI Sys_Sleep( DWORD dwMilliseconds )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_SLEEP, 1 );
    cs.arg0 = (DWORD)dwMilliseconds ;
    CALL_SERVER( &cs );
#else

	PSYS_SLEEP pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_SLEEP, &pfn, &cs ) )
	{
		pfn( dwMilliseconds );
		API_Leave(  );
	}
	//return retv;
#endif
}

//	SYS_GETTICKCOUNT,
typedef DWORD ( WINAPI * PSYS_GETTICKCOUNT )( void );
DWORD WINAPI Sys_GetTickCount( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETTICKCOUNT, 0 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PSYS_GETTICKCOUNT pfn;

	CALLSTACK cs;
	DWORD   retv = 0;

	if( API_Enter( API_KERNEL, SYS_GETTICKCOUNT, &pfn, &cs ) )
	{
		retv = pfn();
		API_Leave(  );
	}
	return retv;
#endif
}

//	TIME_GETSYSTEM
typedef VOID ( WINAPI * PSYS_GETSYSTEMTIME )( LPSYSTEMTIME lpst );
VOID WINAPI Sys_GetSystemTime( LPSYSTEMTIME lpst )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETSYSTEMTIME, 1 );
    cs.arg0 = (DWORD)lpst ;
    CALL_SERVER( &cs );
#else

	PSYS_GETSYSTEMTIME pfn;

	CALLSTACK cs;
	//DWORD   retv = 0;

	if( API_Enter( API_KERNEL, SYS_GETSYSTEMTIME, &pfn, &cs ) )
	{
		pfn(lpst);
		API_Leave(  );
	}
	//return retv;
#endif
}

typedef BOOL ( WINAPI * PSYS_SETSYSTEMTIME )( const SYSTEMTIME *lpst );
BOOL WINAPI Sys_SetSystemTime( const SYSTEMTIME *lpst )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_SETSYSTEMTIME, 1 );
    cs.arg0 = (DWORD)lpst ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PSYS_SETSYSTEMTIME pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_SETSYSTEMTIME, &pfn, &cs ) )
	{
		retv = pfn(lpst);
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PSYS_EXIT )( UINT uFlags, DWORD dwReserved );
BOOL WINAPI Sys_Exit( UINT uFlags, DWORD dwReserved )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_EXIT, 2 );
    cs.arg0 = (DWORD)uFlags;
    return (DWORD)CALL_SERVER( &cs, dwReserved );
#else

	PSYS_EXIT pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_EXIT, &pfn, &cs ) )
	{
		retv = pfn( uFlags, dwReserved );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef VOID ( WINAPI * PSYS_GETINFO )( LPSYSTEM_INFO lpsi );
VOID WINAPI Sys_GetInfo( LPSYSTEM_INFO lpsi )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETINFO, 1 );
    cs.arg0 = (DWORD)lpsi ;
    CALL_SERVER( &cs );
#else
	PSYS_GETINFO pfn;
	CALLSTACK cs;
	//BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_GETINFO, &pfn, &cs ) )
	{
		pfn( lpsi );
		API_Leave(  );
	}
	//return retv;
#endif
}

typedef BOOL ( WINAPI * PSYS_GETVERSION )( LPOSVERSIONINFO lpvi );
BOOL WINAPI Sys_GetVersion( LPOSVERSIONINFO lpvi )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETVERSION, 1 );
    cs.arg0 = (DWORD)lpvi ;
    return (DWORD)CALL_SERVER( &cs );
#else
	PSYS_GETVERSION pfn;
	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_GETVERSION, &pfn, &cs ) )
	{
		retv = pfn( lpvi );
		API_Leave(  );
	}
	return retv;
#endif
}

//    INTERLOCK_INCREMENT,
typedef LONG ( WINAPI * PINTERLOCK_INCREMENT )( LPLONG lpDest );
LONG WINAPI Interlock_Increment( LPLONG lpDest )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTERLOCK_INCREMENT, 1 );
    cs.arg0 = (DWORD)lpDest ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PINTERLOCK_INCREMENT pfn;

	CALLSTACK cs;
	LONG   retv = 0;

	if( API_Enter( API_KERNEL, INTERLOCK_INCREMENT, &pfn, &cs ) )
	{
		retv = pfn( lpDest );
		API_Leave(  );
	}
	return retv;
#endif
}

//    INTERLOCK_DECREMENT,
typedef LONG ( WINAPI * PINTERLOCK_DECREMENT )( LPLONG lpDest );
LONG WINAPI Interlock_Decrement( LPLONG lpDest )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTERLOCK_DECREMENT, 1 );
    cs.arg0 = (DWORD)lpDest ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PINTERLOCK_DECREMENT pfn;

	CALLSTACK cs;
	LONG   retv = 0;

	if( API_Enter( API_KERNEL, INTERLOCK_DECREMENT, &pfn, &cs ) )
	{
		retv = pfn(lpDest);
		API_Leave(  );
	}
	return retv;
#endif
}

//    INTERLOCK_EXCHANGE,
typedef LONG ( WINAPI * PINTERLOCK_EXCHANGE )( LPLONG lpDest, LONG lNewValue );
LONG WINAPI Interlock_Exchange( LPLONG lpDest, LONG lNewValue )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTERLOCK_EXCHANGE, 2 );
    cs.arg0 = (DWORD)lpDest;
    return (DWORD)CALL_SERVER( &cs, lNewValue );
#else

	PINTERLOCK_EXCHANGE pfn;

	CALLSTACK cs;
	LONG   retv = 0;

	if( API_Enter( API_KERNEL, INTERLOCK_EXCHANGE, &pfn, &cs ) )
	{
		retv = pfn(lpDest, lNewValue);
		API_Leave(  );
	}
	return retv;
#endif
}

//    INTERLOCK_EXCHANGEADD,
typedef LONG ( WINAPI * PINTERLOCK_EXCHANGEADD )( LPLONG lpDest, LONG lIncrement );
LONG WINAPI Interlock_ExchangeAdd( LPLONG lpDest, LONG lIncrement )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTERLOCK_EXCHANGEADD, 2 );
    cs.arg0 = (DWORD)lpDest;
    return (DWORD)CALL_SERVER( &cs, lIncrement );
#else

	PINTERLOCK_EXCHANGEADD pfn;

	CALLSTACK cs;
	LONG   retv = 0;

	if( API_Enter( API_KERNEL, INTERLOCK_EXCHANGEADD, &pfn, &cs ) )
	{
		retv = pfn(lpDest, lIncrement);
		API_Leave(  );
	}
	return retv;
#endif
}

//    INTERLOCK_COMPAREEXCHANGE,
typedef LONG ( WINAPI * PINTERLOCK_COMPAREEXCHANGE )( LPLONG lpDest, LONG lExchange, LONG lComperand );
LONG WINAPI Interlock_CompareExchange( LPLONG lpDest, LONG lExchange, LONG lComperand )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTERLOCK_COMPAREEXCHANGE, 3 );
    cs.arg0 = (DWORD)lpDest;
    return (DWORD)CALL_SERVER( &cs, lExchange, lComperand );
#else

	PINTERLOCK_COMPAREEXCHANGE pfn;

	CALLSTACK cs;
	LONG   retv = 0;

	if( API_Enter( API_KERNEL, INTERLOCK_COMPAREEXCHANGE, &pfn, &cs ) )
	{
		retv = pfn(lpDest, lExchange, lComperand);
		API_Leave(  );
	}
	return retv;
#endif
}

// module
//	MODULE_GETPROCADDRESS,
typedef FARPROC ( WINAPI * PMODULE_GETPROCADDRESS )( HMODULE hModule, LPCTSTR lpProcName );
FARPROC WINAPI Module_GetProcAddress( HMODULE hModule, LPCTSTR lpProcName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_GETPROCADDRESS, 2 );
    cs.arg0 = (DWORD)hModule;
    return (FARPROC)CALL_SERVER( &cs, lpProcName );
#else

	PMODULE_GETPROCADDRESS pfn;

	CALLSTACK cs;
	FARPROC   retv = NULL;

	if( API_Enter( API_KERNEL, MODULE_GETPROCADDRESS, &pfn, &cs ) )
	{
		retv = pfn( hModule, lpProcName );
		API_Leave(  );
	}
	return retv;
#endif
}

//	MODULE_GETFILENAME,
typedef DWORD ( WINAPI * PMODULE_GETFILENAME )( HMODULE hModule, LPTSTR lpFilename, DWORD nSize );
DWORD WINAPI Module_GetFileName( HMODULE hModule, LPTSTR lpFilename, DWORD nSize )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_GETFILENAME, 3 );
    cs.arg0 = (DWORD)hModule;
    return (DWORD)CALL_SERVER( &cs, lpFilename, nSize );
#else

	PMODULE_GETFILENAME pfn;

	CALLSTACK cs;
	DWORD   retv = 0;

	if( API_Enter( API_KERNEL, MODULE_GETFILENAME, &pfn, &cs ) )
	{
		retv = pfn( hModule, lpFilename, nSize );
		API_Leave(  );
	}
	return retv;
#endif
}

// MODULE_LOADLIBRARYEX
typedef HMODULE ( WINAPI * PMODULE_LOADLIBRARYEX )( LPCTSTR lpFileName, HANDLE hFile, DWORD dwFlags );
HMODULE WINAPI Module_LoadLibraryEx( LPCTSTR lpFileName, HANDLE hFile, DWORD dwFlags )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_LOADLIBRARYEX, 3 );
    cs.arg0 = (DWORD)lpFileName;
    return (HMODULE)CALL_SERVER( &cs, hFile, dwFlags );
#else

	PMODULE_LOADLIBRARYEX pfn;

	CALLSTACK cs;
	HMODULE   retv = NULL;

	if( API_Enter( API_KERNEL, MODULE_LOADLIBRARYEX, &pfn, &cs ) )
	{
		retv = pfn(lpFileName, hFile, dwFlags);
		API_Leave(  );
	}
	return retv;
#endif
}

//MODULE_FREELIBRARY
typedef BOOL ( WINAPI * PMODULE_FREELIBRARY )( HMODULE hModule );
BOOL WINAPI Module_FreeLibrary( HMODULE hModule )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_FREELIBRARY, 1 );
    cs.arg0 = (DWORD)hModule ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PMODULE_FREELIBRARY pfn;

	CALLSTACK cs;
	BOOL   retv = 0;

	if( API_Enter( API_KERNEL, MODULE_FREELIBRARY, &pfn, &cs ) )
	{
		retv = pfn(hModule);
		API_Leave(  );
	}
	return retv;
#endif
}


//MODULE_GETHANDLE
typedef HMODULE ( WINAPI * PMODULE_GETHANDLE )( LPCTSTR lpModuleName );
HMODULE WINAPI Module_GetHandle( LPCTSTR lpModuleName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_GETHANDLE, 1 );
    cs.arg0 = (DWORD)lpModuleName ;
    return (HMODULE)CALL_SERVER( &cs );
#else

	PMODULE_GETHANDLE pfn;

	CALLSTACK cs;
	HMODULE   retv = NULL;

	if( API_Enter( API_KERNEL, MODULE_GETHANDLE, &pfn, &cs ) )
	{
		retv = pfn(lpModuleName);
		API_Leave(  );
	}
	return retv;
#endif
}

//MODULE_FREELIBRARYANDEXITTHREAD
typedef VOID ( WINAPI * PMODULE_FREELIBRARYANDEXITTHREAD )( HMODULE hModule, DWORD dwExitCode );
VOID WINAPI Module_FreeLibraryAndExitThread( HMODULE hModule, DWORD dwExitCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_FREELIBRARYANDEXITTHREAD, 2 );
    cs.arg0 = (DWORD)hModule;
    CALL_SERVER( &cs, dwExitCode );
#else