Return to queue.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / sys

Annotation of researchv9/jerq/src/lib/sys/queue.c, revision 1.1.1.1

1.1       root        1: #define QUEUE_C
                      2: #include <queue.h>
                      3: #include <setup.h>
                      4: 
                      5: /*
                      6:  * These macros are for speed, not size.
                      7:  */
                      8: #define pswmax()       asm("   PUSHW   %psw    ");\
                      9:                        asm("   ORW2    &0x1e000,%psw ");\
                     10:                        asm("   TSTW    %r0     ")
                     11: 
                     12: #define pswback()      asm("   POPW    %psw    ");\
                     13:                        asm("   TSTW    %r0     ")
                     14: qinit(){
                     15:        register i;
                     16: 
                     17:        for(i=1; i<NCHARS-1; i++)
                     18:                cbuf_next[i] = i+1;
                     19:        cbuf_next[i] = 0;
                     20:        freelist=1;
                     21:        freemark = (9*NCHARS)/10;
                     22: }
                     23: qputc(q, w)
                     24:        register struct clist *q;
                     25:        int w;
                     26: {
                     27:        register p;
                     28:        pswmax();
                     29:        p=freelist;
                     30:        if(p==0 || (freemark <= 0 && !(q->state & QPRIORITY))){
                     31:                pswback();
                     32:                if(!VALDWNLDFLAG )
                     33:                        ringbell();     /* send a warning to the user */
                     34:                return(0);
                     35:        }
                     36:        freelist=cbuf_next[p];
                     37:        --freemark;
                     38:        cbuf_next[p]=0;
                     39:        cbuf_word[p]=w;
                     40:        if(q->c_cc==0)
                     41:                q->c_head=q->c_tail=p;
                     42:        else{
                     43:                cbuf_next[q->c_tail]=p;
                     44:                q->c_tail=p;
                     45:        }
                     46:        p = ++q->c_cc;
                     47:        pswback();
                     48:        return(p);
                     49: }
                     50: qputstr(q, str)
                     51:        register struct clist *q;
                     52:        register char *str;
                     53: {
                     54:        register retval;
                     55:        do; while(*str && ((retval=qputc(q, *str++))>=0));
                     56:        return retval;
                     57: }
                     58: qgetc(q)
                     59:        register struct clist *q;
                     60: {
                     61:        register p;
                     62:        register x;
                     63:        pswmax();
                     64:        if((p=q->c_head)==0){
                     65:                pswback();
                     66:                return(-1);
                     67:        }
                     68:        if(--q->c_cc==0)
                     69:                q->c_head=q->c_tail=0;
                     70:        else
                     71:                q->c_head=cbuf_next[p];
                     72:        cbuf_next[p]=freelist;
                     73:        x=cbuf_word[p];
                     74:        freelist=p;
                     75:        ++freemark;
                     76:        pswback();
                     77:        return(x);
                     78: }
                     79: qclear(q)
                     80:        register struct clist *q;
                     81: {
                     82:        pswmax();
                     83:        if(q->c_cc == 0){
                     84:                pswback();
                     85:                return;
                     86:        }
                     87:        freemark += q->c_cc;
                     88:        q->c_cc=0;
                     89:        cbuf_next[q->c_tail]=freelist;
                     90:        freelist=q->c_head;
                     91:        q->c_head=0;
                     92:        q->c_tail=0;
                     93:        q->state=0;
                     94:        pswback();
                     95: }
                     96: qpeekc(q)
                     97:        register struct clist *q;
                     98: {
                     99:        register p;
                    100:        return (p=q->c_head) ? cbuf_word[p] : -1;
                    101: }

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