📄 corelib.c

📁 深圳市微逻辑电子有限公司巨果&#8226 Kingmos&reg 系统核心
💻 C
📖 第 1 页 / 共 5 页
字号:
	PMODULE_FREELIBRARYANDEXITTHREAD pfn;

	CALLSTACK cs;
	//DWORD   retv = 0;

	if( API_Enter( API_KERNEL, MODULE_FREELIBRARYANDEXITTHREAD, &pfn, &cs ) )
	{
		pfn(hModule, dwExitCode);
		API_Leave(  );
	}
	//return retv;
#endif
}

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

	PMODULE_DISABLETHREADLIBRARYCALLS pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//MODULE_GETFILEHANDLE
typedef HANDLE ( WINAPI * PMODULE_GETFILEHANDLE )( HMODULE hModule );
HANDLE WINAPI Module_GetFileHandle( HMODULE hModule )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_GETFILEHANDLE, 1 );
    cs.arg0 = (DWORD)hModule ;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PMODULE_GETFILEHANDLE pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

//MODULE_GETSECTIONOFFSET
typedef DWORD ( WINAPI * PMODULE_GETSECTIONOFFSET )( HMODULE hModule, LPCTSTR lpcszSectionName );
DWORD WINAPI Module_GetSectionOffset( HMODULE hModule, LPCTSTR lpcszSectionName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MODULE_GETSECTIONOFFSET, 2 );
    cs.arg0 = (DWORD)hModule;
    return (DWORD)CALL_SERVER( &cs, lpcszSectionName );
#else

	PMODULE_GETSECTIONOFFSET pfn;

	CALLSTACK cs;
	DWORD   retv = -1;

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


// ERROR_SETLAST
typedef void ( WINAPI * PERROR_SETLAST )( DWORD dwErrorCode );
void WINAPI Error_SetLast( DWORD dwErrorCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, ERROR_SETLAST, 1 );
    cs.arg0 = (DWORD)dwErrorCode ;
    CALL_SERVER( &cs );
#else

	PERROR_SETLAST pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

typedef DWORD ( WINAPI * PERROR_GETLAST )( void );
DWORD WINAPI Error_GetLast( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, ERROR_GETLAST, 0 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PERROR_GETLAST pfn;

	CALLSTACK cs;
	DWORD   retv = 0;

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

typedef LPVOID ( WINAPI * PMEM_ALLOCPHYSICAL )( DWORD dwSize, DWORD fdwProtect, DWORD dwAlignmentMask, DWORD dwFlags, ULONG * pPhysicalAddress );
LPVOID WINAPI Mem_AllocPhysical( DWORD dwSize, 
								 DWORD fdwProtect,
								 DWORD dwAlignmentMask,
								 DWORD dwFlags,
								 ULONG * pPhysicalAddress )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_ALLOCPHYSICAL, 5 );
    cs.arg0 = (DWORD)dwSize;
    return (LPVOID)CALL_SERVER( &cs, fdwProtect, dwAlignmentMask, dwFlags, pPhysicalAddress );
#else

	PMEM_ALLOCPHYSICAL pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, MEM_ALLOCPHYSICAL, &pfn, &cs ) )
	{
		retv = pfn( dwSize, fdwProtect, dwAlignmentMask, dwFlags, pPhysicalAddress );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PMEM_FREEPHYSICAL )( LPVOID lpvAddress );

BOOL WINAPI Mem_FreePhysical( LPVOID lpvAddress )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_FREEPHYSICAL, 1 );
    cs.arg0 = (DWORD)lpvAddress ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PMEM_FREEPHYSICAL pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

typedef LPVOID ( WINAPI * PMEM_VIRTUALALLOC )( LPVOID lpAddress, DWORD dwSize, DWORD dwAllocationType, DWORD dwProtect );
LPVOID WINAPI Mem_VirtualAlloc( LPVOID lpAddress,
							    DWORD dwSize, 
								DWORD dwAllocationType, 
								DWORD dwProtect )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_VIRTUALALLOC, 4 );
    cs.arg0 = (DWORD)lpAddress;
    return (LPVOID)CALL_SERVER( &cs, dwSize, dwAllocationType, dwProtect );
#else

	PMEM_VIRTUALALLOC pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, MEM_VIRTUALALLOC, &pfn, &cs ) )
	{
		retv = pfn( lpAddress, dwSize, dwAllocationType, dwProtect );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PMEM_VIRTUALFREE )( LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType );
BOOL WINAPI Mem_VirtualFree( LPVOID lpAddress,
							 DWORD dwSize,
							 DWORD dwFreeType )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_VIRTUALFREE, 3 );
    cs.arg0 = (DWORD)lpAddress;
    return (DWORD)CALL_SERVER( &cs, dwSize, dwFreeType );
#else

	PMEM_VIRTUALFREE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, MEM_VIRTUALFREE, &pfn, &cs ) )
	{
		retv = pfn( lpAddress, dwSize, dwFreeType );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PMEM_VIRTUALCOPY )( LPVOID lpvDest, LPVOID lpvSrc, DWORD cbSize, DWORD fdwProtect );
BOOL WINAPI Mem_VirtualCopy( LPVOID lpvDest, LPVOID lpvSrc, DWORD cbSize, DWORD fdwProtect )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_VIRTUALCOPY, 4 );
    cs.arg0 = (DWORD)lpvDest;
    return (DWORD)CALL_SERVER( &cs, lpvSrc, cbSize, fdwProtect );
#else

	PMEM_VIRTUALCOPY pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, MEM_VIRTUALCOPY, &pfn, &cs ) )
	{
		retv = pfn( lpvDest, lpvSrc, cbSize, fdwProtect );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PMEM_VIRTUALPROTECT )( LPVOID lpvAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect );
BOOL WINAPI Mem_VirtualProtect( LPVOID lpvAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MEM_VIRTUALPROTECT, 4 );
    cs.arg0 = (DWORD)lpvAddress;
    return (DWORD)CALL_SERVER( &cs, dwSize, flNewProtect, lpflOldProtect );
#else

	PMEM_VIRTUALPROTECT pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, MEM_VIRTUALPROTECT, &pfn, &cs ) )
	{
		retv = pfn( lpvAddress, dwSize, flNewProtect, lpflOldProtect );
		API_Leave(  );
	}
	return retv;
#endif
}


// heap manger
typedef HANDLE ( WINAPI * PHEAP_CREATE )( DWORD flOptions, ULONG dwInitialSize, ULONG dwMaximumSize );
HANDLE WINAPI Heap_Create( DWORD flOptions, ULONG dwInitialSize, ULONG dwMaximumSize )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_CREATE, 3 );
    cs.arg0 = (DWORD)flOptions;
    return (HANDLE)CALL_SERVER( &cs, dwInitialSize, dwMaximumSize );
#else

	PHEAP_CREATE pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_KERNEL, HEAP_CREATE, &pfn, &cs ) )
	{
		retv = pfn( flOptions, dwInitialSize, dwMaximumSize );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PHEAP_DESTROY )( HANDLE hHeap );
BOOL WINAPI Heap_Destroy( HANDLE hHeap )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_DESTROY, 1 );
    cs.arg0 = (DWORD)hHeap ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PHEAP_DESTROY pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

typedef LPVOID ( WINAPI * PHEAP_ALLOC )( HANDLE hHeap, DWORD dwFlags, ULONG dwBytes );
LPVOID WINAPI Heap_Alloc( HANDLE hHeap, DWORD dwFlags, ULONG dwBytes )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_ALLOC, 3 );
    cs.arg0 = (DWORD)hHeap;
    return (LPVOID)CALL_SERVER( &cs, dwFlags, dwBytes );
#else

	PHEAP_ALLOC pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, HEAP_ALLOC, &pfn, &cs ) )
	{
		retv = pfn( hHeap, dwFlags, dwBytes );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PHEAP_FREE )( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem );
BOOL WINAPI Heap_Free( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_FREE, 3 );
    cs.arg0 = (DWORD)hHeap;
    return (DWORD)CALL_SERVER( &cs, dwFlags, lpMem );
#else

	PHEAP_FREE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, HEAP_FREE, &pfn, &cs ) )
	{
		retv = pfn( hHeap, dwFlags, lpMem );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef LPVOID ( WINAPI * PHEAP_REALLOC )( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, ULONG dwBytes );
LPVOID WINAPI Heap_ReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, ULONG dwBytes )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_REALLOC, 4 );
    cs.arg0 = (DWORD)hHeap;
    return (LPVOID)CALL_SERVER( &cs, dwFlags, lpMem, dwBytes );
#else

	PHEAP_REALLOC pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, HEAP_REALLOC, &pfn, &cs ) )
	{
		retv = pfn( hHeap, dwFlags, lpMem, dwBytes );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PHEAP_VALIDATE )( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem );
BOOL WINAPI Heap_Validate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, HEAP_VALIDATE, 3 );
    cs.arg0 = (DWORD)hHeap;
    return (DWORD)CALL_SERVER( &cs, dwFlags, lpMem );
#else

	PHEAP_VALIDATE pfn;

	CALLSTACK cs;
	BOOL retv = FALSE;

	if( API_Enter( API_KERNEL, HEAP_VALIDATE, &pfn, &cs ) )
	{
		retv = pfn( hHeap, dwFlags, lpMem );
		API_Leave(  );
	}
	return retv;
#endif
}


// debug
typedef BOOL ( WINAPI * PDBG_OUTSTRING )( LPTSTR lpszString );
BOOL WINAPI Dbg_OutString( LPTSTR lpszString )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, DBG_OUTSTRING, 1 );
    cs.arg0 = (DWORD)lpszString ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDBG_OUTSTRING pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

// power manager
typedef void ( WINAPI * PPOWER_SYSTEMOFF )( void );
void WINAPI Power_SystemOff( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, POWER_SYSTEMOFF, 0 );
    cs.arg0 = 0;
    CALL_SERVER( &cs );
#else

	PPOWER_SYSTEMOFF pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

// elf dll open 
//int __dlopen_dependence (struct __dlmodule* module, unsigned int mode)
//struct __dlmodule* __dlopen_module ( const char * name, unsigned int mode, 
//						   struct __dlmodule *caller )


typedef LPVOID ( WINAPI * PDLL_OPENMODULE )( LPCTSTR lpcszName, UINT uiMode, LPVOID lpvCaller );
LPVOID WINAPI Dll_OpenModule( LPCTSTR lpcszName, UINT uiMode, LPVOID lpvCaller )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, DLL_OPENMODULE, 3 );
    cs.arg0 = (DWORD)lpcszName;
    return (LPVOID)CALL_SERVER( &cs, uiMode, lpvCaller );
#else

	PDLL_OPENMODULE pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

	if( API_Enter( API_KERNEL, DLL_OPENMODULE, &pfn, &cs ) )
	{
		retv = pfn( lpcszName, uiMode, lpvCaller );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef int ( WINAPI * PDLL_OPENDEPENDENCE )( LPVOID lpvModule, UINT uiMode );
int WINAPI Dll_OpenDependence( LPVOID lpvModule, UINT uiMode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, DLL_OPENDEPENDENCE, 2 );
    cs.arg0 = (DWORD)lpvModule;
    return (DWORD)CALL_SERVER( &cs, uiMode );
#else

	PDLL_OPENDEPENDENCE pfn;

	CALLSTACK cs;
	int   retv = 0;

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



// interrupt api
typedef BOOL ( WINAPI * PINTR_INIT )( UINT idInt, HANDLE hIntEvent, LPVOID lpvData, DWORD dwSize );
BOOL WINAPI INTR_Init( UINT idInt, 
				       HANDLE hIntEvent,  // // intr event
				       LPVOID lpvData,   // transfer to OEM_InterruptEnable
				       DWORD dwSize      // transfer to OEM_InterruptEnable
				     )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, INTR_INIT, 4 );
    cs.arg0 = (DWORD)idInt;
    return (DWORD)CALL_SERVER( &cs, hIntEvent, lpvData, dwSize );
#else
	PINTR_INIT pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, INTR_INIT, &pfn, &cs ) )
	{
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -