Return to blok.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / sh

Annotation of 40BSD/cmd/sh/blok.c, revision 1.1.1.1

1.1       root        1: #
                      2: /*
                      3:  *     UNIX shell
                      4:  *
                      5:  *     S. R. Bourne
                      6:  *     Bell Telephone Laboratories
                      7:  *
                      8:  */
                      9: 
                     10: #include       "defs.h"
                     11: 
                     12: 
                     13: /*
                     14:  *     storage allocator
                     15:  *     (circular first fit strategy)
                     16:  */
                     17: 
                     18: #define BUSY 01
                     19: #define busy(x)        (Rcheat((x)->word)&BUSY)
                     20: 
                     21: POS            brkincr=BRKINCR;
                     22: BLKPTR         blokp;                  /*current search pointer*/
                     23: BLKPTR         bloktop=BLK(end);       /*top of arena (last blok)*/
                     24: 
                     25: 
                     26: 
                     27: ADDRESS        alloc(nbytes)
                     28:        POS             nbytes;
                     29: {
                     30:        REG POS         rbytes = round(nbytes+BYTESPERWORD,BYTESPERWORD);
                     31: 
                     32:        LOOP    INT             c=0;
                     33:                REG BLKPTR      p = blokp;
                     34:                REG BLKPTR      q;
                     35:                REP     IF !busy(p)
                     36:                        THEN    WHILE !busy(q = p->word) DO p->word = q->word OD
                     37:                                IF ADR(q)-ADR(p) >= rbytes
                     38:                                THEN    blokp = BLK(ADR(p)+rbytes);
                     39:                                        IF q > blokp
                     40:                                        THEN    blokp->word = p->word;
                     41:                                        FI
                     42:                                        p->word=BLK(Rcheat(blokp)|BUSY);
                     43:                                        return(ADR(p+1));
                     44:                                FI
                     45:                        FI
                     46:                        q = p; p = BLK(Rcheat(p->word)&~BUSY);
                     47:                PER     p>q ORF (c++)==0 DONE
                     48:                addblok(rbytes);
                     49:        POOL
                     50: }
                     51: 
                     52: VOID   addblok(reqd)
                     53:        POS             reqd;
                     54: {
                     55:        IF stakbas!=staktop
                     56:        THEN    REG STKPTR      rndstak;
                     57:                REG BLKPTR      blokstak;
                     58: 
                     59:                pushstak(0);
                     60:                rndstak=round(staktop,BYTESPERWORD);
                     61:                blokstak=BLK(stakbas)-1;
                     62:                blokstak->word=stakbsy; stakbsy=blokstak;
                     63:                bloktop->word=BLK(Rcheat(rndstak)|BUSY);
                     64:                bloktop=BLK(rndstak);
                     65:        FI
                     66:        reqd += brkincr; reqd &= ~(brkincr-1);
                     67:        blokp=bloktop;
                     68:        bloktop=bloktop->word=BLK(Rcheat(bloktop)+reqd);
                     69:        bloktop->word=BLK(ADR(end)+1);
                     70:        BEGIN
                     71:           REG STKPTR stakadr=STK(bloktop+2);
                     72:           staktop=movstr(stakbot,stakadr);
                     73:           stakbas=stakbot=stakadr;
                     74:        END
                     75: }
                     76: 
                     77: VOID   free(ap)
                     78:        BLKPTR          ap;
                     79: {
                     80:        REG BLKPTR      p;
                     81: 
                     82:        IF (p=ap) ANDF p<bloktop
                     83:        THEN    Lcheat((--p)->word) &= ~BUSY;
                     84:        FI
                     85: }
                     86: 
                     87: #ifdef DEBUG
                     88: chkbptr(ptr)
                     89:        BLKPTR  ptr;
                     90: {
                     91:        INT             exf=0;
                     92:        REG BLKPTR      p = end;
                     93:        REG BLKPTR      q;
                     94:        INT             us=0, un=0;
                     95: 
                     96:        LOOP
                     97:           q = Rcheat(p->word)&~BUSY;
                     98:           IF p==ptr THEN exf++ FI
                     99:           IF q<end ORF q>bloktop THEN abort(3) FI
                    100:           IF p==bloktop THEN break FI
                    101:           IF busy(p)
                    102:           THEN us += q-p;
                    103:           ELSE un += q-p;
                    104:           FI
                    105:           IF p>=q THEN abort(4) FI
                    106:           p=q;
                    107:        POOL
                    108:        IF exf==0 THEN abort(1) FI
                    109:        prn(un); prc(SP); prn(us); prc(NL);
                    110: }
                    111: #endif

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