Return to queue.c CVS log

Up to [Previous NeXT emulator] / previous / src

Annotation of previous/src/queue.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *          File: queue.c
                      3:  *        Author: Robert I. Pitts <[email protected]>
                      4:  * Last Modified: March 9, 2000
                      5:  *         Topic: Queue - Array Implementation
                      6:  * ----------------------------------------------------------------
                      7:  */
                      8: 
                      9: #include <stdio.h>
                     10: #include <stdlib.h>                  
                     11: #include "queue.h"       
                     12: 
                     13: /*
                     14:  * Constants
                     15:  * ---------
                     16:  * MAX_QUEUE_SIZE = Largest number of items queue can hold.
                     17:  */
                     18: 
                     19: #define MAX_QUEUE_SIZE  100
                     20: 
                     21: /*
                     22:  * struct queueCDT gives the implementation of a queue.
                     23:  * It holds the information that we need for each queue.
                     24:  */
                     25: typedef struct queueCDT {
                     26:   queueElementT contents[MAX_QUEUE_SIZE];
                     27:   int front;
                     28:   int count;
                     29: } queueCDT;
                     30: 
                     31: queueADT QueueCreate(void)
                     32: {
                     33:   queueADT queue;
                     34: 
                     35:   queue = (queueADT)malloc(sizeof(queueCDT));
                     36: 
                     37:   if (queue == NULL) {
                     38:     fprintf(stderr, "Insufficient Memory for new Queue.\n");
                     39:     exit(ERROR_MEMORY);  /* Exit program, returning error code. */
                     40:   }
                     41: 
                     42:   queue->front = 0;
                     43:   queue->count = 0;
                     44: 
                     45:   return queue;
                     46: }
                     47: 
                     48: void QueueDestroy(queueADT queue)
                     49: {
                     50:   free(queue);
                     51: }
                     52: 
                     53: void QueueEnter(queueADT queue, queueElementT element)
                     54: {
                     55:   int newElementIndex;
                     56: 
                     57:   if (queue->count >= MAX_QUEUE_SIZE) {
                     58: //    fprintf(stderr, "QueueEnter on Full Queue.\n");
                     59: //    exit(ERROR_QUEUE);  /* Exit program, returning error code. */
                     60:        return;
                     61:   }
                     62: 
                     63:   /*
                     64:    * Calculate index at which to put
                     65:    * next element.
                     66:    */
                     67:   newElementIndex = (queue->front + queue->count)
                     68:                     % MAX_QUEUE_SIZE;
                     69:   queue->contents[newElementIndex] = element;
                     70: //printf("element %d, pointer to %d, [%s]\n",newElementIndex,element,element);
                     71: 
                     72:   queue->count++;
                     73: }
                     74: 
                     75: int QueuePeek(queueADT queue)
                     76: {
                     77: return queue->count;
                     78: }
                     79: 
                     80: queueElementT QueueDelete(queueADT queue)
                     81: {
                     82:   queueElementT oldElement;
                     83: 
                     84:   if (queue->count <= 0) {
                     85:     //fprintf(stderr, "QueueDelete on Empty Queue.\n");
                     86:     //exit(ERROR_QUEUE);  /* Exit program, returning error code. */
                     87:        return NULL;
                     88:   }
                     89: 
                     90:   /* Save the element so we can return it. */
                     91:   oldElement = queue->contents[queue->front];
                     92: 
                     93:   /*
                     94:    * Advance the index of the front,
                     95:    * making sure it wraps around the
                     96:    * array properly.
                     97:    */
                     98:   queue->front++;
                     99:   queue->front %= MAX_QUEUE_SIZE;
                    100:        
                    101: //printf("dequing @%d [%s]\n",oldElement,oldElement);
                    102: 
                    103:   queue->count--;
                    104: 
                    105:   return oldElement;
                    106: }
                    107: 
                    108: int QueueIsEmpty(queueADT queue)
                    109: {
                    110:   return queue->count <= 0;
                    111: }
                    112: 
                    113: int QueueIsFull(queueADT queue)
                    114: {
                    115:   return queue->count >= MAX_QUEUE_SIZE;
                    116: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.