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

int getmessage (int interval){    int             key = 0;    ULONG           posted;    if (que_n() > 0) return que_get ();        // with interval == 0, we only check for keys in buffer    if (interval == 0)    {        key = 0;    }    else if (interval > 0)    {        DosResetEventSem (hev_NewMessage, &posted);        DosWaitEventSem (hev_NewMessage, interval);        key = que_get ();    }    else if (interval < 0)    {        DosResetEventSem (hev_NewMessage, &posted);        DosWaitEventSem (hev_NewMessage, SEM_INDEFINITE_WAIT);        key = que_get ();    }    return key;}

static APIRET PipeWaitAndResetEventSem(HEV *SemHandle){#define EVENTSEM_TIMEOUT SEM_INDEFINITE_WAIT	APIRET rc;	ULONG PostCt;	rc = DosWaitEventSem(*SemHandle, EVENTSEM_TIMEOUT);	if (!rc) rc = DosResetEventSem(*SemHandle, &PostCt);	if (rc == ERROR_INVALID_HANDLE)	{		rc = DosOpenEventSem(0, SemHandle);		if (!rc) 		{		    rc = DosWaitEventSem(*SemHandle, EVENTSEM_TIMEOUT);		    if (!rc) rc = DosResetEventSem(*SemHandle, &PostCt);		}	}        if (rc == ERROR_ALREADY_RESET) rc = 0;	return rc;}

void NotifyLoopThread(MSG *pMsg)  {  ULONG ulPostCount;  DosResetEventSem(hevNotifyLoopSem,&ulPostCount);  pMsg = pNotifyLoopMsg;  while (1)    {    pMsg->ulMessageNumber = ulMessageNumber++;    SendMessage(pMsg);    DosWaitEventSem(hevNotifyLoopSem,5000);//    DosSleep(300);    DosResetEventSem(hevNotifyLoopSem,&ulPostCount);    }  }

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);}

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;}

int GetPipeEvent(TEvent *Event) {  ULONG ulPostCount;  int   i;  Event->What = evNone;  for (i = 0; i < MAX_PIPES; i++) {    if (Pipes[i].used == 0) continue;    if (Pipes[i].notify == 0) continue;    if (DosResetEventSem(Pipes[i].NewData, &ulPostCount) != 0) continue;    if (ulPostCount > 0) {      // fprintf(stderr, "Pipe New Data: %d/n", i);      Event->What        = evNotify;      Event->Msg.View    = 0;      Event->Msg.Model   = Pipes[i].notify;      Event->Msg.Command = cmPipeRead;      Event->Msg.Param1  = i;      return 1;    }  }  return 0;}

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 TEventQueue::keyboardThread( void * arg ) {  arg = arg;  KBDKEYINFO *info = &TThreads::tiled->keyboardInfo;  while (1) {    jsSuspendThread    USHORT errCode = KbdCharIn( info, IO_NOWAIT, 0 );    jsSuspendThread    if ( errCode || (info->fbStatus & 0xC0)!=0x40 || info->fbStatus & 1) { // no char      keyboardEvent.what = evNothing;      DosSleep(keyboardPollingDelay);      if (keyboardPollingDelay < 500) keyboardPollingDelay += 5;    } else {    keyboardEvent.what = evKeyDown;    if ((info->fbStatus & 2) && (info->chChar==0xE0)) info->chChar=0; // OS/2 cursor keys.    keyboardEvent.keyDown.charScan.charCode=info->chChar;    keyboardEvent.keyDown.charScan.scanCode=info->chScan;    shiftState = info->fsState & 0xFF;    jsSuspendThread    assert(! DosPostEventSem(TThreads::hevKeyboard1) );    jsSuspendThread    assert(! DosWaitEventSem(TThreads::hevKeyboard2, SEM_INDEFINITE_WAIT) );    keyboardEvent.what = evNothing;    ULONG dummy;    jsSuspendThread    assert(! DosResetEventSem(TThreads::hevKeyboard2, &dummy) );    keyboardPollingDelay=0;    }  }  TThreads::deadEnd();}

unsigned long Event::Reset ( ) {   if ( Handle == 0 )      return ( (unsigned long) 0xFFFFFFFF ) ;   if ( DebugFlag ) Log ( "Event(%s)::Reset.", Tag?Tag:"" ) ;   BOOL Result = FALSE ;   #ifdef __OS2__      ULONG PostCount ;      APIRET Status = DosResetEventSem ( Handle, &PostCount ) ;      if ( Status && ( Status != ERROR_ALREADY_RESET ) )         Result = FALSE ;      else         Result = TRUE ;   #else      Result = ResetEvent ( Handle ) ;   #endif   return ( Result ) ;} /* endmethod */

void omni_semaphore::wait(void){    ULONG cnt;    APIRET rc = DosWaitEventSem(nt_sem, SEM_INDEFINITE_WAIT);    if (rc != 0)    throw omni_thread_fatal(rc);    DosResetEventSem(nt_sem,&cnt);}

/* reset_async_info clear async_info in such a way that fresh add_waiter() * calls can be performed. */static void Os2_reset_async_info(void *async_info){   AsyncInfo *ai = async_info;   ULONG ul;   DosResetEventSem(ai->sem, &ul);   ai->mustwait = 0;}

static void BeginSoftModeThread( thread_data *arglist ){    TID         tid;    ULONG       ulCount;    DosResetEventSem( BeginThreadSem , &ulCount );    DosCreateThread( &tid, BeginThreadHelper, (ULONG)arglist, 0, STACK_SIZE );    DosWaitEventSem( BeginThreadSem, SEM_INDEFINITE_WAIT );}

void APIENTRY ReadLoopThread()  {  THREAD *pstThd = pstThread;  CONFIG *pCfg = &pstThd->stCfg;  THREADCTRL *pThread = &pstThd->stThread;  BOOL bReadComplete;  CHAR *pString;  APIRET rc;  BOOL bSkipRead = FALSE;  char szMessage[80];  ULONG ulStringLength;  ULONG ulPostCount;//  DosSetPriority(PRTYS_THREAD,PRTYC_FOREGROUNDSERVER,-28L,0);  DosSetPriority(PRTYS_THREAD,PRTYC_REGULAR,-10L,0);  ulStringLength = pCfg->wReadStringLength;  DosAllocMem((PPVOID)&pString,10010,(PAG_COMMIT | PAG_WRITE | PAG_READ));  while (!pThread->bStopThread)    {    if (ulStringLength != pCfg->wReadStringLength)      {      DosFreeMem(pString);      ulStringLength = pCfg->wReadStringLength;      DosAllocMem((PPVOID)&pString,(ulStringLength + 10),(PAG_COMMIT | PAG_WRITE | PAG_READ));      }    if (pCfg->bHalfDuplex)      {      while ((rc = DosWaitEventSem(hevStartReadSem,10000)) != 0)        if (rc == ERROR_SEM_TIMEOUT)          {          ErrorNotify(pstThd,"Read start semaphore timed out");          bSkipRead = TRUE;          }        else          {          sprintf(szMessage,"Read start semaphore error - rc = %u",rc);          ErrorNotify(pstThd,szMessage);          }      DosResetEventSem(hevStartReadSem,&ulPostCount);      }    if (bSkipRead)      bSkipRead = FALSE;    else      {      if (!pCfg->bReadCharacters)        bReadComplete = ReadString(pstThd,pString);      else        bReadComplete = ReadCharacters(pstThd,pString);      if (bReadComplete)        DosPostEventSem(hevStartWriteSem);      }    }  DosFreeMem(pString);  DosPostEventSem(hevKillReadThreadSem);  DosExit(EXIT_THREAD,0);  }

static int write_os2(audio_output_t *ao,unsigned char *buf,int len){	/* if we're too quick, let's wait */	if(nobuffermode)	{		MCI_MIX_BUFFER *temp = playingbuffer;				while(			(tobefilled != (temp = ((BUFFERINFO *) temp->ulUserParm)->NextBuffer)) &&			(tobefilled != (temp = ((BUFFERINFO *) temp->ulUserParm)->NextBuffer)) &&			(tobefilled != (temp = ((BUFFERINFO *) temp->ulUserParm)->NextBuffer)) )		{			DosResetEventSem(dataplayed,&resetcount);			DosWaitEventSem(dataplayed, -1);			temp = playingbuffer;		}			} else {		while(tobefilled == playingbuffer)		{			DosResetEventSem(dataplayed,&resetcount);			DosWaitEventSem(dataplayed, -1);		}	}			if (justflushed) {		justflushed = FALSE;	} else {		nomoredata = FALSE;				memcpy(tobefilled->pBuffer, buf, len);		tobefilled->ulBufferLength = len;		//      ((BUFFERINFO *) tobefilled->ulUserParm)->frameNum = fr->frameNum;				/* if we're out of the water (3rd ahead buffer filled),		let's reduce our priority */		if(tobefilled == ( (BUFFERINFO *) ( (BUFFERINFO *) ((BUFFERINFO *) playingbuffer->ulUserParm)->NextBuffer->ulUserParm)->NextBuffer->ulUserParm)->NextBuffer)			DosSetPriority(PRTYS_THREAD,normalclass,normaldelta,mainthread->tib_ptib2->tib2_ultid);				tobefilled = ((BUFFERINFO *) tobefilled->ulUserParm)->NextBuffer;	}		return len;}

int os2KbdQueueQuery(){	ULONG numElements,postCount; 	(void)DosQueryQueue(hKbdQueue,&numElements);	if (numElements!=0) return 0; /* We have something in queue */	DosResetEventSem(hKbdSem,&postCount);	return 1;}

//***************************************************************************//*                                                                         *//*  BOOL waitPost()                                                        *//*                                                                         *//*  Waits for postSema being posted by device driver                       *//*  Returns:                                                               *//*    TRUE - Success                                                       *//*    FALSE - Unsuccessful access of event semaphore                       *//*                                                                         *//*  Preconditions: init() has to be called successfully before             *//*                                                                         *//***************************************************************************BOOL scsiObj::waitPost(){  ULONG count=0;  ULONG rc;                                             // return value  rc = DosWaitEventSem(postSema, -1);                   // wait forever  if (rc) return FALSE;                                 // DosWaitEventSem failed  rc = DosResetEventSem(postSema, &count);              // reset semaphore  if (rc) return FALSE;                                 // DosResetEventSem failed  return TRUE;}

static ULONGwait_post(ULONG ulTimeOut){	ULONG count = 0;	ULONG rc;					/* return value *//*	rc = DosWaitEventSem(postSema, -1);*/		/* wait forever*/	rc = DosWaitEventSem(postSema, ulTimeOut);	DosResetEventSem(postSema, &count);	return (rc);}

PRStatus_PR_MD_WAIT(PRThread *thread, PRIntervalTime ticks){    PRInt32 rv;    ULONG count;    PRUint32 msecs = (ticks == PR_INTERVAL_NO_TIMEOUT) ?        SEM_INDEFINITE_WAIT : PR_IntervalToMilliseconds(ticks);    rv = DosWaitEventSem(thread->md.blocked_sema, msecs);    DosResetEventSem(thread->md.blocked_sema, &count);     switch(rv)     {        case NO_ERROR:            return PR_SUCCESS;            break;        case ERROR_TIMEOUT:            _PR_THREAD_LOCK(thread);            if (thread->state == _PR_IO_WAIT) {			  ;            } else {                if (thread->wait.cvar != NULL) {                    thread->wait.cvar = NULL;                    _PR_THREAD_UNLOCK(thread);                } else {                    /* The CVAR was notified just as the timeout                     * occurred.  This led to us being notified twice.                     * call SemRequest() to clear the semaphore.                     */                    _PR_THREAD_UNLOCK(thread);                    rv = DosWaitEventSem(thread->md.blocked_sema, 0);                    DosResetEventSem(thread->md.blocked_sema, &count);                     PR_ASSERT(rv == NO_ERROR);                }            }            return PR_SUCCESS;            break;        default:            break;    }    return PR_FAILURE;}

ULONG CommandSTOP(  PLUGINWORK *pPluginWork, DECODER_PARAMS *pParams ){    ULONG ulTmp;    if(pPluginWork->fStatus == 0) {        return 101;    }    DosResetEventSem( pPluginWork->hevThreadA, &ulTmp );    pPluginWork->fStop = TRUE;    DosWaitEventSem( pPluginWork->hevThreadA, 20000 );    return 0;}

/****************************************************************/ * Routine for consumer threads.                                * *--------------------------------------------------------------* *                                                              * *  Name:     ThreadConsumer(PVOID)                             * *                                                              * *  Purpose:  There are NUMUSERS copies of this thread to act   * *            as consumers of the resource. The thread waits for* *            exclusive access to the resource and colors it.   * *                                                              * *  Usage:    Threads created by StartSemExample.               * *                                                              * *  Method:   Waits for mutex to gain ownership of resource.    * *            Releases resource when user event. Dies when      * *            Stop event.                                       * *  Returns:                                                    * *                                                              */****************************************************************/VOID ThreadConsumer( PVOID pvMyID ){   ULONG  ulPostCnt;   ULONG  ulUser=0L;   ULONG  rc;   HAB    habb;   HMQ    hmqq;   /* Need a message queue for any thread that wants to print messages. */   habb = WinInitialize(0);   hmqq = WinCreateMsgQueue(habb,0);   /* while the user has not selected stop ... */   while ((DosWaitEventSem(hevStop,SEM_IMMEDIATE_RETURN)) == ERROR_TIMEOUT)   {      /* Wait for exclusive ownership of resource */      DosRequestMutexSem(hmtxOwnResource,SEM_INDEFINITE_WAIT);      /* the following check is necessary because the stop semaphore       * may have been posted  while we were waiting on the mutex       */      if (DosWaitEventSem(hevStop, SEM_IMMEDIATE_RETURN) == ERROR_TIMEOUT)      {      /*********************************************************************/       * an item is ready, which one?  don't wait forever because there is *       * a possibility that the stop semaphore was posted and that no more *       * resource is forthcoming. we wait twice as long as we think is     *       * necessary.                                                        *      /*********************************************************************/         if (!DosWaitMuxWaitSem (hmuxResource, max (ulTimeout << 1,            TIMEOUTPERIOD) , &ulUser))         {            MyMove ((ULONG) pvMyID, ulUser);            DosResetEventSem(aSquares[ulUser].hev, &ulPostCnt);         }      }                               /* Let some other thread have resource. */      rc = DosReleaseMutexSem(hmtxOwnResource);      if (rc)      {         SemError("DosReleaseMutexSem",rc);      }   }   /* hevStop was posted, kill this thread */   WinDestroyMsgQueue (hmqq);   WinTerminate (habb);   DosExit(EXIT_THREAD, 0);   return;}

ULONG CommandPLAY(  PLUGINWORK *pPluginWork, DECODER_PARAMS *pParams ){    ULONG ulTmp;    if(pPluginWork->fStatus != 0) {        return 101;    }    strncpy( pPluginWork->szFileName, pParams->filename, 4096 );    DosResetEventSem( pPluginWork->hevThreadA, &ulTmp );    DosPostEventSem( pPluginWork->hevThreadTrigger );    DosWaitEventSem( pPluginWork->hevThreadA, 20000 );        return 0;}

void fly_init (int x0, int y0, int rows, int cols, char *font){    TID       tid;    int       rc;    ULONG     reset;    tiled1 = _tmalloc (tiled_size);    if (tiled1 == NULL) fly_error ("cannot allocate tiled memory/n");    us1_16 = _tmalloc (sizeof(USHORT));    us2_16 = _tmalloc (sizeof(USHORT));    pci = _tmalloc (sizeof(VIOCURSORINFO));    rc = DosCreateMutexSem (NULL, &mtx_Queue, 0, FALSE);    debug_tools ("rc = %d after DosCreateMutexSem/n", rc);    rc = DosCreateMutexSem (NULL, &mtx_Video, 0, FALSE);    debug_tools ("rc = %d after DosCreateMutexSem/n", rc);    rc = DosCreateEventSem (NULL, &hev_NewMessage, 0, FALSE);    debug_tools ("rc = %d after DosCreateEventSem/n", rc);    rc = DosCreateEventSem (NULL, &hev_VideoReady, 0, FALSE);    debug_tools ("rc = %d after DosCreateEventSem/n", rc);        grab_video ();    if (rows != -1 && cols != -1)        video_init (rows, cols);    else        video_init (25, 80);    release_video ();    DosResetEventSem (hev_VideoReady, &reset);    rc = DosCreateThread (&tid, interface_thread, 0, 0, 32786);    debug_tools ("rc = %d after DosCreateThread/n", rc);    DosWaitEventSem (hev_VideoReady, SEM_INDEFINITE_WAIT);    fl_opt.initialized = TRUE;    DosSleep (300);    if (font != NULL)        fly_set_font (font);    //debug_tools ("rows = %d, cols = %d in fly_init/n", rows, cols);    if (rows != -1 && cols != -1)        video_set_window_size (rows, cols);        debug_tools ("x0 = %d, y0 = %d in fly_init/n", x0, y0);    if (x0 >= 0 && y0 >= 0)        video_set_window_pos (x0, y0);}

void DART_WaitDone(_THIS){  pMixBufferDesc pBufDesc;  ULONG ulPostCount;  APIRET rc;  pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[_this->hidden->iLastPlayedBuf].ulUserParm;  rc = NO_ERROR;  while ((pBufDesc->iBufferUsage != BUFFER_EMPTY) && (rc==NO_ERROR))  {    DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);    rc = DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000);   }}

void TEventQueue::getMouseState( TEvent & ev ){#ifdef __NT__  ev.mouse.where   = lastMouse.where;  ev.mouse.buttons = lastMouse.buttons;  if ( lastMouse.buttons != 0 ) ev.what = getTicks();  // Temporarily save tick count when event was read.  INPUT_RECORD *irp = TThreads::get_next_event();  if ( irp == NULL || irp->EventType != MOUSE_EVENT ) return;  TThreads::accept_event();  curMouse.where.x = irp->Event.MouseEvent.dwMousePosition.X;  curMouse.where.y = irp->Event.MouseEvent.dwMousePosition.Y;  curMouse.buttons = irp->Event.MouseEvent.dwButtonState;  curMouse.doubleClick = (irp->Event.MouseEvent.dwEventFlags & DOUBLE_CLICK)                                ? True                                : False;  ev.mouse = curMouse;  if ( lastMouse.buttons == 0 ) ev.what = getTicks();#else   // __NT__#ifdef __OS2__    assert(! DosRequestMutexSem(TThreads::hmtxMouse1,SEM_INDEFINITE_WAIT) );#else    _disable();#endif    if( eventCount == 0 )        {        ev.what = getTicks();        ev.mouse = curMouse;        }    else        {        ev = *eventQHead;        if( ++eventQHead >= eventQueue + eventQSize )            eventQHead = eventQueue;        eventCount--;        }#ifdef __OS2__    if (eventCount==0) {      ULONG dummy;      DosResetEventSem( TThreads::hevMouse1, &dummy );    };    assert(! DosReleaseMutexSem(TThreads::hmtxMouse1) );#else    _enable();#endif  // __OS2__#endif  // __NT__    if( mouseReverse != False && ev.mouse.buttons != 0 && ev.mouse.buttons != 3 )        ev.mouse.buttons ^= 3;}

APIRET APIENTRY thSwitch (void)   {   BOOL  bSuccess;   ULONG ul;   do {      DosResetEventSem (hevSammy, &ul);      DosWaitEventSem (hevSammy, SEM_INDEFINITE_WAIT);      bSuccess = ChangeWPS(pShareInitOS2->pszUserIni, pShareInitOS2->pszSystemIni);      DebugULd (1, "thSwitch", "bSuccess", bSuccess);      }   while( bSuccess );   return 0;   }

RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem){    /*     * Reset the object.     */    ULONG ulIgnore;    int rc = DosResetEventSem(SEM2HND(hEventMultiSem), &ulIgnore);    switch (rc)    {        case NO_ERROR:        case ERROR_ALREADY_RESET:            return VINF_SUCCESS;        default:            return RTErrConvertFromOS2(rc);    }}