![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stat.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 stat.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 root 1: /*
2: * C compiler.
3: * Statement compilation.
4: * The routines in this file compile C statements.
5: * This file also contains a number of small routines that are
6: * only used by the statement compilation code.
7: * This is the new VAX/VMS base version.
8: */
9: #ifdef vax
10: #include "INC$LIB:cc0.h"
11: #else
12: #include "cc0.h"
13: #endif
14:
15: /*
16: * Compile one statement.
17: * On entry, 's' contains the first symbol of the new statement.
18: * On exit, 's' contains the first token beyond the end of the statement.
19: */
20: statement()
21: {
22: register TREE *tp;
23: register int lab1, lab2;
24: TREE *lp, *rp;
25: TREE *itree, *ctree, *stree;
26: SBLOCK *ssbp;
27: int i, sclab, sblab, tt;
28: ival_t v;
29:
30: loop:
31: dbstat(s, line);
32: switch (s) {
33:
34: case EOF:
35: cerror("unexpected end of file");
36: break;
37:
38: case SEMI:
39: lex();
40: break;
41:
42: case LBRACE:
43: lex();
44: savelocals();
45: ++llex;
46: locals();
47: putautos();
48: while (s!=EOF && s!=RBRACE)
49: statement();
50: mustbe(RBRACE);
51: --llex;
52: downlex();
53: dbstat(RBRACE, line);
54: restlocals();
55: break;
56:
57: case BREAK:
58: lex();
59: if (cblab == 0)
60: cerror("break not in a loop");
61: jump(cblab);
62: mustbe(SEMI);
63: break;
64:
65: case CONTINUE:
66: lex();
67: if (cclab == 0)
68: cerror("continue not in a loop");
69: jump(cclab);
70: mustbe(SEMI);
71: break;
72:
73: case CASE:
74: lex();
75: newtree(sizeof(TREE));
76: ++incase;
77: v = iconexpr();
78: --incase;
79: mustbe(COLON);
80: if (sbp == NULL)
81: cerror("case not in a switch");
82: else
83: newcase(v);
84: goto loop;
85:
86: case DEFAULT:
87: lex();
88: mustbe(COLON);
89: if (sbp == NULL)
90: cerror("default label not in a switch");
91: else {
92: if (sbp->sb_dlab != 0)
93: cerror("only one default label allowed");
94: sbp->sb_dlab = here();
95: }
96: goto loop;
97:
98: case GOTO:
99: lex();
100: if (s != ID) {
101: cerror("missing label name in goto");
102: skip();
103: } else {
104: dogoto();
105: lex();
106: mustbe(SEMI);
107: }
108: break;
109:
110: case IF:
111: lex();
112: tp = pexpr();
113: truth(tp);
114: tput(FEXPR, lab1=newlab(), tp);
115: statement();
116: if (s == ELSE) {
117: lab2 = newlab();
118: jump(lab2);
119: label(lab1);
120: lex();
121: statement();
122: label(lab2);
123: break;
124: }
125: label(lab1);
126: break;
127:
128: case DO:
129: sblab = cblab;
130: sclab = cclab;
131: cblab = newlab();
132: cclab = newlab();
133: lab1 = here();
134: lex();
135: statement();
136: label(cclab);
137: dbstat(s, line);
138: mustbe(WHILE);
139: tp = pexpr();
140: truth(tp);
141: tput(TEXPR, lab1, tp);
142: label(cblab);
143: mustbe(SEMI);
144: cclab = sclab;
145: cblab = sblab;
146: break;
147:
148: case WHILE:
149: sblab = cblab;
150: sclab = cclab;
151: cblab = newlab();
152: cclab = here();
153: lex();
154: tp = pexpr();
155: truth(tp);
156: tput(FEXPR, cblab, tp);
157: statement();
158: jump(cclab);
159: label(cblab);
160: cclab = sclab;
161: cblab = sblab;
162: break;
163:
164: case SWITCH:
165: lex();
166: tp = pexpr();
167: tt = tltype(tp);
168: if (tt > T_UINT)
169: cerror("switch of non integer");
170: if (tt != T_INT) {
171: rp = NULL;
172: if (tt == T_PTR)
173: rp = bzcon(psize(tp));
174: tp = bconvert(tp, T_INT, NULL, NULL, rp);
175: }
176: tput(SEXPR, 0, tp);
177: ssbp = sbp;
178: sbp = (SBLOCK *) new(sizeof(SBLOCK));
179: sbp->sb_dlab = 0;
180: sbp->sb_ncase = 0;
181: sblab = cblab;
182: cblab = newlab();
183: statement();
184: jump(cblab);
185: if (sbp->sb_dlab==0 && sbp->sb_ncase==0)
186: cwarn("empty switch");
187: if (sbp->sb_dlab == 0)
188: sbp->sb_dlab = cblab;
189: bput(SBODY);
190: iput((ival_t) sbp->sb_dlab);
191: iput((ival_t) sbp->sb_ncase);
192: for (i=0; i<sbp->sb_ncase; ++i) {
193: iput((ival_t) sbp->sb_case[i].sc_val);
194: iput((ival_t) sbp->sb_case[i].sc_lab);
195: }
196: label(cblab);
197: cblab = sblab;
198: free((char *) sbp);
199: sbp = ssbp;
200: break;
201:
202: case FOR:
203: lex();
204: mustbe(LPAREN);
205: newtree(sizeof(TREE));
206: itree = NULL;
207: if (s != SEMI)
208: itree = expr();
209: mustbe(SEMI);
210: ctree = NULL;
211: if (s != SEMI) {
212: ctree = expr();
213: truth(ctree);
214: }
215: mustbe(SEMI);
216: stree = NULL;
217: if (s != RPAREN)
218: stree = expr();
219: mustbe(RPAREN);
220: sblab = cblab;
221: sclab = cclab;
222: cblab = newlab();
223: cclab = newlab();
224: if (itree != NULL) {
225: tput(EEXPR, 0, itree);
226: }
227: if (stree != NULL)
228: jump(lab1 = newlab());
229: label(cclab);
230: if (stree != NULL) {
231: tput(EEXPR, 0, stree);
232: label(lab1);
233: }
234: if (ctree != NULL) {
235: tput(FEXPR, cblab, ctree);
236: }
237: statement();
238: jump(cclab);
239: label(cblab);
240: cclab = sclab;
241: cblab = sblab;
242: break;
243:
244: case RETURN:
245: lex();
246: if (s != SEMI) {
247: newtree(sizeof(TREE));
248: tp = expr();
249: lp = talloc();
250: lp->t_op = CONVERT;
251: lp->t_type = cfsym->s_type;
252: lp->t_dp = cfsym->s_dp->d_dp; /* Skip D_FUNC */
253: lp->t_ip = cfsym->s_ip;
254: if (lp->t_dp==NULL && lp->t_type==T_VOID) {
255: cerror("return(e) illegal in void function");
256: mustbe(SEMI);
257: break;
258: }
259: if ((tltype(lp)==T_STRUCT || tltype(tp)==T_STRUCT)
260: && (lp->t_type!=tp->t_type||lp->t_dp!=tp->t_dp||lp->t_ip!=tp->t_ip)) {
261: cerror("return type/function type mismatch");
262: mustbe(SEMI);
263: break;
264: }
265: if (bitcompat(tltype(lp), tltype(tp)))
266: adjust(tp, lp->t_type, lp->t_dp, lp->t_ip);
267: else {
268: lp->t_lp = tp;
269: tp = lp;
270: }
271: tput(REXPR, 0, tp);
272: }
273: jump(cflab);
274: mustbe(SEMI);
275: break;
276:
277: case ID:
278: if (spnextis(':')) {
279: dolabel();
280: lex();
281: lex();
282: goto loop;
283: }
284:
285: default:
286: newtree(sizeof(TREE));
287: tp = expr();
288: tput(EEXPR, 0, tp);
289: mustbe(SEMI);
290: }
291: }
292:
293: /*
294: * Check if the given tree can be used in a truth value context.
295: * Put out the appropriate diagnostics.
296: * What does this have to do with stat()?
297: */
298: truth(tp)
299: TREE *tp;
300: {
301: register int tt, op;
302:
303: tt = tltype(tp);
304: op = tp->t_op;
305: if (tt>=T_STRUCT && tt<=T_FUNION)
306: cerror("structure or union used in truth context");
307: if (incpp)
308: return;
309: if (isvariant(VSCCON) && (op==ICON || op==LCON || op==DCON))
310: cstrict("constant used in truth context");
311: if (isvariant(VSRTVC)) {
312: if ((tt>=T_PTR && tt<=T_DOUBLE)
313: || (op==EQ && tp->t_lp->t_type==T_DOUBLE))
314: cstrict("risky type in truth context");
315: }
316: }
317:
318: /*
319: * Read an expression enclosed in parentheses.
320: * Used to read the control expressions in 'if', 'do', 'while' and 'switch'.
321: */
322: TREE *
323: pexpr()
324: {
325: register TREE *tp;
326:
327: mustbe(LPAREN);
328: newtree(sizeof(TREE));
329: tp = expr();
330: mustbe(RPAREN);
331: return (tp);
332: }
333:
334: /*
335: * Labels.
336: */
337: dolabel()
338: {
339: register SYM *sp;
340: register int c;
341:
342: sp = deflookup(SL_LAB, 2);
343: c = sp->s_class;
344: if (c==C_NONE || c==C_FREF) {
345: if (c == C_NONE)
346: sp->s_value = newlab();
347: sp->s_class = C_LAB;
348: label(sp->s_value);
349: dblabel(sp);
350: } else
351: cerror("illegal label \"%s\"", sp->s_id);
352: }
353:
354: /*
355: * The dreaded 'goto' statement.
356: */
357: dogoto()
358: {
359: register SYM *sp;
360: register int c;
361:
362: sp = deflookup(SL_LAB, 2);
363: c = sp->s_class;
364: if (c == C_NONE) {
365: sp->s_class = C_FREF;
366: sp->s_value = newlab();
367: } else if (c!=C_LAB && c!=C_FREF)
368: cerror("identifier \"%s\" is not a label", sp->s_id);
369: jump(sp->s_value);
370: sp->s_flag |= S_USED;
371: }
372:
373: /*
374: * Append a new case to the current switch,
375: * adjusting the size of the switch block if necessary and possible.
376: */
377: newcase(v)
378: ival_t v;
379: {
380: SBLOCK *ssbp;
381: register SCASE *scp, *ocp;
382: register int i;
383:
384: i = sbp->sb_ncase;
385: scp = sbp->sb_case;
386: while (--i >= 0) {
387: if (scp->sc_val == v) {
388: cerror("duplicated case constant");
389: return;
390: } else
391: scp += 1;
392: }
393: i = sbp->sb_ncase;
394: scp = &sbp->sb_case[i];
395: if ((i % 32) == 0) {
396: ssbp = sbp;
397: sbp = new(sizeof(SBLOCK) + (i+32) * sizeof(SCASE));
398: sbp->sb_ncase = ssbp->sb_ncase;
399: sbp->sb_dlab = ssbp->sb_dlab;
400: scp = sbp->sb_case;
401: ocp = ssbp->sb_case;
402: while (--i >= 0) {
403: scp->sc_val = ocp->sc_val;
404: scp->sc_lab = ocp->sc_lab;
405: scp += 1;
406: ocp += 1;
407: }
408: free((char *) ssbp);
409: scp = &sbp->sb_case[sbp->sb_ncase];
410: }
411: scp->sc_val = v;
412: scp->sc_lab = here();
413: sbp->sb_ncase += 1;
414: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.