自学教程：C++ DosReleaseMutexSem函数代码示例

static void dump_buffer (int i){    static int index = 0;    void *b;    b = buffer;    if (index + i > bsize) {        do {            DosRequestMutexSem (mutex, SEM_INDEFINITE_WAIT);            if (ready != 0) {                DosReleaseMutexSem(mutex);                break;            }            DosReleaseMutexSem (mutex);            DosSleep (20);        } while (TRUE);        MixBuffers[next].ulBufferLength = index;        MixSetupParms.pmixWrite (MixSetupParms.ulMixHandle,                                 &(MixBuffers[next]),1);        ready--;        next++;        index = 0;        if (next == BUFFERCOUNT) {            next=0;        }    }    memcpy (&((char*)MixBuffers[next].pBuffer)[index], b, i);    index += i;}

void vlc_sem_wait (vlc_sem_t *sem){    ULONG rc;    do    {        vlc_testcancel ();        DosRequestMutexSem(sem->wait_mutex, SEM_INDEFINITE_WAIT);        rc = vlc_WaitForSingleObject (sem->hev, SEM_INDEFINITE_WAIT );        if (!rc)        {            DosRequestMutexSem(sem->count_mutex, SEM_INDEFINITE_WAIT);            sem->count--;            if (sem->count == 0)            {                ULONG ulPost;                DosResetEventSem(sem->hev, &ulPost);            }            DosReleaseMutexSem(sem->count_mutex);        }        DosReleaseMutexSem(sem->wait_mutex);    } while (rc == ERROR_INTERRUPT);}

static apr_status_t thread_cond_timedwait(apr_thread_cond_t *cond,                                          apr_thread_mutex_t *mutex,                                          ULONG timeout_ms ){    ULONG rc;    apr_status_t rv = APR_SUCCESS;    int wake = FALSE;    unsigned long generation;    DosRequestMutexSem(cond->mutex, SEM_INDEFINITE_WAIT);    cond->num_waiting++;    generation = cond->generation;    DosReleaseMutexSem(cond->mutex);    apr_thread_mutex_unlock(mutex);    do {        rc = DosWaitEventSem(cond->semaphore, timeout_ms);        DosRequestMutexSem(cond->mutex, SEM_INDEFINITE_WAIT);        if (cond->num_wake) {            if (cond->generation != generation) {                cond->num_wake--;                cond->num_waiting--;                rv = APR_SUCCESS;                break;            } else {                wake = TRUE;            }        }        else if (rc != 0) {            cond->num_waiting--;            rv = APR_TIMEUP;            break;        }        DosReleaseMutexSem(cond->mutex);        if (wake) {            wake = FALSE;            DosPostEventSem(cond->semaphore);        }    } while (1);    DosReleaseMutexSem(cond->mutex);    apr_thread_mutex_lock(mutex);    return rv;}

WaWEPluginList_p CreatePluginList(int iPluginType){  WaWEPluginList_p pResult = NULL;  WaWEPluginList_p pLast = NULL;  WaWEPluginList_p pNew;  WaWEPlugin_p temp;  if (DosRequestMutexSem(PluginListProtector_Sem, SEM_INDEFINITE_WAIT)==NO_ERROR)  {    temp = PluginListHead;    while (temp)    {      if (temp->iPluginType == iPluginType)      {        pNew = (WaWEPluginList_p) dbg_malloc(sizeof(WaWEPluginList_t));        if (pNew)        {          pNew->pNext = NULL;          pNew->pPlugin = temp;          if (!pResult)          {            pResult = pNew;          } else          {            pLast->pNext = pNew;          }          pLast = pNew;        }      }      temp = temp->pNext;    }    DosReleaseMutexSem(PluginListProtector_Sem);  }  return pResult;}

WaWEPlugin_p GetExportPluginForFormat(WaWEExP_Create_Desc_p pFormatDesc){  WaWEPlugin_p pResult = NULL;  WaWEPlugin_p temp = NULL;  int iImportance;  if (DosRequestMutexSem(PluginListProtector_Sem, SEM_INDEFINITE_WAIT)==NO_ERROR)  {    // Go through all plugins, in order of importance,    // and check them if they can open the file.    // Return the first one, which reports success!    for (iImportance = WAWE_PLUGIN_IMPORTANCE_MAX;         iImportance >= WAWE_PLUGIN_IMPORTANCE_MIN;         iImportance--)    {      temp = PluginListHead;      while ((temp) && (!pResult))      {        if ((temp->iPluginType == WAWE_PLUGIN_TYPE_EXPORT) &&            (temp->iPluginImportance == iImportance))        {          if (temp->TypeSpecificInfo.ExportPluginInfo.fnIsFormatSupported(pFormatDesc))          {            // Hey, found a plugin which can write in this format!            pResult = temp;          }        }        temp = temp->pNext;      }      if (pResult) break;    }    DosReleaseMutexSem(PluginListProtector_Sem);  }  return pResult;}

int GetClipText(ClipData *cd) {    int rc;    ULONG PostCount;    char *mem;        rc = DosOpenMutexSem(SEM_PREFIX "CLIPSYN", &hmtxSyn);    if (rc != 0) return -1;    rc = DosOpenEventSem(SEM_PREFIX "CLIPGET", &hevGet);    if (rc != 0) return -1;/*    rc = DosOpenEventSem(SEM_PREFIX "CLIPPUT", &hevPut);*//*    if (rc != 0) return -1;*/    rc = DosOpenEventSem(SEM_PREFIX "CLIPEND", &hevEnd);    if (rc != 0) return -1;        DosRequestMutexSem(hmtxSyn, SEM_INDEFINITE_WAIT);    DosResetEventSem(hevEnd, &PostCount);    DosPostEventSem(hevGet);    DosWaitEventSem(hevEnd, SEM_INDEFINITE_WAIT);    if (0 == DosGetNamedSharedMem((void **)&mem, MEM_PREFIX "CLIPDATA", PAG_READ | PAG_WRITE)) {        cd->fLen = *(ULONG*)mem;        cd->fChar = strdup(mem + 4);        DosFreeMem(mem);    } else {        cd->fLen = 0;        cd->fChar = 0;    }    DosPostEventSem(hevGet);    DosReleaseMutexSem(hmtxSyn);/*    DosCloseEventSem(hevPut);*/    DosCloseEventSem(hevGet);    DosCloseEventSem(hevEnd);    DosCloseMutexSem(hmtxSyn);    return 0;}

static void internal_SetPageFont(HWND hwnd){  char *pchTemp;  // Set new window fonts!  if (DosRequestMutexSem(hmtxUseNLSTextArray, SEM_INDEFINITE_WAIT)==NO_ERROR)  {    pchTemp = apchNLSText[SSMODULE_NLSTEXT_FONTTOUSE];    if (pchTemp)    {      HWND hwndChild;      HENUM henum;      // Oookay, we have the font, set the page and all controls inside it!      WinSetPresParam(hwnd, PP_FONTNAMESIZE,		      strlen(pchTemp)+1,		      pchTemp);      // Now go through all of its children, and set it there, too!      henum = WinBeginEnumWindows(hwnd);      while ((hwndChild = WinGetNextWindow(henum))!=NULLHANDLE)      {	WinSetPresParam(hwndChild, PP_FONTNAMESIZE,			strlen(pchTemp)+1,			pchTemp);      }      WinEndEnumWindows(henum);    }    DosReleaseMutexSem(hmtxUseNLSTextArray);  }}

/** * cairo_os2_surface_set_hwnd: * @surface: the cairo surface to associate with the window handle * @hwnd_client_window: the window handle of the client window * * Sets window handle for surface. If Cairo wants to blit into the window * because it is set to blit as the surface changes (see * cairo_os2_surface_set_manual_window_refresh()), then there are two ways it * can choose: * If it knows the HWND of the surface, then it invalidates that area, so the * application will get a WM_PAINT message and it can call * cairo_os2_surface_refresh_window() to redraw that area. Otherwise cairo itself * will use the HPS it got at surface creation time, and blit the pixels itself. * It's also a solution, but experience shows that if this happens from a non-PM * thread, then it can screw up PM internals. * * So, best solution is to set the HWND for the surface after the surface * creation, so every blit will be done from application's message processing * loop, which is the safest way to do. * * Since: 1.4 **/voidcairo_os2_surface_set_hwnd (cairo_surface_t *surface,                            HWND             hwnd_client_window){    cairo_os2_surface_t *local_os2_surface;    local_os2_surface = (cairo_os2_surface_t *) surface;    if ((!local_os2_surface) ||        (local_os2_surface->base.backend != &cairo_os2_surface_backend))    {        /* Invalid parameter (wrong surface)! */        return;    }    if (DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT)        != NO_ERROR)    {        /* Could not get mutex! */        return;    }    local_os2_surface->hwnd_client_window = hwnd_client_window;    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);}

static void internal_SetPwdProtWindowText(HWND hwnd){  char *pchTemp;  // Set new window texts!  if (DosRequestMutexSem(hmtxUseNLSTextArray, SEM_INDEFINITE_WAIT)==NO_ERROR)  {    pchTemp = apchNLSText[SSMODULE_NLSTEXT_PWDPROT_ASK_TITLE];    if (pchTemp)      WinSetWindowText(hwnd, pchTemp);    pchTemp = apchNLSText[SSMODULE_NLSTEXT_PWDPROT_ASK_TEXT];    if (pchTemp)      WinSetDlgItemText(hwnd, ST_PLEASEENTERTHEPASSWORD, pchTemp);    pchTemp = apchNLSText[SSMODULE_NLSTEXT_PWDPROT_ASK_OKBUTTON];    if (pchTemp)      WinSetDlgItemText(hwnd, PB_OK, pchTemp);    pchTemp = apchNLSText[SSMODULE_NLSTEXT_PWDPROT_ASK_CANCELBUTTON];    if (pchTemp)      WinSetDlgItemText(hwnd, PB_CANCEL, pchTemp);    DosReleaseMutexSem(hmtxUseNLSTextArray);  }}

static void_cairo_os2_surface_release_source_image (void                  *abstract_surface,                                         cairo_image_surface_t *image,                                         void                  *image_extra){    cairo_os2_surface_t *local_os2_surface;    local_os2_surface = (cairo_os2_surface_t *) abstract_surface;    if ((!local_os2_surface) ||        (local_os2_surface->base.backend != &cairo_os2_surface_backend))    {        /* Invalid parameter (wrong surface)! */        return;    }    /* Decrease Lend counter! */    DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);    if (local_os2_surface->pixel_array_lend_count > 0)        local_os2_surface->pixel_array_lend_count--;    DosPostEventSem (local_os2_surface->hev_pixel_array_came_back);    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);    return;}

static int RequestCom(void){   USHORT res;   HMTX sem=0;   printf("Sending message to AM4PM to release COM port/n");   res=SendExtQMsg(EQ_RELCOM, NULL, 0);   if (res)      return res;   res=DosOpenMutexSem(szSemCom, &sem);   if (res)   {      printf("Error %u opening semaphore/n", res);      return 3;   }   res=DosRequestMutexSem(sem, 120000l);   if (res)   {      DosCloseMutexSem(sem);      if (res==ERROR_TIMEOUT)      {         printf("Timeout waiting for AM4PM to release COM port/n");         return 4;      }      printf("Error %u waiting for semaphore/n", res);      return 3;   }   DosReleaseMutexSem(sem);   DosCloseMutexSem(sem);   return 0;}

RC MCIDRVSave (FUNCTION_PARM_BLOCK *pFuncBlock){  ULONG                ulrc = MCIERR_SUCCESS;    // Propogated Error Code  ULONG                ulParam1;                 // Message flags  PMCI_INFO_PARMS      pInfoParms;               // Pointer to info structure  PMCI_GENERIC_PARMS   pDrvSaveParms;            // Pointer to GENERIC structure  PINSTANCE            pInstance;                // Pointer to instance  /*****************************************************/  /* dereference the values from pFuncBlock            */  /*****************************************************/  ulParam1       = pFuncBlock->ulParam1;  pInstance      = pFuncBlock->pInstance;  pDrvSaveParms     = (PMCI_GENERIC_PARMS)pFuncBlock->pParam2;  /*****************************************************/  /* NOTE ----->>>                                     */  /*  This is the basic function that should be        */  /*  performed.  See the other samples in the toolkit */  /*  for streaming and MMIO considerations            */  /*****************************************************/  DosRequestMutexSem (pInstance->hmtxAccessSem, -2);  // wait for semaphore  pInstance->Active = FALSE;  DosReleaseMutexSem (pInstance->hmtxAccessSem);      // release semaphore  return (ulrc);}      /* end of MCIDRVSave */

WaWEPlugin_p GetDefaultEditorPlugin(){  WaWEPlugin_p pResult = NULL;  WaWEPlugin_p pTemp;  // The default editor plugin is the edit plugin with the  // greatest iPluginImportance value!  if (DosRequestMutexSem(PluginListProtector_Sem, SEM_INDEFINITE_WAIT)==NO_ERROR)  {    pTemp = PluginListHead;    while (pTemp)    {      if (pTemp->iPluginType == WAWE_PLUGIN_TYPE_EDITOR)      {        if (!pResult) pResult = pTemp;        else          if (pResult->iPluginImportance < pTemp->iPluginImportance)            pResult = pTemp;      }      pTemp = pTemp->pNext;    }    DosReleaseMutexSem(PluginListProtector_Sem);  }  return pResult;}

static cairo_status_t_cairo_os2_surface_acquire_dest_image (void                     *abstract_surface,                                       cairo_rectangle_int_t    *interest_rect,                                       cairo_image_surface_t   **image_out,                                       cairo_rectangle_int_t    *image_rect,                                       void                    **image_extra){    cairo_os2_surface_t *local_os2_surface;    local_os2_surface = (cairo_os2_surface_t *) abstract_surface;    if ((!local_os2_surface) ||        (local_os2_surface->base.backend != &cairo_os2_surface_backend))    {        /* Invalid parameter (wrong surface)! */        return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);    }    DosRequestMutexSem (local_os2_surface->hmtx_use_private_fields, SEM_INDEFINITE_WAIT);    /* Increase lend counter */    local_os2_surface->pixel_array_lend_count++;    *image_out = local_os2_surface->image_surface;    *image_extra = NULL;    image_rect->x = 0;    image_rect->y = 0;    image_rect->width = local_os2_surface->bitmap_info.cx;    image_rect->height = local_os2_surface->bitmap_info.cy;    DosReleaseMutexSem (local_os2_surface->hmtx_use_private_fields);    return CAIRO_STATUS_SUCCESS;}

void omni_condition::wait(void){    _internal_omni_thread_helper me;    DosRequestMutexSem( crit , SEM_INDEFINITE_WAIT );    me->cond_next = NULL;    me->cond_prev = waiting_tail;    if (waiting_head == NULL)    waiting_head = me;    else    waiting_tail->cond_next = me;    waiting_tail = me;    me->cond_waiting = TRUE;    DosReleaseMutexSem( crit );    mutex->unlock();    APIRET result =  DosWaitEventSem(me->cond_semaphore, SEM_INDEFINITE_WAIT);    ULONG c;    DosResetEventSem(me->cond_semaphore,&c);    mutex->lock();    if (result != 0) throw omni_thread_fatal(result);}

void set_volume(int vol){    ULONG rc;    if ((rc=DosRequestMutexSem(hmtxOC, SEM_INDEFINITE_WAIT)))    {        log_warning(dlog, "set_volume, DosRequestMutexSem rc=%i", rc);        return;    }    if (usDeviceID)    {        MCI_SET_PARMS  MciSetParms;        memset(&MciSetParms, 0, sizeof(MCI_SET_PARMS));        MciSetParms.ulLevel = vol;        MciSetParms.ulAudio = MCI_SET_AUDIO_ALL;        log_message(dlog, "Setting volume to %d%%", vol);        rc = mciSendCommand(usDeviceID, MCI_SET, MCI_WAIT|                            MCI_SET_VOLUME|MCI_SET_AUDIO,                            (PVOID) &MciSetParms, 0);        if (rc != MCIERR_SUCCESS)            sound_err(dlog, rc, "Setting up Volume (MCI_SET).");    }    volume=vol;    DosReleaseMutexSem(hmtxOC);}

/* Create a semaphore */DECLSPEC SDL_sem * SDLCALL SDL_CreateSemaphore(Uint32 initial_value){        SDL_sem *sem;        ULONG ulrc;        /* Allocate sem memory */        sem = (SDL_sem *)SDL_malloc(sizeof(*sem));        if ( sem ) {                /* Create the mutex semaphore */                ulrc = DosCreateMutexSem(NULL,&(sem->id),0,TRUE);                if ( ulrc ) {                        SDL_SetError("Couldn't create semaphore");                        SDL_free(sem);                        sem = NULL;                } else                {                    DosCreateEventSem(NULL, &(sem->changed), 0, FALSE);                    sem->value = initial_value;                    DosReleaseMutexSem(sem->id);                }        } else {                SDL_OutOfMemory();        }        return(sem);}

void mute(int state){    ULONG rc;    if ((rc=DosRequestMutexSem(hmtxOC, SEM_INDEFINITE_WAIT)))    {        log_warning(dlog, "mute, DosRequestMutexSem rc=%i", rc);        return;    }    if (usDeviceID)    {        MCI_SET_PARMS MciSetParms;        memset(&MciSetParms, 0, sizeof(MCI_SET_PARMS));        MciSetParms.ulAudio = MCI_SET_AUDIO_ALL;        rc = mciSendCommand(usDeviceID, MCI_SET, MCI_WAIT|state|MCI_SET_AUDIO,                            (PVOID) &MciSetParms, 0);        if (rc != MCIERR_SUCCESS)            sound_err(dlog, rc, "Setting mute state (MCI_SET_ON/OFF).");    }    DosReleaseMutexSem(hmtxOC);    if (state==MCI_SET_ON)        set_volume(volume);}

/*** The sqlite3_mutex_leave() routine exits a mutex that was** previously entered by the same thread.  The behavior** is undefined if the mutex is not currently entered or** is not currently allocated.  SQLite will never do either.*/static void os2MutexLeave(sqlite3_mutex *p){  assert( os2MutexHeld(p) );  DosReleaseMutexSem(p->mutex);#ifdef SQLITE_DEBUG  if( p->trace ) os2MutexTrace(p, "leave");#endif}

/* Unlock the mutex */int__objc_mutex_unlock(objc_mutex_t mutex){  if (DosReleaseMutexSem((HMTX)(mutex->backend)) != 0)    return -1;  else    return 0;}

LONG APIENTRY DARTEvent (ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags){    ULONG rc;    switch (ulFlags)    {    case MIX_WRITE_COMPLETE:        //        // start the playback of the next buffer        //        rc=MixSetupParms.pmixWrite(MixSetupParms.ulMixHandle,                                   &(buffers[play]), 1);        //        // get the sound mutex        //        if (DosRequestMutexSem(hmtxSnd, SEM_INDEFINITE_WAIT))            return TRUE;        //        // empty the buffer which was finished        //        memset(buffers[last].pBuffer, 0, BufferParms.ulBufferSize);        //        // point to the next playable buffer and remember this buffer        // as the last one which was played        //        last  = play++;        play %= BufferParms.ulNumBuffers;        //        // release mutex        //        DosReleaseMutexSem(hmtxSnd);        if (rc != MCIERR_SUCCESS)            sound_err(dlog, rc, "Writing to Mixer (pmixWrite, MIX_WRITE_COMPLETE).");        return TRUE;    case MIX_STREAM_ERROR | MIX_WRITE_COMPLETE: // 130  /* error occur in device */        switch (ulStatus)        {        case ERROR_DEVICE_UNDERRUN: // 5626            sound_err(dlog, ulStatus, "Device underrun.");            play += 2;            play %= BufferParms.ulNumBuffers;            break;        case ERROR_DEVICE_OVERRUN:  // 5627            sound_err(dlog, ulStatus, "Device overrun.");            break;        }        rc=MixSetupParms.pmixWrite(MixSetupParms.ulMixHandle,                                   &(buffers[play]), 1);        if (rc != MCIERR_SUCCESS)            sound_err(dlog, rc, "Writing to Mixer (pmixWrite, MIX_STREAM_ERROR).");        return TRUE;    }    return TRUE;}

int que_n (void){    int result;    DosRequestMutexSem (mtx_Queue, SEM_INDEFINITE_WAIT);    result = nq;    DosReleaseMutexSem (mtx_Queue);    return result;}

BOOL IsMessageMarked(PMARKERLIST pList, PCHAR pchAreaTag, ULONG ulMsgID, ULONG ulFlags){   PMARKERAREA pArea;   PMARKERBUCKET pBucket;   LONG lFoundIndex;   WinRequestMutexSem(pList->hmtxAccess, SEM_INDEFINITE_WAIT);   /* Area suchen */   pArea = FindMarkerArea(pList, pchAreaTag);   if (pArea)   {      /* Area nach vorne setzen */      SetAreaToFront(pList, pArea);      /* Message in den Buckets suchen */      pBucket = FindMarkerBucket(pArea, ulMsgID, &lFoundIndex);      if (pBucket && lFoundIndex >=0)      {         /* Flags pruefen */         if (pBucket->aItems[lFoundIndex].ulFlags & ulFlags)         {            DosReleaseMutexSem(pList->hmtxAccess);            return TRUE;         }         else         {            DosReleaseMutexSem(pList->hmtxAccess);            return FALSE;         }      }      else      {         DosReleaseMutexSem(pList->hmtxAccess);         return FALSE;      }   }   else   {      DosReleaseMutexSem(pList->hmtxAccess);      return FALSE;   }}

static int dart_write2(SWORD *pbuf, size_t nr){    APIRET rc;    int nrtowrite;    written += nr;    nr *= sizeof(SWORD);    while (nr)    {        //        // check if the buffer can be filled completely        //        nrtowrite = nr>rest ? rest : nr;        if ((rc=DosRequestMutexSem(hmtxSnd, SEM_INDEFINITE_WAIT)))        {            log_warning(dlog, "dart_write2, DosRequestMutexSem rc=%i", rc);            return 1;        }        //        // if the buffer we want to write to is the next one which is        // played, skip one buffer and write to the overnext        //        if (play==(pos+1)%BufferParms.ulNumBuffers)        {            pos      = (++pos)%BufferParms.ulNumBuffers;            written += BufferParms.ulBufferSize/sizeof(SWORD);        }        //        // fill the pos-th buffer        //        memcpy((void*)((ULONG)buffers[pos].pBuffer+(BufferParms.ulBufferSize-rest)),               pbuf, nrtowrite);        rest -= nrtowrite;        //        // check if the buffer was filled completely        //        if (!rest)        {            pos++;            pos %= BufferParms.ulNumBuffers;            rest = BufferParms.ulBufferSize;        }        DosReleaseMutexSem(hmtxSnd);        nr -= nrtowrite;    }    return 0;}

/** * Releases the global mutex requested by global_lock(). */void global_unlock(){  APIRET arc;  ASSERT(gMutex != NULLHANDLE);  arc = DosReleaseMutexSem(gMutex);  ASSERT_MSG(arc == NO_ERROR, "%ld", arc);}

/* Initialize joystick support.  */int joy_arch_init(void){    ULONG action;    // return value from DosOpen    APIRET rc;    if (SWhGame)        return 0;    joylog = log_open("Joystick");    archdep_create_mutex_sem(&hmtxJoystick, "Joystick", TRUE);    number_joysticks = JOYDEV_NONE;    if (rc=DosOpen("GAME$", &SWhGame, &action, 0,                   FILE_READONLY, OPEN_ACTION_OPEN_IF_EXISTS/*FILE_OPEN*/,                   OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL))    {        if (rc==ERROR_OPEN_FAILED)        {            log_warning(joylog, "Cannot open device 'GAME$'.");            log_warning(joylog, "Have you installed a MPPM/2 joystick device driver?/n");        }        else            log_error(joylog, "DosOpen 'GAME$' (rc=%i)", rc);    }    else    {    	GAME_PARM_STRUCT parms;        ULONG dataLen = sizeof(parms); // length of gameStatus        if (rc=DosDevIOCtl(SWhGame, IOCTL_CAT_USER, GAME_GET_PARMS,                           NULL, 0, NULL, &parms, dataLen, &dataLen))        {            log_error(joylog, "DosDevIOCtl (rc=%i)", rc);        }        else        {            if (parms.useA)            {                log_message(joylog, "Joystick A found.");                number_joysticks |= JOYDEV_HW1;            }            if (parms.useB)            {                log_message(joylog, "Joystick B found.");                number_joysticks |= JOYDEV_HW2;            }            if (number_joysticks==JOYDEV_NONE)                log_message(joylog, "Sorry, no joystick found!");        }    }    DosReleaseMutexSem(hmtxJoystick);    return 0;}

/*** The sqlite3_mutex_leave() routine exits a mutex that was** previously entered by the same thread.  The behavior** is undefined if the mutex is not currently entered or** is not currently allocated.  SQLite will never do either.*/void sqlite3_mutex_leave(sqlite3_mutex *p){  TID tid;  PID holder1;  ULONG holder2;  assert( p->nRef>0 );  DosQueryMutexSem(p->mutex, &holder1, &tid, &holder2);  assert( p->owner==tid );  p->nRef--;  assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );  DosReleaseMutexSem(p->mutex);}

RTDECL(int)  RTSemMutexRelease(RTSEMMUTEX hMutexSem){    /*     * Unlock mutex semaphore.     */    int rc = DosReleaseMutexSem(SEM2HND(hMutexSem));    if (!rc)        return VINF_SUCCESS;    AssertMsgFailed(("Release hMutexSem %p failed, rc=%d/n", hMutexSem, rc));    return RTErrConvertFromOS2(rc);}

int DLLCALL pthread_mutex_unlock(pthread_mutex_t* mutex){#if defined(PTHREAD_MUTEX_AS_WIN32_MUTEX)	return (ReleaseMutex(*mutex) ? 0 : GetLastError());#elif defined(_WIN32)	/* Win32 Critical Section */	LeaveCriticalSection(mutex);	return 0;	/* No error */#elif defined(__OS2__)	return DosReleaseMutexSem(*mutex);#endif}

int GUI::SetPipeView(int id, EModel *notify) {  if ((id < 0) || (id > MAX_PIPES)) return -1;  if (Pipes[id].used == 0) return -1;  DosRequestMutexSem(Pipes[id].Access, SEM_INDEFINITE_WAIT);  // fprintf(stderr, "Pipe View: %d %08X/n", id, notify);  Pipes[id].notify = notify;  DosReleaseMutexSem(Pipes[id].Access);  return 0;}