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