Return to names.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx

Annotation of 43BSDTahoe/lib/old_compiler/dbx/names.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)names.c    5.2 (Berkeley) 1/12/88";
        !             9: #endif not lint
        !            10: 
        !            11: static char rcsid[] = "$Header: names.c,v 1.2 87/03/26 20:16:59 donn Exp $";
        !            12: 
        !            13: /*
        !            14:  * Name are the internal representation for identifiers.
        !            15:  *
        !            16:  * A hash table is used to map identifiers to names.
        !            17:  */
        !            18: 
        !            19: #include "defs.h"
        !            20: #include "names.h"
        !            21: 
        !            22: #ifndef public
        !            23: typedef struct Name *Name;
        !            24: 
        !            25: /*
        !            26:  * Inline (for speed) function to return the identifier (string)
        !            27:  * associated with a name.  Because C cannot support both inlines
        !            28:  * and data hiding at the same time, the Name structure must be
        !            29:  * publicly visible.  It is not used explicitly, however, outside of this file.
        !            30:  */
        !            31: 
        !            32: struct Name {
        !            33:     char *identifier;
        !            34:     Name chain;
        !            35: };
        !            36: 
        !            37: #define ident(n) ((n == nil) ? "(noname)" : n->identifier)
        !            38: #endif
        !            39: 
        !            40: /*
        !            41:  * The hash table is a power of two, in order to make hashing faster.
        !            42:  * Using a non-prime is ok since we use chaining instead of re-hashing.
        !            43:  */
        !            44: 
        !            45: #define HASHTABLESIZE 8192
        !            46: 
        !            47: private Name nametable[HASHTABLESIZE];
        !            48: 
        !            49: /*
        !            50:  * Names are allocated in large chunks to avoid calls to malloc
        !            51:  * and to cluster names in memory so that tracing hash chains
        !            52:  * doesn't cause many a page fault.
        !            53:  */
        !            54: 
        !            55: #define CHUNKSIZE 1000
        !            56: 
        !            57: typedef struct Namepool {
        !            58:     struct Name name[CHUNKSIZE];
        !            59:     struct Namepool *prevpool;
        !            60: } *Namepool;
        !            61: 
        !            62: private Namepool namepool = nil;
        !            63: private Integer nleft = 0;
        !            64: 
        !            65: /*
        !            66:  * Given an identifier, convert it to a name.
        !            67:  * If it's not in the hash table, then put it there.
        !            68:  *
        !            69:  * The second argument specifies whether the string should be copied
        !            70:  * into newly allocated space if not found.
        !            71:  *
        !            72:  * This routine is time critical when starting up the debugger
        !            73:  * on large programs.
        !            74:  */
        !            75: 
        !            76: public Name identname(s, isallocated)
        !            77: String s;
        !            78: Boolean isallocated;
        !            79: {
        !            80:     register unsigned h;
        !            81:     register char *p, *q;
        !            82:     register Name n, *np;
        !            83:     Namepool newpool;
        !            84: 
        !            85:     h = 0;
        !            86:     for (p = s; *p != '\0'; p++) {
        !            87:        h = (h << 1) ^ (*p);
        !            88:     }
        !            89:     h &= (HASHTABLESIZE-1);
        !            90:     np = &nametable[h];
        !            91:     n = *np;
        !            92:     while (n != nil) {
        !            93:        p = s;
        !            94:        q = n->identifier;
        !            95:        while (*p == *q) {
        !            96:            if (*p == '\0') {
        !            97:                return n;
        !            98:            }
        !            99:            ++p;
        !           100:            ++q;
        !           101:        }
        !           102:        n = n->chain;
        !           103:     }
        !           104: 
        !           105:     /*
        !           106:      * Now we know that name hasn't been found,
        !           107:      * so we allocate a name, store the identifier, and
        !           108:      * enter it in the hash table.
        !           109:      */
        !           110:     if (nleft <= 0) {
        !           111:        newpool = new(Namepool);
        !           112:        newpool->prevpool = namepool;
        !           113:        namepool = newpool;
        !           114:        nleft = CHUNKSIZE;
        !           115:     }
        !           116:     --nleft;
        !           117:     n = &(namepool->name[nleft]);
        !           118:     if (isallocated) {
        !           119:        n->identifier = s;
        !           120:     } else {
        !           121:        /* this case doesn't happen very often */
        !           122:        n->identifier = newarr(char, strlen(s) + 1);
        !           123:        p = s;
        !           124:        q = n->identifier;
        !           125:        while (*p != '\0') {
        !           126:            *q++ = *p++;
        !           127:        }
        !           128:        *q = '\0';
        !           129:     }
        !           130:     n->chain = *np;
        !           131:     *np = n;
        !           132:     return n;
        !           133: }
        !           134: 
        !           135: /*
        !           136:  * Deallocate the name table.
        !           137:  */
        !           138: 
        !           139: public names_free()
        !           140: {
        !           141:     Namepool n, m;
        !           142:     register integer i;
        !           143: 
        !           144:     n = namepool;
        !           145:     while (n != nil) {
        !           146:        m = n->prevpool;
        !           147:        dispose(n);
        !           148:        n = m;
        !           149:     }
        !           150:     for (i = 0; i < HASHTABLESIZE; i++) {
        !           151:        nametable[i] = nil;
        !           152:     }
        !           153:     namepool = nil;
        !           154:     nleft = 0;
        !           155: }

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