![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcl2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00|
Return to dcl2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00 |
1.1 root 1: /*ident "@(#)ctrans:src/dcl2.c 1.3.4.22" */
2: /**************************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All Rights Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: dcl2.c:
11:
12: *************************************************************************/
13:
14: #include "cfront.h"
15: #include "size.h"
16:
17: Pname conv_dominates(Pname on1, Pname on2)
18: /*
19: compare for duplicates and dominance:
20:
21: on1 and on2 are two conversion operator functions
22: return the the one that dominates the other (according to the
23: class hierarchy) otherwise 0 (0 thus indicats ambiguous conversion)
24: */
25: {
26: Ptype r1 = Pfct(on1->tp)->returns;
27: Ptype r2 = Pfct(on2->tp)->returns;
28: //error('d',"conv_dominates(%n,%n)",on1,on2);
29: if (r1==r2 || r1->check(r2,0)==0) return on1;
30: Pptr p1 = r1->is_ptr_or_ref();
31: Pptr p2 = r2->is_ptr_or_ref();
32: if (p1 && p2) {
33: Pname cn1 = p1->typ->is_cl_obj();
34: Pname cn2 = p2->typ->is_cl_obj();
35: if (cn1 && cn2) {
36: // is_cl_obj() returns b_name
37: // Pclass c1 = Pclass(Pbase(cn1->tp)->b_name->tp);
38: // Pclass c2 = Pclass(Pbase(cn2->tp)->b_name->tp);
39: Pclass c1 = Pclass(cn1->tp);
40: Pclass c2 = Pclass(cn2->tp);
41: if (c1 && c2) {
42: if (c1==c2 || c1->has_base(c2))
43: return on1;
44: else if (c2->has_base(c1))
45: return on2;
46: }
47: }
48: }
49: return 0;
50: }
51:
52:
53: Pstmt curr_loop;
54: Pstmt curr_switch;
55: Pblock curr_block;
56:
57: void stmt::reached()
58: {
59: register Pstmt ss = s_list;
60:
61: if (ss == 0) return;
62:
63: switch (ss->base) {
64: case LABEL:
65: case CASE:
66: case DEFAULT:
67: break;
68: default:
69: error('w',"S after%k not reached",base);
70: for (; ss; ss=ss->s_list) { // delete unreacheable code
71: switch (ss->base) {
72: case LABEL:
73: case CASE:
74: case DEFAULT: // reachable
75: s_list = ss;
76: return;
77: case DCL: // the dcl may be used later
78: // keep to avoid cascading errors
79: case IF:
80: case DO:
81: case WHILE:
82: case SWITCH:
83: case FOR:
84: case BLOCK: // may hide a label
85: s_list = ss;
86: return;
87: }
88: }
89: s_list = 0;
90: }
91: }
92:
93: bit arg_err_suppress;
94:
95: Pexpr check_cond(Pexpr e, TOK b, Ptable tbl)
96: {
97: //error('d',"check_cond(%k %k) tbl %d",e->base,b,tbl);
98: Pname cn;
99:
100: if (e == dummy) error("empty condition for %k",b);
101:
102: if (cn = e->tp->is_cl_obj()) {
103: Pclass cl = Pclass(cn->tp);
104: int i = 0;
105: Pname found = 0;
106: for (Pname on = cl->conv; on; on=on->n_list) {
107: Pfct f = Pfct(on->tp);
108: Ptype t = f->returns;
109: xx:
110: switch (t->base) {
111: case TYPE:
112: t = Pbase(t)->b_name->tp;
113: goto xx;
114: case FLOAT:
115: case DOUBLE:
116: case LDOUBLE:
117: case PTR:
118: if (b == DEREF) break;
119: case CHAR:
120: case SHORT:
121: case INT:
122: case LONG:
123: case EOBJ:
124: // if (found==0 || found->tp->check(on->tp,0)) {
125: //error('d',"found %n on %n",found,on);
126: { Pname xx = found;
127: if (found == 0) {
128: i = 1;
129: found = on;
130: }
131: else if ((found = conv_dominates(found,on)) == 0) {
132: i = 2;
133: found = on;
134: error("two conversions for%nO in%kE: %n and %n",cn,b,xx,on);
135: return e;
136: }
137: }
138: }
139: }
140: //error('d',"i %d",i);
141: switch (i) {
142: case 0:
143: error("%nO in%kE",cn,b);
144: return e;
145: /*
146: case 1:
147: { Pname xx = new name(found->string);
148: Pref r = new ref(DOT,e,xx);
149: Pexpr rr = r->typ(tbl);
150: Pexpr c = new expr(G_CALL,rr,0);
151:
152: if (e->lval(0)) {
153: // Pref r = new ref(DOT,e,found);
154: // r->tp = found->tp;
155: // Pexpr c = new expr(G_CALL,r,0);
156: // c->fct_name = found;
157: return c->typ(tbl);
158: }
159: else { // (temp=init,temp.coerce())
160: Pname tmp = make_tmp('U',e->tp,tbl);
161: Pexpr ass = init_tmp(tmp,e,tbl);
162: // Pref r = new ref(DOT,tmp,found);
163: // Pexpr rr = r->typ(tbl);
164: // Pexpr c = new expr(G_CALL,rr,0);
165: // c->fct_name = found;
166: ass = new expr(CM,ass,c);
167: return ass->typ(tbl);
168: }
169: }
170: */
171: case 1:
172: { Pname xx = new name(found->string);
173: Pexpr c;
174:
175: if (e->lval(0)) {
176: Pref r = new ref(DOT,e,xx);
177: Pexpr rr = r->typ(tbl);
178: c = new expr(G_CALL,rr,0);
179: }
180: else { // (temp=init,temp.coerce())
181: Pname tmp = make_tmp('U',e->tp,tbl);
182: Pexpr ass = init_tmp(tmp,e,tbl);
183: Pref r = new ref(DOT,tmp,xx);
184: Pexpr rr = r->typ(tbl);
185: c = new expr(G_CALL,rr,0);
186: c = new expr(CM,ass,c);
187: }
188: return c->typ(tbl);
189: }
190: // default:
191: // error("%d possible conversions for%nO in%kE",i,cn,b);
192: // return e;
193: }
194:
195: }
196: if (e->tp->memptr()) {
197: e = new mdot("i",e);
198: e->i1 = 9;
199: e = new expr(NE,e,zero);
200: }
201: else if (e->tp->num_ptr(b) == FCT)
202: error("%k(F)",b);
203: return e;
204: }
205:
206: void stmt::dcl()
207: /*
208: typecheck statement "this" in scope "curr_block->tbl"
209: */
210: {
211: Pstmt ss;
212: Pname n;
213: Pname nn;
214: Pstmt ostmt = Cstmt;
215: for (ss=this; ss; ss=ss->s_list) {
216: Pstmt old_loop, old_switch;
217: Cstmt = ss;
218: Ptable tbl = curr_block->memtbl;
219: //error('d',"stmt::dcl %k",ss->base);
220: switch (ss->base) {
221: case BREAK:
222: inline_restr |= 16;
223: if (curr_loop==0 && curr_switch==0)
224: error("break not in loop or switch");
225: ss->reached();
226: break;
227:
228: case CONTINUE:
229: inline_restr |= 32;
230: if (curr_loop == 0) error("continue not in loop");
231: ss->reached();
232: break;
233:
234: case DEFAULT:
235: if (curr_switch == 0) {
236: error("default not in switch");
237: break;
238: }
239: if (curr_switch->has_default) error("two defaults in switch");
240: curr_switch->has_default = ss;
241: ss->s->s_list = ss->s_list;
242: ss->s_list = 0;
243: ss->s->dcl();
244: break;
245:
246: case SM:
247: { if (ss->e ==0) break;
248: TOK b = ss->e->base;
249: switch (b) {
250: case DUMMY:
251: ss->e = 0;
252: break;
253: // check for unused results
254: // don't check operators that are likely
255: // to be overloaded to represent "actions":
256: // ! ~ < <= > >= << >>
257: case EQ:
258: case NE:
259: case PLUS:
260: case MINUS:
261: case REF:
262: case DOT:
263: case MUL:
264: case DIV:
265: case ADDROF:
266: case AND:
267: case OR:
268: case ER:
269: case DEREF:
270: case ANDAND:
271: case OROR:
272: case NAME:
273: case VALUE:
274: if (ss->e->tp) break; // avoid looking at generated code
275: ss->e = ss->e->typ(tbl);
276: if (ss->e->base == CALL) break;
277: if (ss->e->tp->base != VOID) {
278: error('w',"result of%kE not used",b);
279: if (ss->e->not_simple()==0) ss->e = dummy;
280: }
281: break;
282: default:
283: ss->e = ss->e->typ(tbl);
284: }
285: break;
286: }
287: case RETURN:
288: { Pname fn = cc->nof;
289: Pfct f = Pfct(fn->tp);
290: Ptype rt = f->returns;
291: Pexpr v = ss->e;
292: //error('d',"rt %t",rt);
293: if (v != dummy) {
294: while (rt->base == TYPE) rt = Pbase(rt)->b_name->tp;
295: extern ref_initializer;
296: if (rt->base == RPTR) {
297: ref_initializer++;
298: v = v->typ(tbl);
299: ref_initializer--;
300: } else
301: v = v->typ(tbl);
302:
303: if (fn->n_oper==CTOR
304: || fn->n_oper==DTOR
305: || (rt->base==VOID && v->tp!=void_type)) {
306: error("unexpected return value");
307: // refuse to return the value:
308: ss->e = dummy;
309: }
310: else {
311: lx:
312: switch (rt->base) {
313: case TYPE:
314: rt = Pbase(rt)->b_name->tp;
315: goto lx;
316: case RPTR:
317: switch (v->base) {
318: case NAME:
319: if (Pname(v)->n_scope==FCT
320: || Pname(v)->n_scope==ARG)
321: error('w',"R to localV returned");
322: break;
323: case ICON:
324: case CCON:
325: case FCON:
326: case STRING:
327: if (Pptr(rt)->typ->tconst()==0)
328: error('w',"R to literal returned");
329: }
330: v = ref_init(Pptr(rt),v,tbl);
331: if (v->base==G_CM
332: && v->e2->base==G_ADDROF
333: && v->e2->e2->base==NAME)
334: error('w',"R to temporary returned (return value is not lvalue or of wrongT)");
335: case ANY:
336: break;
337: case COBJ:
338: if (v->base == DEREF) {
339: Pexpr v1 = v->e1;
340: if (v1->base==CAST) {
341: Pexpr v2 = v1->e1;
342: if (v2->base == G_CM) { // *(T)(e1,e2) => (e1,*(T)e2)
343: Pexpr v3 = v2->e2;
344: v2->e2 = v;
345: v2->tp = v->tp;
346: v = v2;
347: v1->e1 = v3;
348: }
349: }
350: }
351: if (f->f_result) {
352: if (v->base==G_CM && rt->check(v->tp,0/*ASSIGN*/)==0)
353: v = replace_temp(v,f->f_result);
354: else {
355: v = class_init(f->f_result->contents(),rt,v,tbl);
356: Pname rcn = rt->is_cl_obj();
357: if (Pclass(rcn->tp)->has_itor()==0) {
358: // can happen for virtuals and for user defined conversions
359: v->tp = rt;
360: v = new expr(ASSIGN,f->f_result->contents(),v);
361: v->tp = rt;
362: }
363: }
364: }
365: else
366: v = class_init(0,rt,v,tbl);
367: break;
368: case PTR:
369: { Pexpr x = v;
370: v = ptr_init(Pptr(rt),v,tbl);
371: if (v->base == ADDROF
372: && v->e2->base == NAME
373: && Pname(v->e2)->n_stclass == AUTO)
374: error('w',"P to local variable%n returned",Pname(v->e2));
375: // if (v==x ||v->e2==x) goto def;
376: if (Pchecked == 0) goto def;
377: goto ret_save;
378: // break;
379: }
380: case INT:
381: case CHAR:
382: case LONG:
383: case SHORT:
384: if (Pbase(rt)->b_unsigned
385: && v->base==UMINUS
386: && v->e2->base==ICON)
387: error('w',"negative retured fromF returning unsigned");
388: default:
389: def:
390: {
391: Pexpr x = try_to_coerce(rt,v,"return value",tbl);
392: if (x)
393: v = x;
394: else if (rt->check(v->tp,ASSIGN))
395: error("bad return valueT for%n:%t (%tX)",fn,v->tp,rt);
396: }
397:
398: }
399: ret_save:
400: ss->ret_tp = rt;
401: ss->e = v;
402: }
403: }
404: else {
405: if (rt->base != VOID) error("return valueX");
406: }
407: ss->reached();
408: break;
409: }
410:
411: case DO: // in DO the stmt is before the test
412: inline_restr |= 8;
413: old_loop = curr_loop;
414: curr_loop = ss;
415: if (ss->s->base == DCL) error("D as onlyS in do-loop");
416: ss->s->dcl();
417: ss->e = ss->e->typ(tbl);
418: ss->e = check_cond(ss->e,DO,tbl);
419: curr_loop = old_loop;
420: break;
421:
422: case WHILE:
423: inline_restr |= 8;
424: old_loop = curr_loop;
425: curr_loop = ss;
426: ss->e = ss->e->typ(tbl);
427: ss->e = check_cond(ss->e,WHILE,tbl);
428: if (ss->s->base == DCL) error("D as onlyS in while-loop");
429: ss->s->dcl();
430: curr_loop = old_loop;
431: break;
432:
433: case SWITCH:
434: { int ne = 0;
435: inline_restr |= 4;
436: old_switch = curr_switch;
437: curr_switch = ss;
438: ss->e = ss->e->typ(tbl);
439: ss->e = check_cond(ss->e,SWITCH,tbl);
440: if (ss->s->base == DCL) error("D as onlyS in switchS");
441: { Ptype tt = ss->e->tp;
442: sii:
443: switch (tt->base) {
444: case TYPE:
445: tt = Pbase(tt)->b_name->tp; goto sii;
446: case EOBJ:
447: ne = Penum(Pbase(tt)->b_name->tp)->no_of_enumerators;
448: case ZTYPE:
449: case ANY:
450: case CHAR:
451: case SHORT:
452: case INT:
453: case LONG:
454: case FIELD:
455: break;
456: default:
457: error("%t switchE",ss->e->tp);
458: }
459: }
460: ss->s->dcl();
461: if (ne) { /* see if the number of cases is "close to"
462: but not equal to the number of enumerators
463: */
464: int i = 0;
465: Pstmt cs;
466: for (cs=ss->case_list; cs; cs=cs->case_list) i++;
467: if (i && i!=ne) {
468: if (ne < i) {
469: ee: error('w',"switch (%t)W %d cases (%d enumerators)",ss->e->tp,i,ne);
470: }
471: else {
472: switch (ne-i) {
473: case 1: if (3<ne) goto ee;
474: case 2: if (7<ne) goto ee;
475: case 3: if (23<ne) goto ee;
476: case 4: if (60<ne) goto ee;
477: case 5: if (99<ne) goto ee;
478: }
479: }
480: }
481: }
482: curr_switch = old_switch;
483: break;
484: }
485: case CASE:
486: if (curr_switch == 0) {
487: error("case not in switch");
488: break;
489: }
490: ss->e = ss->e->typ(tbl);
491: ss->e->tp->num_ptr(CASE);
492: { Ptype tt = ss->e->tp;
493: iii:
494: switch (tt->base) {
495: case TYPE:
496: tt = Pbase(tt)->b_name->tp; goto iii;
497: case ZTYPE:
498: case ANY:
499: case CHAR:
500: case SHORT:
501: case INT:
502: case LONG:
503: case EOBJ:
504: Neval = 0;
505: long i = ss->e->eval();
506: if (Neval == 0) {
507: Pstmt cs;
508: if (largest_int<i) error("long case value");
509: for (cs=curr_switch->case_list; cs; cs=cs->case_list) {
510: if (cs->case_value == i) error("case %d used twice in switch",i);
511: }
512: ss->case_value = int(i);
513: ss->case_list = curr_switch->case_list;
514: curr_switch->case_list = ss;
515: }
516: else
517: error("bad case label: %s",Neval);
518: break;
519: default:
520: error("%t caseE",ss->e->tp);
521: }
522: }
523: // if (1) {
524: // Neval = 0;
525: // long i = ss->e->eval();
526: // if (Neval == 0) {
527: // Pstmt cs;
528: // if (largest_int<i) error("long case value");
529: // for (cs=curr_switch->case_list; cs; cs=cs->case_list) {
530: // if (cs->case_value == i) error("case %d used twice in switch",i);
531: // }
532: // ss->case_value = int(i);
533: // ss->case_list = curr_switch->case_list;
534: // curr_switch->case_list = ss;
535: // }
536: // else
537: // error("bad case label: %s",Neval);
538: // }
539: if (ss->s->s_list) error('i',"case%k",ss->s->s_list->base);
540: ss->s->s_list = ss->s_list;
541: ss->s_list = 0;
542: ss->s->dcl();
543: break;
544:
545: case GOTO:
546: inline_restr |= 2;
547: ss->reached();
548: case LABEL:
549: /* Insert label in function mem table;
550: labels have function scope.
551: */
552: n = ss->d;
553: nn = cc->ftbl->insert(n,LABEL);
554:
555: /* Set a ptr to the mem table corresponding to the scope
556: in which the label actually occurred. This allows the
557: processing of goto's in the presence of ctors and dtors
558: */
559: if (ss->base == LABEL) {
560: nn->n_realscope = curr_block->memtbl;
561: inline_restr |= 1;
562: }
563:
564: if (Nold) {
565: if (ss->base == LABEL) {
566: if (nn->n_initializer) error("twoDs of label%n",n);
567: nn->n_initializer = (Pexpr)1;
568: }
569: if (n != nn) ss->d = nn;
570: }
571: else {
572: if (ss->base == LABEL) nn->n_initializer = (Pexpr)1;
573: nn->where = ss->where;
574: }
575: if (ss->base == GOTO)
576: nn->use();
577: else {
578: if (ss->s->s_list) error('i',"label%k",ss->s->s_list->base);
579: ss->s->s_list = ss->s_list;
580: ss->s_list = 0;
581: nn->assign();
582: }
583: if (ss->s) ss->s->dcl();
584: break;
585:
586: case IF:
587: {
588: Pexpr ee = ss->e->typ(tbl);
589: if (ee->base == ASSIGN) {
590: Neval = 0;
591: (void)ee->e2->eval();
592: if (Neval == 0)
593: error('w',"constant assignment in condition");
594: }
595: ss->e = ee = check_cond(ee,IF,tbl);
596:
597: if (ss->s->base == DCL) error("D as onlyS after `if'");
598:
599: // pointer to member returns with a tp set to 0
600: if ( ee->tp ) switch (ee->tp->base) {
601: case INT:
602: case EOBJ:
603: case ZTYPE:
604: { long i;
605: Neval = 0;
606: i = ee->eval();
607:
608: if (Neval == 0) {
609: Pstmt sl = ss->s_list;
610: if (i) {
611: DEL(ss->else_stmt);
612: ss->s->dcl();
613: *ss = *ss->s;
614: }
615: else {
616: DEL(ss->s);
617: if (ss->else_stmt) {
618: ss->else_stmt->dcl();
619: *ss = *ss->else_stmt;
620: }
621: else {
622: ss->base = SM;
623: ss->e = dummy;
624: ss->s = 0;
625: }
626: }
627: ss->s_list = sl;
628: continue;
629: }
630: }
631: }
632: ss->s->dcl();
633: if (ss->else_stmt) {
634: if (ss->else_stmt->base == DCL) error("D as onlyS after `else'");
635: ss->else_stmt->dcl();
636: }
637: break;
638: }
639: case FOR:
640: inline_restr |= 8;
641: old_loop = curr_loop;
642: curr_loop = ss;
643: if (ss->for_init) {
644: Pstmt fi = ss->for_init;
645: switch (fi->base) {
646: case SM:
647: if (fi->e == dummy) {
648: ss->for_init = 0;
649: break;
650: }
651: default:
652: fi->dcl();
653: break;
654: case DCL:
655: // if ()
656: // {
657: // // for (dcl; e1; e2) stmt1 stmt2
658: // // => { dcl; for( ; e1; e2) stmt1 } stmt2
659: // ss->base = BLOCK;
660: // ss->d = fi->d;
661: // ss->s = new forstmt(ss->where,new estmt(SM,ss->where,dummy,0),ss->e,ss->e2,ss->s);
662: // Pblock(ss)->dcl(tbl);
663: // continue;
664: // }
665: // else {
666: fi->dcl();
667: switch (fi->base) {
668: case BLOCK:
669: {
670: // { ... for( { a } b ; c) d ; e }
671: // => { ... { a for ( ; b ; c) d ; e }}
672: Pstmt tmp = new stmt (SM,curloc,0);
673: *tmp = *ss; // tmp = for
674: tmp->for_init = 0;
675: *ss = *fi; // ss = { }
676: if (ss->s)
677: ss->s->s_list = tmp;
678: else
679: ss->s = tmp;
680: curr_block = Pblock(ss);
681: tbl = curr_block->memtbl;
682: Cstmt = ss = tmp; // rest of for and s_list
683: break;
684: }
685: }
686: // }
687:
688: }
689: }
690: if (ss->e == dummy)
691: ss->e = 0;
692: else {
693: ss->e = ss->e->typ(tbl);
694: ss->e = check_cond(ss->e,FOR,tbl);
695: }
696: if (ss->s->base == DCL) error("D as onlyS in for-loop");
697: ss->s->dcl();
698: ss->e2 = (ss->e2 == dummy) ? 0 : ss->e2->typ(tbl);
699: curr_loop = old_loop;
700: break;
701:
702: case DCL: /* declaration after statement */
703: {
704: /* collect all the contiguous DCL nodes from the
705: head of the s_list. find the next statement
706: */
707: int non_trivial = 0;
708: int count = 0;
709: Pname tail = ss->d;
710: for (Pname nn=tail; nn; nn=nn->n_list) {
711: // find tail;
712: // detect non-trivial declarations
713: count++;
714:
715: if (nn->n_list) tail = nn->n_list;
716: Pname n = tbl->look(nn->string,0);
717:
718: if (n && n->n_table==tbl) non_trivial = 2;
719: if (non_trivial == 2) continue;
720: if ((nn->n_sto==STATIC && nn->tp->base!=FCT)
721: || nn->tp->is_ref()
722: || (nn->tp->tconst() && fct_const==0)) {
723: non_trivial = 2;
724: continue;
725: }
726:
727: Pexpr in = nn->n_initializer;
728: if (in)
729: switch (in->base) {
730: case ILIST:
731: case STRING:
732: non_trivial = 2;
733: continue;
734: default:
735: non_trivial = 1;
736: }
737: Pname cln = nn->tp->is_cl_obj();
738: if (cln == 0) cln = cl_obj_vec;
739: if (cln == 0) continue;
740: if (Pclass(cln->tp)->has_ctor()) {
741: non_trivial = 2;
742: continue;
743: }
744: if (Pclass(cln->tp)->has_dtor()) non_trivial = 2;
745: }
746:
747: while( ss->s_list && ss->s_list->base==DCL ) {
748: Pstmt sx = ss->s_list;
749: tail = tail->n_list = sx->d; // add to tail
750: for (nn=sx->d; nn; nn=nn->n_list) {
751: // find tail;
752: // detect non-trivial declarations
753: count++;
754: if (nn->n_list) tail = nn->n_list;
755: Pname n = tbl->look(nn->string,0);
756: if (n && n->n_table==tbl) non_trivial = 2;
757: if (non_trivial == 2) continue;
758: if ((nn->n_sto==STATIC && nn->tp->base!=FCT)
759: || nn->tp->is_ref()
760: || (nn->tp->tconst() && fct_const==0)) {
761: non_trivial = 2;
762: continue;
763: }
764: Pexpr in = nn->n_initializer;
765: if (in)
766: switch (in->base) {
767: case ILIST:
768: case STRING:
769: non_trivial = 2;
770: continue;
771: }
772: non_trivial = 1;
773: Pname cln = nn->tp->is_cl_obj();
774: if (cln == 0) cln = cl_obj_vec;
775: if (cln == 0) continue;
776: if (Pclass(cln->tp)->has_ctor()) {
777: non_trivial = 2;
778: continue;
779: }
780: if (Pclass(cln->tp)->has_dtor()) continue;
781: }
782: ss->s_list = sx->s_list;
783: /* delete sx; */
784: }
785:
786: Pstmt next_st = ss->s_list;
787: if (non_trivial==2 // must
788: || (non_trivial==1 // might
789: && ( curr_block->own_tbl==0 // why not?
790: || inline_restr&3 /* label seen */)
791: )
792: ) {
793: if (curr_switch && non_trivial==2) {
794: Pstmt cs = curr_switch->case_list;
795: Pstmt ds = curr_switch->has_default;
796: Pstmt bl;
797: if (cs == 0)
798: bl = ds;
799: else if (ds == 0)
800: bl = cs;
801: else if (cs->where.line<ds->where.line)
802: bl = ds;
803: else
804: bl = cs;
805:
806: if ((bl==0 || bl->s->base!=BLOCK) && curr_switch->s->memtbl==tbl)
807: error('s',"non trivialD in switchS (try enclosing it in a block)");
808: }
809:
810: /* Create a new block,
811: put all the declarations at the head,
812: and the remainder of the slist as the
813: statement list of the block.
814: */
815: ss->base = BLOCK;
816:
817: /* check that there are no redefinitions since the last
818: "real" (user-written, non-generated) block
819: */
820: for( nn=ss->d; nn; nn=nn->n_list ) {
821: Pname n;
822: if( curr_block->own_tbl
823: && (n=curr_block->memtbl->look(nn->string,0))
824: && n->n_table->real_block==curr_block->memtbl->real_block
825: && n->tp->base!=FCT && n->tp->base!=OVERLOAD
826: && nn->lex_level == n->lex_level )
827: error("twoDs of%n",n);
828: }
829:
830: /* attach the remainder of the s_list
831: as the statement part of the block.
832: */
833: ss->s = next_st;
834: ss->s_list = 0;
835:
836: /* create the table in advance, in order to set the
837: real_block ptr to that of the enclosing table
838: */
839: ss->memtbl = new table(count+4,tbl,0);
840: ss->memtbl->real_block = curr_block->memtbl->real_block;
841: Pblock(ss)->dcl(ss->memtbl);
842: }
843: else { /* to reduce the number of symbol tables,
844: do not make a new block,
845: instead insert names in enclosing block,
846: and make the initializers into expression
847: statements.
848: */
849: Pstmt sss = ss;
850: for( nn=ss->d; nn; nn=nn->n_list ) {
851: Pname n;
852: //error('d',"nn %n",nn);
853: if( curr_block->own_tbl
854: && (n=curr_block->memtbl->look(nn->string,0))
855: && n->n_table->real_block==curr_block->memtbl->real_block
856: && n->tp->base!=FCT && n->tp->base!=OVERLOAD
857: && nn->lex_level == n->lex_level )
858: {
859: printf( "\ndump tables: bl_level: %d", bl_level );
860: /*
861: //extern void display_table( Ptable,int=0 );display_table(curr_block->memtbl);
862: //extern void display_name( Pname ); display_name( nn ); display_name(n);
863: */
864: error("twoDs of%n",n);
865: }
866: //error("twoDs of%n",n);
867: /*Pname */n = nn->dcl(tbl,FCT);
868:
869: if (n == 0) {
870: if (ss) {
871: ss->base = SM;
872: ss->e = 0;
873: }
874: continue;
875: }
876:
877: Pexpr in = n->n_initializer;
878: n->n_initializer = 0;
879:
880: if (ss) {
881: sss->base = SM;
882: ss = 0;
883: }
884: else
885: sss = sss->s_list = new estmt(SM,sss->where,0,0);
886: if (in) {
887: switch (in->base) {
888: case G_CALL: /* constructor? */
889: {
890: Pname fn = in->fct_name;
891: if (fn && fn->n_oper==CTOR) break;
892: }
893: default:
894: in = new expr(ASSIGN,n,in);
895: in->tp = n->tp;
896: }
897: // sss->e = in->typ(tbl);
898: sss->e = in;
899: }
900: else
901: sss->e = dummy;
902: }
903:
904: ss = sss;
905: ss->s_list = next_st;
906: }
907: break;
908: }
909:
910: case BLOCK:
911: Pblock(ss)->dcl(tbl);
912: break;
913:
914: case ASM:
915: /* save string */
916: {
917: char* s = (char*)ss->e;
918: int ll = strlen(s);
919: char* s2 = new char[ll+1];
920: strcpy(s2,s);
921: ss->e = Pexpr(s2);
922: break;
923: }
924: default:
925: error('i',"badS(%p %d)",ss,ss->base);
926: }
927: }
928: Cstmt = ostmt;
929: }
930:
931: extern int in_class_dcl;
932: void block::dcl(Ptable tbl)
933: /*
934: Note: for a block without declarations memtbl denotes the table
935: for the enclosing scope.
936: A function body has its memtbl created by fct::dcl().
937: */
938: {
939: int bit_old = bit_offset;
940: int byte_old = byte_offset;
941: int max_old = max_align;
942: Pblock block_old = curr_block;
943:
944: if (base != BLOCK) error('i',"block::dcl(%d)",base);
945:
946: curr_block = this;
947: //error('d',"block %k %k",d?d->base:0,s?s->base:0);
948: if (d) {
949: own_tbl = 1;
950: if (memtbl == 0) {
951: int nmem = d->no_of_names()+4;
952: memtbl = new table(nmem,tbl,0);
953: memtbl->real_block = this;
954: /* this is a "real" block from the
955: source text, and not one created by DCL's
956: inside a block. */
957: }
958: else
959: if (memtbl != tbl) error('i',"block::dcl(?)");
960:
961: Pname nx;
962: for (Pname n=d; n; n=nx) {
963: nx = n->n_list;
964: n->dcl(memtbl,FCT);
965: switch (n->tp->base) {
966: case CLASS:
967: case ANON:
968: case ENUM:
969: break;
970: default:
971: delete n;
972: }
973: }
974: }
975: else
976: memtbl = tbl;
977:
978: if (s) {
979: Pname odcl = Cdcl;
980: Pname m;
981: int i;
982:
983: s->dcl();
984:
985: if (own_tbl)
986: for (m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i)) {
987: Ptype t = m->tp;
988:
989: if (in_class_dcl) m->lex_level -= 1;
990:
991: if (t == 0) {
992: if (m->n_assigned_to == 0)
993: error("label %sU",m->string);
994: if (m->n_used == 0)
995: error('w',"label %s not used", m->string);
996: continue;
997: }
998: ll:
999: switch (t->base) {
1000: case TYPE: t = Pbase(t)->b_name->tp; goto ll;
1001: case CLASS:
1002: case ANON:
1003: case ENUM:
1004: case FCT:
1005: case VEC: continue;
1006: }
1007:
1008: if (m->n_addr_taken == 0) {
1009: if (m->n_used) {
1010: if (m->n_assigned_to) {
1011: }
1012: else {
1013: switch (m->n_scope) {
1014: case FCT:
1015: Cdcl = m;
1016: if (m->string[0] != '_' && m->string[1] != '_' )
1017: error('w',&m->where,"%n used but not set",m);
1018: }
1019: }
1020: }
1021: else {
1022: if (m->n_assigned_to) {
1023: }
1024: else if (m->string[0]!='_' || m->string[1]!='_') {
1025: switch (m->n_scope) {
1026: case ARG:
1027: case FCT:
1028: Cdcl = m;
1029: error('w',&m->where,"%n not used",m);
1030: }
1031: }
1032: }
1033: }
1034: }
1035: Cdcl = odcl;
1036: }
1037:
1038: d = 0;
1039:
1040: if (bit_offset) byte_offset += SZ_WORD;
1041: bit_offset = bit_old;
1042: byte_offset = byte_old;
1043: curr_block = block_old;
1044: }
1045:
1046: void name::field_align()
1047: /*
1048: adjust alignment
1049: */
1050: {
1051: Pbase fld = (Pbase)tp;
1052:
1053: int a = (F_SENSITIVE) ? fld->b_fieldtype->align() : SZ_WORD;
1054: if (max_align < a) max_align = a;
1055:
1056: if (fld->b_bits == 0) { // force word alignment
1057: int b;
1058: if (bit_offset)
1059: fld->b_bits = BI_IN_WORD - bit_offset;
1060: else if (b = byte_offset%SZ_WORD)
1061: fld->b_bits = b * BI_IN_BYTE;
1062: // else
1063: // fld->b_bits = BI_IN_WORD;
1064: if (max_align < SZ_WORD) max_align = SZ_WORD;
1065: }
1066: else if (bit_offset == 0) { // take care of part of word
1067: int b = byte_offset%SZ_WORD;
1068: if (b) {
1069: byte_offset -= b;
1070: bit_offset = b*BI_IN_BYTE;
1071: }
1072: }
1073: //error('d',"byteoff %d bitoff %d bits %d",byte_offset,bit_offset,fld->b_bits);
1074: int x = (bit_offset += fld->b_bits);
1075: if (BI_IN_WORD < x) {
1076: fld->b_offset = 0;
1077: byte_offset += SZ_WORD;
1078: bit_offset = fld->b_bits;
1079: }
1080: else {
1081: fld->b_offset = bit_offset;
1082: if (BI_IN_WORD == x) {
1083: bit_offset = 0;
1084: byte_offset += SZ_WORD;
1085: }
1086: else
1087: bit_offset = x;
1088: }
1089: n_offset = byte_offset;
1090: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.