Return to aj.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / apl

Annotation of 3BSD/cmd/apl/aj.c, revision 1.1

1.1     ! root        1: #include "apl.h"
        !             2: 
        !             3: clear()
        !             4: {
        !             5:        register struct nlist *n;
        !             6:        extern freelist[];
        !             7: 
        !             8:        for(n=nlist; n->namep; n++) {
        !             9:                n->itemp = 0;
        !            10:                n->use = 0;
        !            11:                n->namep = 0;
        !            12:                }
        !            13:                freelist[0] = 0;
        !            14:                freelist[1] = -1;       /*empty free list*/
        !            15:                /* brk(memstart);       /*shrink core*/
        !            16:                stack = sp = 0;
        !            17:                Reset();
        !            18: }
        !            19: 
        !            20: lsize(s)
        !            21: char *s;
        !            22: {
        !            23:        register short i;
        !            24:        register char *p;
        !            25: 
        !            26:        i=1;
        !            27:        p=s;
        !            28:        while (*p++) i++;
        !            29:        return(i);
        !            30: }
        !            31: 
        !            32: isize(ip)
        !            33: struct item *ip;
        !            34: {
        !            35:        register struct item *p;
        !            36:        register i;
        !            37: 
        !            38:        p=ip;
        !            39:        i=sizeof *p + p->rank*SINT;
        !            40:        if(p->type == DA)
        !            41:                i += p->size*SDAT; else
        !            42:        if(p->type == CH)
        !            43:                i += p->size;
        !            44:        return(i);
        !            45: }
        !            46: 
        !            47: wsload(ffile)
        !            48: {
        !            49:        long b [ 256 ];
        !            50:        int     ibuf, obuf;
        !            51:        char name[NAMS];
        !            52:        short  iz;
        !            53:        long    vmagic[1];
        !            54:        register i;
        !            55:        register struct nlist *n;
        !            56:        register struct item *p;
        !            57:        char ch[1];
        !            58: 
        !            59:        iz = 0;
        !            60:        ibuf = ffile;
        !            61:        /* ibuf[1] = ibuf[2] = 0;*/
        !            62: /* Check for correct magic number */
        !            63:        read(ibuf,vmagic,4);
        !            64:        if(vmagic[0] != (long)MAGIC) {
        !            65:                close(ffile);
        !            66:                error("not a ws");
        !            67:        }
        !            68:        read(ibuf,&thread,sizeof thread);
        !            69:        while(read(ibuf,&iz,2) == 2) {
        !            70:                i = iz.c[1];
        !            71: /* read name of vbl or fn */
        !            72:                read(ibuf,name,i);
        !            73:                for(n=nlist; n->namep; n++)
        !            74:                        if(equal(name,n->namep)) {
        !            75:                                erase(n);
        !            76:                                goto hokay;
        !            77:                        }
        !            78:                n->namep = alloc(i);
        !            79:                copy(CH,name,n->namep,i);
        !            80: hokay:
        !            81:                n->use = iz.c[0];
        !            82:                n->type = LV;
        !            83:                switch(n->use) {
        !            84:                    default:
        !            85:                        close(ffile);
        !            86:                        error("can not load ws");
        !            87:                    case DA:
        !            88:                        read(ibuf,&iz,2);
        !            89:                        p=alloc(iz);
        !            90:                        read(ibuf,p,iz);
        !            91:                        p->label +=  ((int)p);/*make absolute*/
        !            92:                        n->itemp = p;
        !            93:                        continue;
        !            94:                    case NF:
        !            95:                    case MF:
        !            96:                    case DF:
        !            97:                        n->itemp = 0;
        !            98:                        fstat(obuf=wfile,b);
        !            99:                        /*obuf[1] = obuf[2] = 0;*/
        !           100:                        n->label=b[4];
        !           101:                        lseek(wfile,b[4],0);
        !           102:                        do {
        !           103:                                read(ibuf,ch,1);
        !           104:                                write(obuf,ch,1);
        !           105:                        } while(ch[0] != '\0');
        !           106:                        fflush(obuf);
        !           107:                }
        !           108:        }
        !           109:        fdat(ffile);
        !           110:        close(ffile);
        !           111: }
        !           112: 
        !           113: wssave(ffile)
        !           114: {      long    vmagic[1];
        !           115:        short   iz;
        !           116:        int  jfile,ibuf, obuf;
        !           117:        register struct nlist *n;
        !           118:        register i;
        !           119:        register struct item *p;
        !           120:        char c[1];
        !           121: 
        !           122:        ibuf = jfile = dup(wfile);
        !           123:        obuf = ffile;
        !           124:        /* obuf[1] = obuf[2] = 0; */
        !           125:        vmagic[0] = (long)MAGIC;
        !           126:        write(obuf,vmagic,4);
        !           127:        /*putw(vmagic, obuf); */
        !           128:        write(obuf,&thread,sizeof thread);
        !           129: 
        !           130:        for(n=nlist; n->namep; n++) {
        !           131:                if(n->use == 0 || (n->use == DA && n->itemp == 0))
        !           132:                        continue;
        !           133:                iz.c[0] = n->use;
        !           134:                i= lsize(n->namep);
        !           135:                iz.c[1] = (char)i ;
        !           136:                write(obuf,&iz,2);
        !           137:                write(obuf,n->namep,i);
        !           138: 
        !           139:                switch(n->use) {
        !           140:                    default:
        !           141:                        close(ffile);
        !           142:                        close(jfile);
        !           143:                        error("save B");
        !           144:                    case DA:
        !           145:                        p = n->itemp;
        !           146:                        i = isize(p);
        !           147:                        iz = (short) i;
        !           148:                        p -> label -= ((int)p);
        !           149:                        write(obuf,&iz,2);
        !           150:                        write(obuf,p,i);
        !           151:                        p->label += ((int)p);
        !           152:                        continue;
        !           153:                    case NF:
        !           154:                    case MF:
        !           155:                    case DF:
        !           156:                        lseek(ibuf,n->label,0);
        !           157:                        /* ibuf[1] = ibuf[2] = 0; */
        !           158:                        do {    
        !           159:                                read(ibuf,c,1);
        !           160:                                write(obuf,c,1);
        !           161:                        } while (c[0] != '\0') ;
        !           162:                }
        !           163:        }
        !           164:        fflush(obuf);
        !           165:        fdat(ffile);
        !           166:        close(ffile);
        !           167:        close(jfile);
        !           168: };
        !           169: 
        !           170: listdir()
        !           171: {
        !           172:        register f;
        !           173:        struct {
        !           174:        short  in;
        !           175:        char nam[14];
        !           176:        } dir;
        !           177: 
        !           178:        if((f = open(".",0)) < 0)
        !           179:                error("directory B");
        !           180:        while(read(f,&dir,sizeof dir) == sizeof dir)
        !           181:                if(dir.in != 0 && dir.nam[0] != '.') {
        !           182:                        if(column+10 >= thread.width){
        !           183:                                aprintf("\n\t");
        !           184:                        }
        !           185:                        aprintf(dir.nam);
        !           186:                        aputchar('\t');
        !           187:                }
        !           188:        aputchar('\n');
        !           189:        close(f);
        !           190: }
        !           191: 
        !           192: fdat(f)
        !           193: {
        !           194:        long b [ 256 ] ;
        !           195:        register long *p;
        !           196:        fstat(f,b);
        !           197:        p = localtime(&b[7]);
        !           198:        aprintf("  ");
        !           199:        pr2d(p[2]);
        !           200:        aputchar('.');
        !           201:        pr2d(p[1]);
        !           202:        aputchar('.');
        !           203:        pr2d(p[0]);
        !           204:        aputchar(' ');
        !           205:        pr2d(p[4]+1);
        !           206:        aputchar('/');
        !           207:        pr2d(p[3]);
        !           208:        aputchar('/');
        !           209:        pr2d(p[5]);
        !           210: }
        !           211: 
        !           212: pr2d(i)
        !           213: long i;
        !           214: {
        !           215:        aputchar(i/10+'0');
        !           216:        aputchar(i % 10 + '0');
        !           217: }

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