![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to print2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 root 1: /*ident "@(#)ctrans:src/print2.c 1.3.6.35" */
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 names and declarations
13:
14: ****************************************************************************/
15:
16: #include "cfront.h"
17:
18: bit Cast;
19: int last_ll = 1;
20: Pin curr_icall;
21: char emode;
22: int ntok;
23:
24: static int MAIN; // fudge to get _main() called by main()
25:
26: #define eprint(e) if (e) Eprint(e)
27:
28: #ifdef DENSE
29: void chop(char*);
30: #endif
31:
32: void puttok(TOK t)
33: /*
34: print the output representation of "t"
35: */
36: {
37: // if (t<=0 || MAXTOK<t) error("illegal token %d",t);
38: // char* s = keys[t];
39: // if (s == 0) error("V representation token %d",t);
40:
41: putstring(keys[t]);
42:
43: if (12<ntok++) {
44: ntok = 0;
45: last_line.putline();
46: }
47: else if (t == SM) {
48: ntok = 0;
49: putch('\n');
50: if (last_ll) last_line.line++;
51: }
52: else
53: putch(' ');
54: }
55:
56: #define MX 20
57: #define NTBUF 10
58: class dcl_buf {
59: /*
60: buffer for assembling declaration (or cast)
61: left contains CONST_PTR => *CONST
62: CONST_RPTR => &CONST
63: PTR => *
64: RPTR => &
65: LP => (
66: right contains RP => )
67: VEC => [ rnode ]
68: FCT => ( rnode )
69: FIELD => : rnode
70: */
71: Pbase b;
72: Pname n;
73: TOK left[MX], right[MX];
74: Pnode rnode[MX];
75: Pclass lnode[MX];
76: int li, ri;
77: public:
78: void init(Pname nn) { b=0; n=nn; li=ri=0; }
79: void base(Pbase bb) { b = bb; }
80: void front(TOK t) { left[++li] = t; }
81: void front(Pclass c) { left[++li] = MEMPTR; lnode[li] = c; }
82: void back(TOK t, Pnode nod) { right[++ri] = t; rnode[ri] = nod; }
83: void paran() { front(LP); back(RP,0); }
84: void put();
85: } *tbufvec[NTBUF] = {0}, *tbuf = 0;
86:
87: int freetbuf = 0;
88:
89: void dcl_buf::put()
90: {
91: int i;
92: Pfct ff = 0;
93:
94: if (MX<=li || MX<=ri) error('i',"T buffer overflow");
95: if (b == 0) error('i',"noBT%s",Cast?" in cast":"");
96:
97: if (n && n->n_sto && n->n_sto!=REGISTER) puttok(n->n_sto);
98:
99: b->dcl_print();
100:
101: for( ; li; li--) {
102: switch (left[li]) {
103: case LP:
104: putch('(');
105: break;
106: case PTR:
107: putch('*');
108: break;
109: case RPTR:
110: if (emode)
111: putch('&');
112: else
113: putch('*');
114: break;
115: case CONST_PTR:
116: if (emode)
117: putstring("*const ");
118: else
119: putch('*');
120: break;
121: case CONST_RPTR:
122: if (emode)
123: putstring("&const ");
124: else
125: putch('*');
126: break;
127: case MEMPTR:
128: if (lnode[li]) fprintf(out_file,"%s::",lnode[li]->string);
129: }
130: }
131:
132: if (n) n->print();
133:
134: for(i=1; i<=ri; i++) {
135: switch (right[i]) {
136: case RP:
137: putch(')');
138: break;
139: case VEC:
140: putch('[');
141: { Pvec v = (Pvec) rnode[i];
142: Pexpr d = v->dim;
143: int s = v->size;
144: if (d) d->print();
145: if (s) fprintf(out_file,"%d",s);
146: }
147: putch(']');
148: break;
149: case FCT: // beware of function returning pointer to
150: // function expressed witout typedef
151: { Pfct f = Pfct(rnode[i]);
152: if (f->body) ff = f;
153: f->dcl_print();
154: break;
155: }
156: case FIELD:
157: { Pbase f = (Pbase) rnode[i];
158: Pexpr d = (Pexpr)f->b_name;
159: int s = f->b_bits;
160: putch(':');
161: if (d)
162: d->print();
163: else if (s)
164: fprintf(out_file,"%d",s);
165: else
166: puttok(ZERO);
167: break;
168: }
169: }
170: }
171: void print_body(Pfct);
172: if (ff && emode==0) print_body(ff);
173: }
174:
175: static Pexpr mk_zero_init( Ptype tt, Pname obname, Pname currname )
176: /*
177: creates 0 initializer for defined objects
178: side effect: generates right nesting level for {}
179: */
180: {
181: zaq:
182: switch (tt->base) {
183: case TYPE:
184: tt = Pbase(tt)->b_name->tp; goto zaq;
185: case VEC: // type a[size]; => type a[size] = {0};
186: {
187: if ( obname == currname ) {
188: //xxx initializing vectors blows up the size of some programs
189: return 0;
190: } else {
191: Pexpr i = mk_zero_init(Pvec(tt)->typ,obname,currname);
192: if ( i == 0 ) return 0;
193: return new expr( ILIST, i, 0 );
194: }
195: }
196: case COBJ: // "X a;" == "X a = {0};"
197: {
198: Pclass cl = Pclass(Pbase(tt)->b_name->tp);
199: if ( !ansi_opt && (cl->csu == ANON || cl->csu == UNION) ) {
200: if ( warning_opt ) {
201: // ridiculous handstands to avoid printing
202: // compiler generated names in warning
203: Ptype tn = obname->tp;
204: for(;;) if(tn->base==VEC) tn=Pvec(tn)->typ; else break;
205: if ( obname == currname && tt == tn ) {
206: if ( cl->string[0]=='_' && cl->string[1]=='_' )
207: error('w',&obname->where,"cannot generate zeroIr for%n ofT union; toI, compile with +a1 or insert non-union object as first member",obname);
208: else
209: error('w',&obname->where,"cannot generate zeroIr for%n ofT%t; toI, compile with +a1 or insert non-union object as first member",obname,obname->tp);
210: } else { Pclass cx;
211: if ( tn->base == COBJ
212: && (cx=(Pclass)Pbase(tn)->b_name->tp,
213: cx->string[0]=='_' && cx->string[1]=='_') )
214: error('w',&obname->where,"cannot generate zeroIr for%n (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname);
215: else
216: error('w',&obname->where,"cannot generate zeroIr for%n ofT%t (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname,obname->tp);
217: }
218: } // if warning_opt
219: return 0;
220: }
221: Pbcl l = cl->baselist;
222: while ( l ) {
223: if ( l->base == NAME ) cl = l->bclass;
224: else return new expr(ILIST,zero,0);
225: l = cl->baselist;
226: }
227: int i = 1;
228: Pname nn = cl->memtbl->get_mem(i);
229: for ( ; nn; nn = cl->memtbl->get_mem(++i) ) {
230: Ptype tx = nn->tp;
231: while ( tx->base == TYPE ) tx = Pbase(tx)->b_name->tp;
232: if (nn->base==NAME
233: && nn->n_union==0
234: && tx->base!=FCT
235: && tx->base!=OVERLOAD
236: && tx->base!=CLASS
237: && tx->base!=ENUM
238: && nn->n_stclass != STATIC) {
239: Pexpr i = mk_zero_init(tx,obname,nn);
240: if ( i == 0 ) return 0;
241: return new expr(ILIST,i,0);
242: }
243: }
244: return 0;
245: }
246: case PTR:
247: if (tt->memptr()) {
248: Pexpr i = new expr(ELIST,zero,zero);
249: return new expr(ILIST,i,zero);
250: }
251: // no break
252: case RPTR:
253: case CHAR:
254: case SHORT:
255: case INT:
256: case EOBJ:
257: case LONG:
258: case FLOAT:
259: case DOUBLE:
260: case LDOUBLE: // "int a;" == "int a = 0;"
261: case FIELD:
262: case ANY:
263: return zero;
264: }
265: return 0;
266: }
267:
268: void name::dcl_print(TOK list)
269: /*
270: Print the declaration for a name (list==0) or a name list (list!=0):
271: For each name
272: (1) print storage class
273: (2) print base type
274: (3) print the name with its declarators
275: Avoid (illegal) repetition of basetypes which are class or enum declarations
276: (A name list may contain names with different base types)
277: list == SM : terminator SM
278: list == 0: single declaration with terminator SM
279: list == CM : separator CM
280: */
281: {
282: if (error_count) return;
283:
284: for (Pname n=this; n; n=n->n_list) {
285: Ptype t = n->tp;
286: int sm = 0;
287:
288: // error('d',"%s->dcl_print() tp %t sto %k",n->string,t,n->n_sto);
289: if (t == 0) error('i',"N::dcl_print(%n)T missing",n);
290:
291: if (n->n_stclass==ENUM) if (list) continue; else return;
292:
293: if (n->where.line!=last_line.line || n->where.file!=last_line.file)
294: //fprintf(stderr,"%s ",n->string?n->string:"<0>"); n->where.put(stderr); fprintf(stderr," last "); last_line.put(stderr); putc('\n',stderr);
295: if (last_ll = n->where.line)
296: n->where.putline();
297: else
298: last_line.putline();
299:
300: int tc = Pbase(t)->b_const;
301: for (Ptype tt = t; tt->base==TYPE; tt = Pbase(tt)->b_name->tp)
302: tc |= Pbase(tt)->b_const;
303:
304: switch (t->base) {
305: case CLASS:
306: //fprintf(stderr,"class %s->dcl_print()\n",n->string);
307: if (n->base != TNAME) {
308: Pclass(t)->dcl_print(n);
309: sm = 1;
310: }
311: break;
312:
313: case ENUM:
314: Penum(t)->dcl_print(0);
315: sm = 1;
316: break;
317:
318: case FCT:
319: { Pfct f = Pfct(t);
320:
321: if (n->base == TNAME) puttok(TYPEDEF);
322:
323: // error('d',"fct %n->dcl_print() printed %d body %d defined %d",n,n->n_dcl_printed,f->body,f->defined);
324: // error('d',"n %d tbl %d tp %t inline %d",n,n->n_table,n->tp,f->f_inline);
325: if (n->n_dcl_printed==2 // definition already printed
326: || (n->n_dcl_printed==1 && f->body==0)
327: // declaration already printed
328: ) {
329: // don't print again
330: sm = 1; // no SM
331: break;
332: }
333:
334: if (f->f_result == 0) make_res(f);
335:
336: if (f->body && n->n_sto==EXTERN) n->n_sto = 0;
337:
338: if (f->f_inline && ((n->n_table!=gtbl) || strcmp(n->string,"main"))) {
339: if (debug_opt) {
340: //error('d',"f %t defined %d inline %d",f,f->defined,f->f_inline);
341: if (f->defined&DEFINED
342: && f->defined&SIMPLIFIED
343: && f->f_inline!=ITOR)
344: goto prnt_def;
345: else if (n->n_dcl_printed==0)
346: goto prnt_dcl;
347: else {
348: sm = 1;
349: break;
350: }
351: }
352: if (f->f_virtual || n->n_addr_taken) {
353: prnt_dcl:
354: //error('d',"prnt_dcl %d %n %k",n,n,n->n_sto);
355: TOK st = n->n_sto;
356: Pblock b = f->body;
357: f->body = 0;
358: t->dcl_print(n);
359: n->n_dcl_printed = 1;
360: n->n_sto = st;
361: f->body = b;
362: break;
363: }
364: else
365: sm = 1; // no SM
366: }
367: else if ((f->defined&DEFINED)==0
368: || (f->defined&SIMPLIFIED)==0)
369: goto prnt_dcl;
370: else if (n->n_table==gtbl && strcmp(n->string,"main")==0) {
371: if (f->f_inline) {
372: if (warning_opt) {
373: error('w',"main() cannot be inlined");
374: error('w',"out-of-line copy of main() created");
375: }
376: n->n_sto=0;
377: }
378: MAIN = 1;
379: gtbl->look("main",0)->use();
380: f->f_signature = 0;
381: t->dcl_print(n);
382: n->n_dcl_printed = f->body?2:1;
383: MAIN = 0;
384: }
385: else {
386: prnt_def:
387: // error('d',"prnt_def %n %k %d %k",n,n->n_oper,n,n->n_sto);
388: if (n->n_oper==CTOR || n->n_oper==DTOR) {
389: Pclass cl = Pclass(n->n_table->t_name->tp);
390: if (cl->c_body == 3) cl->print_all_vtbls(cl);
391: }
392:
393: if ( n->n_sto == STATIC &&
394: pdef_name == 0 && def_name == 0 ) {
395: // error('d', "printing ptbl_vec without first definition" );
396: pdef_name = n;
397: ptbl_init(0);
398: }
399: t->dcl_print(n);
400: n->n_dcl_printed = f->body?2:1;
401: }
402: if (f->body) sm = 1;
403: break;
404: }
405:
406: case OVERLOAD:
407: {
408: for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) {
409: Pname nn = gl->f;
410: nn->dcl_print(0);
411: sm = 1;
412: }
413: break;
414: }
415:
416: case ASM:
417: fprintf(out_file,"asm(\"%s\")\n",(char*)Pbase(t)->b_name);
418: break;
419:
420: case INT:
421: case EOBJ:
422: case CHAR:
423: case LONG:
424: case SHORT:
425: tcx:
426: // do not allocate space for constants unless necessary
427: if (tc
428: && n->n_sto!=EXTERN // extern const one;
429: // const one = 1;
430: // allocates storage
431: && (n->n_scope==EXTERN // FUDGE const one = 1;
432: // is treated as static
433: // need loader support
434: || n->n_scope==STATIC
435: || n->n_scope==FCT)
436: ) {
437: if (n->n_evaluated && n->n_addr_taken==0) {
438: sm = 1; /* no ; */
439: break;
440: }
441: }
442: tc = 0;
443: // no break;
444:
445: default:
446: {
447: /*
448: // don't print local instance of const
449: if ( n->n_dcl_printed == 3 ) {
450: sm = 1;
451: break;
452: }
453: */
454: Pexpr i = n->n_initializer;
455: if (n->base == TNAME && n->n_key == NESTED) i = 0;
456: if (tc) {
457: switch (tt->base) {
458: case CHAR:
459: case SHORT:
460: case INT:
461: case LONG:
462: case EOBJ:
463: goto tcx;
464: }
465: }
466:
467: if (n->base == TNAME) {
468: for (Pname tn=ktbl->look(n->string,HIDDEN); tn; tn=tn->n_tbl_list)
469: if (tn
470: && tn->lex_level
471: && t==tn->tp) return;
472: puttok(TYPEDEF);
473: }
474:
475: if (n->n_stclass == REGISTER) {
476: // (imperfect) check against member functions
477: // register s a; a.f() illegal
478: Pname cln = n->tp->is_cl_obj();
479: if (cln) {
480: Pclass cl = Pclass(cln->tp);
481: if (cl->csu!=CLASS
482: && cl->baselist==0
483: && cl->has_itor()==0
484: && cl->virt_count==0) puttok(REGISTER);
485: }
486: else
487: puttok(REGISTER);
488: }
489:
490: if (i) {
491: if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
492: n->n_initializer = 0;
493: t->dcl_print(n);
494: puttok(SM);
495: n->n_initializer = i;
496: n->n_sto = 0;
497: t->dcl_print(n);
498: n->n_sto = EXTERN;
499: }
500: else
501: t->dcl_print(n);
502: if(n->n_table) {
503: Pname nn = n->n_table->look(n->string,0);
504: if(nn)
505: nn->n_dcl_printed = 1;
506: else
507: n->n_dcl_printed = 1;
508: }
509: else
510: n->n_dcl_printed = 1;
511: }
512: else if (n->n_evaluated && Pbase(t)->b_const) {
513: if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
514: int v = n->n_evaluated;
515: n->n_evaluated = 0;
516: t->dcl_print(n);
517: puttok(SM);
518: if (n->where.line!=last_line.line || n->where.file!=last_line.file)
519: if (last_ll = n->where.line)
520: n->where.putline();
521: else
522: last_line.putline();
523: n->n_evaluated = v;
524: n->n_sto = 0;
525: t->dcl_print(n);
526: n->n_sto = EXTERN;
527: }
528: else
529: t->dcl_print(n);
530: if(n->n_table) {
531: Pname nn = n->n_table->look(n->string,0);
532: if(nn)
533: nn->n_dcl_printed = 1;
534: else
535: n->n_dcl_printed = 1;
536: }
537: else
538: n->n_dcl_printed = 1;
539: }
540: else {
541: //error('d',"%n sto %k val %d stc %k",n,n->n_sto,n->n_val,n_stclass);
542: if ((n->n_sto==0 || (n->n_val && n->n_evaluated==0))
543: && n_stclass==STATIC
544: && n->n_sto!=STATIC
545: && n->n_table==gtbl) {
546: if (n->n_val && n->n_evaluated==0) {
547: // extern x = f();
548: // generate int x = 0;
549: // plus dynamic initialization
550: n->n_sto = 0;
551: }
552:
553: n->n_initializer = i = mk_zero_init(t,n,n);
554: }
555: t->dcl_print(n);
556: if(n->n_table) {
557: Pname nn = n->n_table->look(n->string,0);
558: if(nn)
559: nn->n_dcl_printed = 1;
560: else
561: n->n_dcl_printed = 1;
562: }
563: else
564: n->n_dcl_printed = 1;
565: }
566:
567: if (n->n_scope!=ARG) {
568: if (i) {
569: puttok(ASSIGN);
570:
571: Pexpr i2 = i;
572: while (i2->base == CAST) i2 = i2->e1;
573: if (i2->base == ILIST) i = i2;
574: if (t!=i->tp
575: && i->base!=ZERO
576: && i->base!=ILIST /*&& i->tp!=Pchar_type*/) {
577: Ptype t1 = n->tp;
578: cmp:
579: switch (t1->base) {
580: case TYPE:
581: t1 = Pbase(t1)->b_name->tp;
582: goto cmp;
583: default:
584: i->print();
585: break;
586: // case EOBJ:
587: // goto cst;
588: case VEC:
589: if (Pvec(t1)->typ->base==CHAR) {
590: i->print();
591: break;
592: }
593: // no break
594: case PTR:
595: case RPTR:
596: if (i->tp==0 || n->tp->check(i->tp,0)) {
597: // cst:
598: putch('(');
599: bit oc = Cast;
600: Cast = 1;
601: t->print();
602: Cast = oc;
603: putch(')');
604: }
605: eprint(i);
606: }
607: }
608: else {
609: if (i==zero) {
610: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
611: // if (t->base == EOBJ) {
612: // putch('(');
613: // bit oc = Cast;
614: // Cast = 1;
615: // t->print();
616: // Cast = oc;
617: // putch(')');
618: // }
619: }
620: eprint(i);
621:
622: // i->print();
623: }
624: }
625: else if (n->n_evaluated) {
626: puttok(ASSIGN);
627: if (n->tp->base!=INT || n->tp->is_unsigned()) {
628: putstring("((");
629: bit oc = Cast;
630: Cast = 1;
631: n->tp->print();
632: Cast = oc;
633: fprintf(out_file,")%d)",n->n_val);
634: }
635: else
636: fprintf(out_file,"%d",n->n_val);
637: }
638: }
639: }
640: }
641:
642: switch (list) {
643: case SM:
644: if (sm==0) puttok(SM);
645: break;
646: case 0:
647: if (sm==0) puttok(SM);
648: return;
649: case CM:
650: if (n->n_list) puttok(CM);
651: break;
652: }
653: }
654: }
655:
656: char *local_sign( Ptype pt )
657: { // get function signature for local class
658: char buf[256];
659: char* bb = pt->signature(buf);
660: int ll = bb-buf;
661: if (255 < ll) error('i',"local class N buffer overflow");
662: char *p = new char[ll+1];
663: strcpy(p,buf);
664: return p;
665: }
666:
667: void enumdef::dcl_print(Pname cln)
668: /*
669: */
670: {
671: // note: ***** modify to handle local enums
672: // error('d', "%t::dcl_print(%n) in_class: %t nested_sig: %s", this, cln, in_class, nested_sig );
673: char* s = nested_sig?nested_sig:(cln ? cln->string:0);
674: if ( nested_sig )
675: fprintf(out_file,"enum __%s { ",nested_sig);
676: else fprintf(out_file,"enum %s { ",string);
677:
678: for (Pname px, p=mem; p; p=px) {
679: px = p->n_list;
680: if (s) {
681: if (p->n_evaluated)
682: fprintf(out_file,"%s__%s = %d",p->string,s,p->n_val);
683: else
684: fprintf(out_file,"%s__%s",p->string,s);
685: }
686: else {
687: if (p->n_evaluated)
688: fprintf(out_file,"%s = %d",p->string,p->n_val);
689: else
690: fprintf(out_file,"%s",p->string);
691: }
692: if (px) puttok(CM);
693: p->n_initializer = 0;
694: delete p;
695: }
696: mem = 0;
697: puttok(RC);
698: puttok(SM);
699: }
700:
701: void name::print()
702: /*
703: print just the name itself
704: */
705: {
706: if (this == 0) error('i',"0->N::print()");
707:
708: if (string == 0) {
709: if (emode) putch('?');
710: return;
711: }
712:
713: // error( 'd', "%s->name::print(), base: %k", string, base );
714: switch (base) {
715: case TNAME:
716: if (n_key == NESTED && tpdef &&
717: tpdef->nested_sig) {
718: if ( emode == 0 ) {
719: putstring( " __" );
720: putst(tpdef->nested_sig);
721: }
722: else {
723: putst(tpdef->in_class->string);
724: putstring( "::" );
725: putst(string);
726: }
727: }
728: else putst(string);
729: return;
730: case MDOT:
731: Pexpr(this)->print();
732: return;
733: }
734:
735: if (emode) {
736: Ptable tbl;
737: char* cs = 0;
738: bit f = 0;
739: if (tp) {
740: switch (tp->base) {
741: case OVERLOAD:
742: case FCT:
743: f = 1;
744: default:
745: if (tbl=n_table) {
746: if (tbl == gtbl) {
747: if (f == 0) putstring("::");
748: }
749: else {
750: if (tbl->t_name) {
751: cs = tbl->t_name->string;
752: fprintf(out_file,"%s::",cs);
753: }
754: }
755: }
756:
757: // local class will need to modify ???
758: if (n_scope==ARG && strcmp(string,"this")==0) {
759: // tell which "this" it is
760: Ptype tt = Pptr(tp)->typ;
761: Pname cn = Pbase(tt)->b_name;
762: fprintf(out_file,"%s::",cn->string);
763: }
764:
765: case CLASS:
766: case ENUM:
767: // case TYPE:
768: break;
769: }
770: nop:
771: switch (n_oper) {
772: case TYPE:
773: putstring("operator ");
774: if (tp) Pfct(tp)->returns->dcl_print(0);
775: break;
776: case 0:
777: putstring(string);
778: break;
779: case DTOR:
780: putch('~');
781: case CTOR:
782: if (cs)
783: putstring(cs);
784: else {
785: if ( string )
786: fprintf(out_file,"%s()",string);
787: else putstring("constructor");
788: f = 0;
789: }
790: break;
791: case TNAME:
792: putstring(string);
793: break;
794: default:
795: putstring("operator ");
796: putstring(keys[n_oper]);
797: break;
798: }
799: if (f) putstring("()");
800: }
801: else {
802: if (n_oper) goto nop;
803: if (string) putstring(string);
804: }
805: return;
806: }
807:
808: char* sig = 0;
809: Pclass cl = 0;
810: Penum en = 0;
811: int i = n_union;
812:
813: if (tp) {
814: Ptable tbl;
815:
816: switch (tp->base) {
817: default:
818: if (tbl=n_table) { // global or member
819: Pname tn;
820: if (tbl == gtbl) {
821: // if (i) fprintf(out_file,"__O%d.",i);
822: if ( i ) {
823: if (n_anon)
824: fprintf(out_file,"__O%d.%s.", i, n_anon );
825: else fprintf(out_file,"__O%d.",i);
826: }
827: break;
828: }
829:
830: if (tn=tbl->t_name) {
831: cl = Pclass(tn->tp);
832: if (i) {
833: if (cl->string[0]=='_'
834: && cl->string[1]=='_'
835: && cl->string[2]=='C' ) {
836: if (n_anon)
837: fprintf(out_file,"__O%d.%s.", i, n_anon );
838: else fprintf(out_file,"__O%d.",i);
839: }
840: else
841: if ( cl->nested_sig )
842: fprintf(out_file,"__O%d__%s.",i,cl->nested_sig);
843: else
844: if ( cl->lex_level ) {
845: char *str = make_local_name(cl,1);
846: fprintf(out_file,"__O%d%s.",i,str);
847: delete str;
848: }
849: else fprintf(out_file,"__O%d__%d%s.",i,cl->strlen,cl->string);
850: cl = 0;
851: }
852: else
853: if (cl->string[0]=='_'
854: && cl->string[1]=='_'
855: && cl->string[2]=='C'
856: && n_stclass != STATIC )
857: cl = 0;
858: break;
859: }
860: }
861:
862: switch (n_stclass) { // local variable
863: case STATIC:
864: case EXTERN:
865: if (i)
866: fprintf(out_file,"__O%d.",i);
867: else if (n_sto==STATIC && tp->base!=FCT) {
868: if (lex_level == 0)
869: putstring("__S");
870: else
871: fprintf(out_file,"__%d",lex_level);
872: }
873: break;
874: default:
875: // encode with lexical level UNLESS ``special''
876: // e.g. __builtin
877: if (string[0]!='_' || string[1]!='_' || string[2] != 'C' ) {
878: if (i)
879: {
880: if (n_anon)
881: fprintf(out_file,"__%d__O%d.%s.",lex_level-1,i,n_anon);
882: else fprintf(out_file,"__%d__O%d.",lex_level-1,i);
883: }
884: else
885: fprintf(out_file,"__%d",lex_level);
886: }
887: }
888: break;
889: case CLASS:
890: case ENUM:
891: if (tp->in_class && tp->nested_sig) en = Penum(tp);
892: break;
893: }
894:
895: if (tp->base==FCT) {
896: sig = Pfct(tp)->f_signature;
897: if (sig && sig[0]==0) sig = 0;
898: }
899: }
900:
901: if (string) {
902: #ifdef DENSE
903: int i = strlen(string);
904: if (cl) i += cl->strlen+4; // __dd<class name>
905: if (sig) {
906: if (cl == 0) i += 2;
907: i += strlen(sig);
908: }
909:
910: if (31<i) {
911: char buf[256];
912: if (cl && sig)
913: sprintf(buf,"%s__%d%s%s",string,cl->strlen,cl->string,sig);
914: else if (cl)
915: sprintf(buf,"%s__%d%s",string,cl->strlen,cl->string);
916: else if (sig)
917: sprintf(buf,"%s__%s",string,sig);
918: else
919: sprintf(buf,"%s",string);
920: chop(buf);
921: fprintf(out_file,"%s ",buf);
922: return;
923: }
924: #endif
925:
926: if ( en )
927: fprintf(out_file,"__%s", en->nested_sig);
928: else
929: putstring(string);
930:
931: if ( cl ) {
932: if ( cl->nested_sig )
933: fprintf(out_file,"__%s",cl->nested_sig);
934: else
935: if ( cl->lex_level ) {
936: char *str = make_local_name( cl, 1 );
937: putstring( str );
938: delete str;
939: }
940: else fprintf(out_file,"__%d%s",cl->strlen,cl->string);
941: }
942:
943: if (sig) {
944: if (cl == 0) putstring("__");
945: putstring(sig);
946: }
947: putch(' ');
948: }
949: }
950:
951: #ifdef DENSE
952: void chop(char* buf)
953: {
954: static char alpha[] = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
955: static const asz = sizeof(alpha)-1;
956: int hash = 0;
957: char* p = &buf[29];
958:
959: while (*p) {
960: hash <<= 1;
961: if (hash & (1<<12)) {
962: hash &= ~(1<<12);
963: hash++;
964: }
965: hash ^= *p++;
966: }
967:
968: buf[29] = alpha[(int)(hash%asz)];
969: buf[30] = alpha[(int)((hash/asz)%asz)];
970: buf[31] = 0;
971: }
972: #endif
973:
974: void type::print()
975: {
976: switch (base) {
977: case PTR:
978: case RPTR:
979: case VEC:
980: Pptr(this)->dcl_print(0);
981: break;
982: case FCT:
983: Pfct(this)->dcl_print();
984: break;
985: // case VEC:
986: // Pvec(this)->dcl_print(0);
987: // break;
988: case CLASS:
989: case ENUM:
990: if (emode)
991: fprintf(out_file,"%k",base);
992: else
993: // error('i',"%p->T::print(%k %s)",this,base,Pclass(this)->string);
994: fprintf(out_file,"struct %s *",Pclass(this)->string);
995: break;
996: case TYPE:
997: if (Cast||Pbase(this)->b_name->lex_level) {
998: Pbase(this)->b_name->tp->print();
999: break;
1000: }
1001: // no break
1002: default:
1003: Pbase(this)->dcl_print();
1004: }
1005: }
1006:
1007: char* type::signature(register char* p)
1008: /*
1009: take a signature suitable for argument types for overloaded
1010: function names
1011: */
1012: {
1013: Ptype t = this;
1014: int pp = 0; // pointer to
1015:
1016: xx:
1017: //error('d',"xx(%d) %d %k",this,t,t->base);
1018:
1019: // first unroll typedefs and handle derived types:
1020:
1021: switch (t->base) {
1022: case TYPE:
1023: if (Pbase(t)->b_const) *p++ = 'C';
1024: t = Pbase(t)->b_name->tp;
1025: goto xx;
1026:
1027: case VEC:
1028: if (pp && Pvec(t)->size) { // A<size>_
1029: *p++ = 'A';
1030: sprintf(p,"%d\0",Pvec(t)->size); // don't trust
1031: // sprintf return value
1032: while (*++p);
1033: *p++ = '_';
1034: }
1035: else
1036: *p++ = 'P';
1037: t = Pvec(t)->typ;
1038: pp = 1;
1039: goto xx;
1040:
1041: case PTR:
1042: if (Pptr(t)->rdo) *p++ = 'C'; // *const
1043: if (Pptr(t)->memof) { // M<size><classname>
1044: Pclass cl = Pptr(t)->memof;
1045: register char* s = cl->string;
1046: int d = cl->strlen;
1047: if (d==0) cl->strlen = d = strlen(s);
1048: *p++ = 'M';
1049: if (d/10) *p++ = '0'+d/10;
1050: *p++ = '0'+ d%10; // assume <100 char
1051: while (*p++ = *s++);
1052: --p; // not the '\0'
1053: }
1054: else
1055: *p++ = 'P';
1056: t = Pptr(t)->typ;
1057: pp = 1;
1058: goto xx;
1059:
1060: case RPTR:
1061: *p++ = 'R';
1062: t = Pptr(t)->typ;
1063: pp = 1;
1064: goto xx;
1065:
1066: case FCT:
1067: { Pfct f = Pfct(t);
1068: Pname n = f->argtype;
1069:
1070: if (f->f_const) *p++ = 'C'; // constant member function
1071: if (f->f_static) *p++ = 'S'; // static member function
1072: // if (f->memof && f->f_this==0) *p++ = 'S'; //SSS static member function
1073: *p++ = 'F';
1074: if (n == 0)
1075: *p++ = 'v'; // VOID, that is f() == f(void)
1076: else
1077: for ( ; n; n=n->n_list) { // print argument encoding
1078: // check if argtype is the same
1079: // as previously seen argtype
1080: int i = 0;
1081: for (Pname nn=f->argtype; n!=nn; nn=nn->n_list) {
1082: i++;
1083: if (nn->tp==n->tp || nn->tp->check(n->tp,0)==0) {
1084: // typeof (n) == typeof(arg i)
1085: int x = 1; // try for a run after n
1086: Pname nnn = n;
1087: while ((nnn=nnn->n_list) && x<9) {
1088: if (nnn->tp==n->tp
1089: || nnn->tp->check(n->tp,0)==0) {
1090: x++;
1091: n = nnn;
1092: }
1093: else
1094: break;
1095: }
1096:
1097: if (x == 1) // Ti
1098: *p++ = 'T';
1099: else { // Nxi
1100: *p++ = 'N';
1101: *p++ = '0'+x;
1102: }
1103:
1104: // assume <100 arguments
1105: if (9<i) *p++ = '0'+i/10;
1106: *p++ = '0'+i%10;
1107: goto zk;
1108: }
1109: }
1110:
1111: // ``normal'' case print argument type signature
1112: // if (n->n_xref) *p++ = 'R';
1113: p = n->tp->signature(p);
1114: zk:;
1115: }
1116:
1117: if (f->nargs_known == ELLIPSIS) *p++ = 'e';
1118:
1119: if (pp) { // '_' result type
1120: *p++ = '_';
1121: p = f->returns->signature(p);
1122: }
1123:
1124: *p = 0;
1125: return p;
1126: }
1127: }
1128:
1129: // base type modifiers:
1130:
1131: if ( Pbase(t)->b_const ) *p++ = 'C';
1132: // if ( Pbase(t)->b_signed ) *p++ = 'S';
1133: if ( Pbase(t)->b_unsigned ) *p++ = 'U';
1134: // if ( Pbase(t)->b_volatile ) *p++ = 'V';
1135:
1136:
1137: // now base types:
1138:
1139: register char *s, *ns = 0;;
1140: int d;
1141: Pclass cl;
1142: //lll:
1143: switch (t->base) {
1144: // case TNAME: t = Pbase(t)->b_name->tp; goto lll;
1145: case ANY: break;
1146: case ZTYPE: break;
1147: case VOID: *p++ = 'v'; break;
1148: case CHAR: *p++ = 'c'; break;
1149: case SHORT: *p++ = 's'; break;
1150: // case EOBJ:
1151: case INT: *p++ = 'i'; break;
1152: case LONG: *p++ = 'l'; break;
1153: case FLOAT: *p++ = 'f'; break;
1154: case DOUBLE: *p++ = 'd'; break;
1155: case LDOUBLE: *p++ = 'r'; break;
1156: case EOBJ:
1157: // *p++ = 'i';
1158: // break;
1159: { Penum en = Penum(Pbase(t)->b_name->tp);
1160: // t = en->e_type;
1161: // goto lll;
1162: ns = en->nested_sig;
1163: s = en->string;
1164: d = en->strlen;
1165: if (d==0) en->strlen = d = strlen(s);
1166: goto pppp;
1167: }
1168:
1169: case COBJ:
1170: { cl = Pclass(Pbase(t)->b_name->tp);
1171: ns = cl->nested_sig;
1172: s = cl->string;
1173: d = cl->strlen;
1174: if (d==0) cl->strlen = d = strlen(s);
1175: pppp:
1176: if ( ns == 0 ) {
1177: if (d/10) *p++ = '0'+d/10;
1178: *p++ = '0'+ d%10; // assume less that 99 characters
1179: }
1180: else s = ns;
1181:
1182: while (*p++ = *s++);
1183: --p;
1184: break;
1185: }
1186: case FIELD:
1187: default:
1188: error('i',"signature of %k",t->base);
1189: }
1190:
1191: *p = 0;
1192: return p;
1193: }
1194:
1195: void basetype::dcl_print()
1196: {
1197: Pname nn;
1198: Pclass cl;
1199:
1200: if (emode) {
1201: if (b_virtual) puttok(VIRTUAL);
1202: if (b_inline) puttok(INLINE);
1203: }
1204: if(ansi_opt || emode)
1205: if (b_const) puttok(CONST);
1206: if (b_unsigned) puttok(UNSIGNED);
1207:
1208: switch (base) {
1209: case ANY:
1210: if (emode)
1211: putstring("any ");
1212: else
1213: putstring("int ");
1214: break;
1215:
1216: case ZTYPE:
1217: if (emode)
1218: putstring("zero ");
1219: else
1220: putstring("int ");
1221: break;
1222:
1223: case VOID:
1224: if (emode==0 && ansi_opt==0) {
1225: // silly trick to bypass BSD C compiler bug
1226: // void* (*)() dosn't work there
1227: // note simpl.c knows that VOID -> CHAR grep for VCVC
1228: puttok(CHAR);
1229: break;
1230: }
1231: case CHAR:
1232: case SHORT:
1233: case INT:
1234: case LONG:
1235: case FLOAT:
1236: case DOUBLE:
1237: case LDOUBLE:
1238: puttok(base);
1239: break;
1240:
1241: case EOBJ:
1242: nn = b_name;
1243: eob:
1244: if (emode == 0)
1245: // puttok(INT);
1246: Penum(nn->tp)->e_type->dcl_print();
1247: else {
1248: puttok(ENUM);
1249: nn->print();
1250: }
1251: break;
1252:
1253: case COBJ:
1254: nn = b_name;
1255: cob:
1256: cl = Pclass(nn->tp);
1257: if (cl && (cl->csu==UNION || cl->csu==ANON))
1258: puttok(UNION);
1259: else
1260: puttok(STRUCT);
1261: {
1262: char* s = 0;
1263: if ( cl && cl->nested_sig )
1264: fprintf(out_file," __%s ",cl->nested_sig);
1265: else {
1266: if ( cl && cl->lex_level )
1267: s = make_local_name( cl );
1268: putst(s?s:nn->string);
1269: delete s;
1270: }
1271: }
1272: break;
1273:
1274: case TYPE:
1275: if (emode == 0) {
1276: switch (b_name->tp->base) {
1277: case COBJ:
1278: nn = Pbase(b_name->tp)->b_name;
1279: goto cob;
1280: case EOBJ:
1281: nn = Pbase(b_name->tp)->b_name;
1282: goto eob;
1283: }
1284: }
1285: b_name->print();
1286: break;
1287:
1288: default:
1289: if (emode) {
1290: if (0<base && base<=MAXTOK && keys[base])
1291: fprintf(out_file," %s",keys[base]);
1292: else
1293: putch('?');
1294: }
1295: else
1296: error('i',"%p->BT::dcl_print(%d)",this,base);
1297: }
1298: }
1299: Pbase memptr_type;
1300:
1301: void type::dcl_print(Pname n)
1302: /*
1303: "this" type is the type of "n". Print the declaration
1304: */
1305: {
1306: //error('d',"%p::dcl_print(%n)",this,n);
1307: Ptype t = this;
1308: Pptr p;
1309: TOK pre = 0;
1310:
1311: if (t == 0) error('i',"0->dcl_print()");
1312: if (n && n->tp!=t) error('i',"not %n'sT (%p)",n,t);
1313:
1314: if (base == OVERLOAD) {
1315: for (Plist gl=Pgen(this)->fct_list; gl; gl=gl->l) {
1316: Pname nn = gl->f;
1317: nn->tp->dcl_print(nn);
1318: if (gl->l) puttok(SM);
1319: }
1320: return;
1321: }
1322:
1323: tbuf = tbufvec[freetbuf];
1324: if (tbuf == 0) {
1325: if (freetbuf == NTBUF-1) error('i',"AT nesting overflow");
1326: tbufvec[freetbuf] = tbuf = new class dcl_buf;
1327: }
1328: freetbuf++;
1329: if ( base==FIELD && Pbase(this)->b_bits == 0 )
1330: tbuf->init(0);// some compilers can't handle mangled names here
1331: else
1332: tbuf->init(n);
1333: if (n && n->n_xref) tbuf->front(PTR);
1334:
1335: while (t) {
1336: TOK k;
1337:
1338: switch (t->base) {
1339: case PTR:
1340: p = Pptr(t);
1341: k = (p->rdo) ? CONST_PTR : PTR;
1342: goto ppp;
1343: case RPTR:
1344: p = Pptr(t);
1345: k = (p->rdo) ? CONST_RPTR : RPTR;
1346: ppp:
1347: if (p->memof) {
1348: if (emode) {
1349: tbuf->front(k);
1350: tbuf->front(p->memof);
1351: }
1352: else {
1353: t = p->typ;
1354: while (t->base==TYPE) t = Pbase(t)->b_name->tp;
1355: if (t->base == FCT) {
1356: tbuf->base(mptr_type);
1357: goto zaq;
1358: }
1359: else
1360: tbuf->front(k);
1361: }
1362: }
1363: else
1364: tbuf->front(k);
1365: pre = PTR;
1366: t = p->typ;
1367: break;
1368: case VEC:
1369: { Pvec v = Pvec(t);
1370: if (Cast && pre != PTR && pre != VEC) { // for Macintosh: ptr to array uses [] notation
1371: tbuf->front(PTR);
1372: pre = PTR;
1373: }
1374: else {
1375: if (pre == PTR) tbuf->paran();
1376: tbuf->back(VEC,v);
1377: pre = VEC;
1378: }
1379: t = v->typ;
1380: break;
1381: }
1382:
1383: case FCT:
1384: { Pfct f = Pfct(t);
1385: if (pre == PTR)
1386: tbuf->paran();
1387: else if (emode && f->memof && n==0)
1388: tbuf->front(f->memof);
1389: tbuf->back(FCT,f);
1390: pre = FCT;
1391: t = (f->s_returns) ? f->s_returns : f->returns;
1392: break;
1393: }
1394: case FIELD:
1395: tbuf->back(FIELD,t);
1396: tbuf->base( Pbase(Pbase(t)->b_fieldtype) );
1397: t = 0;
1398: break;
1399: case 0:
1400: error('i',"noBT(B=0)");
1401: case TYPE:
1402: if (Cast||Pbase(t)->b_name->lex_level) { // unravel type in case it contains vectors
1403: t = Pbase(t)->b_name->tp;
1404: break;
1405: }
1406:
1407: default: // the base has been reached
1408: if (emode) {
1409: char* s;
1410: for (Ptype tt = t; tt->base==TYPE; tt=Pbase(tt)->b_name->tp);
1411: switch (tt->base) {
1412: case CLASS:
1413: s = Pclass(tt)->string;
1414: if (s[0]=='_' &&s[1]=='_' && s[2]=='C') s="class";
1415: goto fret;
1416: case ENUM:
1417: s = "enum";
1418: goto fret;
1419: case OVERLOAD:
1420: s = "overloaded";
1421: fret:
1422: putstring(s);
1423: freetbuf--;
1424: return;
1425: }
1426: }
1427:
1428: tbuf->base( Pbase(t) );
1429: goto zaq;
1430: } // switch
1431: } // while
1432: zaq:
1433: tbuf->put();
1434: freetbuf--;
1435: }
1436:
1437: void fct::dcl_print()
1438: {
1439: Pname nn;
1440: //error('d',"fct::dcl_print()");
1441: if (emode) {
1442: putch('(');
1443: for (nn=argtype; nn;) {
1444: nn->tp->dcl_print(0);
1445: if (nn=nn->n_list) puttok(CM); else break;
1446: }
1447: switch (nargs_known) {
1448: case 0: // putst("?"); break;
1449: case ELLIPSIS: puttok(ELLIPSIS); break;
1450: }
1451: putch(')');
1452: if (f_const) puttok(CONST);
1453: if (f_static) puttok(STATIC); // wrong place for ``static''
1454: return;
1455: }
1456:
1457: Pname at = f_args;
1458: putch('(');
1459:
1460: if (ansi_opt) {
1461: // print typed arguments:
1462: at = (f_this) ? f_this : (f_result) ? f_result : argtype;
1463: // WNG -- note: at = f_args had 0 value with ansi_opt set
1464: // mystery fix added here
1465: if (at == 0) {
1466: if (nargs_known == ELLIPSIS) {
1467: putch(')');
1468: return;
1469: }
1470: puttok(VOID);
1471: }
1472: else if (body && Cast==0)
1473: at->dcl_print(CM); // print argument type and name
1474: else {
1475: for (nn=at; nn;) {
1476: // nn->tp->dcl_print(0); // print argument type
1477: nn->tp->dcl_print(nn); // print argument type
1478: // (there may not be a name)
1479: if (nn=nn->n_list) puttok(CM); else break;
1480: }
1481: }
1482: if (nargs_known == ELLIPSIS) putstring(",...");
1483: putch(')');
1484: }
1485: else {
1486: // print argument names followed by argument type declarations:
1487: if (body && Cast==0) {
1488: for (nn=at; nn;) {
1489: nn->print();
1490: if (nn=nn->n_list) puttok(CM); else break;
1491: }
1492: #ifdef mips
1493: if (nargs_known == ELLIPSIS)
1494: putstring(", va_alist");
1495: #endif
1496: putch(')');
1497: }
1498: else
1499: putch(')');
1500: }
1501: }
1502:
1503: void print_body(Pfct f)
1504: {
1505: if (Cast==0) {
1506:
1507: if (ansi_opt==0 && f->f_args) {
1508: f->f_args->dcl_print(SM);
1509: if ( last_ll==0 && (last_ll = f->body->where.line) )
1510: f->body->where.putline();
1511: }
1512:
1513: if (MAIN) {
1514: putstring("{ _main(); "); // call constructors
1515: f->body->print();
1516: puttok(RC);
1517: }
1518: else
1519: f->body->print();
1520: }
1521: }
1522:
1523: Pbcl shared_seen;
1524:
1525: void classdef::print_members()
1526: {
1527: int i;
1528:
1529: Pbcl l = baselist;
1530: // error('d',"%t->print_members()",this);
1531: if (l) {
1532: if (l->base == NAME) {
1533: l->bclass->print_members(); // first base only
1534: // pad to ensure alignment:
1535: int boff = l->bclass->real_size;
1536: int ba = l->bclass->align();
1537: int xtra = boff%ba;
1538: int waste = (xtra) ? ba-xtra : 0; // padding
1539: //error('d',"%s: size % align %d waste %d",string,boff,ba,waste);
1540: if (waste) {
1541: // waste it to protect against structure
1542: // assignments to the base class
1543: char* s = make_name('W');
1544: fprintf(out_file,"char %s[%d];\n",s,waste);
1545: delete s;
1546: }
1547: l = l->next;
1548: }
1549:
1550: for (; l; l=l->next)
1551: /* for second base etc. one must allocate as an object
1552: (rather than a list of members) to ensure proper alignment
1553: for shared base allocate a pointer
1554: size, alignment, & offset handled in cassdef::dcl()
1555: */
1556: if (l->base == NAME) {
1557: Pclass bcl = l->bclass;
1558: char *str = 0;
1559: char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string;
1560: if (bcl->lex_level &&
1561: bcl->nested_sig==0)
1562: str=make_local_name(bcl);
1563: puttok(STRUCT);
1564: putst(str?str:cs);
1565: putcat('O',bcl->string); // leave as unencoded
1566: puttok(SM);
1567: delete str;
1568: }
1569: }
1570:
1571: // Sam: A class or an enum type declared within a class can hide a
1572: // member with the same name, so make sure that it gets printed by
1573: // traversing the n_tbl_list to get at these names.
1574: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i)) {
1575: do { if (nn->base==NAME
1576: && nn->n_union==0
1577: && nn->tp->base!=FCT
1578: && nn->tp->base!=OVERLOAD
1579: && nn->tp->base!=CLASS
1580: && nn->tp->base!=ENUM
1581: && nn->n_stclass != STATIC) {
1582: // if (nn->tp->base==FIELD && Pbase(nn->tp)->b_bits==0) continue;
1583: Pexpr i = nn->n_initializer;
1584: nn->n_initializer = 0;
1585: nn->dcl_print(0);
1586: nn->n_initializer = i;
1587: }
1588: } while ((nn->base == NAME) &&
1589: ((nn->tp->base!=CLASS) || (nn->tp->base!=ENUM)) &&
1590: (nn = nn->n_tbl_list)) ;
1591: }
1592:
1593: for (l=baselist; l; l=l->next)
1594: if (l->base==VIRTUAL && l->ptr_offset) {
1595: Pclass bcl = l->bclass;
1596: char* str = 0;
1597: char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string;
1598: if (bcl->lex_level &&
1599: bcl->nested_sig==0)
1600: str=make_local_name(bcl);
1601: puttok(STRUCT);
1602: putst(str?str:cs);
1603: putch('*');
1604: putcat('P',bcl->string); // leave unencoded
1605: puttok(SM);
1606: delete str;
1607: }
1608: }
1609:
1610: // void classdef::print_vtbl(Pvirt vtab)
1611: // {
1612: // error('d',"%s->print_vtbl(%s) vtbl_opt %d",string,vtab->string,vtbl_opt);
1613: // error('d',"print_vtbl: lex_level: %d", lex_level );
1614: //
1615: // switch (vtbl_opt) {
1616: // case -1:
1617: // case 1:
1618: // vlist = new vl(this,vtab,vlist);
1619: // }
1620: //
1621: // int oo = vtbl_opt; // make `simulated static' name
1622: // vtbl_opt = -1;
1623: // char* str = lex_level ? make_local_name(this) : 0;
1624: // char* s = vtbl_name(vtab->string,str?str:string);
1625: // vtbl_opt = oo;
1626: // fprintf(out_file,"extern struct __mptr %s[];\n",s);
1627: // s[2] = 'p'; // pointer, not tbl itself
1628: // fprintf(out_file,"extern struct __mptr* %s;\n",s);
1629: //
1630: // delete s;
1631: // delete str;
1632: // }
1633:
1634: vl* vlist;
1635:
1636: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss);
1637:
1638: int p2(Pname nn, Ptype t, Pclass cl, Pvirt vtab, char* s)
1639: {
1640: int init;
1641:
1642: if (t->base == FCT) {
1643: Pfct f = Pfct(t);
1644:
1645: //error('d',"p2 %n init %d inline %d virtual %d",nn,nn->n_initializer,f->f_inline,f->f_virtual);
1646: //error('d',"p2 %s expr %d imeasure %d body %d",s,f->f_expr,f->f_imeasure,f->body);
1647: //error('d',"sto %k",nn->n_sto);
1648: if (nn->n_initializer
1649: || nn->n_sto==STATIC
1650: || f->f_inline
1651: || f->f_imeasure
1652: || f->f_virtual==0) return 0;
1653: init = f->body!=0;
1654: }
1655: else
1656: init = nn->n_initializer!=0;
1657:
1658: int oo = vtbl_opt;
1659: vtbl_opt = 1; // make sure the name is universal
1660: char *cs = cl->nested_sig?cl->nested_sig:cl->string;
1661: char* sstr = (cl->lex_level&&cl->nested_sig==0)? make_local_name(cl) : 0;
1662: char* ss = vtbl_name(vtab->string,sstr?sstr:cs);
1663:
1664: if (init) { // unique definition here
1665: really_really_print(cl,vtab,ss,s);
1666: }
1667: else { // unique definition elsewhere
1668: char *vstr = 0;
1669: if ( vtab && vtab->string ) {
1670: vstr = new char[strlen(vtab->string)+cl->strlen+1];
1671: strcpy( vstr, vtab->string );
1672: strcat( vstr, cl->string );
1673: }
1674: Pname nn;
1675: if (nn=ptbl->look(vstr?vstr:cl->string,0)) { // use of ptbl in file
1676: fprintf(out_file,"extern struct __mptr %s[];\n",ss);
1677: s[2] = 'p';
1678: // fprintf(out_file,"struct __mptr* %s = ",s);
1679: // fprintf(out_file,"%s;\n",ss);
1680: ptbl_add_pair(s, ss);
1681: nn->n_key=HIDDEN;
1682: }
1683: delete vstr;
1684: }
1685: vtbl_opt = oo;
1686:
1687: delete ss;
1688: delete sstr;
1689:
1690: return 1;
1691: }
1692:
1693: void classdef::really_print(Pvirt vtab)
1694: {
1695: // error('d',"really_print %t %d",this,vtbl_opt);
1696: int oo = vtbl_opt; // make `simulated static' name
1697: vtbl_opt = -1;
1698: char *cs = nested_sig?nested_sig:string;
1699: char* str = (lex_level&&nested_sig==0) ? make_local_name(this) : 0;
1700: char* s = vtbl_name(vtab->string,str?str:cs);
1701: // error('d', "really_print: %s, vtab: %s, s: %s", string, vtab->string, s );
1702: vtbl_opt = oo;
1703:
1704: // see if needed
1705: int i;
1706: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
1707: Ptype t = nn->tp;
1708: zse:
1709: if (t)
1710: switch (t->base) {
1711: case TYPE:
1712: t = Pbase(t)->b_name->tp;
1713: goto zse;
1714: /*
1715: case COBJ:
1716: if (nn->n_sto == EXTERN)
1717: { Pclass cl = Pclass(Pbase(t)->b_name->tp);
1718: if (cl->has_ctor()) {
1719: p2(nn,t,this,vtab,s);
1720: return;
1721: }
1722: }
1723: break;
1724: */
1725: case FCT:
1726: if (p2(nn,t,this,vtab,s))
1727: goto xyzzy;
1728: break;
1729:
1730: case OVERLOAD:
1731: { for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l)
1732: if (p2(gl->f,gl->f->tp,this,vtab,s))
1733: goto xyzzy;
1734: }
1735: }
1736: }
1737:
1738: { // must be initialized var in block to permit goto
1739: char* ss = vtbl_name(vtab->string,str?str:cs);
1740: // error('d', "really_print: %s, vtab: %s, ss: %s", cs, vtab->string, s );
1741:
1742: if (vtbl_opt)
1743: really_really_print(this,vtab,ss,s);
1744: else {
1745: char *vstr = 0;
1746: if ( vtab && vtab->string ) {
1747: vstr = new char[::strlen(vtab->string)+strlen+1];
1748: strcpy( vstr, vtab->string );
1749: strcat( vstr, string );
1750: }
1751: Pname nn;
1752: if (nn=ptbl->look(vstr?vstr:string,0)) { // use of ptbl in file
1753: fprintf(out_file,"extern struct __mptr %s[];\n",ss);
1754: s[2] = 'p';
1755: // fprintf(out_file,"struct __mptr* %s = ",s);
1756: // fprintf(out_file,"%s;\n",ss);
1757: ptbl_add_pair(s, ss);
1758: nn->n_key=HIDDEN;
1759: }
1760: delete vstr;
1761: }
1762: delete ss;
1763: }
1764: xyzzy:
1765: delete s;
1766: delete str;
1767: }
1768:
1769: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss)
1770: {
1771: // error('d',"really %s %s",s, ss);
1772: // make sure function is declared before using
1773: // it in vtbl initializer
1774: Pname nn;
1775: int i;
1776: for (i=0; nn = vtab->virt_init[i].n; i++) {
1777: Pfct f = Pfct(nn->tp);
1778: if (nn->n_initializer) { // pure virtual
1779: static pv;
1780: if (pv == 0) { // VCVC void->char assumed
1781: fprintf(out_file,"char __pure_virtual_called();\n");
1782: pv = 1;
1783: }
1784: continue;
1785: }
1786: if (f->base != FCT) error('i',"vtbl %n",nn);
1787: //void expand_dtor(Pclass cl);
1788: // if (f->f_inline == IDTOR) expand_dtor(f->memof);
1789:
1790: if (nn->n_dcl_printed==0 /*|| f->f_inline*/) {
1791: if (f->f_inline && vtbl_opt) puttok(STATIC);
1792: if (f->f_result == 0) make_res(f);
1793: Ptype r = f->s_returns ? f->s_returns : f->returns;
1794: r->print();
1795: nn->print();
1796: putstring("()");
1797: puttok(SM);
1798: nn->n_dcl_printed = 1;
1799: }
1800: }
1801:
1802: // if (vtbl_opt == -1) puttok(STATIC);
1803:
1804:
1805: fprintf(out_file,"struct __mptr %s[] = {0,0,0,\n",s);
1806:
1807: Pname n;
1808: for (i=0; n=vtab->virt_init[i].n; i++) {
1809: if (n->n_initializer)
1810: putstring("0,0,(__vptp)__pure_virtual_called,\n");
1811: else {
1812: fprintf(out_file,"%d,0,(__vptp)",-vtab->virt_init[i].offset);
1813: n->print();
1814: n->n_addr_taken = 1;
1815: putstring(",\n");
1816: }
1817: }
1818: putstring("0,0,0};\n");
1819:
1820: ss[2] = 'p';
1821: // fprintf(out_file,"struct __mptr* %s = ",ss);
1822: s[2] = 'v';
1823: // fprintf(out_file,"%s;\n",s);
1824: ptbl_add_pair(ss,s);
1825:
1826: Pname nm;
1827: char *cstr = 0;
1828: char *vstr = 0;
1829: char *cs = cl->nested_sig?cl->nested_sig:cl->string;
1830: if (cl->lex_level && cl->nested_sig==0) cstr = make_local_name( cl );
1831: if ( vtab && vtab->string ) {
1832: vstr = new char[strlen(vtab->string)+(cstr?strlen(cstr):strlen(cs))+1];
1833: strcpy( vstr, vtab->string );
1834: strcat( vstr, cstr?cstr:cs );
1835: }
1836:
1837: if ( vstr == 0 ) vstr = cstr;
1838: if ( nm = ptbl->look(vstr?vstr:cl->string,0) )
1839: nm->n_key = HIDDEN;
1840: else
1841: if ( ptbl->look(vstr?vstr:cl->string,HIDDEN) == 0 )
1842: ptbl->insert(new name(vstr?vstr:cl->string),HIDDEN);
1843: delete cstr;
1844: delete vstr;
1845:
1846: //error('d',"really-> %s",s);
1847: }
1848:
1849: #include <ctype.h>
1850: char* vtbl_name(char* s1, char* s2)
1851: {
1852: char* s3 = (vtbl_opt == -1 && *src_file_name) ? src_file_name : 0;
1853: // if vtbl_opt == -1 fake a static (there are no portable
1854: // way of doing a forward declaration of a static in C)
1855: int ll = s1 ? strlen(s1) : 0;
1856: int ll2 = strlen(s2);
1857: int ll3 = s3 ? strlen(s3) : 0;
1858: // int ll4 = s3&&def_name ? strlen(def_name->string) : 0;
1859: // int sz = (ll+ll2+ll3+ll4+22)/32+1; // avoid fragmentation
1860: int sz = (ll+ll2+ll3+20)/32+1; // avoid fragmentation
1861:
1862: sz *= 32;
1863: // error('d',"vtbl_name(%s,%s,%s) %d",s1?s1:"",s2,s3?s3:"",sz);
1864: char* buf = new char[sz];
1865: if (s3) {
1866: // if (s1 && def_name)
1867: // sprintf(buf,"__vtbl__%d%s__%d%s__%s__%s",ll,s1,ll2,s2,s3,def_name->string);
1868: // else
1869: if (s1)
1870: sprintf(buf,"__vtbl__%d%s__%d%s__%s",ll,s1,ll2,s2,s3);
1871: // else if (def_name)
1872: // sprintf(buf,"__vtbl__%d%s__%s__%s",ll2,s2,s3,def_name->string);
1873: else
1874: sprintf(buf,"__vtbl__%d%s__%s",ll2,s2,s3);
1875: }
1876: else if (s1)
1877: sprintf(buf,"__vtbl__%d%s__%d%s",ll,s1,ll2,s2);
1878: else
1879: sprintf(buf,"__vtbl__%d%s",ll2,s2);
1880:
1881: if (vtbl_opt == -1) {
1882: for (char* p = buf+ll2+11; *p; p++)
1883: if (!isalpha(*p) && !isdigit(*p)) *p = '_';
1884: }
1885: #ifdef DENSE
1886: chop(buf);
1887: #endif
1888: return buf;
1889: }
1890:
1891: void classdef::print_all_vtbls(Pclass bcl)
1892: {
1893: //error('d',"%t->print_all_vtbls(%t) vlt %d bl %d",this,bcl,virt_list,baselist);
1894:
1895: for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
1896: if (this != blist->vclass) continue;
1897: if (blist->printed) continue;
1898: // if (blist->string==0 && find_vptr(this)==0) { //BSopt
1899: // continue;
1900: // }
1901: // print_vtbl(blist);
1902: vlist = new vl(this,blist,vlist);
1903: blist->printed = 1;
1904: }
1905:
1906: for (Pbcl b = bcl->baselist; b; b = b->next)
1907: print_all_vtbls(b->bclass);
1908:
1909: if (this==bcl) c_body = 0;
1910: }
1911:
1912: void classdef::dcl_print(Pname)
1913: {
1914: //error('d',"%t->classdef::dcl_print() -- c_body==%d defined==0%o",this,c_body,defined);
1915: defined |= REF_SEEN;
1916: if (c_body==0 || c_body==3 || (defined&DEFINED)==0) return;
1917: c_body = 3;
1918:
1919: int i;
1920: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
1921: if (nn->base==NAME
1922: && nn->n_union==0
1923: && nn->tp->base==CLASS
1924: && Pclass(nn->tp)->c_body==1)
1925: Pclass(nn->tp)->dcl_print(nn);
1926: else if (nn->base == TNAME && Pbase(nn->tp)->base != COBJ)
1927: nn->dcl_print(0);
1928: else if (nn->tp && nn->tp->base == ENUM) {
1929: if(nn->n_union==0) Penum(nn->tp)->dcl_print(nn);
1930: }
1931: }
1932:
1933: TOK lvl = in_class ? NESTED : lex_level ? LOCAL : 0;
1934: Pname n = ktbl->look(string,lvl);
1935: if (n==0) n = ktbl->look(string,HIDDEN);
1936:
1937: if (n) {
1938: if (n->where.line!=last_line.line
1939: || n->where.file!=last_line.file)
1940: if (last_ll = n->where.line)
1941: n->where.putline();
1942: else
1943: last_line.putline();
1944: }
1945:
1946: TOK c = csu==CLASS ? STRUCT : csu;
1947: puttok(c);
1948: // if (string[0]!='_' || string[1]!='_' || string[2]!='C')
1949:
1950: char *str = 0;
1951: if ( lex_level && nested_sig == 0) str = make_local_name( this );
1952: if ( nested_sig ) putstring( " __" );
1953: putst(str?str:(nested_sig?nested_sig:string));
1954:
1955: int sm = 0;
1956: int sz = tsizeof();
1957: int dvirt = 0;
1958:
1959: if ( nested_sig )
1960: fprintf(out_file,"{\t/* sizeof __%s == %d */\n",nested_sig,obj_size);
1961: else
1962: fprintf(out_file,"{\t/* sizeof %s == %d */\n",str?str:string,obj_size);
1963: if ( last_ll ) last_line.line++;
1964: delete str;
1965:
1966: print_members();
1967: for (Pbcl b = baselist; b; b = b->next) { // declare virtual classes
1968: if (b->base != VIRTUAL) continue;
1969: Pclass bcl = b->bclass;
1970: dvirt += bcl->virt_count;
1971: //error('d',"%t in %t %d",b->bclass,this,b->allocated);
1972: if (b->allocated==0) continue;
1973: char* str = 0;
1974: if (bcl->lex_level) str = make_local_name(bcl);
1975: puttok(STRUCT); // struct bcl Obcl;
1976: putst(str?str:bcl->string);
1977: putcat('O',bcl->string); // leave unencoded
1978: puttok(SM);
1979: delete str;
1980: }
1981: putstring("};\n");
1982: if ( last_ll ) last_line.line++;
1983:
1984: for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
1985: if (nn->base==NAME && nn->n_union==0) {
1986: Ptype t = nn->tp;
1987: switch (t->base) {
1988: case FCT:
1989: case OVERLOAD:
1990: break;
1991: default:
1992: if (nn->n_stclass == STATIC) {
1993: TOK b = nn->n_sto;
1994: //error('d',"print nn %n tp %t b %k eval %d",nn,nn->tp,b,nn->n_evaluated);
1995: /*
1996: Pname cn;
1997: TOK bb = ((cn=nn->tp->is_cl_obj())
1998: && Pclass(cn->tp)->has_ctor())==0
1999: ?0:b; // force explicit initialization
2000: nn->n_sto = (nn->n_evaluated) ? STATIC : bb;
2001: */
2002: nn->n_sto = (nn->n_evaluated) ? STATIC : b;
2003: nn->dcl_print(0);
2004: nn->n_sto = b;
2005: }
2006: }
2007: }
2008: }
2009: if (vtbl_opt != -1) print_all_vtbls(this); // force declaration
2010: //error('d',"dcl_print -> ");
2011: }
2012:
2013:
2014: char *
2015: make_local_name( Pclass cl, int ln )
2016: {
2017: char *buf;
2018: if ( cl->in_fct == 0 ) error( 'i', "localC %s missingFN", cl->string );
2019: char *fsig = Pfct(cl->in_fct->tp)->f_signature;
2020: if ( fsig == 0 ) fsig = local_sign( cl->in_fct->tp );
2021: char *fs = cl->in_fct->string;
2022: int class_len=cl->strlen+strlen(fsig)+strlen(fs)+strlen(cl->lcl)+4;
2023: int sz = (class_len+20)/32+1; // from vtbl_name()
2024:
2025: if ( Pfct(cl->in_fct->tp)->memof == 0 ) {
2026: sz *= 32;
2027: buf = new char[ sz ];
2028: // error('d', "make_local_name: sz: %d", sz );
2029:
2030: if (ln)
2031: sprintf(buf, "__%d%s__%s__%s%s", class_len, cl->string, fs, fsig, cl->lcl);
2032: else
2033: sprintf(buf, "%s__%s__%s%s", cl->string, fs, fsig, cl->lcl);
2034: }
2035: else
2036: {
2037: char *cs = Pclass(Pfct(cl->in_fct->tp)->memof)->string;
2038: int len = Pclass(Pfct(cl->in_fct->tp)->memof)->strlen;
2039: if ( len < 10 )
2040: ++class_len;
2041: else
2042: if ( len > 99 )
2043: class_len += 3;
2044: else class_len += 2;
2045: class_len += len;
2046: sz = (class_len+20)/32+1;
2047: sz *= 32;
2048: buf = new char[ sz ];
2049: // error('d', "make_local_name: sz: %d", sz );
2050:
2051: if ( ln )
2052: sprintf(buf, "__%d%s__%s__%d%s%s%s",class_len,cl->string,fs,len,cs,fsig,cl->lcl);
2053: else sprintf(buf, "%s__%s__%d%s%s%s",cl->string,fs,len,cs,fsig,cl->lcl);
2054: }
2055:
2056: #ifdef DENSE
2057: chop( buf );
2058: #endif
2059:
2060: return buf;
2061: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.