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

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.