Return to fdsymbol.c CVS log

Up to [Research Unix] / researchv10no / cmd / movie

Annotation of researchv10no/cmd/movie/fdsymbol.c, revision 1.1

1.1     ! root        1: /* symbol.c:
        !             2:        General: functions for mapping {string} x {int} -> {int}
        !             3:        In pass 1: {name} x {viewnum} -> {int file line num}
        !             4:        In pass 2: {} x {int file line num} -> {slot num}
        !             5:                   Therefore be careful with blank strings
        !             6:  */
        !             7: 
        !             8: #include "fdevelop.h"
        !             9: 
        !            10: #define        steq(s, n, p) (p->innum == n && ((p->instr == s) || eq(p->instr,s)))
        !            11: 
        !            12: #define SIZE   2053
        !            13: Symbol *head[SIZE];
        !            14: 
        !            15: int hash(s, n) /* form hash value */
        !            16:        register char *s;
        !            17:        register int n;
        !            18: {
        !            19:        register int hashval;
        !            20: 
        !            21:        for (hashval = 0; *s != '\0'; s++)
        !            22:                hashval = (*s + 31 * hashval) % SIZE;
        !            23:        hashval = (31 * hashval + 1259 * n) % SIZE;
        !            24:        return hashval;
        !            25: }
        !            26: 
        !            27: Symbol *lookup(s, n)   /* return element with s, n */
        !            28:        register char *s;
        !            29:        register int n;
        !            30: {
        !            31:        register Symbol *p;
        !            32:        for (p = head[hash(s, n)]; p != NULL; p = p->next)
        !            33:                if (steq(s, n, p))
        !            34:                        return p;
        !            35:        return NULL;
        !            36: }
        !            37: 
        !            38: insert(s, n, v)        /* insert s, n with value v */
        !            39:        register char *s;
        !            40:        register int n;
        !            41:        int v;
        !            42: {
        !            43:        register Symbol *p;
        !            44:        char *q;
        !            45:        int i;
        !            46: 
        !            47:        /* fprintf(stderr, "Inserting: |%s|, %d with hash %d\n",
        !            48:                s, n, hash(s,n)); */
        !            49:        if (*s == '\0')
        !            50:                q = NULLSTR;
        !            51:        else {
        !            52:                q = emalloc(strlen(s)+1);
        !            53:                strcpy(q, s);
        !            54:        }
        !            55:        p = (Symbol *) emalloc(sizeof(Symbol));
        !            56:        p->instr = q;
        !            57:        p->innum = n;
        !            58:        p->outnum = v;
        !            59:        i = hash(s, n);
        !            60:        p->next = head[i];
        !            61:        head[i] = p;
        !            62: }
        !            63: 
        !            64: delete(s, n)   /* remove s, n */
        !            65:        char *s;
        !            66:        int n;
        !            67: {
        !            68:        Symbol *p, *pp;
        !            69:        int i;
        !            70: 
        !            71:        /* fprintf(stderr, "Deleting:  |%s|, %d with hash %d\n",
        !            72:                s, n, hash(s,n)); */
        !            73:        i = hash(s, n);
        !            74:        pp = NULL;
        !            75:        for (p = head[i]; p != NULL; p = p->next) {
        !            76:                if (steq(s, n, p))
        !            77:                        break;
        !            78:                pp = p;
        !            79:        }
        !            80:        if (p == NULL)
        !            81:                error(FATAL, "symtab bug: bad delete");
        !            82:        if (p->instr != NULLSTR)
        !            83:                efree(p->instr);
        !            84:        if (pp == NULL) {
        !            85:                head[i] = p->next;
        !            86:        } else {
        !            87:                pp->next = p->next;
        !            88:        }
        !            89:        efree((char *) p);
        !            90: }
        !            91: 
        !            92: opensymtab()   /* init table */
        !            93: {
        !            94:        int i;
        !            95: 
        !            96:        for (i = 0; i < SIZE; i++)
        !            97:                head[i] = NULL;
        !            98: }
        !            99: 
        !           100: closesymtab()  /* reclaim storage */
        !           101: {
        !           102:        int i;
        !           103:        Symbol *p, *np;
        !           104: 
        !           105:        for (i = 0; i < SIZE; i++)
        !           106:                for (p = head[i]; p != NULL; p = np) {
        !           107:                        if (p->instr != NULLSTR)
        !           108:                                efree(p->instr);
        !           109:                        np = p->next;
        !           110:                        efree((char *) p);
        !           111:                }
        !           112: }

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