node *Get(void) { if (!IsQueueEmpty()) return Queue[(front++) % tree]; else printf("Queue is Empty!\n"); return NULL; }
void LevelOrderTraverse(BinaryTree * binaryTree,void(*visit)()){ if(binaryTree){ NodeQueue * queue=NULL; queue=InitQueue(); visit(binaryTree->data); if(binaryTree->lChild){ EnQueue(queue,binaryTree->lChild); } if(binaryTree->rChild){ EnQueue(queue,binaryTree->rChild); } while(IsQueueEmpty(queue)==1){ Node * e=NULL; e=DeQueue(queue); visit(e->data); if(e->lChild){ EnQueue(queue,e->lChild); } if(e->rChild){ EnQueue(queue,e->rChild); } } DestroyQueue(queue); } }
void AddToReadyQueue(ProcessControlBlock **head, ProcessControlBlock *pcb) { ProcessControlBlock *tmp; ProcessControlBlock *prev; if (IsQueueEmpty(*head)) { *head = pcb; (*head)->nextPCB = NULL; return; } if ( pcb->priority < (*head)->priority ) { // infront of queue pcb->nextPCB = *head; *head = pcb; return; } tmp = *head; while ( (tmp != NULL) && (tmp->priority <= pcb->priority) ) { prev = tmp; tmp = tmp->nextPCB; } prev->nextPCB = pcb; // insert in the Middle & End pcb->nextPCB = tmp; }
CORE_PROC(int, RelayInput)( PDATAPATH pdp , PTEXT (CPROC *Datacallback)( PDATAPATH pdp, PTEXT pLine ) ) { extern int gbTrace; if( pdp->pPrior ) { PTEXT p; int moved = 0; if( gbTrace ) xlprintf(LOG_NOISE+1)( WIDE("Relay input from %s to %s..........") , GetText( pdp->pPrior->pName ) , GetText( pdp->pName ) ); do { if( pdp->pPrior->Read ) { pdp->pPrior->Read( pdp->pPrior ); } if( IsQueueEmpty( &pdp->pPrior->Input ) ) break; //Log( WIDE("Has some input to handle...") ); while( ( p = (PTEXT)DequeLink( &pdp->pPrior->Input ) ) ) { if( gbTrace ) lprintf( WIDE("Data is: %s"), GetText( p ) ); if( Datacallback && !( ( p->flags & TF_RELAY ) == TF_RELAY ) ) { //lprintf( WIDE("Data callback...") ); for( p = Datacallback( pdp, p ); p; p = Datacallback( pdp, NULL ) ) { moved++; if( p != (POINTER)1 ) EnqueLink( &pdp->Input, p ); else lprintf( WIDE("Data was consumed by datapath.") ); } } else { PTEXT out = BuildLine( p ); Log1( WIDE("Relay In: %s"), GetText( out ) ); LineRelease( out ); moved++; EnqueLink( &pdp->Input, p ); } } if( gbTrace && !moved && !pdp->pPrior->flags.Closed ) { lprintf( WIDE("Did not result in data, try reading source again, rerelay. %s %s"), GetText( pdp->pName ), GetText( pdp->pPrior->pName ) ); } } while( !moved && !pdp->pPrior->flags.Closed ); // stop relaying closes at datasource points //if( !pdp->pPrior->flags.Data_Source ) pdp->flags.Closed |= pdp->pPrior->flags.Closed; return moved; } return 0; }
void AddToTimerQueue(ProcessControlBlock **head, ProcessControlBlock *pcb) { ProcessControlBlock *tmp; ProcessControlBlock *prev; if (IsQueueEmpty(*head)) { *head = pcb; (*head)->nextPCB = NULL; return; } // add by increasing of time if ( (*head)->wakeup_time > pcb->wakeup_time) { //in front pcb->nextPCB = *head; *head = pcb; return; } tmp = *head; while ( (tmp != NULL) && (tmp->wakeup_time <= pcb->wakeup_time)) { // <= so prev always has value prev = tmp; tmp = tmp->nextPCB; } prev->nextPCB = pcb; // insert in the Middle & End pcb->nextPCB = NULL; // reset linker if (tmp != NULL) { // insert in the Middle pcb->nextPCB = tmp; return; } }
/*++ Routine Description: This routine is used to determine if conditions are appropriate to satisfy a wait for transmit empty event, and if so to complete the request that is waiting for that event. It also call the code that checks to see if we should lower the RTS line if we are doing transmit toggling. NOTE: This routine is called by WdfInterruptSynchronize. NOTE: This routine assumes that it is called with the cancel spinlock held. Arguments: Context - Really a pointer to the device extension. Return Value: This routine always returns FALSE. --*/ _Use_decl_annotations_ BOOLEAN SerialProcessEmptyTransmit( WDFINTERRUPT Interrupt, PVOID Context ) { PSERIAL_DEVICE_EXTENSION extension = Context; UNREFERENCED_PARAMETER(Interrupt); if (extension->IsrWaitMask && (extension->IsrWaitMask & SERIAL_EV_TXEMPTY) && extension->EmptiedTransmit && (!extension->TransmitImmediate) && (!extension->CurrentWriteRequest) && IsQueueEmpty(extension->WriteQueue)) { extension->HistoryMask |= SERIAL_EV_TXEMPTY; if (extension->IrpMaskLocation) { *extension->IrpMaskLocation = extension->HistoryMask; extension->IrpMaskLocation = NULL; extension->HistoryMask = 0; SerialGetRequestContext(extension->CurrentWaitRequest)->Information = sizeof(ULONG); SerialInsertQueueDpc(extension->CommWaitDpc); } extension->CountOfTryingToLowerRTS++; SerialPerhapsLowerRTS(extension->WdfInterrupt, extension); } return FALSE; }
void Enqueue(struct queue * queue, struct hash *thash, int pageno, char *contents, time_t expirystamp, char *etag,char *modifystampstr) { if (IsQueueFull(queue)) { thash->array[queue->rear->pageno] = NULL; Dequeue(queue); } struct queuenode *newnode = CreateNewQueueNode(pageno, contents, expirystamp, etag,modifystampstr); if (IsQueueEmpty(queue)) { queue->front = queue->rear = newnode; } else { newnode->next = queue->front; queue->front->prev = newnode; queue->front = newnode; } thash->array[pageno] = newnode; queue->count++; }
DWORD DequeueEvent( ROUTING_PROTOCOL_EVENTS *prpeEvent, MESSAGE *pmMessage) { DWORD dwErr = NO_ERROR; PQUEUE_ENTRY pqe = NULL; PEVENT_ENTRY pee = NULL; ACQUIRE_QUEUE_LOCK(&(g_ce.lqEventQueue)); do { if (IsQueueEmpty(&(g_ce.lqEventQueue.head))) { dwErr = ERROR_NO_MORE_ITEMS; TRACE0(CONFIGURATION, "No events in the queue."); break; } pqe = Dequeue(&(g_ce.lqEventQueue.head)); pee = CONTAINING_RECORD(pqe, EVENT_ENTRY, qeEventQueueLink); *(prpeEvent) = pee->rpeEvent; *(pmMessage) = pee->mMessage; /* created in EE_EnqueueEvent */ EE_Destroy(pee); pee = NULL; } while (FALSE); RELEASE_QUEUE_LOCK(&(g_ce.lqEventQueue)); return dwErr; }
struct proc* DequeueProcess(struct processQueue* queue) { if(!IsQueueEmpty(queue)) { struct proc* p = queue->proc[queue->head]; queue->head= (queue->head+1)%QUEUE_CAPACITY; queue->size=queue->size-1; return p; } return 0; }
struct PP_Var DequeueMessage() { struct PP_Var message; pthread_mutex_lock(&g_queue_mutex); while ( IsQueueEmpty() != 0 ) pthread_cond_wait(&g_queue_not_empty_cond, &g_queue_mutex); message = g_queue[g_queue_start]; g_queue_start = (g_queue_start + 1) % MAX_QUEUE_SIZE; g_queue_size--; pthread_mutex_unlock(&g_queue_mutex); return(message); }
void addNewNode(Queue* _queue,QNode* node){ if ( IsQueueEmpty( _queue ) )// If queue is empty, change both head and last pointers _queue->last = _queue->head = node; else // Else change the last { _queue->last->next = node; node->prev = _queue->last; _queue->last = node; } _queue->_size++; }
// End of Queue routines // ------------------------------------------------------------------- void Scanner::nextTokenInternal() { // check if a token has been pushed back into the token stream, if so use it first // I think I should get rid of this code, use queue methods instead if (previousToken.tokenCode != CodeTypes::tEmptyToken) { ftoken = previousToken.tokenCode; tokenString = previousToken.tokenString; tokenDouble = previousToken.tokenDouble; tokenInteger = previousToken.tokenInteger; previousToken.tokenCode = CodeTypes::tEmptyToken; return; } // Check if there is anything in the token queue, if so get the item // from the queue and exit. If not, read as normal from the stream. // Checking the queue before reading from the stream can be turned off and on // by setting the FromQueue Flag. if(FromQueue) { if(!IsQueueEmpty()) { getTokenFromQueue(); return; } } skipBlanks(); tokenString = ""; TCharCode::TCharCode code = FCharTable[fch]; switch(code) { case TCharCode::cLETTER: case TCharCode::cUNDERSCORE: getWord(); break; case TCharCode::cDIGIT: getNumber(); break; case TCharCode::cDOUBLEQUOTE: getString(); break; case TCharCode::cETX: ftoken = CodeTypes::tEndOfStreamToken; break; default: getSpecial(); break; } }
void LevelOrderIterative( TreeNode *root ) { if( !root ) { return; } Enqueue( root ); Enqueue( NULL ); while( !IsQueueEmpty() ) { root = Dequeue(); if( !root ) { if( !IsQueueEmpty() ) { Enqueue( NULL ); continue; } else { break; } } root->next = Queue[ front ]; if( root->left ) Enqueue( root->left ); if( root->right ) Enqueue( root->right ); } }
TreeNode* Dequeue() { TreeNode *retVal = NULL; if( IsQueueEmpty() ) { printf("\n Empty Queue. \n"); } else { retVal = Queue[ front++ ]; if( front > rear ) front = rear = -1; } return retVal; }
ProcessControlBlock *DeQueue(ProcessControlBlock **head) { ProcessControlBlock *tmp; if (IsQueueEmpty(*head)) { return NULL; } tmp = *head; *head = (*head)->nextPCB; tmp->nextPCB = NULL; // release next pointer, go to anothe queue return tmp; }
INT32 SizeQueue(ProcessControlBlock *head) { int count = 0; if (IsQueueEmpty(head)) { return 0; } else { while (head != NULL) { count++; head = head->nextPCB; } } return count; }
void PrintQueue(ProcessControlBlock *head) { if (IsQueueEmpty(head)) { return; } else { while (head != NULL) { printf("%d ",head->process_id); head = head->nextPCB; } printf(";\n"); } }
/** Dequeue a message and return it. * * This function blocks until a message is available. It should not be called * on the main thread. * * NOTE: this function assumes g_queue_mutex is _NOT_ held. * @return The message at the head of the queue. */ char* DequeueMessage() { char* message = NULL; pthread_mutex_lock(&g_queue_mutex); while (IsQueueEmpty()) { pthread_cond_wait(&g_queue_not_empty_cond, &g_queue_mutex); } message = g_queue[g_queue_start]; g_queue_start = (g_queue_start + 1) % MAX_QUEUE_SIZE; g_queue_size--; pthread_mutex_unlock(&g_queue_mutex); return message; }
/** Event notification function registered for EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL.WaitForKeyEx and EFI_SIMPLE_TEXT_INPUT_PROTOCOL.WaitForKey. @param Event Event to be signaled when a key is pressed. @param Context Points to USB_KB_DEV instance. **/ VOID EFIAPI USBKeyboardWaitForKey ( IN EFI_EVENT Event, IN VOID *Context ) { USB_KB_DEV *UsbKeyboardDevice; EFI_KEY_DATA KeyData; EFI_TPL OldTpl; UsbKeyboardDevice = (USB_KB_DEV *) Context; // // Enter critical section // OldTpl = gBS->RaiseTPL (TPL_NOTIFY); // // WaitforKey doesn't suppor the partial key. // Considering if the partial keystroke is enabled, there maybe a partial // keystroke in the queue, so here skip the partial keystroke and get the // next key from the queue // while (!IsQueueEmpty (&UsbKeyboardDevice->EfiKeyQueue)) { // // If there is pending key, signal the event. // CopyMem ( &KeyData, UsbKeyboardDevice->EfiKeyQueue.Buffer[UsbKeyboardDevice->EfiKeyQueue.Head], sizeof (EFI_KEY_DATA) ); if (KeyData.Key.ScanCode == SCAN_NULL && KeyData.Key.UnicodeChar == CHAR_NULL) { Dequeue (&UsbKeyboardDevice->EfiKeyQueue, &KeyData, sizeof (EFI_KEY_DATA)); continue; } gBS->SignalEvent (Event); break; } // // Leave critical section and return // gBS->RestoreTPL (OldTpl); }
void Level_Traverse(node *ptr) { InitializeQueue(); Put(ptr); while (!IsQueueEmpty()) { ptr = Get(); Display(ptr); if (ptr->left != head) Put(ptr->left); if (ptr->mid != head) Put(ptr->mid); if (ptr->right != head) Put(ptr->right); } }
/** Internal function to read the next keystroke from the keyboard buffer. @param UsbKeyboardDevice USB keyboard's private structure. @param KeyData A pointer to buffer to hold the keystroke data for the key that was pressed. @retval EFI_SUCCESS The keystroke information was returned. @retval EFI_NOT_READY There was no keystroke data availiable. @retval EFI_DEVICE_ERROR The keystroke information was not returned due to hardware errors. @retval EFI_INVALID_PARAMETER KeyData is NULL. @retval Others Fail to translate keycode into EFI_INPUT_KEY **/ EFI_STATUS USBKeyboardReadKeyStrokeWorker ( IN OUT USB_KB_DEV *UsbKeyboardDevice, OUT EFI_KEY_DATA *KeyData ) { if (KeyData == NULL) { return EFI_INVALID_PARAMETER; } if (IsQueueEmpty (&UsbKeyboardDevice->EfiKeyQueue)) { return EFI_NOT_READY; } Dequeue (&UsbKeyboardDevice->EfiKeyQueue, KeyData, sizeof (*KeyData)); return EFI_SUCCESS; }
void Dequeue(struct queue *queue) { if (IsQueueEmpty(queue)) { return; } struct queuenode *temp = queue->rear; if (queue->front == queue->rear) queue->front = NULL; queue->rear = queue->rear->prev; if (queue->rear) queue->rear->next = NULL; free(temp); queue->count--; }
plNetMessage* plNetClientStreamRecorder::IGetNextMessage() { plNetMessage* msg = nil; if (!IsQueueEmpty() && GetNextMessageTimeDelta() <= 0 ) { msg = plNetMessage::ConvertNoRef(GetResMgr()->ReadCreatableVersion(fRecordStream)); // msg->SetPeeked(true); // Fix the flags on game messages, so we won't get an assert later plNetMsgGameMessage* gameMsg = plNetMsgGameMessage::ConvertNoRef(msg); if (gameMsg) { plMessage* plMsg = gameMsg->GetContainedMsg(GetResMgr()); plNetClientApp::GetInstance()->UnInheritNetMsgFlags(plMsg); // write message (and label) to ram stream hsRAMStream stream; GetResMgr()->WriteCreatable(&stream, plMsg); // put stream in net msg wrapper gameMsg->StreamInfo()->CopyStream(&stream); // gameMsg->StreamInfo()->SetStreamType(plMsg->ClassIndex()); // type of game msg } double nextPlaybackTime = fRecordStream->ReadLEDouble(); if (nextPlaybackTime < fNextPlaybackTime) fBetweenAges = true; fNextPlaybackTime = nextPlaybackTime; // If this was the last message, stop playing back if (fRecordStream->AtEnd()) { fRecordStream->Close(); delete fRecordStream; fRecordStream = nil; } } return msg; }
int main() { Queue q; int nData = 0; int nLength = 0; BOOL bEmpty = FALSE; InitQueue(&q); EnQueue(&q, 12); EnQueue(&q, 3); EnQueue(&q, 8); EnQueue(&q, 34); EnQueue(&q, 6); EnQueue(&q, 9); EnQueue(&q, 56); EnQueue(&q, 78); EnQueue(&q, 4); EnQueue(&q, 90); printf("入队后的队列:"); TraverseQueue(&q, OutputQueue); nLength = GetQueueLength(&q); printf("队列长度:%d\n", nLength); bEmpty = IsQueueEmpty(&q); printf("队列为%s\n", bEmpty ? "空" : "非空"); DeQueue(&q, &nData); printf("出队数据:%d\n", nData); printf("出队后的队列:"); TraverseQueue(&q, OutputQueue); DeQueue(&q, &nData); printf("出队数据:%d\n", nData); printf("出队后的队列:"); TraverseQueue(&q, OutputQueue); DestroyQueue(&q); return 0; }
void AddToReadyQueueNotPriority(ProcessControlBlock **head, ProcessControlBlock *pcb) { ProcessControlBlock *tmp; ProcessControlBlock *prev; if (IsQueueEmpty(*head)) { *head = pcb; (*head)->nextPCB = NULL; return; } tmp = *head; while (tmp != NULL) { prev = tmp; tmp = tmp->nextPCB; } prev->nextPCB = pcb; // insert in the Middle & End pcb->nextPCB = tmp; }
int main(){ int value =0; QueType* queue; QueType* q1 = QueType* q2 = NULL; printf("enter value; %d\n", value); scanf("%d\n",&value); queue = CreateQueue(); while(value <= 7){ Enqueue(queue,value); value++; printf("\n Elements in the queue are:\n"); printqueue(queue,value); } /* Print all the items */ while(!IsQueueEmpty(queue)){ Dequeue(queue,&value); printf("%d\n",value); } DestroyQueue(queue); return 0; }
ProcessControlBlock *DeQueueWithDiskId(ProcessControlBlock **head, INT32 disk_id) { ProcessControlBlock *tmp = *head; ProcessControlBlock *prev = NULL; if (IsQueueEmpty(*head)) { return NULL; } while (tmp != NULL) { if ( (tmp->disk_io.disk_id == disk_id) ) { // && (tmp->state != PROCESS_STATE_TERMINATE) //First one if (tmp == *head) { *head = tmp->nextPCB; tmp->nextPCB = NULL; return tmp; } // last one else if (tmp->nextPCB == NULL) { prev->nextPCB = NULL; return tmp; } else { // middile prev->nextPCB = tmp->nextPCB; tmp->nextPCB = NULL; return tmp; } } prev = tmp; tmp = tmp->nextPCB; } if ( (tmp == NULL) &&(prev != NULL) ) return NULL; }
int CQueue::DeQueue(void) { if(!IsQueueEmpty()) { switch(label) { case SEQ: { return p->arrayQueue[++p->front]; } case CYCLE: { q->front=(q->front+1)%MAXLEN; q->queueLen--; return q->arrayQueue[q->front]; } case CHAIN: { int x=r->front->data; queueNode *r_1; r_1=r->front; r->front=r->front->next; if(r->front==NULL) r->rear=NULL; delete r_1; return x; } default: { return 0; break; } } } return 0; }
void main(void) { /* put your own code here */ SET_TCNT_PRESCALE( TCNT_PRESCALE_8); TSCR1 = TSCR1_INIT; seg_init(); CANinit(THE_FLOOR); SET_BITS(LED_DDR, LED1_MASK|LED2_MASK); node_id = PORTB & 3; //get hardware specified node id while (!(CANCTL0&0x10)); CANRFLG = 0xC3; CANRIER = 0x01; InitializeQueue(&rec); // Create the Recieve Queue clear_seg(); EnableInterrupts; for(;;) { if(IsQueueEmpty(rec) != 0) { DeQueue(&rec); Parse_Floor(); } // button 1 press if((PTJ & (SWITCH1_MASK |SWITCH2_MASK) )== SWITCH1_MASK) { if(THE_FLOOR == F1 || THE_FLOOR == F2) { if (last != SWITCH1_MASK) { // check if button already pressed data[0] = THE_FLOOR; data[1] = CALL_SWITCH1; data[2] = UP; (void)CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data); last = SWITCH1_MASK; } } else if(THE_FLOOR == F3) { if (last != SWITCH1_MASK) { // check if button already pressed data[0] = THE_FLOOR; data[1] = CALL_SWITCH1; data[2] = DOWN; (void)CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data); last = SWITCH1_MASK; } } } //button 2 press else if((PTJ & (SWITCH1_MASK |SWITCH2_MASK) )== SWITCH2_MASK) { if(THE_FLOOR == F2) { if (last != SWITCH2_MASK) { // check if button already pressed data[0] = THE_FLOOR; data[1] = CALL_SWITCH2; data[2] = DOWN; CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data); last = SWITCH2_MASK; } } } else last = 0; // Updates the LED FORCE_BITS(PTS,0b00001100 , led) ; } /* loop forever */ /* please make sure that you never leave main */ }
VOID SerialStartOrQueue( IN PSERIAL_DEVICE_EXTENSION Extension, IN WDFREQUEST Request, IN WDFQUEUE QueueToExamine, IN WDFREQUEST *CurrentOpRequest, IN PSERIAL_START_ROUTINE Starter ) /*++ Routine Description: This routine is used to either start or queue any requst that can be queued in the driver. Arguments: Extension - Points to the serial device extension. Request - The request to either queue or start. In either case the request will be marked pending. QueueToExamine - The queue the request will be place on if there is already an operation in progress. CurrentOpRequest - Pointer to a pointer to the request the is current for the queue. The pointer pointed to will be set with to Request if what CurrentOpRequest points to is NULL. Starter - The routine to call if the queue is empty. Return Value: --*/ { NTSTATUS status; PREQUEST_CONTEXT reqContext; WDF_REQUEST_PARAMETERS params; reqContext = SerialGetRequestContext(Request); WDF_REQUEST_PARAMETERS_INIT(¶ms); WdfRequestGetParameters( Request, ¶ms); // // If this is a write request then take the amount of characters // to write and add it to the count of characters to write. // if (params.Type == WdfRequestTypeWrite) { Extension->TotalCharsQueued += reqContext->Length; } else if ((params.Type == WdfRequestTypeDeviceControl) && ((params.Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR) || (params.Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_XOFF_COUNTER))) { reqContext->IoctlCode = params.Parameters.DeviceIoControl.IoControlCode; // We need this in the destroy callback Extension->TotalCharsQueued++; } if (IsQueueEmpty(QueueToExamine) && !(*CurrentOpRequest)) { // // There were no current operation. Mark this one as // current and start it up. // *CurrentOpRequest = Request; Starter(Extension); return; } else { // // We don't know how long the request will be in the // queue. If it gets cancelled while waiting in the queue, we will // be notified by EvtCanceledOnQueue callback so that we can readjust // the lenght or free the buffer. // reqContext->Extension = Extension; // We need this in the destroy callback status = WdfRequestForwardToIoQueue(Request, QueueToExamine); if(!NT_SUCCESS(status)) { TraceEvents(TRACE_LEVEL_ERROR, DBG_READ, "WdfRequestForwardToIoQueue failed%X\n", status); ASSERTMSG("WdfRequestForwardToIoQueue failed ", FALSE); SerialCompleteRequest(Request, status, 0); } return; } }