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