![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yyid.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / src|
Return to yyid.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 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[] = "@(#)yyid.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: #include "whoami.h"
12: #include "0.h"
13: #include "tree_ty.h" /* must be included for yy.h */
14: #include "yy.h"
15:
16: #ifdef PI
17: extern union semstack *yypv;
18: /*
19: * Determine whether the identifier whose name
20: * is "cp" can possibly be a kind, which is a
21: * namelist class. We look through the symbol
22: * table for the first instance of cp as a non-field,
23: * and at all instances of cp as a field.
24: * If any of these are ok, we return true, else false.
25: * It would be much better to handle with's correctly,
26: * even to just know whether we are in a with at all.
27: *
28: * Note that we don't disallow constants on the lhs of assignment.
29: */
30: identis(cp, kind)
31: register char *cp;
32: int kind;
33: {
34: register struct nl *p;
35: int i;
36:
37: /*
38: * Cp is NIL when error recovery inserts it.
39: */
40: if (cp == NIL)
41: return (1);
42:
43: /*
44: * Record kind we want for possible later use by yyrecover
45: */
46: yyidwant = kind;
47: yyidhave = NIL;
48: i = ( (int) cp ) & 077;
49: for (p = disptab[i]; p != NIL; p = p->nl_next)
50: if (p->symbol == cp) {
51: if (yyidok(p, kind))
52: goto gotit;
53: if (p->class != FIELD && p->class != BADUSE)
54: break;
55: }
56: if (p != NIL)
57: for (p = p->nl_next; p != NIL; p = p->nl_next)
58: if (p->symbol == cp && p->class == FIELD && yyidok(p, kind))
59: goto gotit;
60: return (0);
61: gotit:
62: if (p->class == BADUSE && !Recovery) {
63: yybadref(p, OY.Yyeline);
64: yypv[0].i_entry = NIL;
65: }
66: return (1);
67: }
68:
69: /*
70: * A bad reference to the identifier cp on line
71: * line and use implying the addition of kindmask
72: * to the mask of kind information.
73: */
74: struct nl *
75: yybaduse(cp, line, kindmask)
76: register char *cp;
77: int line, kindmask;
78: {
79: register struct nl *p, *oldp;
80: int i;
81:
82: i = ( (int) cp ) & 077;
83: for (p = disptab[i]; p != NIL; p = p->nl_next)
84: if (p->symbol == cp)
85: break;
86: oldp = p;
87: if (p == NIL || p->class != BADUSE)
88: p = enter(defnl(cp, BADUSE, NLNIL, 0));
89: p->value[NL_KINDS] |= kindmask;
90: yybadref(p, line);
91: return (oldp);
92: }
93:
94: /*
95: * ud is initialized so that esavestr will allocate
96: * sizeof ( struct udinfo ) bytes for the 'real' struct udinfo
97: */
98: struct udinfo ud = { ~0 , (struct udinfo *) ~0 , 0};
99: /*
100: * Record a reference to an undefined identifier,
101: * or one which is improperly used.
102: */
103: yybadref(p, line)
104: register struct nl *p;
105: int line;
106: {
107: register struct udinfo *udp;
108:
109: if (p->chain != NIL && ((struct udinfo *) p->chain)->ud_line == line)
110: return;
111: udp = (struct udinfo *) esavestr((char *) &ud);
112: udp->ud_line = line;
113: udp->ud_next = (struct udinfo *) p->chain;
114: p->chain = (struct nl *) udp;
115: }
116:
117: #define varkinds ((1<<CONST)|(1<<VAR)|(1<<REF)|(1<<ARRAY)|(1<<PTR) \
118: |(1<<RECORD)|(1<<FIELD)|(1<<FUNC)|(1<<FVAR) \
119: |(1<<FFUNC)|(1<<PROC)|(1<<FPROC))
120: /*
121: * Is the symbol in the p entry of the namelist
122: * even possibly a kind kind? If not, update
123: * what we have based on this encounter.
124: */
125: yyidok(p, kind)
126: register struct nl *p;
127: int kind;
128: {
129:
130: if (p->class == BADUSE) {
131: if (kind == VAR)
132: return (p->value[0] & varkinds);
133: return (p->value[0] & (1 << kind));
134: }
135: if (yyidok1(p, kind))
136: return (1);
137: if (yyidhave != NIL)
138: yyidhave = IMPROPER;
139: else
140: yyidhave = p->class;
141: return (0);
142: }
143:
144: yyidok1(p, kind)
145: register struct nl *p;
146: int kind;
147: {
148:
149: switch (kind) {
150: default:
151: case FUNC:
152: return ( p -> class == FUNC
153: || p -> class == FVAR
154: || p -> class == FFUNC );
155: case PROC:
156: return ( p -> class == PROC || p -> class == FPROC );
157: case CONST:
158: case TYPE:
159: case FIELD:
160: return (p->class == kind);
161: case VAR:
162: return (p->class == CONST || yyisvar(p, NIL));
163: case ARRAY:
164: case RECORD:
165: return (yyisvar(p, kind));
166: case PTRFILE:
167: return (yyisvar(p, PTR) || yyisvar(p, FILET));
168: }
169: }
170:
171: yyisvar(p, varclass)
172: register struct nl *p;
173: int varclass;
174: {
175:
176: switch (p->class) {
177: case FIELD:
178: case VAR:
179: case REF:
180: case FVAR:
181: /*
182: * We would prefer to return
183: * parameterless functions only.
184: */
185: case FUNC:
186: case FFUNC:
187: return (varclass == NIL || (p->type != NIL && p->type->class == varclass));
188: case PROC:
189: case FPROC:
190: return ( varclass == NIL );
191: }
192: return (0);
193: }
194: #endif
195: #ifdef PXP
196: #ifndef DEBUG
197: identis()
198: {
199:
200: return (1);
201: }
202: #endif
203: #ifdef DEBUG
204: extern char *classes[];
205:
206: char kindchars[] "UCTVAQRDPF";
207: /*
208: * Fake routine "identis" for pxp when testing error recovery.
209: * Looks at letters in variable names to answer questions
210: * about attributes. Mapping is
211: * C const_id
212: * T type_id
213: * V var_id also if any of AQRDF
214: * A array_id
215: * Q ptr_id
216: * R record_id
217: * D field_id D for "dot"
218: * P proc_id
219: * F func_id
220: */
221: identis(cp, kind)
222: register char *cp;
223: int kind;
224: {
225: register char *dp;
226: char kindch;
227:
228: /*
229: * Don't do anything unless -T
230: */
231: if (!typetest)
232: return (1);
233:
234: /*
235: * Inserted symbols are always correct
236: */
237: if (cp == NIL)
238: return (1);
239: /*
240: * Set up the names for error messages
241: */
242: yyidwant = classes[kind];
243: for (dp = kindchars; *dp; dp++)
244: if (any(cp, *dp)) {
245: yyidhave = classes[dp - kindchars];
246: break;
247: }
248:
249: /*
250: * U in the name means undefined
251: */
252: if (any(cp, 'U'))
253: return (0);
254:
255: kindch = kindchars[kind];
256: if (kindch == 'V')
257: for (dp = "AQRDF"; *dp; dp++)
258: if (any(cp, *dp))
259: return (1);
260: return (any(cp, kindch));
261: }
262: #endif
263: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.