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