Return to task.c CVS log

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

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

1.1       root        1: #include <jerq.h>
                      2: #include <layer.h>
                      3: #define        TASK_C
                      4: #include <jerqproc.h>
                      5: 
                      6: #define STACK  16
                      7: int    swstk[STACK];
                      8: int    swpcbp[20];
                      9: extern int (*Sys[])();         /* pcb for the switcher */
                     10: #define        PSW     0x281A100       /* ipl 13 */
                     11: 
                     12: struct Proc *
                     13: newproc(f)
                     14:        int (*f)();
                     15: {
                     16:        register struct Proc *u;
                     17:        register i;
                     18:        for(i=0,u=proctab; i<NPROC; i++,u++) {
                     19:                if((u->state&BUSY)==0){
                     20:                        u->state |= BUSY;
                     21:                        restart(u, f);
                     22:                        u->layer=0;
                     23:                        u->nchars=0;
                     24:                        u->cbufpin=u->cbuf;
                     25:                        u->cbufpout=u->cbuf;
                     26:                        u->traptype=0;
                     27:                        u->traploc=0;
                     28:                        u->defaultfont = (struct Font*)Sys[1];
                     29:                        return u;
                     30:                }
                     31:        }
                     32:        return 0;
                     33: }
                     34: restart(p, loc)
                     35:        register struct Proc *p;
                     36:        register (*loc)();
                     37: {
                     38:        register i;
                     39:        p->pcb.psw=PSW;
                     40:        p->pcb.pc=(char(*)())loc;
                     41:        p->pcb.sp=(int)(p->stack);
                     42:        p->pcb.lower=p->pcb.sp;
                     43:        p->pcb.upper=p->pcb.lower+STKSIZ;
                     44:        p->pcb.ap=p->pcb.sp;
                     45:        p->pcb.fp=p->pcb.sp;
                     46:        for(i=8; i>=0; i--)
                     47:                p->pcb.reg[i]=0;
                     48:        p->pcb.blkmv=0; /* no block moves */
                     49:        p->text=(char *)(loc);
                     50: }
                     51: sw(run){
                     52:        if(!run)
                     53:                setnorun(P);
                     54:        callps(swpcbp);
                     55:        return;
                     56: }
                     57: switcher()
                     58: {
                     59:        register struct Proc *p=P;
                     60:        for(;;){
                     61:                p++;    /* 'cos we are the current p */
                     62:                if(p>=&proctab[NPROC])
                     63:                        p=proctab;
                     64:                if((p->state&(RUN|ZOMBIE))==RUN)
                     65:                        resume(P=p);
                     66:        }
                     67: }
                     68: swinit()
                     69: {
                     70:        register int * pcbptr = swpcbp;
                     71: 
                     72:        *pcbptr=0x281a180;              /* psw, r+i bits set only */
                     73:        *(pcbptr+1)=(int)switcher;      /* initial pc */
                     74:        *(pcbptr+2)=(int)swstk;         /* initial stack */
                     75:        *(pcbptr+3)=0x1a100;
                     76:        *(pcbptr+4)=(int)switcher;      /* initial pc */
                     77:        *(pcbptr+5)=(int)swstk;
                     78:        *(pcbptr+6)=(int)swstk;
                     79:        *(pcbptr+7)=(int)&swstk[STACK-1];
                     80:        *(pcbptr+8)=(int)swstk; /* ap */
                     81:        *(pcbptr+9)=(int)swstk; /* fp */
                     82:        *(pcbptr+19)=0;         /* no block moves */
                     83: };

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