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     ! 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.