corelib.c

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

}

//    THREAD_GETEXITCODE,
typedef BOOL ( WINAPI * PTHREAD_GETEXITCODE )( HANDLE hThread, LPDWORD lpExitCode );
BOOL WINAPI Thread_GetExitCode( HANDLE hThread, LPDWORD lpExitCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_GETEXITCODE, 2 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs, lpExitCode );
#else

	PTHREAD_GETEXITCODE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//    THREAD_EXIT,
typedef void ( WINAPI * PTHREAD_EXIT )( DWORD dwExitCode );
void WINAPI Thread_Exit( DWORD dwExitCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_EXIT, 1 );
    cs.arg0 = (DWORD)dwExitCode ;
    CALL_SERVER( &cs );
#else

	PTHREAD_EXIT pfn;

	CALLSTACK cs;
//	BOOL   retv = FALSE;

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

//    THREAD_SWITCHTO,
typedef BOOL ( WINAPI * PTHREAD_SWITCHTO ) ( VOID );
BOOL WINAPI Thread_SwitchTo( VOID )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_SWITCHTO, 0 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTHREAD_SWITCHTO pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

typedef BOOL ( WINAPI * PTHREAD_TERMINATE ) ( HANDLE hThread, DWORD dwExitCode );
BOOL WINAPI Thread_Terminate( HANDLE hThread, DWORD dwExitCode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, THREAD_TERMINATE, 2 );
    cs.arg0 = (DWORD)hThread;
    return (DWORD)CALL_SERVER( &cs, dwExitCode );
#else

	PTHREAD_TERMINATE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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


// semphore...
//    SEMAPHORE_CREATE,
typedef HANDLE ( WINAPI * PSEMAPHORE_CREATE )( LPSECURITY_ATTRIBUTES lpAttr, int nInitialCount, int nMaximumCount, LPCTSTR lpcszName );
HANDLE WINAPI Semaphore_Create( LPSECURITY_ATTRIBUTES lpAttr,
							    int nInitialCount, 
								int nMaximumCount, 
								LPCTSTR lpcszName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SEMAPHORE_CREATE, 4 );
    cs.arg0 = (DWORD)lpAttr;
    return (HANDLE)CALL_SERVER( &cs, nInitialCount, nMaximumCount, lpcszName );
#else

	PSEMAPHORE_CREATE pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_KERNEL, SEMAPHORE_CREATE, &pfn, &cs ) )
	{
		retv = pfn( lpAttr, nInitialCount, nMaximumCount, lpcszName );
		API_Leave(  );
	}
	return retv;
#endif
}

//    SEMAPHORE_RELEASE,
typedef BOOL ( WINAPI * PSEMAPHORE_RELEASE )( HANDLE hSemaphore, int lReleaseCount, LPINT lpPreviousCount );
BOOL WINAPI Semaphore_Release( HANDLE hSemaphore, 
							  int lReleaseCount, 
							  LPINT lpPreviousCount )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, SEMAPHORE_RELEASE, 3 );
    cs.arg0 = (DWORD)hSemaphore;
    return (DWORD)CALL_SERVER( &cs, lReleaseCount, lpPreviousCount );
#else

	PSEMAPHORE_RELEASE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_KERNEL, SEMAPHORE_RELEASE, &pfn, &cs ) )
	{
		retv = pfn( hSemaphore, lReleaseCount, lpPreviousCount );
		API_Leave(  );
	}
	return retv;
#endif
}

//    MUTEX_CREATE,
typedef HANDLE ( WINAPI * PMUTEX_CREATE )( LPSECURITY_ATTRIBUTES lpAttr, BOOL bInitialOwner, LPCTSTR lpcszName );
HANDLE WINAPI Mutex_Create( LPSECURITY_ATTRIBUTES lpAttr,
						   BOOL bInitialOwner, LPCTSTR lpcszName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MUTEX_CREATE, 3 );
    cs.arg0 = (DWORD)lpAttr;
    return (HANDLE)CALL_SERVER( &cs, bInitialOwner, lpcszName );
#else

	PMUTEX_CREATE pfn;

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_KERNEL, MUTEX_CREATE, &pfn, &cs ) )
	{
		retv = pfn( lpAttr, bInitialOwner, lpcszName );
		API_Leave(  );
	}
	return retv;
#endif
}

//    MUTEX_RELEASE,
typedef BOOL ( WINAPI * PMUTEX_RELEASE )( HANDLE hMutex );
BOOL WINAPI Mutex_Release( HANDLE hMutex )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, MUTEX_RELEASE, 1 );
    cs.arg0 = (DWORD)hMutex ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PMUTEX_RELEASE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//    EVENT_CREATE,
typedef HANDLE ( WINAPI * PEVENT_CREATE )(
      LPSECURITY_ATTRIBUTES lpEventAttributes,    // must is NULL
  	  BOOL bManualReset, 
	  BOOL bInitialState, 
	  LPCTSTR lpName );

HANDLE WINAPI Event_Create(
      LPSECURITY_ATTRIBUTES lpEventAttributes,    // must is NULL
  	  BOOL bManualReset, 
	  BOOL bInitialState, 
	  LPCTSTR lpName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, EVENT_CREATE, 4 );
    cs.arg0 = (DWORD)lpEventAttributes;
    return (HANDLE)CALL_SERVER( &cs, bManualReset, bInitialState, lpName );
#else

	PEVENT_CREATE pfn;

	CALLSTACK cs;
	HANDLE  retv = NULL;

	if( API_Enter( API_KERNEL, EVENT_CREATE, &pfn, &cs ) )
	{
		retv = pfn( lpEventAttributes, bManualReset, bInitialState, lpName );
		API_Leave(  );
	}
	return retv;
#endif
}


//    EVENT_RESET,
typedef BOOL ( WINAPI * PEVENT_RESET )( HANDLE hEvent );
BOOL WINAPI Event_Reset( HANDLE hEvent )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, EVENT_RESET, 1 );
    cs.arg0 = (DWORD)hEvent ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PEVENT_RESET pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//EVENT_SET,
typedef BOOL ( WINAPI * PEVENT_SET )( HANDLE hEvent );
BOOL WINAPI Event_Set( HANDLE hEvent )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, EVENT_SET, 1 );
    cs.arg0 = (DWORD)hEvent ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PEVENT_SET pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//EVENT_PULSE,
typedef BOOL ( WINAPI * PEVENT_PULSE )( HANDLE hEvent );
BOOL WINAPI Event_Pulse( HANDLE hEvent )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, EVENT_PULSE, 1 );
    cs.arg0 = (DWORD)hEvent ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PEVENT_PULSE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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


//    CRITICALSECTION_INITIALIZE,
//void WINAPI ddd( DWORD * lp )
//{
//	lp++;
//}
typedef VOID ( WINAPI * PCRITICALSECTION_INITIALIZE )( LPCRITICAL_SECTION lpCriticalSection );

VOID WINAPI CriticalSection_Initialize( LPCRITICAL_SECTION lpCriticalSection )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, CRITICALSECTION_INITIALIZE, 1 );
    cs.arg0 = (DWORD)lpCriticalSection ;
    CALL_SERVER( &cs );
	//return ddd( lpCriticalSection );
#else

	PCRITICALSECTION_INITIALIZE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

//    CRITICALSECTION_DELETE,
typedef VOID ( WINAPI * PCRITICALSECTION_DELETE )( LPCRITICAL_SECTION lpCriticalSection );
VOID WINAPI CriticalSection_Delete( LPCRITICAL_SECTION lpCriticalSection )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, CRITICALSECTION_DELETE, 1 );
    cs.arg0 = (DWORD)lpCriticalSection ;
    CALL_SERVER( &cs );
#else

	PCRITICALSECTION_DELETE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

//    CRITICALSECTION_LEAVE,
typedef VOID ( WINAPI * PCRITICALSECTION_LEAVE )( LPCRITICAL_SECTION lpCriticalSection );
VOID WINAPI CriticalSection_Leave( LPCRITICAL_SECTION lpCriticalSection )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, CRITICALSECTION_LEAVE, 1 );
    cs.arg0 = (DWORD)lpCriticalSection ;
    CALL_SERVER( &cs );
#else

	PCRITICALSECTION_LEAVE pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

//    CRITICALSECTION_ENTER,
typedef VOID ( WINAPI * PCRITICALSECTION_ENTER )( LPCRITICAL_SECTION lpCriticalSection );
VOID WINAPI CriticalSection_Enter( LPCRITICAL_SECTION lpCriticalSection )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, CRITICALSECTION_ENTER, 1 );
    cs.arg0 = (DWORD)lpCriticalSection ;
    CALL_SERVER( &cs );
#else

	PCRITICALSECTION_ENTER pfn;

	CALLSTACK cs;
	//BOOL   retv = FALSE;

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

//    CRITICALSECTION_TRYENTER,
typedef BOOL ( WINAPI * PCRITICALSECTION_TRYENTER )( LPCRITICAL_SECTION lpCriticalSection );
BOOL WINAPI CriticalSection_TryEnter( LPCRITICAL_SECTION lpCriticalSection )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, CRITICALSECTION_TRY_ENTER, 1 );
    cs.arg0 = (DWORD)lpCriticalSection ;
    return CALL_SERVER( &cs );
#else

	PCRITICALSECTION_TRYENTER pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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



// tls
//    TLS_ALLOC,
typedef DWORD ( WINAPI * PTLS_ALLOC )(VOID);
DWORD WINAPI Tls_Alloc(VOID)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_ALLOC, 1 );
    cs.arg0 = 0;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTLS_ALLOC pfn;

	CALLSTACK cs;
	DWORD   retv = TLS_OUT_OF_INDEXES;

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

//    TLS_FREE,
typedef BOOL ( WINAPI * PTLS_FREE )( DWORD dwTlsIndex );
BOOL WINAPI Tls_Free( DWORD dwTlsIndex )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_FREE, 1 );
    cs.arg0 = (DWORD)dwTlsIndex ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PTLS_FREE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

//    TLS_GETVALUE,
typedef LPVOID ( WINAPI * PTLS_GETVALUE )( DWORD dwTlsIndex );
LPVOID WINAPI Tls_GetValue( DWORD dwTlsIndex )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_GETVALUE, 1 );
    cs.arg0 = (DWORD)dwTlsIndex ;
    return (LPVOID)CALL_SERVER( &cs );
#else

	PTLS_GETVALUE pfn;

	CALLSTACK cs;
	LPVOID   retv = NULL;

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

//    TLS_SETVALUE,
typedef BOOL ( WINAPI * PTLS_SETVALUE )( DWORD dwTlsIndex, LPVOID lpValue );
BOOL WINAPI Tls_SetValue( DWORD dwTlsIndex, LPVOID lpValue )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_SETVALUE, 2 );
    cs.arg0 = (DWORD)dwTlsIndex;
    return (DWORD)CALL_SERVER( &cs, lpValue );
#else

	PTLS_SETVALUE pfn;

	CALLSTACK cs;
	BOOL   retv = FALSE;

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

typedef LPVOID ( WINAPI * PTLS_GETTHREADVALUE )( DWORD dwThreadId, DWORD dwTlsIndex );
LPVOID WINAPI Tls_GetThreadValue( DWORD dwThreadId, DWORD dwTlsIndex )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_KERNEL, TLS_GETTHREADVALUE, 2 );
    cs.arg0 = (DWORD)dwThreadId;
    return (LPVOID)CALL_SERVER( &cs, dwTlsIndex );
#else

	PTLS_GETTHREADVALUE pfn;

	CALLSTACK cs;