Return to brk.c CVS log

Up to [MW Coherent from dump] / coherent / d / lib / libc / sys

Annotation of coherent/d/lib/libc/sys/brk.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sys/types.h>
        !             3: #include <errno.h>
        !             4: 
        !             5: extern char *_brk();
        !             6: 
        !             7: #if Z8001
        !             8: paddr_t
        !             9: vtop( cp)
        !            10: register unsigned long cp;
        !            11: {
        !            12:        register unsigned int offs = cp;
        !            13: 
        !            14:        cp >>= 8;
        !            15:        cp &= 0x7F0000L;
        !            16:        return( cp | offs);
        !            17: }
        !            18: 
        !            19: char *
        !            20: ptov( p)
        !            21: register unsigned long p;
        !            22: {
        !            23:        register unsigned int offs = p;
        !            24: 
        !            25:        p <<=8;
        !            26:        p &= 0x7F000000L;
        !            27:        return( p | offs);
        !            28: }
        !            29: #else
        !            30: #define vtop( A) ( (paddr_t)(A))
        !            31: #define ptov( A) ( (char *)(A))
        !            32: #endif
        !            33: 
        !            34: #if IAPX86
        !            35: static char    *minbrk = NULL;         /* must init at run time */
        !            36: static char    *actbrk = NULL;
        !            37: static char    *reqbrk = NULL;
        !            38: #else
        !            39: extern char    end[];                  /* end of loaded private data */
        !            40: static char    *minbrk = end;          /* can't brk before end */
        !            41: static char    *actbrk = end;          /* actual end of private data */
        !            42: static char    *reqbrk = end;          /* requested (virtual) end of p.d. */
        !            43: #endif
        !            44: 
        !            45: int
        !            46: brk( newbrk)
        !            47: register char *newbrk;
        !            48: {
        !            49:        register char *abrk;
        !            50: 
        !            51:        errno = 0;
        !            52:        newbrk += (int)newbrk & 1;
        !            53: #if IAPX86
        !            54:        if( minbrk == NULL)
        !            55:                minbrk = actbrk = reqbrk = _brk( NULL);
        !            56: #endif
        !            57:        if( newbrk < minbrk) {
        !            58:                errno = EINVAL;
        !            59:                return( -1);
        !            60:        }
        !            61:        abrk = _brk( newbrk);
        !            62:        if( errno)
        !            63:                return( -1);
        !            64:        if( abrk < newbrk) {
        !            65:                errno = ENOMEM;
        !            66:                return( -1);
        !            67:        }
        !            68:        reqbrk = newbrk;
        !            69:        actbrk = abrk;
        !            70:        return( 0);
        !            71: }
        !            72: 
        !            73: char *
        !            74: sbrk( incr)
        !            75: register unsigned int incr;
        !            76: {
        !            77:        register paddr_t rbrk;
        !            78: 
        !            79: #if IAPX86
        !            80:        if( minbrk == NULL)
        !            81:                minbrk = actbrk = reqbrk = _brk(NULL);
        !            82: #endif
        !            83:        incr += incr & 1;
        !            84:        rbrk = vtop( reqbrk);
        !            85:        if( rbrk + incr <= vtop( actbrk)) {
        !            86:                reqbrk = ptov( rbrk + incr);
        !            87:                return( ptov(rbrk));
        !            88:        }
        !            89: #if Z8001
        !            90:        if( (rbrk+incr ^ rbrk) > 65536L  &&  (int)rbrk+incr) {
        !            91:                rbrk += 65536L;
        !            92:                rbrk &= 0xFFFF0000L;
        !            93:                reqbrk = ptov( rbrk);
        !            94:        }
        !            95: #endif
        !            96:        if( brk( ptov( rbrk + incr)))
        !            97:                return( (char *)-1);
        !            98:        return( ptov( rbrk));
        !            99: }

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