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