Return to misc.c CVS log

Up to [Research Unix] / researchv8dc / cmd / cyntax / cem

Annotation of researchv8dc/cmd/cyntax/cem/misc.c, revision 1.1.1.1

1.1       root        1: #include       "cem.h"
                      2: 
                      3: /*
                      4:  *     Allocate some memory.
                      5:  */
                      6: char   *
                      7: salloc(n)
                      8: long   n;
                      9: {
                     10:        register char   *p;
                     11:        extern char     *malloc();
                     12: 
                     13:        if ((p = malloc((unsigned int)n)) == NULL)
                     14:        {
                     15:                fprintf(stderr, "%s: ran out of memory\n", my_name);
                     16:                exit(1);
                     17:        }
                     18: 
                     19:        return p;
                     20: }
                     21: /*
                     22:  *     Reallocate some memory.
                     23:  */
                     24: 
                     25: char   *
                     26: srealloc(p, n)
                     27: register char  *p;
                     28: long           n;
                     29: {
                     30:        extern char     *realloc();
                     31: 
                     32:        if (p == NULL)
                     33:                return salloc(n);
                     34:        else if ((p = realloc(p, (unsigned int)n)) == NULL)
                     35:        {
                     36:                fprintf(stderr, "%s: ran out of memory\n", my_name);
                     37:                exit(1);
                     38:        }
                     39: 
                     40:        return p;
                     41: }
                     42: 
                     43: /*
                     44:  *     Refill the alloc buffer.
                     45:  */
                     46: char   *
                     47: alloc_fill(want)
                     48: long   want;
                     49: {
                     50:        register long   sz;
                     51: 
                     52:        if (want < ALLOC_SIZE)
                     53:                sz = ALLOC_SIZE;
                     54:        else
                     55:                sz = want;
                     56: 
                     57:        alloc_ptr = salloc(sz);
                     58:        alloc_end = alloc_ptr + sz;
                     59:        alloc_ptr += want;
                     60:        return alloc_ptr - want;
                     61: }
                     62: 
                     63: /*
                     64:  *     Fetch 'u' datum.
                     65:  *
                     66:  *     B0 = 11xxxxxx
                     67:  *
                     68:  *             B0 5:0 sext to 31:24
                     69:  *             B1 7:0      as 23:16
                     70:  *             B2 7:0      as 15: 8
                     71:  *             B3 7:0      as  7: 0
                     72:  *
                     73:  *     B0 = 10xxxxxx
                     74:  *
                     75:  *             B0 5:0 sext to 31: 8
                     76:  *             B1 7:0      as  7: 0
                     77:  *
                     78:  *     B0 = 0xxxxxxx
                     79:  *
                     80:  *             B0 6:0 sext to 31: 0
                     81:  */
                     82: long
                     83: getu()
                     84: {
                     85:        register int    i;
                     86:        register long   j;
                     87: 
                     88:        switch ((i = getd()) & 0xC0)
                     89:        {
                     90:        case 0xC0:
                     91:                j = ((i & 0x3F) << 8) | (getd() & 0xFF);
                     92:                j = (j << 8) | (getd() & 0xFF);
                     93:                j = (j << 8) | (getd() & 0xFF);
                     94: 
                     95:                if ((i & 0x20) == 0)
                     96:                        return j;
                     97:                else
                     98:                        return j | 0xC0000000L;
                     99: 
                    100:        case 0x80:
                    101:                j = ((i & 0x3F) << 8) | (getd() & 0xFF);
                    102: 
                    103:                if ((i & 0x20) == 0)
                    104:                        return j;
                    105:                else
                    106:                        return j | 0xFFFFC000L;
                    107: 
                    108:        case 0x40:
                    109:                return (i & 0x3F) | 0xFFFFFF80L;
                    110:        }
                    111: 
                    112:        return i;
                    113: }
                    114: 
                    115: /*
                    116:  *     Fetch 'v' datum.  Format as 'u' but zero extend.
                    117:  */
                    118: long
                    119: getv()
                    120: {
                    121:        register int    i;
                    122:        register long   j;
                    123: 
                    124:        switch ((i = getd()) & 0xC0)
                    125:        {
                    126:        case 0xC0:
                    127:                j = ((i & 0x3F) << 8) | (getd() & 0xFF);
                    128:                j = (j << 8) | (getd() & 0xFF);
                    129:                return (j << 8) | (getd() & 0xFF);
                    130: 
                    131:        case 0x80:
                    132:                return ((i & 0x3F) << 8) | (getd() & 0xFF);
                    133:        }
                    134: 
                    135:        return i & 0xFF;
                    136: }
                    137: 
                    138: /*
                    139:  *     Fetch '4' datum.
                    140:  */
                    141: long
                    142: get4()
                    143: {
                    144:        register long   j;
                    145: 
                    146:        j = getd() & 0xFF;
                    147:        j =  (j << 8) | (getd() & 0xFF);
                    148:        j =  (j << 8) | (getd() & 0xFF);
                    149:        return  (j << 8) | (getd() & 0xFF);
                    150: }
                    151: 
                    152: /*
                    153:  *     Skip 'u' or 'v' datum.
                    154:  */
                    155: void
                    156: skip()
                    157: {
                    158:        switch (getd() & 0xC0)
                    159:        {
                    160:        case 0xC0:
                    161:                getd();
                    162:                getd();
                    163:                getd();
                    164:                break;
                    165: 
                    166:        case 0x80:
                    167:                getd();
                    168:        }
                    169: }

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