FcLibs/FcThread/src/FcThread_WINAPI_Definition.h - master - vTech/FcApps

FcLibs/FcThread/src/FcThread_WINAPI_Definition.h
303 строки10 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#if defined(_WIN32) || defined(_WIN64)
#ifndef FCTHREAD_WINAPI_DEFINITION_H
#define FCTHREAD_WINAPI_DEFINITION_H

#include <stdio.h>

#ifdef _ISOC99_SOURCE
#define sprintf_s snprintf
#elif _MSC_VER
#define sprintf_s sprintf_s
#endif


FCTHREADDEF BOOL FcThread_getLastError(FcThread_Error_t error,
                                       TCHAR *const pError, size_t length,
                                       const TCHAR *pFile, const TCHAR *pFunc,
                                       const TCHAR *pFailedFunc, int line) {
  DWORD mError;
  TCHAR *mInfo = NULL;
  mError = GetLastError();
  if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                         FORMAT_MESSAGE_FROM_SYSTEM |
                         FORMAT_MESSAGE_IGNORE_INSERTS,
                     0, mError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                     (LPTSTR)&mInfo, 0, NULL)) {
    wprintf(L"Format message failed with 0x%x\n", GetLastError());
    return FALSE;
  }
  wsprintf(pError, TEXT("File : %s\nLine : %d\nCurrent function : %s()\nFailed function ")
          TEXT(": %s()\nError message : %s\n"), pFile, line, pFunc, pFailedFunc, mInfo);
  LocalFree(mInfo);
  return TRUE;
}

/*static FcThread_Error_t FcThread_getLastErrorMessage(int line, char const*
pFile) { LPVOID lpMsgBuf = NULL; (void)line; (void)pFile; DWORD code =
GetLastError(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                FORMAT_MESSAGE_FROM_SYSTEM |
                                FORMAT_MESSAGE_IGNORE_INSERTS,
                                NULL,
                                code,
                                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                (LPTSTR)&lpMsgBuf,
                                0, NULL);
                return lpMsgBuf;
}

static void FcThread_printLastErrorMessage(const TCHAR* pInfo) {
                LPVOID lpMsgBuf = NULL;
                DWORD code = GetLastError();
                if (!code)
                                return;
                FormatMessage(
                                FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                FORMAT_MESSAGE_FROM_SYSTEM |
                                FORMAT_MESSAGE_IGNORE_INSERTS,
                                NULL,
                                code,
                                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                (LPTSTR)&lpMsgBuf,
                                0, NULL);

                MessageBox(NULL, (LPCTSTR)lpMsgBuf, pInfo, MB_ICONERROR);
                LocalFree((HLOCAL)lpMsgBuf);
}

FCTHREADDEF void FcThread_getLastErrorMessage_free(FcThread_Error_t pError) {
                LocalFree((HLOCAL)pError);
}*/

FCTHREADDEF FcThread_Error_t FcThread(FcThread_t *pThread,
                                      const FcThread_settings_t *pSetting) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  pThread->threadHandle = CreateThread(NULL, 0, pSetting->f, pSetting->arg, 0, &pThread->threadId);
  if (!pThread->threadHandle)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF size_t FcThread_getId(const FcThread_t *pThread) {
  return (size_t)pThread->threadId;
}

FCTHREADDEF size_t FcThread_getCurrentId() { return GetCurrentThreadId(); }

FCTHREADDEF FcThread_Error_t FcThread_getExitCode(const FcThread_t *pThread,
                                                  DWORD *pCode) {
  FcThread_Error_t mError;
  if (GetExitCodeThread(pThread->threadHandle, pCode) == FALSE)
    mError = FCTHREAD_ERROR_WINAPI;
  else
    mError = FCTHREAD_ERROR_NOERROR;
  if (*pCode == STILL_ACTIVE) {
    mError = FCTHREAD_ERROR_STILL_ACTIVE;
  }
  return mError;
}

FCTHREADDEF FcThread_Error_t FcThread_join(const FcThread_t *pThread) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (WaitForSingleObject(pThread->threadHandle, INFINITE) == WAIT_FAILED)
    mError = FCTHREAD_ERROR_WINAPI;

  return mError;
}

FCTHREADDEF BOOL FcThread_running(const FcThread_t *thread) {
  BOOL mError = FALSE;
  DWORD exitCode = 0;
  mError = GetExitCodeThread(thread->threadHandle, &exitCode);
  if (!mError)
    return mError;
  if (exitCode == STILL_ACTIVE)
    mError = TRUE;
  return mError;
}

FCTHREADDEF void FcThread_exit(FcThread_t thread) {
  while (PostThreadMessage(thread.threadId, WM_QUIT, 0, 0) == 0)
    Sleep(0);
}

FCTHREADDEF void FcThread_exitLock(FcThread_t thread) {
  while (PostThreadMessage(thread.threadId, WM_QUIT, 0, 0) == 0)
    Sleep(0);
  WaitForSingleObject(thread.threadHandle, INFINITE);
  CloseHandle(thread.threadHandle);
}

FCTHREADDEF FcThread_Error_t FcMutex(FcMutex_t *pMutex) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  *pMutex = CreateMutex(NULL, FALSE, NULL);
  if (*pMutex == NULL)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcMutex_Lock(FcMutex_t *pMutex) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (WaitForSingleObject(*pMutex, INFINITE) != WAIT_OBJECT_0)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcMutex_Unlock(FcMutex_t *pMutex) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (ReleaseMutex(*pMutex) == 0)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcMutex_Free(FcMutex_t *pMutex) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (CloseHandle(*pMutex) == 0)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphore(FcSemaphore_t *pSemaphore,
                                         unsigned int initCounter) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  *pSemaphore = CreateSemaphore(NULL, initCounter, SEM_VALUE_MAX, NULL);
  if (*pSemaphore == NULL)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphoreN(FcSemaphore_t *pSemaphore,
                                          const TCHAR *name,
                                          unsigned int initCounter) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  *pSemaphore = CreateSemaphore(NULL, initCounter, SEM_VALUE_MAX, name);
  if (*pSemaphore == NULL)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Dec(FcSemaphore_t *pSemaphore) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (WaitForSingleObject(*pSemaphore, INFINITE) != WAIT_OBJECT_0)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Inc(FcSemaphore_t *pSemaphore) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (ReleaseSemaphore(*pSemaphore, 1, NULL) == 0)
    mError = FCTHREAD_ERROR_WINAPI; 
  return mError;
}

FCTHREADDEF BOOL FcSemaphore_Signal(FcSemaphore_t *pSemaphore) {
  LONG mCount;
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    if (!mError)
        if (ReleaseSemaphore(*pSemaphore, 1, &mCount) == 0) 
            mError = FCTHREAD_ERROR_WINAPI;
    if (!mError)
        if (WaitForSingleObject(*pSemaphore, 0) != WAIT_OBJECT_0)
            mError = FCTHREAD_ERROR_WINAPI;
    if (mCount)
      return FALSE;
    else 
      return TRUE;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Count(FcSemaphore_t *pSemaphore, int* mCount) {
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    LONG mValue;
    if (!mError)
        if (ReleaseSemaphore(*pSemaphore, 1, &mValue) == 0) 
            mError = FCTHREAD_ERROR_WINAPI;
    *mCount = mValue;
    if (!mError)
        if (WaitForSingleObject(*pSemaphore, 0) != WAIT_OBJECT_0)
            mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Free(FcSemaphore_t *pSemaphore) {
  FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
  if (CloseHandle(*pSemaphore) == 0)
    mError = FCTHREAD_ERROR_WINAPI;
  return mError;
}

FCTHREADDEF FcThread_Error_t FcSemaphoreN_Free(FcSemaphore_t *pSemaphore) {
  return FcSemaphore_Free(pSemaphore);
}

FCTHREADDEF FcThread_Error_t FcEvent(FcEvent_t* pEvent, const TCHAR* pName) {
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    *pEvent = CreateEvent(NULL, TRUE, FALSE, pName);
    if (!*pEvent)
        mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

FCTHREADDEF BOOL FcEvent_Signal(FcEvent_t* pEvent) {
    if (WaitForSingleObject(*pEvent, 0) != WAIT_OBJECT_0)
        return 0;
    return 1;
}


FCTHREADDEF BOOL FcEvent_Signal_wait(FcEvent_t* pEvent) {
    DWORD mResult;
    if ((mResult = WaitForSingleObject(*pEvent, INFINITE)) != WAIT_OBJECT_0)
        return 0;
    return 1;
}

FCTHREADDEF FcThread_Error_t FcEvent_SetEvent(FcEvent_t* pEvent) {
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    if (!SetEvent(*pEvent))
        mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

FCTHREADDEF FcThread_Error_t FcEvent_ResetEvent(FcEvent_t* pEvent) {
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    if (!ResetEvent(*pEvent))
        mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

FCTHREADDEF FcThread_Error_t FcEvent_Free(FcEvent_t* pEvent) {
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    if (!CloseHandle(*pEvent))
        mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

#define _SECOND 10000000

FCTHREADDEF FcThread_Error_t    FcTimer(FcTimer_t* pTimer, size_t msec, PTIMERAPCROUTINE pFunction, void* pData){
  LARGE_INTEGER mTime;
   __int64      qwDueTime;
  qwDueTime = -1 * _SECOND;

  mTime.LowPart  = (DWORD) ( qwDueTime & 0xFFFFFFFF );
  mTime.HighPart = (LONG)  ( qwDueTime >> 32 );

  *pTimer = CreateWaitableTimer(NULL, FALSE, NULL);
  if (NULL == *pTimer)
    return FCTHREAD_ERROR_WINAPI;
  if (!SetWaitableTimer(*pTimer, &mTime, msec, pFunction, pData, 0))
    return FCTHREAD_ERROR_WINAPI;
    
  return FCTHREAD_ERROR_NOERROR;
}

FCTHREADDEF FcThread_Error_t    FcTimer_free(FcTimer_t* pTimer){
    FcThread_Error_t mError = FCTHREAD_ERROR_NOERROR;
    if (!CloseHandle(*pTimer))
        mError = FCTHREAD_ERROR_WINAPI;
    return mError;
}

#undef _SECOND

#endif
#endif // defined(_WIN32) || defined(WIN32)