Return to boot.c CVS log

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

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

1.1       root        1: #include <jerq.h>
                      2: #include <layer.h>
                      3: #include <jerqproc.h>
                      4: #include "../msgs.h"
                      5: 
                      6: long getlong();
                      7: 
                      8: extern Texture cup;
                      9: 
                     10: boot(){
                     11:        register argc;
                     12:        register char **argv;
                     13:        register char *address;
                     14:        char *bootaddress;
                     15:        char *Ualloc();
                     16:        register unsigned nbytes, nargchars;
                     17:        register long i, amtloaded;
                     18:        int text, data, bss;
                     19: 
                     20:        Urequest(MOUSE);
                     21:        Ucursswitch(&cup);
                     22:        argc=getlong();
                     23:        nargchars=getlong();
                     24:        argv=(char **)Ualloc(nargchars+(argc+1)*sizeof(char *));
                     25:        if(argv==0)
                     26:                address==0;
                     27:        else{
                     28:                text=getlong();
                     29:                data=getlong();
                     30:                bss=getlong();
                     31:                nbytes=text+data;       /* the amount to be downloaded */
                     32:                address=Ualloc((unsigned)(nbytes+bss+4));
                     33:                if (((unsigned)address) & 4)
                     34:                        address += 4;
                     35:                bootaddress=address;
                     36:        }
                     37:        P->data=address+text;
                     38:        P->bss=P->data+data;
                     39:        muxublk(P);
                     40:        muxmesg((int)(P-proctab), C_PUSHLD);
                     41:        sendwithdelim(4, &bootaddress);
                     42:        bldargs(argc, argv);
                     43: #define Y(a) (P->rect.corner.y-muldiv(P->rect.corner.y-P->rect.origin.y, a, nbytes))
                     44:        amtloaded=0;
                     45:        for(i=0; i<nbytes; i++){
                     46:                *address++=getchar();
                     47:                if(P->state&(RESHAPED|MOVED)){
                     48:                        if(!(P->state&MOVED))
                     49:                                amtloaded=0;
                     50:                        P->state&=~(RESHAPED|MOVED);
                     51:                }
                     52:                if((i&127)==0){
                     53:                        lrectf(P->layer, Rect(P->rect.origin.x, Y(i),
                     54:                                P->rect.corner.x, Y(amtloaded)), F_XOR);
                     55:                        amtloaded=i;
                     56:                }
                     57:        }
                     58:        muxublk(P);
                     59:        clear(P->rect, 1);
                     60:        Urequest(0);
                     61:        P->text=bootaddress;
                     62:        P->state|=USER;
                     63:        setdata(P);
                     64: #define        udp     ((struct udata *)P->data)
                     65:        udp->argc=argc;
                     66:        udp->argv=argv; /* these get set as arguments to main in notsolow.o */
                     67:        if(P->state&ZOMBOOT){
                     68:                P->state&=~ZOMBOOT;
                     69:                P->state|=ZOMBIE;
                     70:                zombexec(P->text);
                     71:        }
                     72:        exec(P->text);
                     73: }
                     74: bldargs(argc, argv)
                     75:        register char **argv;
                     76: {
                     77:        register i;
                     78:        register char *p=(char *)(argv+argc+1);
                     79:        for(i=0; i<argc; i++){
                     80:                *argv++=p;
                     81:                do
                     82:                        *p=getchar();
                     83:                while(*p++);
                     84:        }
                     85:        *argv++=0;
                     86: }
                     87: setdata(p)
                     88:        register struct Proc *p;
                     89: {
                     90:        register struct udata *u=((struct udata *)p->data);
                     91:        u->Drect=p->rect;
                     92:        u->Jdisplayp=p->layer;
                     93: }
                     94: getchar(){
                     95:        register c;
                     96:        register struct Proc *p=P;
                     97: 
                     98:        while(p->nchars==0){
                     99:                muxublk(p);
                    100:                sw(0);
                    101:        }
                    102:        c = *(p->cbufpout)++;
                    103:        if(p->cbufpout >= &p->cbuf[sizeof(p->cbuf)])
                    104:                p->cbufpout = p->cbuf;
                    105:        if((--p->nchars)==0)
                    106:                muxublk(p);     /* shouldn't be necessary, but... */
                    107:        return c;
                    108: }
                    109: 
                    110: long
                    111: getlong(){
                    112:        long l;
                    113:        register char *p=(char *)&l;
                    114:        register i;
                    115:        for(i=0; i<4; i++)
                    116:                *p++=getchar();
                    117:        return(l);
                    118: }
                    119: 
                    120: shutdown(p)
                    121:        register struct Proc *p;
                    122: {
                    123:        extern struct Proc *debugger;
                    124:        extern struct Proc *kbdproc;
                    125:        Lbox(p->layer);
                    126:        setborder(p);
                    127:        if(debugger==p)
                    128:                debugger=0;
                    129:        muxublk(p);
                    130:        p->state&=~(KBDLOCAL|MOUSELOCAL|GOTMOUSE|USER);
                    131:        p->nticks=0;
                    132:        p->inhibited=0;
                    133:        qclear(&p->kbdqueue);
                    134:        if((p->state&ZOMBIE)==0)
                    135:                freemem(p);
                    136: }
                    137: freemem(p)
                    138:        register struct Proc *p;
                    139: {
                    140:        extern int end;
                    141:        extern int windowstart();
                    142:        freeall((char *)p);
                    143:        clearname(p);
                    144: }

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