corelib.c

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

		retv = pfn( idInt, hIntEvent, lpvData, dwSize );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef void ( WINAPI * PINTR_DONE )( UINT idInt );
void WINAPI INTR_Done( UINT idInt )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTR_DONE, 1 );
    cs.arg0 = (DWORD)idInt ;
    CALL_SERVER( &cs );
#else

	PINTR_DONE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

typedef void ( WINAPI * PINTR_DISABLE )( UINT idInt );
void WINAPI INTR_Disable( UINT idInt )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTR_DISABLE, 1 );
    cs.arg0 = (DWORD)idInt ;
    CALL_SERVER( &cs );
#else

	PINTR_DISABLE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

typedef void ( WINAPI * PINTR_ENABLE )( UINT idInt, LPVOID lpvData, DWORD dwSize );
void WINAPI INTR_Enable( UINT idInt, LPVOID lpvData, DWORD dwSize )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTR_ENABLE, 3 );
    cs.arg0 = (DWORD)idInt;
    CALL_SERVER( &cs, lpvData, dwSize );
#else

	PINTR_ENABLE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, INTR_ENABLE, &pfn, &cs ) )
	{
		pfn( idInt, lpvData, dwSize );
		API_Leave(  );
	}
	//return retv;
#endif
}

// TOC
typedef LPCVOID ( WINAPI * PSYS_GETTOC )( void );
LPCVOID WINAPI Sys_GetTOC( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETTOC, 0 );
    cs.arg0 = 0;
    return (LPCVOID)CALL_SERVER( &cs );
#else

	PSYS_GETTOC pfn;

	CALLSTACK cs;
	LPCVOID   retv = NULL;

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

typedef void ( WINAPI * PMEM_GLOBALSTATUS )( LPMEMORYSTATUS lpms );
void WINAPI Mem_GlobalStatus( LPMEMORYSTATUS lpms )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_GLOBALSTATUS, 1 );
    cs.arg0 = (DWORD)lpms;
    CALL_SERVER( &cs );
#else

	PMEM_GLOBALSTATUS pfn;

	CALLSTACK cs;

	if( API_Enter( API_KERNEL, MEM_GLOBALSTATUS, (LPVOID)&pfn, &cs ) )
	{
		pfn( lpms );
		API_Leave( );
	}
#endif
}

// 
typedef void ( WINAPI * PSYS_PROFILEKERNEL )( UINT uiOption, LPVOID lpv  );
void WINAPI Sys_ProfileKernel( UINT uiOption, LPVOID lpv )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_PROFILEKERNEL, 2 );
    cs.arg0 = (DWORD)uiOption;
    CALL_SERVER( &cs, lpv );
#else

	PSYS_PROFILEKERNEL pfn;

	CALLSTACK cs;

	if( API_Enter( API_KERNEL, SYS_PROFILEKERNEL, (LPVOID)&pfn, &cs ) )
	{
		pfn( uiOption, lpv );
		API_Leave( );
	}
#endif
}

typedef LPTSTR ( WINAPI * PSYS_GETCOMMANDLINE )( VOID  );
LPTSTR WINAPI Sys_GetCommandLine( VOID )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GETCOMMANDLINE, 0 );
    cs.arg0 = 0;
    return (LPTSTR)CALL_SERVER( &cs );
#else

	PSYS_GETCOMMANDLINE pfn;

	CALLSTACK cs;
	LPTSTR retv = NULL;

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

typedef LPVOID ( WINAPI * PPROCESS_GETUSERDATA )( VOID  );
LPVOID WINAPI Process_GetUserData( VOID )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETUSERDATA, 0 );
    cs.arg0 = 0;
    return (LPVOID)CALL_SERVER( &cs );
#else

	PPROCESS_GETUSERDATA pfn;

	CALLSTACK cs;
	LPVOID retv = NULL;

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

typedef LPVOID ( WINAPI * PPROCESS_SETUSERDATA )( LPVOID lpvData );
LPVOID WINAPI Process_SetUserData( LPVOID lpvData )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_SETUSERDATA, 1 );
    cs.arg0 = (DWORD)lpvData ;
    return (LPVOID)CALL_SERVER( &cs );
#else

	PPROCESS_SETUSERDATA pfn;

	CALLSTACK cs;
	LPVOID retv = NULL;

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

typedef UINT ( WINAPI * PTHREAD_LOCKSCHEDULE )( void );
UINT WINAPI Thread_LockSchedule( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_LOCKSCHEDULE, 0 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTHREAD_LOCKSCHEDULE pfn;

	CALLSTACK cs;
	UINT retv = -1;

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

typedef UINT ( WINAPI * PTHREAD_UNLOCKSCHEDULE )( void );
UINT WINAPI Thread_UnlockSchedule( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_UNLOCKSCHEDULE, 0 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTHREAD_UNLOCKSCHEDULE pfn;

	CALLSTACK cs;
	UINT retv = -1;

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

typedef LPVOID ( WINAPI * PPAGE_ALLOCMEM )( DWORD dwNeedSize, DWORD * lpdwRealSize, UINT uiFlag );

LPVOID WINAPI Page_AllocMem( DWORD dwNeedSize, DWORD * lpdwRealSize, UINT uiFlag )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PAGE_ALLOCMEM, 3 );
    cs.arg0 = (DWORD)dwNeedSize;
    return (LPVOID)CALL_SERVER( &cs, lpdwRealSize, uiFlag);
#else
	PPAGE_ALLOCMEM pfn;
	CALLSTACK cs;
	LPVOID retv = NULL;

	if( API_Enter( API_KERNEL, PAGE_ALLOCMEM, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn(dwNeedSize, lpdwRealSize, uiFlag);
		API_Leave();
	}
	return retv;
#endif
}

typedef UINT ( WINAPI * PPAGE_FREEMEM )( LPVOID lp, DWORD dwSize );

BOOL WINAPI Page_FreeMem( LPVOID lp, DWORD dwSize )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PAGE_FREEMEM, 2 );
    cs.arg0 = (DWORD)lp;
    return (DWORD)CALL_SERVER( &cs, dwSize);
#else

	PPAGE_FREEMEM pfn;

	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, PAGE_FREEMEM, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn(lp, dwSize);
		API_Leave();
	}
	return retv;
#endif
}

typedef int ( WINAPI * PTHREAD_GETPRIORITY )( HANDLE );

int WINAPI Thread_GetPriority( HANDLE hThread )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_GETPRIORITY, 1 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs, 0 );
#else

	PTHREAD_GETPRIORITY pfn;

	CALLSTACK cs;
	int retv = 0;

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

typedef int ( WINAPI * PTHREAD_GETPOLICY )( HANDLE hThread );

BOOL WINAPI Thread_GetPolicy( HANDLE hThread )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_GETPOLICY , 1 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTHREAD_GETPOLICY pfn;

	CALLSTACK cs;
	int retv = 0;

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


//HANDLE WINAPI Process_Open( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId );
typedef HANDLE ( WINAPI * PPROCESS_OPEN )( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId );
HANDLE WINAPI Process_Open( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_OPEN , 3 );
    cs.arg0 = (DWORD)dwDesiredAccess;
    return (HANDLE)CALL_SERVER( &cs, bInheritHandle, dwProcessId );
#else

	PPROCESS_OPEN pfn;

	CALLSTACK cs;
	HANDLE retv = 0;

	if( API_Enter( API_KERNEL, PROCESS_OPEN, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn( dwDesiredAccess, bInheritHandle, dwProcessId );
		API_Leave();
	}
	return retv;
#endif
}
/*
typedef UINT ( WINAPI * PSYS_ENTRYTRY )( jmp_buf jmp_data );
UINT WINAPI _Sys_EntryTry( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
	jmp_buf jmp_data;
	UINT retv;
	if( ( retv = sys_setjmp( jmp_data ) ) == 0 )
	{
		RETAILMSG( 1, ( "Sys_EntryTry cs=0x%x, sp=0x%x, lr=0x%x.\r\n", &cs, jmp_data->sp, jmp_data->lr ) );
		cs.apiInfo = CALL_API( API_KERNEL, SYS_ENTRYTRY , 1 );
		cs.arg0 = (DWORD)jmp_data;
		return (DWORD)CALL_SERVER( &cs );
	}
    RETAILMSG( 1, ( "Sys_EntryTry leave.\r\n" ) );
	return retv;
#else

	PSYS_ENTRYTRY pfn;

	CALLSTACK cs;
	UINT retv;
	jmp_buf jmp_data;

	if( ( retv = sys_setjmp( jmp_data ) ) == 0 )
	{
		if( API_Enter( API_KERNEL, SYS_ENTRYTRY, (LPVOID)&pfn, &cs ) )
		{
			retv = pfn( jmp_data );
			API_Leave();
		}
	}
	return retv;
#endif
}
*/

typedef UINT ( WINAPI * PSYS_CAPTURE_EXCEPTION )( LPEXCEPTION_CONTEXT lpctx );
UINT WINAPI _Sys_CaptureException( LPEXCEPTION_CONTEXT lpctx )
{
#ifdef CALL_TRAP

	CALLTRAP cs;
    UINT retv;

	//RETAILMSG( 1, ( "_Sys_CaptureException cs=0x%x,sp=0x%x,lr=0x%x,ip=0x%x.\r\n", &cs, jmp_data->sp, jmp_data->lr, jmp_data->ip ) );
	cs.apiInfo = CALL_API( API_KERNEL, SYS_CAPTUREEXCEPTION , 1 );
	cs.arg0 = (DWORD)lpctx;
	retv = (DWORD)CALL_SERVER( &cs );

    //RETAILMSG( 1, ( "_Sys_EntryTry leave(%d).\r\n", retv ) );
	return retv;
	
#else

	PSYS_CAPTURE_EXCEPTION pfn;

	CALLSTACK cs;
	UINT retv;

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

typedef UINT ( WINAPI * PSYS_RELEASE_EXCEPTION )( void );
BOOL WINAPI Sys_ReleaseException( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_RELEASEEXCEPTION , 0 );
    cs.arg0 = 0;
    return CALL_SERVER( &cs );
#else

	PSYS_RELEASE_EXCEPTION pfn;
	CALLSTACK cs;
	UINT retv = 0;

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


typedef UINT ( WINAPI * PSYS_GET_COMPUTER_NAME_EX )( COMPUTER_NAME_FORMAT NameType, LPTSTR lpBuffer, LPDWORD lpnSize );
BOOL WINAPI Sys_GetComputerNameEx( COMPUTER_NAME_FORMAT NameType, LPTSTR lpBuffer, LPDWORD lpnSize )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_GET_COMPUTER_NAME_EX , 3 );
    cs.arg0 = NameType;
    return CALL_SERVER( &cs, lpBuffer, lpnSize );
#else

	PSYS_GET_COMPUTER_NAME_EX pfn;
	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_GET_COMPUTER_NAME_EX, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn(NameType, lpBuffer, lpnSize);
		API_Leave();
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PSYS_SET_COMPUTER_NAME_EX )( COMPUTER_NAME_FORMAT NameType, LPCTSTR lpBuffer );
BOOL WINAPI Sys_SetComputerNameEx( COMPUTER_NAME_FORMAT NameType, LPCTSTR lpBuffer  )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_SET_COMPUTER_NAME_EX , 2 );
    cs.arg0 = NameType;
    return CALL_SERVER( &cs, lpBuffer );
#else

	PSYS_SET_COMPUTER_NAME_EX pfn;
	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_SET_COMPUTER_NAME_EX, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn(NameType,lpBuffer);
		API_Leave();
	}
	return retv;
#endif
}


typedef BOOL ( WINAPI * PSYS_REGISTRYIO )( LPBYTE lpDataBuf, DWORD nNumberOfBytes, DWORD dwFlag );
BOOL WINAPI Sys_RegistryIO( LPBYTE lpDataBuf, DWORD nNumberOfBytes, DWORD dwFlag )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SYS_REGISTRYIO , 3 );
    cs.arg0 = (DWORD)lpDataBuf;
    return CALL_SERVER( &cs, nNumberOfBytes, dwFlag );
#else

	PSYS_REGISTRYIO pfn;
	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, SYS_REGISTRYIO, (LPVOID)&pfn, &cs ) )
	{
		retv = pfn(lpDataBuf,nNumberOfBytes, dwFlag);
		API_Leave();
	}
	return retv;
#endif
}

//UINT WINAPI KL_ChangeThreadRotate( DWORD dwThreadId, int nAddRotate )
typedef UINT ( WINAPI * PTHREAD_CHANGE_ROTATE )( DWORD dwThreadId, int nAddRotate );
UINT WINAPI Thread_ChangeRotate( DWORD dwThreadId, int nAddRotate )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_CHANGE_ROTATE , 2 );
    cs.arg0 = dwThreadId;
    return CA