Return to comm.c CVS log

Up to [Research Unix] / researchv10dc / 630 / src

Annotation of researchv10dc/630/src/comm.c, revision 1.1.1.1

1.1       root        1: #include <jerq.h>
                      2: #include <layer.h>
                      3: #include <queue.h>
                      4: #include <jerqproc.h>
                      5: #include <setup.h>
                      6: #include <kbd.h>
                      7: 
                      8: #ifdef BLITKBD
                      9: #define        REBOOTKEY       0xEC    /* ctrl-shift-BREAK */
                     10: #else
                     11: #define        REBOOTKEY       0x81    /* discon */
                     12: #endif
                     13: extern int doubleclickOK;
                     14: 
                     15: /*
                     16:  * clockroutine() called at video interrupt time.
                     17:  *     reads chars off the keyboard, sends things to host
                     18:  */
                     19: 
                     20: short          second;
                     21: short          ticks;
                     22: extern long    ticks0;
                     23: extern char    *patchedspot;
                     24: extern char    patch;
                     25: extern int     kbdrepeat;
                     26: #define        CONTROL 1
                     27: 
                     28: clockroutine()
                     29: {
                     30:        register c;
                     31:        extern struct Proc *kbdproc;
                     32:        register struct Proc *p;
                     33:        register char *upc;     /*SFBOTCH*/
                     34: 
                     35:        ticks0++;
                     36:        if(--ticks<=0){
                     37:                ticks=60;       /* really HZ */
                     38:                second=1;
                     39:        }
                     40: 
                     41:        for(p= &proctab[CONTROL+1]; p<&proctab[NPROC]; p++)
                     42:                if(p->nticks>0 && --p->nticks==0)
                     43:                        p->state|=WAKEUP|RUN;
                     44:        setrun(&proctab[CONTROL]);
                     45:        if((p=kbdproc)==0 && qpeekc(&KBDQUEUE) != 0x8E)
                     46:                return;
                     47:        while(KBDQUEUE.c_cc>0){
                     48:                doubleclickOK=0;
                     49:                c=qgetc(&KBDQUEUE);
                     50:                if(c==0x8E){    /* SHIFT-SETUP; show what's up */
                     51:                        rectf(&display, P->rect, F_XOR);
                     52:                        do auto4(); while(button123()==0);
                     53:                        if(button2()){
                     54:                                /*SFBOTCHchar **/upc=(char *)P->pcb.pc;
                     55:                                patchedspot=upc;
                     56:                                patch= *upc;
                     57:                                *upc=0x14;      /* EXTOP trap */
                     58:                        }
                     59:                        rectf(&display, P->rect, F_XOR);
                     60:                        do auto4(); while(button123());
                     61:                }else if(c==REBOOTKEY)
                     62:                        reboot();
                     63:                else
                     64:                        qputc(&p->kbdqueue, c);
                     65:                if(p->state&KBDLOCAL)
                     66:                        p->state|=WAKEUP;
                     67:        }
                     68: #ifndef        BLITKBD
                     69:        if((kbdrepeat&(RPTHAVECHR|RPTON)) && (ticks&1)==0)
                     70:                kbdrpt();
                     71: #endif
                     72:        givemouse(p);
                     73: }
                     74: givemouse(p)
                     75:        register struct Proc *p;
                     76: {
                     77:                register struct Mouse *m;       /*SFBOTCH*/
                     78:        if((p->state&(MOUSELOCAL|USER)) == (MOUSELOCAL|USER)){
                     79:                /*SFBOTCHregister struct Mouse * */m= &((struct udata *)p->data)->mouse;
                     80:                *m=mouse;
                     81:        }
                     82: }
                     83: sleep(s){
                     84:        register struct Proc *p=P;
                     85:        register alarmed=p->state&ALARMREQD;
                     86:        register long nticks;
                     87:        extern long ticks0;
                     88:        nticks=ticks0+p->nticks;
                     89:        alarm(s);
                     90:        Uwait(ALARM);
                     91:        /* a little dance because sleep calls alarm */
                     92:        if(alarmed){
                     93:                spl1();
                     94:                if(nticks>ticks0)
                     95:                        p->nticks=nticks-ticks0;
                     96:                else    /* we missed his wakeup! */
                     97:                        p->state|=WAKEUP;
                     98:                spl0();
                     99:                p->state|=ALARMREQD;
                    100:        }else
                    101:                p->state&=~ALARMREQD;
                    102: }
                    103: alarm(s){
                    104:        P->state|=ALARMREQD;
                    105:        if(s>0)
                    106:                P->nticks=s;
                    107: }

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