![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc0sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0|
Return to cc0sym.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 ! root 1: /* ! 2: * C compiler. ! 3: * Symbol table routines. ! 4: */ ! 5: #ifdef vax ! 6: #include "INC$LIB:cc0.h" ! 7: #else ! 8: #include "cc0.h" ! 9: #endif ! 10: ! 11: /* ! 12: * Compare a token to id[] for equality. ! 13: */ ! 14: ideq(tp) TOK *tp; ! 15: { ! 16: register int *ip1, *ip2, n; ! 17: ip1 = tp->t_id; ! 18: ip2 = id; ! 19: n = (idsize+2)>>1; ! 20: while (--n >= 0) ! 21: if (*ip1++ != *ip2++) ! 22: return 0; ! 23: return 1; ! 24: } ! 25: ! 26: /* ! 27: * Create a new token with id[] ! 28: * and return a pointer. ! 29: */ ! 30: TOK *newtoken() ! 31: { ! 32: register TOK *tp; ! 33: ! 34: tp = (TOK *)new(sizeof(TOK) + ((idsize+2)&~1)); ! 35: tp->t_tp = NULL; ! 36: tp->t_sym = NULL; ! 37: strncpy(tp->t_id, id, (idsize+2)&~1); ! 38: return tp; ! 39: } ! 40: ! 41: /* ! 42: * Allocate a new symbol node. ! 43: */ ! 44: SYM *newsym() ! 45: { ! 46: register SYM *sp; ! 47: ! 48: sp = (SYM *) new(sizeof(SYM)); ! 49: zero(sp, sizeof(SYM)); ! 50: sp->s_seg = SANY; ! 51: sp->s_id = idp->t_id; ! 52: return (sp); ! 53: } ! 54: ! 55: /* ! 56: * Allocate a new cpp symbol ! 57: */ ! 58: CPPSYM *newcpp(narg, value, nval) int narg; char *value; int nval; ! 59: { ! 60: register CPPSYM *sp; ! 61: ! 62: sp = (CPPSYM *) new(sizeof(CPPSYM)+nval); ! 63: sp->s_slevel = SL_CPP; ! 64: sp->s_narg = narg; ! 65: sp->s_value = narg >= 0 ? XUSERA : XUSER; ! 66: strcpy(sp->s_body, value); ! 67: return (sp); ! 68: } ! 69: ! 70: /* ! 71: * Search a symbol list for a symbol pointer ! 72: */ ! 73: SYM *memberp(sp, splist) register SYM *sp, *splist; ! 74: { ! 75: while (splist != NULL) ! 76: if (sp == splist) ! 77: return splist; ! 78: else ! 79: splist = splist->s_sp; ! 80: return splist; ! 81: } ! 82: ! 83: /* ! 84: * Look up the name in 'id' in a reference context. ! 85: * The name may appear at any lexic level. ! 86: */ ! 87: SYM *reflookup(ls) register int ls; ! 88: { ! 89: register SYM *sp; ! 90: ! 91: for (sp = idp->t_sym; sp != NULL; sp = sp->s_sp) ! 92: if (sp->s_slevel < ls) ! 93: continue; ! 94: else if (sp->s_slevel == ls) ! 95: return sp; ! 96: else ! 97: break; ! 98: return(NULL); ! 99: } ! 100: ! 101: /* ! 102: * Look up the identifier in 'id' in the context of a declaration. ! 103: * If the symbol is not found, it is created. ! 104: * The argument 'll' is the lexic level to search in. ! 105: * The argument 'ls' is the symbol class to search. ! 106: */ ! 107: SYM *deflookup(ls, ll) int ls, ll; ! 108: { ! 109: register SYM *sp, **spp; ! 110: ! 111: for (spp = &idp->t_sym; (sp = *spp) != NULL; spp = &sp->s_sp) ! 112: if (sp->s_slevel < ls) ! 113: continue; ! 114: else if (sp->s_slevel == ls) { ! 115: if (sp->s_level == ll) ! 116: return (sp); ! 117: else if (sp->s_level < ll) { ! 118: if (sp->s_level == LL_ARG && ll >= LL_AUTO) ! 119: cwarn("parameter \"%s\" redeclared as automatic", ! 120: sp->s_id); ! 121: break; ! 122: } else ! 123: continue; ! 124: } else ! 125: break; ! 126: *spp = newsym(); ! 127: (*spp)->s_sp = sp; ! 128: sp = *spp; ! 129: sp->s_slevel = ls; ! 130: sp->s_level = ll; ! 131: return (sp); ! 132: } ! 133: ! 134: /* ! 135: * Look up a member of a structure. ! 136: */ ! 137: SYM *moslookup(tp) TREE *tp; ! 138: { ! 139: INFO *ip; ! 140: register SYM *sp, *sp2; ! 141: register int i; ! 142: ! 143: sp = idp->t_sym; ! 144: /* First search using info of left hand context */ ! 145: if ((tp->t_type==T_STRUCT || tp->t_type==T_UNION) ! 146: && (ip=tp->t_ip)!=NULL) { ! 147: for (i=0; i<ip->i_nsp; i+=1) { ! 148: sp2 = ip->i_sp[i]; ! 149: if (memberp(sp2, sp)) ! 150: return (sp2); ! 151: } ! 152: } ! 153: /* Now search for unambiguous reference */ ! 154: for (sp2 = NULL; sp != NULL; sp = sp->s_sp) { ! 155: if (sp->s_slevel < SL_MOS) ! 156: continue; ! 157: if (sp2 == NULL) { ! 158: sp2 = sp; ! 159: continue; ! 160: } ! 161: if (sp->s_value!=sp2->s_value ! 162: || sp->s_offset!=sp2->s_offset ! 163: || sp->s_width!=sp2->s_width) { ! 164: cerror("ambiguous reference to \"%s\"", id); ! 165: break; ! 166: } ! 167: } ! 168: return (sp2); ! 169: } ! 170: ! 171: /* ! 172: * Try to find a structure tag, given a pointer to an info structure. ! 173: * Used to hunt up the name of the structure ! 174: * when doing strict structure member checks. ! 175: */ ! 176: SYM *taglookup(ip) register INFO *ip; ! 177: { ! 178: register SYM *sp; ! 179: register TOK *tp; ! 180: register int i; ! 181: ! 182: for (i=0; i<NHASH; ++i) ! 183: for (tp = hash0[i]; tp != NULL; tp = tp->t_tp) { ! 184: for (sp = tp->t_sym; sp != NULL; sp = sp->s_sp) { ! 185: if (sp->s_slevel != SL_TAG) ! 186: continue; ! 187: if (istag(sp->s_class) && sp->s_ip==ip) ! 188: return (sp); ! 189: } ! 190: } ! 191: return (NULL); ! 192: } ! 193: ! 194: /* ! 195: * Fake a definition. ! 196: * Put the name into the hash table with the specified flags. ! 197: * Set the type to int. ! 198: * The class will be auto or member, depending on the flags. ! 199: */ ! 200: SYM *fakedef(ls) int ls; ! 201: { ! 202: register SYM *sp; ! 203: ! 204: sp = deflookup(ls, llex); ! 205: sp->s_type = T_INT; ! 206: sp->s_class = (ls == SL_MOS) ? C_MOS : C_AUTO; ! 207: sp->s_flag |= S_USED; ! 208: return (sp); ! 209: } ! 210: ! 211: /* ! 212: * 'sp' is a symbol pointer for an external function ! 213: * which was entered at local lexical level ! 214: * because no "extern" appeared in the declaration. ! 215: * Return a symbol pointer at the correct lexical level. ! 216: * This is a pathological case, not worth optimizing. ! 217: */ ! 218: SYM *fixlevel(sp) register SYM *sp; ! 219: { ! 220: register SYM **tsp; ! 221: ! 222: /* Chase the chain for this identifier */ ! 223: setid(sp->s_id); ! 224: for (tsp = &idp->t_sym; *tsp != sp; tsp = &(*tsp)->s_sp) ! 225: if (*tsp == NULL) cbotch("bad fixlevel"); ! 226: *tsp = sp->s_sp; ! 227: free(sp); ! 228: if ((sp = reflookup(SL_VAR)) == NULL) ! 229: sp = deflookup(SL_VAR, LL_EXT); ! 230: return sp; ! 231: } ! 232: ! 233: /* ! 234: * Sweep through the symbol table, ! 235: * backplugging the structure data for any ! 236: * structures waiting for the definition ! 237: * of structure tag "tsp". ! 238: */ ! 239: backplug(tsp) ! 240: register SYM *tsp; ! 241: { ! 242: register SYM *sp; ! 243: register int t; ! 244: register TOK *tp; ! 245: register int i; ! 246: ! 247: for (i=0; i<NHASH; ++i) ! 248: for (tp = hash0[i]; tp != NULL; tp = tp->t_tp) { ! 249: for (sp = tp->t_sym; sp != NULL; sp = sp->s_sp) { ! 250: if (sp->s_slevel < SL_VAR) ! 251: continue; ! 252: t = sp->s_type; ! 253: if ((t==T_FSTRUCT || t==T_FUNION || t==T_FENUM) ! 254: && sp->s_ip==tsp) { ! 255: --sp->s_type; /* Magic */ ! 256: sp->s_ip = tsp->s_ip; ! 257: ++tsp->s_ip->i_refc; ! 258: } ! 259: } ! 260: } ! 261: } ! 262: ! 263: /* ! 264: * The lexic level has decremented. ! 265: * Delete symbol table entries associated with the old level. ! 266: * Look for undefined forward referenced labels ! 267: * and put out diagnostics for them. ! 268: */ ! 269: downlex() ! 270: { ! 271: register SYM *sp, **spp; ! 272: register TOK *tp; ! 273: register int c, i; ! 274: ! 275: dbdown(); ! 276: for (i=0; i<NHASH; ++i) ! 277: for (tp = hash0[i]; tp != NULL; tp = tp->t_tp) { ! 278: for (spp = &tp->t_sym; (sp = *spp) != NULL; ) { ! 279: if (sp->s_slevel < SL_VAR) { ! 280: spp = &sp->s_sp; ! 281: continue; ! 282: } ! 283: c = sp->s_class; ! 284: if (c==C_FREF && llex==LL_EXT) ! 285: cerror("label \"%s\" undefined", tp->t_id); ! 286: if (sp->s_level <= llex) { ! 287: spp = &sp->s_sp; ! 288: continue; ! 289: } ! 290: if ((c!=C_LAB && c!=C_FREF) || llex==LL_EXT) { ! 291: if (llex >= LL_EXT) ! 292: usedcheck(sp); ! 293: *spp = sp->s_sp; ! 294: free((char *) sp); ! 295: continue; ! 296: } ! 297: spp = &sp->s_sp; ! 298: } ! 299: } ! 300: } ! 301: ! 302: /* ! 303: * Put out the required warning if used checking is enabled. ! 304: */ ! 305: usedcheck(sp) register SYM *sp; ! 306: { ! 307: register char *lp, *tp; ! 308: char lb[32]; ! 309: ! 310: if ((sp->s_flag&S_USED) != 0) ! 311: return; ! 312: if (isvariant(VSUVAR) ! 313: || (isvariant(VSUREG) && sp->s_class==C_REG)) { ! 314: switch (sp->s_class) { ! 315: default: ! 316: tp = "variable"; ! 317: break; ! 318: case C_REG: ! 319: tp = "register variable"; ! 320: break; ! 321: case C_TYPE: ! 322: tp = "type definition"; ! 323: break; ! 324: case C_LAB: ! 325: tp = "label"; ! 326: break; ! 327: case C_NONE: /* for forward references */ ! 328: case C_GREF: ! 329: case C_MOS: ! 330: case C_MOU: ! 331: case C_MOE: ! 332: case C_STAG: ! 333: case C_UTAG: ! 334: case C_ETAG: ! 335: return; ! 336: } ! 337: lp = ""; ! 338: if (sp->s_dline != 0) ! 339: sprintf(lp = lb, " (line %d)", sp->s_dline); ! 340: cstrict("%s \"%s\"%s is not used", tp, sp->s_id, lp); ! 341: } ! 342: } ! 343: ! 344: /* ! 345: * Copy 'n' bytes. ! 346: */ ! 347: copy(t, f, n) ! 348: register char *t, *f; ! 349: register int n; ! 350: { ! 351: while (--n >= 0) ! 352: *t++ = *f++; ! 353: } ! 354: ! 355: /* ! 356: * Zero 'n' bytes. ! 357: */ ! 358: zero(p, n) ! 359: register char *p; ! 360: register int n; ! 361: { ! 362: while (--n >= 0) ! 363: *p++ = 0; ! 364: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.