Return to stak.c CVS log

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

Annotation of researchv8dc/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: 
                     12: /* ========    storage allocation      ======== */
                     13: 
                     14: char *
                     15: getstak(asize)                 /* allocate requested stack */
                     16: int    asize;
                     17: {
                     18:        register char   *oldstak;
                     19:        register int    size;
                     20: 
                     21:        size = round(asize, BYTESPERWORD);
                     22:        oldstak = stakbot;
                     23:        staktop = stakbot += size;
                     24:        return(oldstak);
                     25: }
                     26: 
                     27: /*
                     28:  * set up stack for local use
                     29:  * should be followed by `endstak'
                     30:  */
                     31: char *
                     32: locstak()
                     33: {
                     34:        if (brkend - stakbot < BRKINCR)
                     35:        {
                     36:                if (setbrk(brkincr) == -1)
                     37:                        error(nostack);
                     38:                if (brkincr < BRKMAX)
                     39:                        brkincr += 256;
                     40:        }
                     41:        return(stakbot);
                     42: }
                     43: 
                     44: char *
                     45: savstak()
                     46: {
                     47:        assert(staktop == stakbot);
                     48:        return(stakbot);
                     49: }
                     50: 
                     51: char *
                     52: endstak(argp)          /* tidy up after `locstak' */
                     53: register char  *argp;
                     54: {
                     55:        register char   *oldstak;
                     56: 
                     57:        *argp++ = 0;
                     58:        oldstak = stakbot;
                     59:        stakbot = staktop = (char *)round(argp, BYTESPERWORD);
                     60:        return(oldstak);
                     61: }
                     62: 
                     63: tdystak(x)             /* try to bring stack back to x */
                     64: register char  *x;
                     65: {
                     66:        while ((char *)(stakbsy) > (char *)(x))
                     67:        {
                     68:                free(stakbsy);
                     69:                stakbsy = stakbsy->word;
                     70:        }
                     71:        staktop = stakbot = max((char *)(x), (char *)(stakbas));
                     72:        rmtemp(x);
                     73: }
                     74: 
                     75: stakchk()
                     76: {
                     77:        if ((brkend - stakbas) > BRKINCR + BRKINCR)
                     78:                setbrk(-BRKINCR);
                     79: }
                     80: 
                     81: char *
                     82: cpystak(x)
                     83: char   *x;
                     84: {
                     85:        return(endstak(movstr(x, locstak())));
                     86: }

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