![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to print.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/print.c 1.1.5.20" */
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 rigths Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: print.c:
11:
12: print statements and expressions
13:
14: ****************************************************************************/
15:
16: #include "cfront.h"
17:
18: extern FILE* out_file;
19: extern bit Cast;
20: extern int last_ll;
21:
22: static int addrof_cm ;
23:
24: void puttok(TOK);
25: /*
26: void cprint(Pexpr e)
27: {
28: if (e == 0) return;
29: //error('d',"%k %n %t",e->base,e->base==NAME?e:0,e->tp);
30: // if ((e->base==NAME || e->base==ANAME)
31: // && Pname(e)->n_evaluated==0) {
32: Ptype t = e->tp;
33: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
34: if (t->base == EOBJ) fprintf(out_file,"(int)");
35: // }
36:
37: Eprint(e);
38: }
39: */
40: #define cprint(e) if (e) Eprint(e)
41: #define eprint(e) if (e) Eprint(e)
42:
43: void Eprint(Pexpr e)
44: {
45: switch (e->base) {
46: case REF:
47: if (Pref(e)->mem && Pref(e)->mem->tp && Pref(e)->mem->tp->base == FCT) {
48: // suppress ``this'' in ``this->f''
49: Pref(e)->mem->print();
50: break;
51: }
52: case NAME:
53: case MDOT:
54: case ID:
55: case ZERO:
56: case ICON:
57: case CCON:
58: case FCON:
59: case STRING:
60: case IVAL:
61: case TEXT:
62: case CM:
63: case G_CM:
64: case ELIST:
65: case COLON:
66: case ILIST:
67: case DOT:
68: case THIS:
69: case CALL:
70: case G_CALL:
71: case ICALL:
72: case ANAME:
73: e->print();
74: case DUMMY:
75: break;
76: default:
77: putch('(');
78: e->print();
79: putch(')');
80: }
81: }
82:
83: void expr::print()
84: {
85: if (this == 0) error('i',"0->E::print()");
86: if (this==e1 || this==e2) error('i',"(%p%k)->E::print(%p %p)",this,base,e1,e2);
87: //error('d',"(%d %k)->expr::print(%d %d)",this,base,e1,e2);
88:
89: switch (base) {
90: case MDOT:
91: //error('d',"mdot %s i1 %d %t",string2,i1,mem->tp);
92: switch (i1) {
93: case 0:
94: putcat('O',string2);
95: puttok(DOT); // use sub-object directly
96: mem->print();
97: break;
98: case 1:
99: putcat('P',string2);
100: puttok(REF); // use through pointer
101: mem->print();
102: break;
103: case 2:
104: if (mem->tp->is_ptr_or_ref()==0) {
105: mem->print();
106: puttok(DOT);
107: putcat('O',string2);
108: }
109: else
110: {
111: putch('('); // REF turns pointer into object: add &
112: putch('&'); // ``this'' is a pointer
113: putch('(');
114: eprint(mem);//mem->print();
115: puttok(REF); // call sub-object directly
116: putcat('O',string2);
117: putch(')');
118: putch(')');
119: }
120: break;
121: case 3:
122: if (mem->tp->is_ptr_or_ref()==0) {
123: putch('('); // Px is a pointer (T*) turn it back to a T
124: putch('*'); // *Px
125: putch('(');
126: eprint(mem);//mem->print();
127: puttok(DOT); // call through pointer
128: putcat('P',string2);
129: putch(')');
130: putch(')');
131: }
132: else {
133: eprint(mem); // <<< mem->print()
134: puttok(REF); // call through pointer
135: putcat('P',string2);
136: }
137: break;
138:
139: case 9: // vtbl entry: (p->_vtbl).f, (p->_vtbl).i, (p->_vtbl).d
140: // or memptr: mp.f, mp.i, mp.d
141: eprint(mem);
142: putch('.');
143: putstring(string2);
144:
145: }
146: break;
147: case NAME:
148: { Pname n = Pname(this);
149: if (n->n_evaluated
150: // && n->tp->base!=EOBJ // this output enumerators
151: && n->n_scope!=ARG) {
152: Ptype t = tp;
153: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
154: if (t->base == EOBJ) t = Penum(Pbase(t)->b_name->tp)->e_type;
155: if (t->base!=INT || t->is_unsigned()) {
156: putstring("((");
157: bit oc = Cast;
158: Cast = 1;
159: t->print();
160: Cast = oc;
161: fprintf(out_file,")%d)",n->n_val);
162: }
163: else
164: fprintf(out_file,"%d",n->n_val);
165: }
166: else
167: n->print();
168: break;
169: }
170: case ANAME:
171: if (curr_icall) { // in expansion: look it up
172: Pname n = Pname(this);
173: int argno = int(n->n_val);
174:
175: for (Pin il=curr_icall; il; il=il->i_next)
176: if (n->n_table == il->i_table) goto aok;
177: goto bok;
178: aok:
179: if (n = il->i_args[argno].local) {
180: n->print();
181: }
182: else {
183: Pexpr ee = il->i_args[argno].arg;
184: Ptype t = il->i_args[argno].tp;
185: if (ee==0 || ee==this) error('i',"%p->E::print(A %p)",this,ee);
186: if (ee->tp==0
187: || (t!=ee->tp
188: && t->check(ee->tp,0)
189: && t->is_cl_obj()==0
190: // && eobj==0)
191: )
192: ) {
193: putstring("((");
194: bit oc = Cast;
195: Cast = 1;
196: t->print();
197: Cast = oc;
198: putch(')');
199: // eprint(ee);
200: // if (ee->base == CAST) {
201: // eprint(ee->e1);
202: // }
203: // else
204: eprint(ee);
205: putch(')');
206: }
207: else
208: eprint(ee);
209: }
210: }
211: else {
212: bok: /* in body: print it: */
213: Pname(this)->print();
214: }
215: break;
216:
217: case ICALL:
218: { il->i_next = curr_icall;
219: curr_icall = il;
220: //error('d',"icall %n",il->fct_name);
221: if (il == 0) error('i',"E::print: iline missing");
222: Pexpr a0 = il->i_args[0].arg;
223: int val = QUEST;
224: if (il->fct_name->n_oper != CTOR) goto dumb;
225:
226: /*
227: find the value of "this"
228: if the argument is a "this" NOT assigned to
229: by the programmer, it was initialized
230: */
231: switch (a0->base) {
232: case ZERO:
233: val = 0;
234: break;
235: case ADDROF:
236: case G_ADDROF:
237: val = 1;
238: break;
239: case CAST:
240: if (a0->e1->base == ANAME || a0->e1->base == NAME) {
241: Pname a = (Pname)a0->e1;
242: if (a->n_assigned_to == FUDGE111) val = FUDGE111;
243: }
244: }
245: if (val==QUEST) goto dumb;
246: /*
247: now find the test: "(this==0) ? _new(sizeof(X)) : 0"
248:
249: e1 is a comma expression,
250: the test is either the first sub-expression
251: or the first sub-expression after the assignments
252: initializing temporary variables
253: */
254: dumb:
255: eprint(e1);
256: if (e2) Pstmt(e2)->print();
257: curr_icall = il->i_next;
258: break;
259: }
260: case REF:
261: case DOT:
262: eprint(e1);
263: puttok(base);
264: if (mem == 0) {
265: fprintf(out_file,"MEM0");
266: break;
267: }
268: if (mem->base == NAME)
269: Pname(mem)->print();
270: else
271: mem->print();
272: break;
273:
274: case MEMPTR:
275: error("P toMF not called");
276: break;
277:
278: case VALUE:
279: tp2->print();
280: puttok(LP);
281:
282: // if (e2) {
283: // putstring("/* &");
284: // e2->print();
285: // putstring(", */");
286: // }
287: if (e1) e1->print();
288: puttok(RP);
289: break;
290:
291: case SIZEOF:
292: puttok(SIZEOF);
293: if (e1 && e1!=dummy) {
294: eprint(e1);
295: }
296: else if (tp2) {
297: putch('(');
298: if (tp2->base == CLASS) {
299: Pclass cl = Pclass(tp2);
300: putstring((cl->csu == UNION)?"union ":"struct ");
301: char *str = 0;
302: extern char *make_local_name(Pclass, int=0);
303: if ( cl->lex_level ) str = make_local_name( cl );
304: putstring( str?str:cl->string );
305: delete str;
306: }
307: else
308: tp2->print();
309: putch(')');
310: }
311: break;
312:
313: /*
314: // always turned into function calls:
315: case NEW:
316: case GNEW:
317: // error('d',"print new %d tp2 %t e1 %d e2 %d",base,tp2,e1,e2);
318: puttok(NEW);
319: tp2->print();
320: if (e1) {
321: putch('(');
322: e1->print();
323: putch(')');
324: }
325: break;
326:
327: case DELETE:
328: case GDELETE:
329: //error('d',"print delete");
330: puttok(DELETE);
331: e1->print();
332: break;
333: */
334: case CAST:
335: putch('(');
336: //error('d',"print cast %t",tp2);
337: if (tp2->base != VOID && tp2->memptr() == 0 ) {
338: // when VOID is represented as CHAR not everything
339: // can be cast to VOID
340: putch('(');
341: bit oc = Cast;
342: Cast = 1;
343: tp2->print();
344: Cast = oc;
345: putch(')');
346: }
347: eprint(e1);
348: putch(')');
349: break;
350:
351: case ICON:
352: case FCON:
353: case CCON:
354: case ID:
355: if (string) putst(string);
356: break;
357:
358: case STRING:
359: extern ntok;
360: // avoid printing very long lines
361: ntok += 4;
362: fprintf(out_file,"\"%s\"",string);
363: break;
364:
365: case THIS:
366: case ZERO:
367: putstring("0 ");
368: break;
369:
370: case IVAL:
371: fprintf(out_file,"%d",i1);
372: break;
373:
374: case TEXT:
375: {
376: int oo = vtbl_opt; // make `simulated static' name
377: vtbl_opt = -1;
378: char* s = vtbl_name(string,string2);
379: vtbl_opt = oo;
380: s[2] = 'p'; // pointer, not tbl itself
381: fprintf(out_file, " %s",s);
382: delete s;
383: }
384: // no break;
385:
386: case DUMMY:
387: break;
388:
389: case G_CALL:
390: case CALL:
391: { Pname fn = fct_name;
392: Pname at;
393: int m_ptr = 0;
394:
395: if (fn) {
396: Pfct f = Pfct(fn->tp);
397:
398: if (f->base==OVERLOAD) { // overloaded after call
399: fct_name = fn = Pgen(f)->fct_list->f;
400: f = Pfct(fn->tp);
401: }
402:
403: fn->print();
404: at = f->f_args;
405: }
406: else {
407: Pfct f = Pfct(e1->tp);
408:
409: if (f) { // pointer to fct
410: Pexpr exex = e1;
411: if ( exex->base == DEREF ) {
412: exex = exex->e1;
413: while ( exex->base == CAST )
414: exex = exex->e1;
415: if ( exex->base == MDOT )
416: m_ptr = 1;
417: }
418:
419: if (f->base == OVERLOAD) { // overloaded after call
420: fct_name = fn = Pgen(f)->fct_list->f;
421: f = Pfct(fn->tp);
422: }
423:
424: while (f->base == TYPE) f = Pfct(Pbase(f)->b_name->tp);
425: if (f->base == PTR) {
426: putstring("(*");
427: e1->print();
428: putch(')');
429: f = Pfct(Pptr(f)->typ);
430: while (f->base == TYPE) f = Pfct(Pbase(f)->b_name->tp);
431: }
432: else
433: eprint(e1);
434:
435: // at = (f->f_result) ? f->f_result : f->argtype;
436: at = f->f_args;
437: }
438: else { // virtual: argtype encoded
439: // f_this already linked to f_result and/or argtype
440: at = (e1->base==QUEST) ? Pname(e1->e1->tp2) : Pname(e1->tp2);
441: eprint(e1);
442: }
443: }
444:
445: puttok(LP);
446:
447: if (e2) {
448: if (at) {
449: Pexpr e = e2;
450: while (at) {
451: Pexpr ex;
452: Ptype t = at->tp;
453:
454: if (t == 0) error('i',"T ofA missing for%n",fn);
455: if (e == 0) error('i',"%tA missing for%n",t,fn);
456: if (e->base == ELIST) {
457: ex = e->e1;
458: e = e->e2;
459: }
460: else
461: ex = e;
462:
463: if (ex == 0) error('i',"A ofT%t missing",t);
464: extern Pclass Mptr;
465: if (t!=ex->tp
466: && ex->tp
467: && t->check(ex->tp,0)
468: && t->is_cl_obj()==0
469: && eobj==0
470: && m_ptr == 0
471: && (t->is_ptr()==0 || Mptr==0)) {
472: putch('(');
473: bit oc = Cast;
474: Cast = 1;
475: t->print();
476: Cast = oc;
477: putch(')');
478: #ifdef sun
479: if (ex->base == DIV) { // defend against perverse SUN cc bug
480: putstring("(0+");
481: eprint(ex);
482: putch(')');
483: }
484: else
485: #endif
486: // eprint(ex);
487: // if (ex->base==CAST) {
488: // eprint(ex->e1);
489: // }
490: // else
491: eprint(ex);
492: }
493: else
494: ex->print();
495:
496: // if m_ptr is set, then don't advance at
497: // at does not know about generated `this'
498: if ( m_ptr ) {
499: m_ptr = 0;
500: if (at) puttok(CM);
501: continue;
502: }
503:
504: at = at->n_list;
505: if (at) puttok(CM);
506: }
507: if (e) {
508: puttok(CM);
509: e->print();
510: }
511: }
512: else
513: e2->print();
514: }
515: puttok(RP);
516: break;
517: }
518:
519: case ASSIGN:
520: if (e1->base==ANAME && Pname(e1)->n_assigned_to==FUDGE111) {
521: // suppress assignment to "this" that has been optimized away
522: Pname n = Pname(e1);
523: int argno = int(n->n_val);
524: for (Pin il=curr_icall; il; il=il->i_next)
525: if (il->i_table == n->n_table) goto akk;
526: goto bkk;
527: akk:
528: if (il->i_args[argno].local == 0) {
529: e2->print();
530: break;
531: }
532: }
533: //no break
534: case EQ:
535: case NE:
536: case GT:
537: case GE:
538: case LE:
539: case LT:
540: bkk:
541: { Ptype t1 = e1->tp;
542: Ptype t2 = e2->tp;
543:
544: if (base!=ASSIGN) {
545: cprint(e1);
546: }
547: else
548: eprint(e1);
549: puttok(base);
550:
551: if (t1 && t1!=t2 && e2->base!=ZERO) {
552: // cast, but beware of int!=long etc.
553: cmp:
554: switch (t1->base) {
555: case TYPE:
556: t1 = Pbase(t1)->b_name->tp;
557: goto cmp;
558: default:
559: // if (e2->base==NAME
560: // && Pname(e2)->n_evaluated==0
561: // && e2->tp->base==EOBJ)
562: // fprintf(out_file,"(int)");
563: break;
564: // case EOBJ:
565: // if (base==ASSIGN) goto cst;
566: // break;
567: case PTR:
568: case RPTR:
569: case VEC:
570: if (t2)
571: while ( t2->base == TYPE )
572: t2 = Pbase(t2)->b_name->tp;
573:
574: if (e2->tp==0
575: || (Pptr(t1)->typ!=Pptr(t2)->typ && t1->check(t2,0))) {
576: // cst:
577: putch('(');
578: bit oc = Cast;
579: Cast = 1;
580: e1->tp->print();
581: Cast = oc;
582: putch(')');
583: }
584: }
585: }
586:
587: eprint(e2);
588: break;
589: }
590:
591: case DEREF:
592: if (e2) {
593:
594: eprint(e1);
595: putch('[');
596: cprint(e2);
597: putch(']');
598: }
599: else {
600: putch('(');
601: putch('*');
602: eprint(e1);
603: putch(')');
604: }
605: break;
606:
607: case ILIST:
608: puttok(LC);
609: if (e1) e1->print();
610: if (e2) { // member pointer initiliazers
611: puttok(CM);
612: e2->print();
613: }
614: puttok(RC);
615: break;
616:
617: case ELIST:
618: { Pexpr e = this;
619: for(;;) {
620: if (e->base == ELIST) {
621: e->e1->print();
622: if (e = e->e2) {
623: extern ntok;
624: puttok(CM);
625: }
626: else
627: return;
628: }
629: else {
630: e->print();
631: return;
632: }
633: }
634: }
635:
636: case QUEST:
637: { // look for (&a == 0) etc.
638: extern bit binary_val;
639: Neval = 0;
640: binary_val = 1;
641: long i = cond->eval();
642: binary_val = 0;
643: if (Neval == 0)
644: (i?e1:e2)->print();
645: else {
646: eprint(cond);
647: putch('?');
648: cprint(e1);
649: putch(':');
650: cprint(e2);
651: }
652: break;
653: }
654:
655: case CM: // do &(a,b) => (a,&b) for previously checked inlines
656: case G_CM:
657: puttok(LP);
658: switch (e1->base) {
659: case ZERO:
660: case IVAL:
661: case ICON:
662: case NAME:
663: case MDOT:
664: case DOT:
665: case REF:
666: case FCON:
667: case FVAL:
668: case STRING:
669: goto le2; // suppress constant a: &(a,b) => (&b)
670: default:
671: { int oo = addrof_cm; // &(a,b) does not affect a
672: addrof_cm = 0;
673: eprint(e1);
674: addrof_cm = oo;
675: }
676: puttok(CM);
677: le2:
678: if (addrof_cm) {
679: switch (e2->base) {
680: case CAST:
681: if (e2->e2)
682: switch (e2->e2->base) {
683: case CM:
684: case G_CM:
685: case ICALL: goto ec;
686: }
687: case NAME:
688: case MDOT:
689: case DOT:
690: case DEREF:
691: case REF:
692: case ANAME:
693: puttok(ADDROF);
694: addrof_cm--;
695: eprint(e2);
696: addrof_cm++;
697: break;
698: case ICALL:
699: // case CALL:
700: case CM:
701: case G_CM:
702: ec:
703: eprint(e2);
704: break;
705: case G_CALL:
706: /* & ( e, ctor() ) with temporary optimized away */
707: if (e2->fct_name
708: && e2->fct_name->n_oper==CTOR) {
709: addrof_cm--;
710: eprint(e2);
711: addrof_cm++;
712: break;
713: }
714: default:
715: error('i',"& inlineF call (%k)",e2->base);
716: }
717: }
718: else
719: // e2->print();
720: eprint(e2);
721: puttok(RP);
722: }
723: break;
724:
725: case UMINUS:
726: case NOT:
727: case COMPL:
728: // puttok(base);
729: // eprint(e2);
730: // break;
731: goto op2;
732: case ADDROF:
733: case G_ADDROF:
734: switch (e2->base) { // & *e1 or &e1[e2]
735: case DEREF:
736: if (e2->e2 == 0) { // &*e == e
737: e2->e1->print();
738: return;
739: }
740: break;
741: case ICALL:
742: addrof_cm++; // assumes inline expanded into ,-expression
743: eprint(e2);
744: addrof_cm--;
745: return;
746: case ASSIGN: // &(a=b) ??? works on many cc s
747: eprint(e2); // make sure it breaks!
748: return;
749: }
750:
751: // suppress cc warning on &fct
752: if (e2->tp==0 || e2->tp->base!=FCT) puttok(ADDROF);
753:
754: eprint(e2);
755: break;
756:
757: case PLUS:
758: case MINUS:
759: case MUL:
760: case DIV:
761: case MOD:
762: case LS:
763: case RS:
764: #ifdef DK
765: case AND: putc('&'); break;
766: case OR: putc('|'); break;
767: case ER: putc('^'); break;
768: case ANDAND: putstring("&&"); break;
769: case OROR: putstring("||"); break;
770: #else
771: case AND:
772: case OR:
773: case ER:
774: case ANDAND:
775: case OROR:
776: #endif
777: case DECR:
778: case INCR:
779: cprint(e1);
780: op2:
781: puttok(base);
782: cprint(e2);
783: break;
784: case ASOR:
785: case ASER:
786: case ASAND:
787: case ASPLUS:
788: case ASMINUS:
789: case ASMUL:
790: case ASMOD:
791: case ASDIV:
792: case ASLS:
793: case ASRS:
794: eprint(e1);
795: goto op2;
796:
797: default:
798: error('i',"%p->E::print%k",this,base);
799: // fprintf(out_file," EEE(%d) ",base);
800: }
801: }
802:
803: Pexpr aval(Pname a)
804: {
805: int argno = int(a->n_val);
806: Pin il;
807: for (il=curr_icall; il; il=il->i_next)
808: if (il->i_table == a->n_table) goto aok;
809: return 0;
810: aok:
811: Pexpr aa = il->i_args[argno].arg;
812: ll:
813: switch (aa->base) {
814: case CAST: aa = aa->e1; goto ll;
815: case ANAME: return aval(Pname(aa));
816: default: return aa;
817: }
818: }
819:
820: #define putcond() putch('('); e->print(); putch(')')
821:
822: void stmt::print()
823: {
824: //error('d',"S::print %d:%k s %d s_list %d",this,base,s,s_list);
825: if (where.line && where.line!=last_line.line)
826: if (last_ll = where.line)
827: where.putline();
828: else
829: last_line.putline();
830:
831: if (memtbl && base!=BLOCK) { /* also print declarations of temporaries */
832: puttok(LC);
833: Ptable tbl = memtbl;
834: memtbl = 0;
835: int i;
836: int bl = 1;
837: for (Pname n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i)){
838: if (n->tp == any_type) continue;
839: /* avoid double declarartion of temporaries from inlines */
840: char* s = n->string;
841: if (s[0]!='_' || s[1]!='_' || s[2]!='X') {
842: n->dcl_print(0);
843: bl = 0;
844: }
845: Pname cn;
846: if (bl
847: && (cn=n->tp->is_cl_obj())
848: && Pclass(cn->tp)->has_dtor()) bl = 0;
849: }
850:
851: if (bl) {
852: Pstmt sl = s_list;
853: s_list = 0;
854: print();
855: memtbl = tbl;
856: puttok(RC);
857: if (sl) {
858: s_list = sl;
859: sl->print();
860: }
861: }
862: else {
863: print();
864: memtbl = tbl;
865: puttok(RC);
866: }
867: return;
868: }
869:
870: switch (base) {
871: default:
872: error('i',"S::print(base=%k)",base);
873:
874: case ASM:
875: fprintf(out_file,"asm(\"%s\");\n",(char*)e);
876: break;
877:
878: case DCL:
879: d->dcl_print(SM);
880: break;
881:
882: case BREAK:
883: case CONTINUE:
884: puttok(base);
885: puttok(SM);
886: break;
887:
888: case DEFAULT:
889: puttok(base);
890: //puttok(COLON);
891: putch(':');
892: s->print();
893: break;
894:
895: case SM:
896: if (e) {
897: e->print();
898: if (e->base==ICALL && e->e2) break; /* a block: no SM */
899: }
900: puttok(SM);
901: break;
902:
903: case WHILE:
904: puttok(WHILE);
905: putcond();
906: if (s->s_list) {
907: puttok(LC);
908: s->print();
909: puttok(RC);
910: }
911: else
912: s->print();
913: break;
914:
915: case DO:
916: puttok(DO);
917: s->print();
918: puttok(WHILE);
919: putcond();
920: puttok(SM);
921: break;
922:
923: case SWITCH:
924: puttok(SWITCH);
925: putcond();
926: s->print();
927: break;
928:
929: case RETURN:
930: {
931: puttok(RETURN);
932: if (e) {
933: //error('d',"print return rt %t etp %t",ret_tp,e->tp);
934: if (ret_tp && ret_tp!=e->tp) {
935: Ptype tt = ret_tp;
936: gook:
937: switch (tt->base) {
938: case TYPE:
939: tt = Pbase(tt)->b_name->tp;
940: goto gook;
941: case COBJ:
942: break; // cannot cast to struct
943: case RPTR:
944: case PTR:
945: if (Pptr(tt)->typ==Pptr(e->tp)->typ) break;
946: if (Pptr(tt)->memof) break;
947: default:
948: if (e->tp==0 || ret_tp->check(e->tp,0)) {
949: int oc = Cast;
950: putch('(');
951: Cast = 1;
952: ret_tp->print();
953: Cast = oc;
954: putch(')');
955: }
956: }
957: }
958: eprint(e);
959: }
960: puttok(SM);
961: }
962: while (s_list && s_list->base==SM) s_list = s_list->s_list; // FUDGE!!
963: break;
964:
965: case CASE:
966: puttok(CASE);
967: eprint(e);
968: //puttok(COLON);
969: putch(':');
970: s->print();
971: break;
972:
973: case GOTO:
974: puttok(GOTO);
975: d->print();
976: puttok(SM);
977: break;
978:
979: case LABEL:
980: d->print();
981: putch(':');
982: s->print();
983: break;
984:
985: case IF:
986: { int val = QUEST;
987: if (e->base == ANAME) {
988: Pname a = Pname(e);
989: Pexpr arg = aval(a);
990: //error('d',"arg %d%k %d (%d)",arg,arg?arg->base:0,arg?arg->base:0,arg?arg->e1:0);
991: if (arg)
992: switch (arg->base) {
993: case ZERO: val = 0; break;
994: case ADDROF:
995: case G_ADDROF: val = 1; break;
996: case IVAL: val = arg->i1!=0;
997: }
998: }
999: //error('d',"val %d",val);
1000: switch (val) {
1001: case 1:
1002: s->print();
1003: break;
1004: case 0:
1005: if (else_stmt)
1006: else_stmt->print();
1007: else
1008: puttok(SM); /* null statement */
1009: break;
1010: default:
1011: puttok(IF);
1012: putcond();
1013: if (s->s_list) {
1014: puttok(LC);
1015: s->print();
1016: puttok(RC);
1017: }
1018: else
1019: s->print();
1020: if (else_stmt) {
1021: puttok(ELSE);
1022: if (else_stmt->s_list) {
1023: puttok(LC);
1024: else_stmt->print();
1025: puttok(RC);
1026: }
1027: else
1028: else_stmt->print();
1029: }
1030: }
1031: break;
1032: }
1033:
1034: case FOR:
1035: {
1036: // int fi = for_init && ((for_init->base!=SM || for_init->memtbl || for_init->s_list);
1037: int fi = 0; // is the initializer statement an expression?
1038: if (for_init) {
1039: fi = 1;
1040: if (for_init->memtbl==0 && for_init->s_list==0)
1041: if (for_init->base==SM)
1042: if (for_init->e->base!=ICALL || for_init->e->e1)
1043: fi = 0;
1044: }
1045: //error('d',"for(; %d%k; %d%k)",e,e->base,e2,e2->base);
1046: if (fi) {
1047: puttok(LC);
1048: for_init->print();
1049: }
1050: putstring("for(");
1051: if (fi==0 && for_init) for_init->e->print();
1052: putch(';'); // to avoid newline: not puttok(SM)
1053: if (e) e->print();
1054: putch(';');
1055: if (e2) e2->print();
1056: puttok(RP);
1057: s->print();
1058: if (fi) puttok(RC);
1059: break;
1060: }
1061:
1062: case PAIR:
1063: if (s&&s2) {
1064: puttok(LC);
1065: s->print();
1066: s2->print();
1067: puttok(RC);
1068: }
1069: else {
1070: if (s) s->print();
1071: if (s2) s2->print();
1072: }
1073: break;
1074:
1075: case BLOCK:
1076: puttok(LC);
1077: //error('d',"block %d d %d memtbl %d own_tbl %d",this,d,memtbl,own_tbl);
1078: if (d) d->dcl_print(SM);
1079: if (memtbl && own_tbl) {
1080: Pname n;
1081: int i;
1082: for (n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) {
1083: if (n->tp && n->n_union==0 && n->tp!=any_type)
1084: switch (n->n_scope) {
1085: case ARGT:
1086: case ARG:
1087: break;
1088: default:
1089: n->dcl_print(0);
1090: }
1091: }
1092: }
1093: if (s) s->print();
1094: putstring("}\n");
1095: if (last_ll && where.line) last_line.line++;
1096: }
1097:
1098: if (s_list) s_list->print();
1099: }
1100: /*
1101: void table::dcl_print(TOK s, TOK pub)
1102:
1103: // print the declarations of the entries in the order they were inserted
1104: // ignore labels (tp==0)
1105:
1106: {
1107: register Pname* np;
1108: register int i;
1109:
1110: if (this == 0) return;
1111:
1112: np = entries;
1113: for (i=1; i<free_slot; i++) {
1114: register Pname n = np[i];
1115: switch (s) {
1116: case 0:
1117: n->dcl_print(0);
1118: break;
1119: case EQ:
1120: if (n->tp && n->n_scope == pub) n->dcl_print(0);
1121: break;
1122: case NE:
1123: if (n->tp && n->n_scope != pub) n->dcl_print(0);
1124: break;
1125: }
1126: }
1127: }
1128: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.