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