Return to sym.c CVS log

Up to [Research Unix] / researchv9 / cmd / sun / c2

Annotation of researchv9/cmd/sun/c2/sym.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)sym.c 1.1 86/02/03 Copyr 1983 Sun Micro";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1983 by Sun Microsystems, Inc.
        !             7:  */
        !             8: 
        !             9: 
        !            10: #include "as.h"
        !            11: 
        !            12: /* Allocation increments for symbol buckets and character blocks */
        !            13: #define        SYM_INCR        50
        !            14: #define CBLOCK_INCR    512
        !            15: 
        !            16: extern struct stab_sym_bkt *stabkt_head;
        !            17: 
        !            18: struct sym_bkt *last_symbol;                   /* last symbol defined */
        !            19: struct sym_bkt *sym_hash_tab[HASH_MAX];                /* Symbol hash table */
        !            20: struct sym_bkt *sym_free = NULL;               /* head of free list */
        !            21: char *cblock = NULL;                           /* storage for symbol names */
        !            22: int ccnt = 0;                                  /* number of chars left in c block */
        !            23: 
        !            24: /* grab a new symbol bucket off of the free list; allocate space
        !            25:  * for a new free list if necessary
        !            26:  */
        !            27: struct sym_bkt *
        !            28: gsbkt()
        !            29:   {    register struct sym_bkt *sbp;
        !            30:        register int i;
        !            31: 
        !            32:        if ((sbp = sym_free) != NULL) sym_free = sbp->next_s;
        !            33:        else {
        !            34:          sbp = (struct sym_bkt *)calloc(SYM_INCR,sizeof(struct sym_bkt));
        !            35:          if (sbp == NULL) sys_error("Symbol storage exceeded\n",0);
        !            36:          for (i = SYM_INCR-1; i--;) {
        !            37:            sbp->next_s = sym_free;
        !            38:            sym_free = sbp++;
        !            39:          }
        !            40:        }
        !            41: 
        !            42:        return(sbp);
        !            43: }
        !            44: 
        !            45: /* initialize hash table */
        !            46: sym_init()
        !            47: {
        !            48:        register int i;
        !            49:        for (i=0; i<HASH_MAX; i++) sym_hash_tab[i] = NULL;
        !            50: } /* end Sym_Init */
        !            51: 
        !            52: char *
        !            53: sstring(string)
        !            54:        register char *string;
        !            55: {      
        !            56:        register char *p,*q;    /* working char string */
        !            57:        register int i;
        !            58: 
        !            59:        i = strlen(string);     /* get length of string */
        !            60: 
        !            61:        if (++i > ccnt) {       /* if not enough room get more */
        !            62:          if ((cblock = (char *)calloc(CBLOCK_INCR,1)) == NULL)
        !            63:            sys_error("Symbol storage exceeded\n",0);
        !            64:          ccnt = CBLOCK_INCR;
        !            65:        }
        !            66: 
        !            67:        p = q = cblock;         /* copy string into permanent storage */
        !            68:        while (*p++ = *string++);
        !            69:        cblock = p;
        !            70:        ccnt -= i;
        !            71:        return(q);
        !            72: } /* end sstring */
        !            73: 
        !            74: /* lookup symbol in symbol table */
        !            75: struct sym_bkt *
        !            76: lookup(s)
        !            77:        register char *s;
        !            78: {
        !            79:        register struct sym_bkt *sbp;   /* general purpose ptr */
        !            80:        register int Save;              /* save subscript in sym_hash_tab */
        !            81:        register char *p;
        !            82:        static char local[250];         /* used for constructing local sym */
        !            83:        extern char *ll_format;
        !            84: 
        !            85:        if (*s>='0' && *s<='9') {       /* local symbol hackery */
        !            86:          /* we hope no-one uses really long local symbols */
        !            87:          p = local;
        !            88:          while ((*p++ = *s++) && (p < &local[sizeof local-1]));/* copy local symbol */
        !            89:          p--;
        !            90:          s = last_symbol->name_s;      /* add last symbol defined as suffix */
        !            91:          while ((*p++ = *s++) && (p < &local[sizeof local-1]));
        !            92:          s = local;                    /* this becomes name to deal with */
        !            93:        }
        !            94: 
        !            95:        /* if the symbol is already in here, return a ptr to it */
        !            96:        for (sbp = sym_hash_tab[Save=hash(s)]; sbp != NULL ; sbp = sbp->next_s)
        !            97:          if (strcmp(sbp->name_s,s) == 0) return(sbp);
        !            98: 
        !            99:        /* Since it's not, make a bucket for it, and put the bucket in the symbol table */
        !           100:        sbp = gsbkt();                          /* get the bucket */
        !           101:        sbp->name_s = sstring(s);               /* Store it's name */
        !           102:        sbp->value_s =  sbp->attr_s = 0;
        !           103: #if AS
        !           104:        sbp->id_s = 0;
        !           105: #endif
        !           106:        sbp->csect_s = C_UNDEF;
        !           107:        sbp->next_s = sym_hash_tab[Save];       /* and insert on top of list */
        !           108:        if (s == local || *s == *ll_format) sbp->attr_s |= S_LOCAL;
        !           109:        return(sym_hash_tab[Save] = sbp);
        !           110: }
        !           111: 
        !           112: 
        !           113: /*
        !           114:  * Perm        Flags all currently defined symbols as permanent (and therefore
        !           115:  *     ineligible for redefinition.  Also prevents them from being output
        !           116:  *     in the object file).
        !           117:  */
        !           118: perm()
        !           119:   {    register struct sym_bkt **sbp1, *sbp2;
        !           120: 
        !           121:        for (sbp1 = sym_hash_tab; sbp1 < &sym_hash_tab[HASH_MAX]; sbp1++)
        !           122:                for (sbp2 = *sbp1; sbp2; sbp2 = sbp2->next_s)
        !           123:                        sbp2->attr_s |= S_PERM;
        !           124: }

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