corelib.c

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

/******************************************************
Copyright(c) 版权所有，1998-2003微逻辑。保留所有权利。
******************************************************/

/*****************************************************
文件说明：核心库
版本号：1.0.0
开发时期：2002-04-20
作者：李林
修改记录：
    2003-05-13: LN, 增加 DLL_OpenModule & DLL_OpenDependence
******************************************************/

#include <eframe.h>
#include <eucore.h>
#include <eapisrv.h>

#include <epcore.h>
/*
//test
#define CALL_TRAP
typedef struct _CALLTRAP
{
    DWORD apiInfo;
    DWORD arg0;
}CALLTRAP;
    
//
*/


// application
typedef BOOL ( WINAPI * PAP_REGISTER )( LPCTSTR lpcszName, WINMAINPROC lpApProc, HICON hIcon );
BOOL WINAPI Application_Register( LPCTSTR lpcszName, WINMAINPROC lpApProc, HICON hIcon )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, AP_REGISTER, 3 );
    cs.arg0 = (DWORD)lpcszName;
    return (DWORD)CALL_SERVER( &cs, lpApProc, hIcon );
#else

	PAP_REGISTER pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, AP_REGISTER, &pfn, &cs ) )
	{
		//lpcszName = MapProcessPtr( lpcszName, (LPPROCESS)cs.lpvData );
		retv = pfn( lpcszName, lpApProc, hIcon );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PAP_LOAD )( LPCTSTR lpcszName, LPCTSTR lpcszCmdLine );
BOOL WINAPI Application_Load( LPCTSTR lpcszName, LPCTSTR lpcszCmdLine )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, AP_LOAD, 2 );
    cs.arg0 = (DWORD)lpcszName;
    return (DWORD)CALL_SERVER( &cs, lpcszCmdLine );
#else

	PAP_LOAD pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, AP_LOAD, &pfn, &cs ) )
	{
		//lpcszName = MapProcessPtr( lpcszName, (LPPROCESS)cs.lpvData );
		//lpcszCmdLine = MapProcessPtr( lpcszCmdLine, (LPPROCESS)cs.lpvData );
		retv = pfn( lpcszName, lpcszCmdLine );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HICON ( WINAPI * PAP_GETICON )( LPCTSTR lpcszName, UINT fIconType );
HICON WINAPI Application_GetIcon( LPCTSTR lpcszName, UINT fIconType )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, AP_GETICON, 2 );
    cs.arg0 = (DWORD)lpcszName;
    return (HICON)CALL_SERVER( &cs, fIconType );
#else

	PAP_GETICON pfn;

	CALLSTACK cs;
	HICON   retv = NULL;

	if( API_Enter( API_KERNEL, AP_GETICON, &pfn, &cs ) )
	{
		//lpcszName = MapProcessPtr( lpcszName, (LPPROCESS)cs.lpvData );
		retv = pfn( lpcszName, fIconType );
		API_Leave(  );
	}
	return retv;
#endif
}

//PROCESS_CREATE,
typedef BOOL ( WINAPI * PPROCESS_CREATE )(
						   LPCTSTR lpszApplicationName,                 // name of executable module
						   LPCTSTR lpszCommandLine,                      // command line string
						   LPSECURITY_ATTRIBUTES lpProcessAttributes, // set to NULL
						   LPSECURITY_ATTRIBUTES lpThreadAttributes,  // set to NULL
						   BOOL bInheritHandles,                      // set to FALSE
						   DWORD dwCreationFlags,                     // set to 0
						   LPVOID lpEnvironment,                      // set to NULL
						   LPCTSTR lpCurrentDirectory,                // set to NULL
						   LPSTARTUPINFO lpStartupInfo,               // set to NULL
						   LPPROCESS_INFORMATION lpProcessInformation 
						   );

BOOL WINAPI Process_Create(
						   LPCTSTR lpszApplicationName,                 // name of executable module
						   LPCTSTR lpszCommandLine,                      // command line string
						   LPSECURITY_ATTRIBUTES lpProcessAttributes, // set to NULL
						   LPSECURITY_ATTRIBUTES lpThreadAttributes,  // set to NULL
						   BOOL bInheritHandles,                      // set to FALSE
						   DWORD dwCreationFlags,                     // set to 0
						   LPVOID lpEnvironment,                      // set to NULL
						   LPCTSTR lpCurrentDirectory,                // set to NULL
						   LPSTARTUPINFO lpStartupInfo,               // set to NULL
						   LPPROCESS_INFORMATION lpProcessInformation 
						   )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_CREATE, 10 );
    cs.arg0 = (DWORD)
																			lpszApplicationName;
    return (DWORD)CALL_SERVER( &cs,
											lpszCommandLine,
											lpProcessAttributes,
											lpThreadAttributes,
											bInheritHandles,
											dwCreationFlags,
											lpEnvironment,
											lpCurrentDirectory,
											lpStartupInfo,
											lpProcessInformation );
#else

	PPROCESS_CREATE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, PROCESS_CREATE, &pfn, &cs ) )
	{
		retv = pfn( 
					lpszApplicationName,
					lpszCommandLine,
					lpProcessAttributes,
					lpThreadAttributes,
					bInheritHandles,
					dwCreationFlags,
					lpEnvironment,
					lpCurrentDirectory,
					lpStartupInfo,
					lpProcessInformation
			     );
		API_Leave(  );
	}
	return retv;
#endif
}

//	PROCESS_TERMINATE,
typedef VOID ( WINAPI * PPROCESS_TERMINATE )( HANDLE hProcess, UINT uExitCode );
VOID WINAPI Process_Terminate(
							HANDLE hProcess,
							UINT uExitCode   // exit code for all threads
						 )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_TERMINATE, 2 );
    cs.arg0 = (DWORD)hProcess;
    CALL_SERVER( &cs, uExitCode );
#else

	PPROCESS_TERMINATE pfn;

	CALLSTACK cs;

	if( API_Enter( API_KERNEL, PROCESS_TERMINATE, &pfn, &cs ) )
	{
		pfn( hProcess, uExitCode );
		API_Leave(  );
	}
#endif
}


//	PROCESS_EXIT,
typedef VOID ( WINAPI * PPROCESS_EXIT )( UINT uExitCode );
VOID WINAPI Process_Exit(
						 UINT uExitCode   // exit code for all threads
						 )
{
	Process_Terminate( Process_GetCurrent(), uExitCode );
}

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

	PPROCESS_GETCURRENTID pfn;

	CALLSTACK cs;
	DWORD   retv = -1;

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

//	PROCESS_GETHEAP,
typedef HANDLE ( WINAPI * PPROCESS_GETHEAP )( void );
HANDLE WINAPI Process_GetHeap( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETHEAP, 0 );
    cs.arg0 = 0;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PPROCESS_GETHEAP pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

//	PROCESS_MAPPTR,
typedef LPVOID ( WINAPI * PPROCESS_MAPPTR )( LPVOID lpv, HANDLE hProcess );
LPVOID WINAPI Process_MapPtr( LPVOID lpv, HANDLE hProcess )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_MAPPTR, 2 );
    cs.arg0 = (DWORD)lpv;
    return (LPVOID)CALL_SERVER( &cs, hProcess );
#else

	PPROCESS_MAPPTR pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

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

//	PROCESS_UNMAPPTR
typedef LPVOID ( WINAPI * PPROCESS_UNMAPPTR )( LPVOID lpv );
LPVOID WINAPI Process_UnMapPtr( LPVOID lpv )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_UNMAPPTR, 1 );
    cs.arg0 = (DWORD)lpv ;
    return (LPVOID)CALL_SERVER( &cs );
#else

	PPROCESS_UNMAPPTR pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

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

//    PROCESS_GETCURRENT,
typedef HANDLE ( WINAPI * PPROCESS_GETCURRENT )( void );
HANDLE WINAPI Process_GetCurrent( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETCURRENT, 0 );
    cs.arg0 = 0;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PPROCESS_GETCURRENT pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

//    PROCESS_GETCALLER,
typedef HANDLE ( WINAPI * PPROCESS_GETCALLER )( void );
HANDLE WINAPI Process_GetCaller( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETCALLER, 0 );
    cs.arg0 = 0;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PPROCESS_GETCALLER pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

//   PROCESS_GETOWNER
typedef HANDLE ( WINAPI * PPROCESS_GETOWNER )( void );
HANDLE WINAPI Process_GetOwner( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETOWNER, 0 );
    cs.arg0 = 0;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PPROCESS_GETOWNER pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

typedef BOOL ( WINAPI * PPROCESS_GETEXITCODE )( HANDLE hProcess, LPDWORD lpExitCode );
BOOL WINAPI Process_GetExitCode( HANDLE hProcess, LPDWORD lpExitCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, PROCESS_GETEXITCODE, 2 );
    cs.arg0 = (DWORD)hProcess;
    return (DWORD)CALL_SERVER( &cs, lpExitCode );
#else

	PPROCESS_GETEXITCODE pfn;

	CALLSTACK cs;
	BOOL   retv = 0;

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

static DWORD WINAPI UserThreadProc( LPVOID lpParameter )
{
}

// thread
//    THREAD_CREATE,
typedef HANDLE ( WINAPI * PTHREAD_CREATE )(
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    DWORD dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
   );

HANDLE WINAPI Thread_Create(
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    DWORD dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
   )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_CREATE, 6 );
    cs.arg0 = (DWORD)			lpThreadAttributes;
    return (HANDLE)CALL_SERVER( &cs,
			dwStackSize,
			lpStartAddress,
			lpParameter,
			dwCreationFlags,
			lpThreadId );
#else

	PTHREAD_CREATE pfn;

	CALLSTACK cs;
	HANDLE   retv = FALSE;

	if( API_Enter( API_KERNEL, THREAD_CREATE, &pfn, &cs ) )
	{
		retv = pfn(
			lpThreadAttributes,
			dwStackSize,
			lpStartAddress,
			lpParameter,
			dwCreationFlags,
			lpThreadId
			);
		API_Leave(  );
	}
	return retv;
#endif
}

//    THREAD_SETPRIORITY
typedef BOOL ( WINAPI * PTHREAD_SETPRIORITY )( HANDLE hThread, long lPriority, UINT flag );
BOOL WINAPI Thread_SetPriority( HANDLE hThread, long lPriority )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_SETPRIORITY, 3 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs, lPriority, 0 );
#else

	PTHREAD_SETPRIORITY pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, THREAD_SETPRIORITY, &pfn, &cs ) )
	{
		retv = pfn( hThread, lPriority, 0 );
		API_Leave(  );
	}
	return retv;
#endif
}

//KL_SetThreadPolicy
typedef BOOL ( WINAPI * PTHREAD_SETPOLICY )( HANDLE hThread, UINT uiPolicy );
BOOL WINAPI Thread_SetPolicy( HANDLE hThread, UINT uiPolicy )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_SETPOLICY, 2 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs, uiPolicy );
#else

	PTHREAD_SETPOLICY pfn;
	CALLSTACK cs;
	BOOL   retv = FALSE;

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


//    THREAD_GETCURRENT,
typedef HANDLE ( WINAPI * PTHREAD_GETCURRENT )( void );
HANDLE WINAPI Thread_GetCurrent( void )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_GETCURRENT, 0 );
    cs.arg0 = 0;
    return (HANDLE)CALL_SERVER( &cs );
#else

	PTHREAD_GETCURRENT pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

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

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

	PTHREAD_GETCURRENTID pfn;

	CALLSTACK cs;
	DWORD   retv = -1;

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