Return to stak.c CVS log

Up to [Research Unix] / researchv9 / cmd / sh

Annotation of researchv9/cmd/sh/stak.c, revision 1.1.1.1

1.1       root        1: /*     @(#)stak.c      1.4     */
                      2: /*
                      3:  * UNIX shell
                      4:  *
                      5:  * Bell Telephone Laboratories
                      6:  *
                      7:  */
                      8: 
                      9: #include       "defs.h"
                     10: 
                     11: char *setbrk();
                     12: 
                     13: 
                     14: /* ========    storage allocation      ======== */
                     15: 
                     16: char *
                     17: getstak(asize)                 /* allocate requested stack */
                     18: int    asize;
                     19: {
                     20:        register char   *oldstak;
                     21:        register int    size;
                     22: 
                     23:        size = round(asize, BYTESPERWORD);
                     24:        oldstak = stakbot;
                     25:        staktop = stakbot += size;
                     26:        while (staktop >= brkend)
                     27:                setbrk(round(staktop - brkend + 1, BRKINCR));
                     28:        return(oldstak);
                     29: }
                     30: 
                     31: /*
                     32:  * set up stack for local use
                     33:  * should be followed by `endstak'
                     34:  */
                     35: char *
                     36: locstak()
                     37: {
                     38:        if (brkend - stakbot < BRKINCR)
                     39:        {
                     40:                if (setbrk(brkincr) == (char *) -1)
                     41:                        error(nostack);
                     42:                if (brkincr < BRKMAX)
                     43:                        brkincr += 256;
                     44:        }
                     45:        return(stakbot);
                     46: }
                     47: 
                     48: char *
                     49: savstak()
                     50: {
                     51:        assert(staktop == stakbot);
                     52:        return(stakbot);
                     53: }
                     54: 
                     55: char *
                     56: endstak(argp)          /* tidy up after `locstak' */
                     57: register char  *argp;
                     58: {
                     59:        register char   *oldstak;
                     60: 
                     61:        *argp++ = 0;
                     62:        oldstak = stakbot;
                     63:        stakbot = staktop = (char *)sround(argp, BYTESPERWORD);
                     64:        return(oldstak);
                     65: }
                     66: 
                     67: tdystak(x)             /* try to bring stack back to x */
                     68: register char  *x;
                     69: {
                     70:        while ((char *)(stakbsy) > (char *)(x))
                     71:        {
                     72:                shfree(stakbsy);
                     73:                stakbsy = stakbsy->word;
                     74:        }
                     75:        staktop = stakbot = max((char *)(x), (char *)(stakbas));
                     76:        rmtemp(x);
                     77: }
                     78: 
                     79: stakchk()
                     80: {
                     81:        if ((brkend - stakbas) > BRKINCR + BRKINCR)
                     82:                setbrk(-BRKINCR);
                     83: }
                     84: 
                     85: char *
                     86: cpystak(x)
                     87: char   *x;
                     88: {
                     89:        return(endstak(movstr(x, locstak())));
                     90: }
                     91: 
                     92: setstak(x)
                     93: char *x;
                     94: {
                     95:        staktop = absstak(x);
                     96:        while (staktop >= brkend)
                     97:                setbrk(BRKINCR);
                     98: }
                     99: 
                    100: pushstak(c)
                    101: char c;
                    102: {
                    103:        *staktop++ = c;
                    104:        while (staktop >= brkend)
                    105:                setbrk(BRKINCR);
                    106: }

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