Return to queues.c CVS log

Up to [Research Unix] / researchv10no / cmd / visi

Annotation of researchv10no/cmd/visi/queues.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *      queues.c 1.4
                      3:  *
                      4:  *     Queue Handling Functions for Spreadsheet Program `vis'
                      5:  *
                      6:  *      A. F. Gettier
                      7:  *      Bell Laboratories
                      8:  *      Update made 11/1/82 11:13:33
                      9:  *      Retrieved 11/15/82 13:22:42
                     10:  */
                     11: #include       "vis.h"
                     12: #include       <stdio.h>
                     13: 
                     14: /*LINTLIBRARY*/
                     15: /*
                     16:  *     Add to the end of a queue
                     17:  */
                     18: void qadd( hdr, val )
                     19: struct qheader *hdr;
                     20: struct node    *val;
                     21: {
                     22:        struct qentry   *t, *a, *b;
                     23:        struct node     *x;
                     24:        t = NODE( qentry );
                     25:        t->next = 0;
                     26:        t->nodeptr = val;
                     27:        a = hdr->first;
                     28:        b = 0;
                     29:        if ( a == 0 ) {
                     30:                hdr->first = hdr->last = t;
                     31:                return;
                     32:        }
                     33:        loop {
                     34:                x = a->nodeptr;
                     35:                /*
                     36:                 *      don't enter if present
                     37:                 */
                     38:                if ( (val->row == x->row && val->col < x->col )
                     39:                    || val->row < x->row ) {
                     40:                        b = a;
                     41:                        a = a->next;
                     42:                        if ( a == 0 ) {
                     43:                                b->next = hdr->last = t;
                     44:                                return;
                     45:                        }
                     46:                }
                     47:                else {
                     48:                        if (val->row == x->row && val->col == x->col )
                     49:                                return;
                     50:                        if ( b == 0 ) {
                     51:                                t->next = hdr->first;
                     52:                                hdr->first = t;
                     53:                        }
                     54:                        else {
                     55:                                t->next = b->next;
                     56:                                b->next = t;
                     57:                        }
                     58:                        return;
                     59:                }
                     60:        }
                     61: }
                     62: 
                     63: 
                     64: 
                     65: /*
                     66:  *     Read from the front of a queue
                     67:  */
                     68: struct node *qread( hdr )
                     69: struct qheader *hdr;
                     70: {
                     71:        struct node     *t;
                     72:        struct qentry   *s;
                     73:        if ( hdr->first == 0 )  return( 0 );
                     74:        t = (hdr->first)->nodeptr;
                     75:        s = (hdr->first)->next;
                     76:        free( (char *)hdr->first );
                     77:        hdr->first = s;
                     78:        if ( s == 0 ) hdr->last = 0;
                     79:        return( t );
                     80: }
                     81: 
                     82: 
                     83: 
                     84: /*
                     85:  *     Empty a queue
                     86:  */
                     87: void qempty( hdr )
                     88: struct qheader *hdr;
                     89: {
                     90:        struct qentry   *t;
                     91:        while ( hdr->first != 0 ) {
                     92:                t = hdr->first;
                     93:                free( (char *)hdr->first );
                     94:                hdr->first = t;
                     95:        }
                     96:        hdr->last = 0;
                     97: }
                     98: 
                     99: 
                    100: 
                    101: /*
                    102:  *     Initialize a queue
                    103:  */
                    104: void qinit( hdr )
                    105: struct qheader *hdr;
                    106: {
                    107:        hdr->first = 0;
                    108:        hdr->last = 0;
                    109: }
                    110: 
                    111: 
                    112: 
                    113: /*
                    114:  *     Copy a Queue
                    115:  */
                    116: struct qheader *qcopy( hdr )
                    117: struct qheader *hdr;
                    118: {
                    119:        struct qheader  *t;
                    120:        struct qentry   *s, *s1;
                    121:        t = NODE( qheader );
                    122:        t->first = 0;
                    123:        t->last = 0;
                    124:        s1 = hdr->first;
                    125:        while( s1 != 0 ) {
                    126:                s = NODE( qentry );
                    127:                if ( t->first == 0 )
                    128:                        t->first = s;
                    129:                else 
                    130:                        (t->last)->next = s;
                    131:                t->last = s;
                    132:                s->next = 0;
                    133:                s->nodeptr = s1->nodeptr;
                    134:                s1 = s1->next;
                    135:        }
                    136:        return( t );
                    137: }

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