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
**/
void
cairo_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;
}
