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