![[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 / ooptcfront|
Return to print2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
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: #include <string.h>
18: #include "template.h"
19:
20: extern FILE* out_file;
21: bit Cast;
22: int last_ll = 1;
23: Pin curr_icall;
24: char emode;
25: int ntok;
26:
27: static int MAIN; // fudge to get _main() called by main()
28:
29: #define eprint(e) if (e) Eprint(e)
30:
31: #ifdef DENSE
32: void chop(char*);
33: #endif
34:
35:
36: /* The following strings (new_string and tmp_string) are
37: used to capture a transformed string. The captured
38: string is then assigned to "name::output_string".
39: This is done in "name::print". */
40:
41: static char new_string[1024]; // The transformed string.
42: static char tmp_string[1024]; // Used to format the transformed string.
43:
44: /* Rick, ODI, 6-20-89: The following #define is used to control whether
45: renamings are saved. */
46:
47: #define OUTPUT_PAIR_FUNCTIONALITY 0
48:
49: #if OUTPUT_PAIR_FUNCTIONALITY
50: static void output_pair (name *declarator);
51: #endif
52:
53: /* Rick, ODI, 6-20-89: Local functions used in renaming work. */
54:
55: extern bit capture_renaming;/* Rick, ODI; used to switch off cfront renaming
56: capture. */
57: static Pname is_data_member (Pname p_name);
58: static Pname matches_base_member (Pname p_name, Pclass class_);
59: static Pname look_any (Ptable p_table, char* s);
60:
61: void puttok(TOK t)
62: /*
63: print the output representation of "t"
64: */
65: {
66: // if (t<=0 || MAXTOK<t) error("illegal token %d",t);
67: // char* s = keys[t];
68: // if (s == 0) error("V representation token %d",t);
69:
70: putstring(keys[t]);
71:
72: if(!emode) {
73: if (12<ntok++) {
74: ntok = 0;
75: last_line.putline();
76: }
77: else if (t == SM) {
78: ntok = 0;
79: putch('\n');
80: if (last_ll) last_line.line++;
81: }
82: else
83: putch(' ');
84: } else putch(' ');
85: }
86:
87: #define MX 20
88: #define NTBUF 10
89: class dcl_buf {
90: /*
91: buffer for assembling declaration (or cast)
92: left contains CONST_PTR => *CONST
93: CONST_RPTR => &CONST
94: PTR => *
95: RPTR => &
96: LP => (
97: right contains RP => )
98: VEC => [ rnode ]
99: FCT => ( rnode )
100: FIELD => : rnode
101: */
102: Pbase b;
103: Pname n;
104: TOK left[MX], right[MX];
105: Pnode rnode[MX];
106: Pclass lnode[MX];
107: int li, ri;
108: public:
109: void init(Pname nn) { b=0; n=nn; li=ri=0; }
110: void base(Pbase bb) { b = bb; }
111: void front(TOK t) { left[++li] = t; }
112: void front(Pclass c) { left[++li] = MEMPTR; lnode[li] = c; }
113: void back(TOK t, Pnode nod) { right[++ri] = t; rnode[ri] = nod; }
114: void paran() { front(LP); back(RP,0); }
115: void put();
116: } *tbufvec[NTBUF] = {0}, *tbuf = 0;
117:
118: int freetbuf = 0;
119:
120: void dcl_buf::put()
121: {
122: int i;
123: Pfct ff = 0;
124:
125: if (MX<=li || MX<=ri) error('i',"T buffer overflow");
126: if (b == 0) error('i',"noBT%s",Cast?" in cast":"");
127:
128: if (n && n->n_sto && n->n_sto!=REGISTER) puttok(n->n_sto);
129:
130: b->dcl_print();
131:
132: for( ; li; li--) {
133: switch (left[li]) {
134: case LP:
135: putch('(');
136: break;
137: case PTR:
138: putch('*');
139: break;
140: case RPTR:
141: if (emode)
142: putch('&');
143: else
144: putch('*');
145: break;
146: case CONST_PTR:
147: if (emode)
148: putstring("*const ");
149: else
150: putch('*');
151: break;
152: case CONST_RPTR:
153: if (emode)
154: putstring("&const ");
155: else
156: putch('*');
157: break;
158: case MEMPTR:
159: if (lnode[li]) {
160: char buff[1024] ;
161: fprintf(out_file,"%s::", (lnode[li]->string)) ;
162: }
163: }
164: }
165:
166: if (n) n->print();
167:
168: for(i=1; i<=ri; i++) {
169: switch (right[i]) {
170: case RP:
171: putch(')');
172: break;
173: case VEC:
174: putch('[');
175: { Pvec v = (Pvec) rnode[i];
176: Pexpr d = v->dim;
177: int s = v->size;
178: if (d) d->print();
179: if (s) fprintf(out_file,"%d",s);
180: }
181: putch(']');
182: break;
183: case FCT: // beware of function returning pointer to
184: // function expressed witout typedef
185: { Pfct f = Pfct(rnode[i]);
186: if (f->body) ff = f;
187: f->dcl_print();
188: break;
189: }
190: case FIELD:
191: { Pbase f = (Pbase) rnode[i];
192: Pexpr d = (Pexpr)f->b_name;
193: int s = f->b_bits;
194: putch(':');
195: if (d)
196: d->print();
197: else if (s)
198: fprintf(out_file,"%d",s);
199: else
200: puttok(ZERO);
201: break;
202: }
203: }
204: }
205: void print_body(Pfct);
206: if (ff && emode==0) print_body(ff);
207: }
208:
209: void name::dcl_print(TOK list)
210: /*
211: Print the declaration for a name (list==0) or a name list (list!=0):
212: For each name
213: (1) print storage class
214: (2) print base type
215: (3) print the name with its declarators
216: Avoid (illegal) repetition of basetypes which are class or enum declarations
217: (A name list may contain names with different base types)
218: list == SM : terminator SM
219: list == 0: single declaration with terminator SM
220: list == CM : separator CM
221: */
222: {
223: if (error_count) return;
224:
225: if (capture_renaming) { /* rick, ODI, 3-28-89; used to switch off some
226: cfront renaming. */
227: new_string[0] = '\0';
228: tmp_string[0] = '\0';
229: }
230:
231: for (Pname n=this; n; n=n->n_list) {
232: Ptype t = n->tp;
233: int sm = 0;
234:
235: //error('d',"%s->dcl_print() tp %t sto %k",n->string,t,n->n_sto);
236:
237: if (t == 0) error('i',"N::dcl_print(%n)T missing",n);
238:
239: if (t->base == TYPE) { // unroll local typedefs:
240: Pname bn = Pbase(t)->b_name;
241: if (bn->lex_level && (! bn->n_template_arg)
242: && bn->tp->base != COBJ
243: && bn->tp->base != EOBJ )
244: n->tp = t = bn->tp;
245: }
246:
247: switch (t->base) { // HACK, recursive unroller needed
248: case RPTR:
249: case PTR:
250: case VEC:
251: if (Pptr(t)->typ->base == TYPE) { // unroll local typedefs:
252: Pname bn = Pbase(Pptr(t)->typ)->b_name;
253: if (bn->lex_level && (! bn->n_template_arg)
254: && bn->tp->base != COBJ
255: && bn->tp->base != EOBJ )
256: Pptr(t)->typ = bn->tp;
257: }
258: }
259:
260: if (n->n_stclass==ENUM) if (list) continue; else return;
261:
262: if (n->where.line!=last_line.line || n->where.file!=last_line.file)
263: if (last_ll = n->where.line)
264: n->where.putline();
265: else
266: last_line.putline();
267:
268: int tc = Pbase(t)->b_const;
269: for (Ptype tt = t; tt->base==TYPE; tt = Pbase(tt)->b_name->tp)
270: tc |= Pbase(tt)->b_const;
271:
272: switch (t->base) {
273: case CLASS:
274: //fprintf(stderr,"class %s->dcl_print()\n",n->string);
275: if (n->base != TNAME) {
276: Pclass(t)->dcl_print(n);
277: sm = 1;
278: }
279: break;
280:
281: case ENUM:
282: Penum(t)->dcl_print(0);
283: sm = 1;
284: break;
285:
286: case FCT:
287: { Pfct f = Pfct(t);
288:
289: if (n->base == TNAME) puttok(TYPEDEF);
290:
291: //error('d',"fct %n->dcl_print() printed %d body %d defined %d",n,n->n_dcl_printed,f->body,f->defined);
292: //error('d',"n %d tbl %d tp %t inline %d",n,n->n_table,n->tp,f->f_inline);
293: if (n->n_dcl_printed==2 // definition already printed
294: || (n->n_dcl_printed==1 && f->body==0)
295: // declaration already printed
296: ) {
297: // don't print again
298: sm = 1; // no SM
299: break;
300: }
301:
302: if (f->f_result == 0) make_res(f);
303:
304: if (f->body && n->n_sto==EXTERN) n->n_sto = 0;
305:
306: if (f->f_inline) {
307: if (debug_opt) {
308: //error('d',"f %t defined %d inline %d",f,f->defined,f->f_inline);
309: if (f->defined&DEFINED
310: && f->defined&SIMPLIFIED
311: && f->f_inline!=ITOR)
312: goto prnt_def;
313: else if (n->n_dcl_printed==0)
314: goto prnt_dcl;
315: else {
316: sm = 1;
317: break;
318: }
319: }
320: if (f->f_virtual || n->n_addr_taken) {
321: prnt_dcl:
322: //error('d',"prnt_dcl %d %n %k",n,n,n->n_sto);
323: TOK st = n->n_sto;
324: Pblock b = f->body;
325: f->body = 0;
326: t->dcl_print(n);
327: n->n_dcl_printed = 1;
328: n->n_sto = st;
329: f->body = b;
330: break;
331: }
332: else
333: sm = 1; // no SM
334: }
335: else if ((f->defined&DEFINED)==0
336: || (f->defined&SIMPLIFIED)==0)
337: goto prnt_dcl;
338: else if (n->n_table==gtbl && strcmp(n->string,"main")==0) {
339: MAIN = 1;
340: gtbl->look("main",0)->use();
341: f->f_signature = 0;
342: t->dcl_print(n);
343: n->n_dcl_printed = f->body?2:1;
344: MAIN = 0;
345: }
346: else {
347: prnt_def:
348: //error('d',"prnt_def %n %k %d %k",n,n->n_oper,n,n->n_sto);
349: if (n->n_oper==CTOR || n->n_oper==DTOR) {
350: Pclass cl = Pclass(n->n_table->t_name->tp);
351: if (cl->c_body == 3) cl->print_all_vtbls(cl);
352: }
353: t->dcl_print(n);
354: n->n_dcl_printed = f->body?2:1;
355: }
356: if (f->body) sm = 1;
357: break;
358: }
359:
360: case OVERLOAD:
361: {
362: for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) {
363: Pname nn = gl->f;
364: nn->dcl_print(0);
365: sm = 1;
366: }
367: break;
368: }
369:
370: case ASM:
371: fprintf(out_file,"asm(\"%s\")\n",(char*)Pbase(t)->b_name);
372: break;
373:
374: case INT:
375: case EOBJ:
376: case CHAR:
377: case LONG:
378: case SHORT:
379: tcx:
380: // do not allocate space for constants unless necessary
381: if (tc
382: && n->n_sto!=EXTERN // extern const one;
383: // const one = 1;
384: // allocates storage
385: && (n->n_scope==EXTERN // FUDGE const one = 1;
386: // is treated as static
387: // need loader support
388: || n->n_scope==STATIC
389: || n->n_scope==FCT)
390: ) {
391: if (n->n_evaluated) {
392: sm = 1; /* no ; */
393: break;
394: }
395: }
396: tc = 0;
397: // no break;
398:
399: default:
400: {
401: /*
402: // don't print local instance of const
403: if ( n->n_dcl_printed == 3 ) {
404: sm = 1;
405: break;
406: }
407: */
408: Pexpr i = n->n_initializer;
409: if (tc) {
410: switch (tt->base) {
411: case CHAR:
412: case SHORT:
413: case INT:
414: case LONG:
415: case EOBJ:
416: goto tcx;
417: }
418: }
419:
420: if (n->base == TNAME) {
421: // Always print template formals, even when
422: // they have the same formal name, since the
423: // instantiation name is different. This fix
424: // should not be required when the copy
425: // mechanism is in place.
426: if (! n_template_arg)
427: for (Pname tn=ktbl->look(n->string,HIDDEN); tn; tn=tn->n_tbl_list)
428: if (tn
429: && tn->lex_level
430: && t==tn->tp) return;
431: puttok(TYPEDEF);
432: }
433:
434: if (n->n_stclass == REGISTER) {
435: // (imperfect) check against member functions
436: // register s a; a.f() illegal
437: Pname cln = n->tp->is_cl_obj();
438: if (cln) {
439: Pclass cl = Pclass(cln->tp);
440: if (cl->csu!=CLASS
441: && cl->baselist==0
442: && cl->has_itor()==0
443: && cl->virt_count==0) puttok(REGISTER);
444: }
445: else
446: puttok(REGISTER);
447: }
448:
449: if (i) {
450: if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
451: n->n_initializer = 0;
452: t->dcl_print(n);
453: puttok(SM);
454: n->n_initializer = i;
455: n->n_sto = 0;
456: t->dcl_print(n);
457: n->n_sto = EXTERN;
458: }
459: else
460: t->dcl_print(n);
461: }
462: else if (n->n_evaluated && Pbase(t)->b_const) {
463: if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
464: int v = n->n_evaluated;
465: n->n_evaluated = 0;
466: t->dcl_print(n);
467: puttok(SM);
468: n->n_evaluated = v;
469: n->n_sto = 0;
470: t->dcl_print(n);
471: n->n_sto = EXTERN;
472: }
473: else
474: t->dcl_print(n);
475: }
476: else {
477: //error('d',"%n sto %k val %d stc %k",n,n->n_sto,n->n_val,n_stclass);
478: if ((n->n_sto==0 || (n->n_val && n->n_evaluated==0))
479: && n_stclass==STATIC
480: && n->n_sto!=STATIC
481: && n->n_table==gtbl) {
482: if (n->n_val && n->n_evaluated==0) {
483: // extern x = f();
484: // generate int x = 0;
485: // plus dynamic initialization
486: n->n_sto = 0;
487: }
488: Ptype tt = t;
489: zaq:
490: switch (tt->base) {
491: case TYPE:
492: tt = Pbase(tt)->b_name->tp; goto zaq;
493: case COBJ: // "X a;" == "X a = {0};"
494: {
495: TOK csu = Pclass(Pbase(tt)->b_name->tp)->csu;
496: if (csu != UNION)
497: n->n_initializer = i = new expr(ILIST,zero,0);
498: break;
499: }
500: case PTR:
501: if (tt->memptr()) {
502: i = new expr(ELIST,zero,zero);
503: n->n_initializer = i = new expr(ILIST,i,zero);
504: break;
505: }
506: // no break
507: case CHAR:
508: case SHORT:
509: case INT:
510: case EOBJ:
511: case LONG:
512: case FLOAT:
513: case DOUBLE:
514: case LDOUBLE: // "int a;" == "int a = 0;"
515: n->n_initializer = i = zero;
516: }
517: }
518: t->dcl_print(n);
519: }
520:
521: if (n->n_scope!=ARG) {
522: if (i) {
523: puttok(ASSIGN);
524:
525: Pexpr i2 = i;
526: while (i2->base == CAST) i2 = i2->e1;
527: if (i2->base == ILIST) i = i2;
528: if (t!=i->tp
529: && i->base!=ZERO
530: && i->base!=ILIST /*&& i->tp!=Pchar_type*/) {
531: Ptype t1 = n->tp;
532: cmp:
533: switch (t1->base) {
534: case TYPE:
535: t1 = Pbase(t1)->b_name->tp;
536: goto cmp;
537: default:
538: i->print();
539: break;
540: // case EOBJ:
541: // goto cst;
542: case VEC:
543: if (Pvec(t1)->typ->base==CHAR) {
544: i->print();
545: break;
546: }
547: // no break
548: case PTR:
549: case RPTR:
550: if (i->tp==0 || n->tp->check(i->tp,0)) {
551: // cst:
552: putch('(');
553: bit oc = Cast;
554: Cast = 1;
555: t->print();
556: Cast = oc;
557: putch(')');
558: }
559: eprint(i);
560: }
561: }
562: else {
563: if (i==zero) {
564: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
565: // if (t->base == EOBJ) {
566: // putch('(');
567: // bit oc = Cast;
568: // Cast = 1;
569: // t->print();
570: // Cast = oc;
571: // putch(')');
572: // }
573: }
574: eprint(i);
575:
576: // i->print();
577: }
578: }
579: else if (n->n_evaluated) {
580: puttok(ASSIGN);
581: if (n->tp->base!=INT || n->tp->is_unsigned()) {
582: putstring("((");
583: bit oc = Cast;
584: Cast = 1;
585: n->tp->print();
586: Cast = oc;
587: fprintf(out_file,")%d)",n->n_val);
588: }
589: else
590: fprintf(out_file,"%d",n->n_val);
591: }
592: }
593: }
594: }
595:
596: switch (list) {
597: case SM:
598: if (sm==0) puttok(SM);
599: break;
600: case 0:
601: if (sm==0) puttok(SM);
602: #if OUTPUT_PAIR_FUNCTIONALITY
603: if (capture_renaming) { /* Rick, ODI, 3-28-89; used
604: to switch on renaming
605: capture. */
606: output_pair(this);
607: }
608: #endif
609: return;
610: case CM:
611: if (n->n_list) puttok(CM);
612: break;
613: }
614: }
615:
616: #if OUTPUT_PAIR_FUNCTIONALITY
617: if (capture_renaming) { /* rick, ODI, 3-28-89; used
618: to switch off some cfront
619: renaming. */
620: if (list != SM)
621: output_pair(this);
622: }
623: #endif
624:
625: }
626:
627: char *local_sign( Ptype pt )
628: { // get function signature for local class
629: char buf[1024];
630: char* bb = pt->signature(buf);
631: int ll = bb-buf;
632: if (1023 < ll) error('i',"local class N buffer overflow");
633: char *p = new char[ll+1];
634: strcpy(p,buf);
635: return p;
636: }
637:
638:
639: void enumdef::dcl_print(Pname cln)
640: /*
641: */
642: {
643: char* s = cln ? cln->string : 0;
644: fprintf(out_file,"enum %s { ",string);
645: for (Pname px, p=mem; p; p=px) {
646: px = p->n_list;
647: if (s) {
648: if (p->n_initializer)
649: fprintf(out_file,"%s__%s = %d",p->string,s,p->n_val);
650: else
651: fprintf(out_file,"%s__%s",p->string,s);
652: }
653: else {
654: if (p->n_initializer)
655: fprintf(out_file,"%s = %d",p->string,p->n_val);
656: else
657: fprintf(out_file,"%s",p->string);
658: }
659: if (px) puttok(CM);
660: p->n_initializer = 0;
661: delete p;
662: }
663: /* Sam says: don't zap MEM. It may be needed for the program database later. */
664: // mem = 0;
665: puttok(RC);
666: puttok(SM);
667: }
668:
669:
670: extern char *make_local_name(Pclass,int=0);
671:
672: void name::print()
673:
674: /* print just the name itself */
675:
676: {
677:
678: /* Rick, ODI, 3-28-89: This function transforms the names of name
679: instances. In fact, with default cfront renaming, only types and
680: globals pass though unscathed. This makes debugging a real pain
681: in the ass. Consequently, a mode has been introduced to cfront which
682: limits renaming (see main.c:main:case "+gx"). Using this mode reduces
683: the renaming to the following cases:
684:
685: -- static data members are suffixed with the name of their
686: class with '__#' at the beginning of the class name. The '#'
687: is the length of the class name. So, for example, given
688: "class C { static int i; }", "i" would become the global variable
689: "i__1C"--this makes global name clashes less likely;
690:
691: -- data members are prefixed just like static data members
692: only when the data member's name is identical to the name
693: of a data member in a base class. For example, given
694: "class B { int i; } class D : B { float i; }" the first
695: would not be renamed, so its name would be "i", while
696: the second would be renamed to "i__1D";
697:
698: -- functions are transformed as before. Given overloading
699: and the fact that function members are transformed into
700: global functions, function renaming must be preserved;
701:
702: -- anonymous unions have names generated for them (someone's
703: got to do it).
704:
705: All other cases are not renamed using the the "gx" mode. Additionally,
706: the generated names of anonymous unions have been simplified. Finally,
707: all names which are transformed into global objects have must have
708: any renamings be exactly as with default renaming. */
709:
710: if (this == 0) error('i',"0->N::print()");
711:
712: if (capture_renaming) { /* rick, ODI, 3-28-89; used to switch on
713: renaming capture. */
714: new_string[0] = '\0';
715: tmp_string[0] = '\0';
716: }
717:
718: if (string == 0) {
719: if (emode) putch('?');
720: if (capture_renaming) { /* rick, ODI, 3-28-89; used to switch
721: on renaming capture. */
722: new_string[0] = '\0';
723: goto handle_new_string;
724: }
725: return;
726: }
727:
728: // error( 'd', "%s->name::print(), base: %k", string, base );
729:
730: switch (base) {
731: case TNAME:
732: if ((n_template_arg_string) && emode &&tp) {
733: // hide the mangled type name, and use the type instead, since it is
734: // more useful
735: tp->dcl_print(0) ;
736: return ;
737: } ;
738:
739: if( emode && tp && tp->base == COBJ) {
740: Pclass cl = Pclass(Pbase(tp)->b_name->tp);
741: if(cl && cl->base == CLASS &&
742: (cl->class_base == instantiated_template_class)) {
743: Ptclass(cl)->inst->print_pretty_name() ;
744: return;
745: }
746: }
747:
748: putst(n_template_arg_string ? n_template_arg_string : string);
749: if (capture_renaming) {
750: /* Rick, ODI, 3-28-89: capture renaming. */
751: strcat(new_string,
752: (n_template_arg_string ? n_template_arg_string : string));
753: goto handle_new_string;
754: }
755: return;
756:
757: case MDOT:
758: Pexpr(this)->print();
759: return;
760: }
761:
762: if (emode) {
763: Ptable tbl;
764: char* cs = 0;
765: bit f = 0;
766: if (tp) {
767: switch (tp->base) {
768: case OVERLOAD:
769: case FCT:
770: f = 1;
771: default:
772: if (tbl=n_table) {
773: if (tbl == gtbl) {
774: if (f == 0) {
775: putstring("::");
776: if (capture_renaming) {
777: /* Rick, ODI, 3-28-89: capture renaming. */
778: strcat(new_string, "::");
779: }
780: }
781: }
782: else {
783: if (tbl->t_name) {
784: Ptclass pc = Ptclass(tbl->t_name->tp) ;
785: cs = tbl->t_name->string;
786: if ((pc->base == CLASS) &&
787: (pc->class_base == instantiated_template_class))
788: pc->inst->print_pretty_name() ;
789: else fprintf(out_file,"%s",cs);
790: fprintf (out_file, "::") ;
791:
792: if (capture_renaming) {
793: // Sam: I think this is not necessary in
794: // "emode" context
795: /* Rick, ODI, 3-28-89: capture renaming. */
796: sprintf(tmp_string,"%s::",cs);
797: strcat(new_string, tmp_string);
798: }
799: }
800: }
801: }
802:
803: // local class will need to modify ???
804:
805: if (n_scope==ARG && strcmp(string,"this")==0) {
806: // tell which "this" it is
807: Ptype tt = Pptr(tp)->typ;
808: Pname cn = Pbase(tt)->b_name;
809: fprintf(out_file,"%s::",cn->string);
810: if (capture_renaming) {
811: /* Rick, ODI, 3-28-89: capture renaming. */
812: sprintf(tmp_string, "%s::",cn->string);
813: strcat(new_string, tmp_string);
814: }
815:
816: }
817:
818: case CLASS:
819: case ENUM:
820: // case TYPE:
821: break;
822: }
823: nop:
824: switch (n_oper) {
825: case TYPE:
826: putstring("operator ");
827: if (capture_renaming) {
828: /* Rick, ODI, 3-28-89: capture renaming. */
829: strcat(new_string, "operator ");
830: }
831: if (tp) Pfct(tp)->returns->dcl_print(0);
832: break;
833: case 0:
834: putstring(string);
835: if (capture_renaming) {
836: /* Rick, ODI, 3-28-89: capture renaming. */
837: strcat(new_string, string);
838: }
839: break;
840: case DTOR:
841: putch('~');
842: if (capture_renaming) {
843: /* Rick, ODI, 6-6-89: capture renaming. */
844: strcat(new_string, "~");
845: }
846: case CTOR:
847: if (cs) {
848: if(tbl->t_name) {
849: Ptclass pc = Ptclass(tbl->t_name->tp) ;
850: if ((pc->base == CLASS) &&
851: (pc->class_base == instantiated_template_class))
852: pc->inst->print_pretty_name() ;
853: } else putstring(cs);
854: if (capture_renaming) {
855: /* Rick, ODI, 3-28-89: capture renaming. */
856: strcat(new_string, cs);
857: }
858: }
859:
860: else {
861: putstring("constructor");
862: if (capture_renaming) {
863: /* Rick, ODI, 3-28-89: capture renaming. */
864: strcat(new_string, "constructor");
865: }
866: f = 0;
867: }
868: break;
869: case TNAME:
870: putstring(string);
871: if (capture_renaming) {
872: /* Rick, ODI, 3-28-89: capture renaming. */
873: strcat(new_string, string);
874: }
875: break;
876: default:
877: putstring("operator ");
878: if (capture_renaming) {
879: /* Rick, ODI, 3-28-89: capture renaming. */
880: strcat(new_string,"operator " );
881: }
882: putstring(keys[n_oper]);
883: if (capture_renaming) {
884: /* Rick, ODI, 3-28-89: capture renaming. */
885: strcat(new_string, keys[n_oper]);
886: }
887: break;
888: }
889: if (f) {
890: putstring("()");
891: if (capture_renaming) {
892: /* Rick, ODI, 3-28-89: capture renaming. */
893: strcat(new_string,"()");
894: }
895: }
896: }
897: else {
898: if (n_oper) goto nop;
899: if (string) {
900: putstring(n_template_arg_string ?
901: n_template_arg_string : string);
902: if (capture_renaming) {
903: /* Rick, ODI, 3-28-89: capture renaming. */
904: strcat(new_string,
905: (n_template_arg_string ?
906: n_template_arg_string : string));
907: }
908: }
909: }
910: if (capture_renaming) { /* rick, ODI, 3-28-89; used
911: to switch on renaming capture. */
912: goto handle_new_string;
913: }
914: return;
915: }
916:
917: // AT&T used initializations. Rick's goto povoked a diagnostic. so...
918: char* sig; sig = 0;
919: Pclass cl; cl = 0;
920: int i; i = n_union;
921:
922: if (tp) {
923: Ptable tbl;
924:
925: switch (tp->base) {
926: default:
927: if (tbl=n_table) { // global or member
928: Pname tn;
929: if (tbl == gtbl) {
930:
931: /* Rick, ODI, 3-28-89: "gtbl" is the table of global
932: names (see cfront.h:124). So, "tbl" is the table
933: of global names here. */
934:
935: // if (i) fprintf(out_file,"__O%d.",i);
936:
937: if ( i ) {
938: /* Rick, ODI, 3-28-89: If "i" is greater than 0, then
939: then "this" refers to an anonymous union member,
940: whose union is global (see closest-containing
941: if). */
942:
943: if ( ! capture_renaming) {
944: /* Rick, ODI, 3-28-89: use full cfront
945: renaming. */
946: if (n_anon)
947: fprintf(out_file,"__O%d.%s.", i, n_anon );
948: else fprintf(out_file,"__O%d.",i);
949: }
950: else {
951: /* Capture the transformed name. */
952: if (n_anon) {
953: fprintf(out_file,"__O%d.%s.", i, n_anon );
954: sprintf(tmp_string, "__O%d.%s.", i, n_anon);
955: }
956: else {
957: fprintf(out_file,"__O%d.",i);
958: sprintf(tmp_string, "__O%d.", i);
959: }
960: strcat(new_string, tmp_string);
961: }
962: }
963: break;
964: }
965:
966: if (tn=tbl->t_name) {
967: cl = Pclass(tn->tp);
968: /* Rick, ODI: The table associated with "this" has a
969: name--it corresponds to a named scope. */
970: if (i) {
971:
972: /* Rick, ODI, 3-28-89: If "i" is greater than 0, then
973: then "this" refers to an anonymous union member,
974: whose union is NOT global (see if(tbl == gtbl)
975: above, note case global anonymous union has
976: break). */
977:
978: if (cl->string[0]=='_'
979: && cl->string[1]=='_'
980: && cl->string[2]=='C' )
981: {
982: if ( ! capture_renaming) {
983: /* Rick, ODI, 3-28-89; use full cfront
984: renaming. */
985: if (n_anon)
986: fprintf(out_file,"__O%d.%s.", i, n_anon );
987: else fprintf(out_file,"__O%d.",i);
988: }
989: else {
990: /* Rick, ODI: Capture the transformed name. */
991: if (n_anon) {
992: fprintf(out_file,"__O%d.%s.", i, n_anon );
993: sprintf(tmp_string, "__O%d.%s", i, n_anon);
994: }
995: else {
996: fprintf(out_file,"__O%d.",i);
997: sprintf(tmp_string, "__O%d.", i);
998: }
999: strcat(new_string, tmp_string);
1000: }
1001: }
1002: else if ( cl->lex_level ) {
1003: char *str = make_local_name(cl,1);
1004: if ( ! capture_renaming) {
1005: /* Rick, ODI, 3-28-89; use full cfront
1006: renaming. */
1007: fprintf(out_file,"__O%d%s.",i,str);
1008: }
1009: else {
1010: /* Rick, ODI: Capture the transformed name. */
1011: fprintf(out_file,"__O%d%s.",i,str);
1012: sprintf(tmp_string, "__O%d%s.", i, str);
1013: strcat(new_string, tmp_string);
1014: }
1015: delete str;
1016: }
1017: else {
1018: if ( ! capture_renaming) {
1019: /* Rick, ODI, 3-28-89; use full cfront
1020: renaming. */
1021: fprintf(out_file,"__O%d__%d%s.",
1022: i,cl->strlen,cl->string);
1023: }
1024: else if ( ! limit_renaming) {
1025: /* Rick, ODI: Capture the transformed name. */
1026: fprintf(out_file,"__O%d__%d%s.",
1027: i,cl->strlen,cl->string);
1028: sprintf(tmp_string, "__O%d__%d%s.",
1029: i,cl->strlen,cl->string);
1030: strcat(new_string, tmp_string);
1031: }
1032: else {
1033: /* Rick, ODI: Capture the transformed name.
1034: Note, that renaming less extensive than
1035: if part. */
1036: fprintf(out_file,"__O%d.", i);
1037: sprintf(tmp_string, "__O%d.", i);
1038: strcat(new_string, tmp_string);
1039: }
1040: }
1041: cl = 0;
1042: }
1043: else if (cl->string[0]=='_'
1044: && cl->string[1]=='_'
1045: && cl->string[2]=='C'
1046: && n_stclass != STATIC )
1047: cl = 0;
1048: break;
1049: }
1050: }
1051:
1052: switch (n_stclass) { // local variable
1053: case STATIC:
1054: case EXTERN:
1055: if (i) {
1056: /* Rick, ODI, 3-28-89: If "i" is greater than 0, then
1057: then "this" refers to a an anonymous union member. */
1058:
1059: if ( ! capture_renaming) {
1060: /* Rick, ODI, 3-28-89; use full cfront renaming. */
1061: fprintf(out_file,"__O%d.",i);
1062: }
1063: else {
1064: /* Capture the renaming. */
1065: fprintf(out_file,"__O%d.",i);
1066: sprintf(tmp_string, "__O%d.", i);
1067: strcat(new_string, tmp_string);
1068: }
1069: }
1070: else if (n_sto==STATIC && tp->base!=FCT) {
1071: /* Rick, ODI, 3-28-89: With full renaming, if the
1072: transformation of "this" is static (n_sto == STATIC)
1073: and not a function, then the name is prefixed with
1074: "_static_". I'm not sure why this transformation is
1075: ever necessary. Static variables never seem to have
1076: their scopes changed, so there aren't any conflicts.
1077: As for static data members, their n_sto == EXTERN
1078: since they are transformed into global variables. */
1079: // Benson sez: death to __0 names!
1080: if (capture_renaming && ! limit_renaming) {
1081: /* rick, ODI, 3-28-89; use full cfront renaming. */
1082: if (lex_level == 0) {
1083: putstring("__S");
1084: strcat(new_string, "__S");
1085: }
1086: else {
1087: fprintf(out_file,"__%d",lex_level);
1088: sprintf(tmp_string, "__%d", lex_level);
1089: strcat(new_string, tmp_string);
1090: }
1091: }
1092: else if ( ! capture_renaming && ! limit_renaming) {
1093: /* rick, ODI, 3-28-89; use full cfront renaming. */
1094: if (lex_level == 0)
1095: putstring("__S");
1096: else
1097: fprintf(out_file,"__%d",lex_level);
1098: }
1099: }
1100: break;
1101: default:
1102: // encode with lexicallevel UNLESS ``special''
1103: // e.g. __builtin
1104: if (string[0]!='_' || string[1]!='_' || string[2] != 'C' ) {
1105: // error( 'd', "print2 i: %d, lex_level: %d this: %n", i, lex_level,this );
1106: if (i) {
1107: if ( ! capture_renaming) {
1108: /* Rick, ODI: WARNING: should check that new
1109: version doesn't have problem with anonymous
1110: classes at the file level or within a block. */
1111:
1112: /* Rick, ODI, 6-20-89: Lex lexel can't be
1113: printed here unless it is also printed in
1114: the union's declaration which is handled
1115: above. The simplest fix is to get rid of
1116: the lex level output. */
1117: /* Previous version's prints:
1118: fprintf(out_file,"__%d__O%d.",lex_level-1,i,i);
1119: fprintf(out_file,"__O%d.",i,i); */
1120: if (n_anon)
1121: fprintf(out_file,"__%d__O%d.%s.",
1122: lex_level-1,i,n_anon);
1123: else fprintf(out_file,"__%d__O%d.",lex_level-1,i);
1124: }
1125: else if (capture_renaming && ! limit_renaming) {
1126: /* Rick, ODI: WARNING: should check that new
1127: version doesn't have problem with anonymous
1128: classes at the file level or within a block. */
1129:
1130: /* Rick, ODI, 6-20-89: Lex lexel can't be
1131: printed here unless it is also printed in
1132: the union's declaration which is handled
1133: above. The simplest fix is to get rid of
1134: the lex level output. */
1135: /* Previous version's prints:
1136: fprintf(out_file,"__%d__O%d.",lex_level-1,i,i);
1137: fprintf(out_file,"__O%d.",i,i); */
1138: if (n_anon) {
1139: fprintf(out_file,"__%d__O%d.%s.",
1140: lex_level-1,i,n_anon);
1141: sprintf(tmp_string, "__%d__O%d.%s.",
1142: lex_level-1,i,n_anon);
1143: strcat(new_string, tmp_string);
1144: }
1145: else {
1146: fprintf(out_file,"__%d__O%d.",lex_level-1,i);
1147: sprintf(tmp_string, "__%d__O%d.",
1148: lex_level-1,i);
1149: strcat(new_string, tmp_string);
1150: }
1151: }
1152: else {
1153: /* Capture the renaming. Note, the renaming is not
1154: as extensive as the if part. */
1155: if (n_anon) {
1156: fprintf(out_file,"__O%d.%s.", i,n_anon);
1157: sprintf(tmp_string,"__O%d.%s.", i,n_anon);
1158: }
1159: else {
1160: fprintf(out_file,"__O%d.", i);
1161: sprintf(tmp_string,"__O%d.", i);
1162: }
1163: strcat(new_string, tmp_string);
1164: }
1165: }
1166: else
1167: if( ! limit_renaming) {
1168: /* rick, ODI, 3-28-89; use full cfront renaming. */
1169: fprintf(out_file,"__%d",lex_level);
1170: if (capture_renaming) {
1171: sprintf(tmp_string, "__%d", lex_level);
1172: strcat(new_string, tmp_string);
1173: }
1174: }
1175: }
1176: }
1177: break;
1178: case CLASS:
1179: case ENUM:
1180: break;
1181: }
1182:
1183: if (tp->base==FCT) {
1184: sig = Pfct(tp)->f_signature;
1185: if (sig && sig[0]==0) sig = 0;
1186: }
1187: }
1188:
1189: if (string) {
1190: #ifdef DENSE
1191: /* Rick, ODI, 6-6-89: This is suppose to be for machines with a 31
1192: character limit on the length of an identifier. Only the first
1193: 29 [0..28] characters are perserved, the remaining characters are
1194: hashed and the result is used to generate characters [29] and
1195: [30] out of a choice of 63 characters (see chop() below). In a
1196: uniform distribution, the two characters positions would produce
1197: 3969 possibilities. The real question is what are the likely
1198: distributions? We might want to analyse the reliability
1199: of this algorithm to determine whether or not it should be
1200: removed. At least the authors gave the #define an appropriate
1201: name. */
1202: int i = strlen(string);
1203: if (cl) i += cl->strlen+4; // __dd<class name>
1204: if (sig) {
1205: if (cl == 0) i += 2;
1206: i += strlen(sig);
1207: }
1208:
1209: if (31<i) {
1210: char buf[1024];
1211:
1212: if ( ! limit_renaming || tp->base == FCT || tp->base == INLINE ||
1213: tp->base == VIRTUAL || tp->base == OVERLOAD ||
1214: tp->base == OPERATOR) {
1215:
1216: /* Rick, ODI, 3-28-89: Not much can be done with
1217: functions. Given overloading and the fact that
1218: all class function members are transformed into
1219: global functions, function name transformation
1220: must be left alone. */
1221:
1222: if (cl && sig)
1223: sprintf(buf,"%s__%d%s%s",string,cl->strlen,cl->string,sig);
1224: else if (cl)
1225: sprintf(buf,"%s__%d%s",string,cl->strlen,cl->string);
1226: else if (sig)
1227: sprintf(buf,"%s__%s",string,sig);
1228: else
1229: sprintf(buf,"%s",string);
1230:
1231: }
1232:
1233: else if ((class_name = is_data_member(this)) &&
1234: (n_stclass == STATIC ||
1235: matches_base_member(this, Pclass(class_name->tp)))) {
1236:
1237: /* Rick, ODI, 3-28-89: There are two cases where
1238: a data member must have its name transformed:
1239: -- when the data member is static;
1240: -- when the data member has the same name
1241: as data member belonging to any of the
1242: class's base types.
1243: Capture the name transformation. */
1244:
1245: if (cl)
1246: sprintf(buf,"%s__%d%s",string,cl->strlen,cl->string);
1247: else
1248: sprintf(buf,"%s",string);
1249:
1250: }
1251:
1252: else /* Don't rename. */
1253: sprintf(buf,"%s",string);
1254:
1255: chop(buf);
1256: fprintf(out_file,"%s ",buf);
1257: if (capture_renaming) {
1258: /* Capture renaming. */
1259: strcat(new_string, buf);
1260: }
1261: if (capture_renaming)
1262: goto handle_new_string;
1263: return;
1264: }
1265: #endif
1266: putstring(n_template_arg_string ? n_template_arg_string : string);
1267: if (capture_renaming) { /* Capture renaming. */
1268: strcat(new_string,
1269: (n_template_arg_string ? n_template_arg_string : string));
1270: }
1271:
1272: // local class
1273:
1274: /* Rick, ODI, 6-7-89: I don't know why the previous comment
1275: asserts that "cl" is a "local class". As near as I can tell
1276: any class will set cl to non-zero and only the cases of
1277: unions and classes whose names begin with "__C" and have
1278: non-static data members clear cl. */
1279:
1280: Pname class_name; /* Rick, ODI, 6-7-89: Used to hold
1281: a data member's class name. */
1282:
1283: if ( cl ) {
1284: if ( cl->lex_level ) { /* Rick, ODI, 6-7-89: Can assert here
1285: that "cl" is a local class. */
1286: char *str = str = make_local_name( cl, 1 );
1287: putstring( str );
1288: delete str;
1289: }
1290: else { // Rick, ODI, 6-7-89: Global class (cl->lex_level == 0).
1291:
1292: if ( ! limit_renaming || tp->base == FCT ||
1293: tp->base == INLINE || tp->base == VIRTUAL ||
1294: tp->base == OVERLOAD || tp->base == OPERATOR) {
1295:
1296: /* Rick, ODI, 3-28-89: Not much can be done with
1297: functions. Given overloading and the fact that
1298: all class function members are transformed into
1299: global functions, function name transformation
1300: must be left alone. */
1301:
1302: fprintf(out_file,"__%d%s",cl->strlen,cl->string);
1303: if (capture_renaming) { /* Capture renaming. */
1304: sprintf(tmp_string, "__%d%s", cl->strlen,cl->string);
1305: strcat(new_string, tmp_string);
1306: }
1307: }
1308:
1309: else if ((class_name = is_data_member(this)) &&
1310: (n_stclass == STATIC ||
1311: matches_base_member(this, Pclass(class_name->tp)))) {
1312:
1313: /* Rick, ODI, 3-28-89: There are two cases where
1314: a data member must have its name transformed:
1315: -- when the data member is static;
1316: -- when the data member has the same name
1317: as data member belonging to any of the
1318: class's base types.
1319: Capture the name transformation. */
1320:
1321: fprintf(out_file,"__%d%s",cl->strlen,cl->string);
1322: if (capture_renaming) { /* Capture renaming. */
1323: sprintf(tmp_string, "__%d%s", cl->strlen,cl->string);
1324: strcat(new_string, tmp_string);
1325: }
1326: }
1327: }
1328: }
1329:
1330: if (sig) { /* Rick, ODI, 6-7-89: Function, so output signiture */
1331: if (cl == 0) {
1332: putstring("__");
1333: if (capture_renaming) { /* Capture renaming. */
1334: strcat(new_string, "__");
1335: }
1336: }
1337: putstring(sig);
1338: if (capture_renaming) { /* Capture renaming. */
1339: strcat(new_string, sig);
1340: }
1341: }
1342: putch(' ');
1343:
1344: }
1345:
1346: handle_new_string:
1347:
1348: if (capture_renaming) {
1349:
1350: /* Rick, ODI, 3-28-89: If the renaming has not been seen before,
1351: then set "this"'s "output_string" to refer to the renaming. */
1352:
1353: if (string && new_string[0] != '\0' &&
1354: strcmp(string, new_string) != 0 &&
1355: ! (tp->base == FCT && ! Pfct(tp)->body)) {
1356: if ( ! output_string || strcmp(output_string, new_string) != 0) {
1357: if (output_string)
1358: delete output_string;
1359: output_string = new char[strlen(new_string) + 1];
1360: strcpy(output_string, new_string);
1361: }
1362: #if OUTPUT_PAIR_FUNCTIONALITY
1363: if (tp->base == FCT)
1364: output_pair(this);
1365: #endif
1366: }
1367: else
1368: output_string = (char *) 0;
1369: }
1370:
1371: } // name::print
1372:
1373:
1374: #ifdef DENSE
1375: void chop(char* buf)
1376: {
1377: static char alpha[] = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1378: static const asz = sizeof(alpha)-1;
1379: int hash = 0;
1380: char* p = &buf[29];
1381:
1382: while (*p) {
1383: hash <<= 1;
1384: if (hash & (1<<12)) {
1385: hash &= ~(1<<12);
1386: hash++;
1387: }
1388: hash ^= *p++;
1389: }
1390:
1391: buf[29] = alpha[(int)(hash%asz)];
1392: buf[30] = alpha[(int)((hash/asz)%asz)];
1393: buf[31] = 0;
1394: }
1395: #endif
1396:
1397: void type::print()
1398: {
1399: switch (base) {
1400: case PTR:
1401: case RPTR:
1402: case VEC:
1403: Pptr(this)->dcl_print(0);
1404: break;
1405: case FCT:
1406: Pfct(this)->dcl_print();
1407: break;
1408: // case VEC:
1409: // Pvec(this)->dcl_print(0);
1410: // break;
1411: case CLASS:
1412: case ENUM:
1413: if (emode)
1414: fprintf(out_file,"%k",base);
1415: else
1416: // error('i',"%p->T::print(%k %s)",this,base,Pclass(this)->string);
1417: fprintf(out_file,"struct %s *",Pclass(this)->string);
1418: break;
1419: case TYPE:
1420: if (Cast) {
1421: Pbase(this)->b_name->tp->print();
1422: break;
1423: }
1424: // no break
1425: default:
1426: Pbase(this)->dcl_print();
1427: }
1428: }
1429:
1430: char* type::signature(register char* p)
1431: /*
1432: take a signature suitable for argument types for overloaded
1433: function names
1434: */
1435: {
1436: Ptype t = this;
1437: int pp = 0; // pointer to
1438:
1439: xx:
1440: //error('d',"xx(%d) %d %k",this,t,t->base);
1441:
1442: // first unroll typedefs and handle derived types:
1443:
1444: switch (t->base) {
1445: case TYPE:
1446: if (Pbase(t)->b_const) *p++ = 'C';
1447: t = Pbase(t)->b_name->tp;
1448: goto xx;
1449:
1450: case VEC:
1451: if (pp && Pvec(t)->size) { // A<size>_
1452: *p++ = 'A';
1453: sprintf(p,"%d\0",Pvec(t)->size); // don't trust
1454: // sprintf return value
1455: while (*++p);
1456: *p++ = '_';
1457: }
1458: else
1459: *p++ = 'P';
1460: t = Pvec(t)->typ;
1461: pp = 1;
1462: goto xx;
1463:
1464: case PTR:
1465: if (Pptr(t)->rdo) *p++ = 'C'; // *const
1466: if (Pptr(t)->memof) { // M<size><classname>
1467: Pclass cl = Pptr(t)->memof;
1468: register char* s = cl->string;
1469: int d = cl->strlen;
1470: if (d==0) cl->strlen = d = strlen(s);
1471: *p++ = 'M';
1472: if (d/10) *p++ = '0'+d/10;
1473: *p++ = '0'+ d%10; // assume <100 char
1474: while (*p++ = *s++);
1475: --p; // not the '\0'
1476: }
1477: else
1478: *p++ = 'P';
1479: t = Pptr(t)->typ;
1480: pp = 1;
1481: goto xx;
1482:
1483: case RPTR:
1484: *p++ = 'R';
1485: t = Pptr(t)->typ;
1486: pp = 1;
1487: goto xx;
1488:
1489: case FCT:
1490: { Pfct f = Pfct(t);
1491: Pname n = f->argtype;
1492:
1493: if (f->f_const) *p++ = 'C'; // constant member function
1494: if (f->f_static) *p++ = 'S'; // static member function
1495: // if (f->memof && f->f_this==0) *p++ = 'S'; //SSS static member function
1496: *p++ = 'F';
1497: if (n == 0)
1498: *p++ = 'v'; // VOID, that is f() == f(void)
1499: else
1500: for ( ; n; n=n->n_list) { // print argument encoding
1501: // check if argtype is the same
1502: // as previously seen argtype
1503: int i = 0;
1504: for (Pname nn=f->argtype; n!=nn; nn=nn->n_list) {
1505: i++;
1506: if (nn->tp==n->tp || nn->tp->check(n->tp,0)==0) {
1507: // typeof (n) == typeof(arg i)
1508: int x = 1; // try for a run after n
1509: Pname nnn = n;
1510: while ((nnn=nnn->n_list) && x<9) {
1511: if (nnn->tp==n->tp
1512: || nnn->tp->check(n->tp,0)==0) {
1513: x++;
1514: n = nnn;
1515: }
1516: else
1517: break;
1518: }
1519:
1520: if (x == 1) // Ti
1521: *p++ = 'T';
1522: else { // Nxi
1523: *p++ = 'N';
1524: *p++ = '0'+x;
1525: }
1526:
1527: // assume <100 arguments
1528: if (9<i) *p++ = '0'+i/10;
1529: *p++ = '0'+i%10;
1530: goto zk;
1531: }
1532: }
1533:
1534: // ``normal'' case print argument type signature
1535: // if (n->n_xref) *p++ = 'R';
1536: p = n->tp->signature(p);
1537: zk:;
1538: }
1539:
1540: if (f->nargs_known == ELLIPSIS) *p++ = 'e';
1541:
1542: if (pp) { // '_' result type
1543: *p++ = '_';
1544: p = f->returns->signature(p);
1545: }
1546:
1547: *p = 0;
1548: return p;
1549: }
1550: }
1551:
1552: // base type modifiers:
1553:
1554: if ( Pbase(t)->b_const ) *p++ = 'C';
1555: // if ( Pbase(t)->b_signed ) *p++ = 'S';
1556: if ( Pbase(t)->b_unsigned ) *p++ = 'U';
1557: // if ( Pbase(t)->b_volatile ) *p++ = 'V';
1558:
1559:
1560: // now base types:
1561:
1562: register char* s;
1563: int d;
1564: Pclass cl;
1565: //lll:
1566: switch (t->base) {
1567: // case TNAME: t = Pbase(t)->b_name->tp; goto lll;
1568: case ANY: break;
1569: case ZTYPE: break;
1570: case VOID: *p++ = 'v'; break;
1571: case CHAR: *p++ = 'c'; break;
1572: case SHORT: *p++ = 's'; break;
1573: // case EOBJ:
1574: case INT: *p++ = 'i'; break;
1575: case LONG: *p++ = 'l'; break;
1576: case FLOAT: *p++ = 'f'; break;
1577: case DOUBLE: *p++ = 'd'; break;
1578: case LDOUBLE: *p++ = 'r'; break;
1579: case EOBJ:
1580: // *p++ = 'i';
1581: // break;
1582: { Penum en = Penum(Pbase(t)->b_name->tp);
1583: // t = en->e_type;
1584: // goto lll;
1585: s = en->string;
1586: d = en->strlen;
1587: if (d==0) en->strlen = d = strlen(s);
1588: goto pppp;
1589: }
1590:
1591: case COBJ:
1592: { cl = Pclass(Pbase(t)->b_name->tp);
1593: s = cl->string;
1594: d = cl->strlen;
1595: if (d==0) cl->strlen = d = strlen(s);
1596: pppp:
1597: sprintf(p, "%d", d) ;
1598: while (*p++) ; --p ;
1599: while (*p++ = *s++);
1600: --p;
1601: break;
1602:
1603: // pppp:
1604: // if (d/10) *p++ = '0'+d/10;
1605: // *p++ = '0'+ d%10; // assume less that 99 characters
1606: // while (*p++ = *s++);
1607: // --p;
1608: // break;
1609: }
1610: case FIELD:
1611: default:
1612: error('i',"signature of %k",t->base);
1613: }
1614:
1615: *p = 0;
1616: return p;
1617: }
1618:
1619: void basetype::dcl_print()
1620: {
1621: Pname nn;
1622: Pclass cl;
1623:
1624: if (emode) {
1625: if (b_virtual) puttok(VIRTUAL);
1626: if (b_inline) puttok(INLINE);
1627: if (b_const) puttok(CONST);
1628: }
1629: if (b_unsigned) puttok(UNSIGNED);
1630:
1631: switch (base) {
1632: case ANY:
1633: if (emode)
1634: putstring("any ");
1635: else
1636: putstring("int ");
1637: break;
1638:
1639: case ZTYPE:
1640: if (emode)
1641: putstring("zero ");
1642: else
1643: putstring("int ");
1644: break;
1645:
1646: case VOID:
1647: /* sun's compiler, and most all others, support void */
1648: #ifndef sun
1649: if (emode==0 && ansi_opt==0
1650: ) {
1651: // silly trick to bypass BSD C compiler bug
1652: // void* (*)() dosn't work there
1653: // note simpl.c knows that VOID -> CHAR grep for VCVC
1654: puttok(CHAR);
1655: } else puttok(VOID);
1656: #else
1657: puttok(VOID);
1658: #endif
1659: break;
1660:
1661: case CHAR:
1662: case SHORT:
1663: case INT:
1664: case LONG:
1665: case FLOAT:
1666: case DOUBLE:
1667: case LDOUBLE:
1668: puttok(base);
1669: break;
1670:
1671: case EOBJ:
1672: nn = b_name;
1673: eob:
1674: if (emode == 0)
1675: // puttok(INT);
1676: Penum(nn->tp)->e_type->dcl_print();
1677: else {
1678: puttok(ENUM);
1679: nn->print();
1680: }
1681: break;
1682:
1683: case COBJ:
1684: nn = b_name;
1685: cob:
1686: cl = Pclass(nn->tp);
1687: if (emode && (cl->base == CLASS) &&
1688: (cl->class_base == instantiated_template_class)) {
1689: Ptclass(cl)->inst->print_pretty_name() ;
1690: break ;
1691: }else if (cl && (cl->csu==UNION || cl->csu==ANON))
1692: puttok(UNION);
1693: else
1694: puttok(STRUCT);
1695: { // local class
1696: char* s = 0;
1697: if ( cl && cl->lex_level ) s = make_local_name( cl );
1698: putst(s?s:nn->string);
1699: delete s;
1700: }
1701: break;
1702:
1703: case TYPE:
1704: if (emode == 0) {
1705: switch (b_name->tp->base) {
1706: case COBJ:
1707: nn = Pbase(b_name->tp)->b_name;
1708: goto cob;
1709: case EOBJ:
1710: nn = Pbase(b_name->tp)->b_name;
1711: goto eob;
1712: // default:
1713: // {
1714: // if (b_name->lex_level !=0 )
1715: // {
1716: // error('d', "default: %n %t", b_name, b_name->tp );
1717: // Pbase(b_name->tp)->dcl_print();
1718: // b_name->tp->print();
1719: // return;
1720: // }
1721: // }
1722:
1723: }
1724: }
1725: b_name->print();
1726: break;
1727:
1728: default:
1729: if (emode) {
1730: if (0<base && base<=MAXTOK && keys[base])
1731: fprintf(out_file," %s",keys[base]);
1732: else
1733: putch('?');
1734: }
1735: else
1736: error('i',"%p->BT::dcl_print(%d)",this,base);
1737: }
1738: }
1739: Pbase memptr_type;
1740:
1741: void type::dcl_print(Pname n)
1742: /*
1743: "this" type is the type of "n". Print the declaration
1744: */
1745: {
1746: //error('d',"%p::dcl_print(%n)",this,n);
1747: Ptype t = this;
1748: Pptr p;
1749: TOK pre = 0;
1750:
1751: if (t == 0) error('i',"0->dcl_print()");
1752: if (n && n->tp!=t) error('i',"not %n'sT (%p)",n,t);
1753:
1754: if (base == OVERLOAD) {
1755: for (Plist gl=Pgen(this)->fct_list; gl; gl=gl->l) {
1756: Pname nn = gl->f;
1757: nn->tp->dcl_print(nn);
1758: if (gl->l) puttok(SM);
1759: }
1760: return;
1761: }
1762:
1763: tbuf = tbufvec[freetbuf];
1764: if (tbuf == 0) {
1765: if (freetbuf == NTBUF-1) error('i',"AT nesting overflow");
1766: tbufvec[freetbuf] = tbuf = new class dcl_buf;
1767: }
1768: freetbuf++;
1769: tbuf->init(n);
1770: if (n && n->n_xref) tbuf->front(PTR);
1771:
1772: while (t) {
1773: TOK k;
1774:
1775: switch (t->base) {
1776: case PTR:
1777: p = Pptr(t);
1778: k = (p->rdo) ? CONST_PTR : PTR;
1779: goto ppp;
1780: case RPTR:
1781: p = Pptr(t);
1782: k = (p->rdo) ? CONST_RPTR : RPTR;
1783: ppp:
1784: if (p->memof) {
1785: if (emode) {
1786: tbuf->front(k);
1787: tbuf->front(p->memof);
1788: }
1789: else {
1790: t = p->typ;
1791: while (t->base==TYPE) t = Pbase(t)->b_name->tp;
1792: if (t->base == FCT) {
1793: extern Pbase mptr_type;
1794: tbuf->base(mptr_type);
1795: goto zaq;
1796: }
1797: else
1798: tbuf->front(k);
1799: }
1800: }
1801: else
1802: tbuf->front(k);
1803: pre = PTR;
1804: t = p->typ;
1805: break;
1806: case VEC:
1807: { Pvec v = Pvec(t);
1808: if (Cast && pre != PTR && pre != VEC) { // for Macintosh: ptr to array uses [] notation
1809: tbuf->front(PTR);
1810: pre = PTR;
1811: }
1812: else {
1813: if (pre == PTR) tbuf->paran();
1814: tbuf->back(VEC,v);
1815: pre = VEC;
1816: }
1817: t = v->typ;
1818: break;
1819: }
1820:
1821: case FCT:
1822: { Pfct f = Pfct(t);
1823: if (pre == PTR)
1824: tbuf->paran();
1825: else if (emode && f->memof && n==0)
1826: tbuf->front(f->memof);
1827: tbuf->back(FCT,f);
1828: pre = FCT;
1829: t = (f->s_returns) ? f->s_returns : f->returns;
1830: break;
1831: }
1832: case FIELD:
1833: tbuf->back(FIELD,t);
1834: tbuf->base( Pbase(Pbase(t)->b_fieldtype) );
1835: t = 0;
1836: break;
1837: case 0:
1838: error('i',"noBT(B=0)");
1839: case TYPE:
1840: if (Cast) { // unravel type in case it contains vectors
1841: t = Pbase(t)->b_name->tp;
1842: break;
1843: }
1844:
1845: default: // the base has been reached
1846: /* This is WRONG. What happens to all the CONST, etc, stuff that
1847: basetype::dcl_print knows about ? */
1848: #if 0
1849: if (emode) {
1850: tbuf->base(Pbase(t));
1851: for (Ptype tt = t; tt->base==TYPE; tt=Pbase(tt)->b_name->tp);
1852: switch (tt->base) {
1853: case COBJ:
1854: tt == Pbase(tt)->b_name->tp;
1855: /* and fall through into the CLASS case */
1856: case CLASS:
1857: s = Pclass(tt)->string;
1858: if (Ptclass(this)->class_base == instantiated_template_class ||
1859: Ptclass(this)->class_base == uninstantiated_template_class)
1860: {
1861: Ptclass(this)->inst->print_pretty_name() ;
1862: freetbuf-- ;
1863: return ;
1864: } else {
1865: if (s[0]=='_' &&s[1]=='_' && s[2]=='C') s="class";
1866: putstring(s);
1867: }
1868: break ;
1869: case ENUM:
1870: s = "enum";
1871: goto fret;
1872: case OVERLOAD:
1873: s = "overloaded";
1874: fret:
1875: putstring(s);
1876: freetbuf--;
1877: return;
1878: }
1879:
1880: }
1881: #endif
1882:
1883: tbuf->base( Pbase(t) );
1884: goto zaq;
1885: } // switch
1886: } // while
1887: zaq:
1888: tbuf->put();
1889: freetbuf--;
1890: }
1891:
1892: void fct::dcl_print()
1893: {
1894: Pname nn;
1895: //error('d',"fct::dcl_print()");
1896: if (emode) {
1897: putch('(');
1898: for (nn=argtype; nn;) {
1899: nn->tp->dcl_print(0);
1900: if (nn=nn->n_list) puttok(CM); else break;
1901: }
1902: switch (nargs_known) {
1903: case 0: // putst("?"); break;
1904: case ELLIPSIS: puttok(ELLIPSIS); break;
1905: }
1906: putch(')');
1907: if (f_const) puttok(CONST);
1908: if (f_static) puttok(STATIC); // wrong place for ``static''
1909: return;
1910: }
1911:
1912: Pname at = f_args;
1913: putch('(');
1914:
1915: if (ansi_opt) {
1916: // print typed arguments:
1917: at = (f_this) ? f_this : (f_result) ? f_result : argtype;
1918: // WNG -- note: at = f_args had 0 value with ansi_opt set
1919: // mystery fix added here
1920: if (at == 0) {
1921: if (nargs_known == ELLIPSIS) {
1922: putch(')');
1923: return;
1924: }
1925: puttok(VOID);
1926: }
1927: else if (body && Cast==0)
1928: at->dcl_print(CM); // print argument type and name
1929: else {
1930: for (nn=at; nn;) {
1931: // nn->tp->dcl_print(0); // print argument type
1932: nn->tp->dcl_print(nn); // print argument type
1933: // (there may not be a name)
1934: if (nn=nn->n_list) puttok(CM); else break;
1935: }
1936: }
1937: if (nargs_known == ELLIPSIS) putstring(",...");
1938: putch(')');
1939: }
1940: else {
1941: // print argument names followed by argument type declarations:
1942: if (body && Cast==0) {
1943: for (nn=at; nn;) {
1944: nn->print();
1945: #if OUTPUT_PAIR_FUNCTIONALITY
1946: if (capture_renaming) { /* rick, ODI, 3-28-89; used
1947: to switch off some cfront
1948: renaming. */
1949: output_pair(nn);
1950: }
1951: #endif
1952: if (nn=nn->n_list) puttok(CM); else break;
1953: }
1954: putch(')');
1955: }
1956: else
1957: putch(')');
1958: }
1959: }
1960:
1961: void print_body(Pfct f)
1962: {
1963: if (Cast==0) {
1964:
1965: if (ansi_opt==0 && f->f_args) f->f_args->dcl_print(SM);
1966:
1967: if (MAIN) {
1968: putstring("{ _main(); "); // call constructors
1969: f->body->print();
1970: puttok(RC);
1971: }
1972: else
1973: f->body->print();
1974: }
1975: }
1976:
1977: Pbcl shared_seen;
1978:
1979: void classdef::print_members()
1980: {
1981: int i;
1982:
1983: Pbcl l = baselist;
1984: // error('d',"%t->print_members()",this);
1985: if (l) {
1986: if (l->base == NAME) {
1987: l->bclass->print_members(); // first base only
1988: // pad to ensure alignment:
1989: int boff = l->bclass->real_size;
1990: int ba = l->bclass->align();
1991: int xtra = boff%ba;
1992: int waste = (xtra) ? ba-xtra : 0; // padding
1993: //error('d',"%s: size % align %d waste %d",string,boff,ba,waste);
1994: if (waste) {
1995: // waste it to protect against structure
1996: // assignments to the base class
1997: char* s = make_name('W');
1998: fprintf(out_file,"char %s[%d];\n",s,waste);
1999: delete s;
2000: }
2001: l = l->next;
2002: }
2003:
2004: for (; l; l=l->next)
2005: /* for second base etc. one must allocate as an object
2006: (rather than a list of members) to ensure proper alignment
2007: for shared base allocate a pointer
2008: size, alignment, & offset handled in cassdef::dcl()
2009: */
2010: if (l->base == NAME) {
2011: Pclass bcl = l->bclass;
2012: puttok(STRUCT);
2013: putst(bcl->string);
2014: putcat('O',bcl->string);
2015: puttok(SM);
2016: }
2017: }
2018:
2019: // Sam: A class or an enum type declared within a class can hide a
2020: // member with the same name, so make sure that it gets printed by
2021: // traversing the n_tbl_list to get at these names.
2022: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i))
2023: do if (nn->base==NAME
2024: && nn->n_union==0
2025: && nn->tp->base!=FCT
2026: && nn->tp->base!=OVERLOAD
2027: && nn->tp->base!=CLASS
2028: && nn->tp->base!=ENUM
2029: && nn->n_stclass != STATIC) {
2030: if (nn->tp->base==FIELD && Pbase(nn->tp)->b_bits==0) continue;
2031: Pexpr i = nn->n_initializer;
2032: nn->n_initializer = 0;
2033: nn->dcl_print(0);
2034: nn->n_initializer = i;
2035: }
2036: // The while condition can be true for atmost one iteration per
2037: // outer iteration.
2038: while ((nn->base == NAME) &&
2039: ((nn->tp->base!=CLASS) || (nn->tp->base!=ENUM)) &&
2040: (nn = nn->n_tbl_list)) ;
2041:
2042: for (l=baselist; l; l=l->next)
2043: if (l->base==VIRTUAL && l->ptr_offset) {
2044: Pclass bcl = l->bclass;
2045: char* bs = bcl->string;
2046:
2047: puttok(STRUCT); // struct bcl* Pbcl;
2048: putst(bs);
2049: putch('*');
2050: putcat('P',bs);
2051: puttok(SM);
2052: }
2053: }
2054:
2055: void classdef::print_vtbl(Pvirt vtab)
2056: {
2057: //error('d',"%s->print_vtbl(%s) vtbl_opt %d",string,vtab->string,vtbl_opt);
2058: // error('d',"print_vtbl: lex_level: %d", lex_level );
2059:
2060: // switch (vtbl_opt) {
2061: // case -1:
2062: // case 1:
2063: vlist = new vl(this,vtab,vlist);
2064: // }
2065:
2066: int oo = vtbl_opt; // make `simulated static' name
2067: vtbl_opt = -1;
2068: char* str = lex_level ? make_local_name(this) : 0;
2069: char* s = vtbl_name(vtab->string,str?str:string);
2070: vtbl_opt = oo;
2071: // char* s = vtbl_name(vtab->string,string);
2072: // fprintf(out_file,"extern struct __mptr %s[];\n",s);
2073: s[2] = 'p'; // pointer, not tbl itself
2074: fprintf(out_file,"extern struct __mptr* %s;\n",s);
2075:
2076: delete s;
2077: delete str;
2078: }
2079:
2080: vl* vlist;
2081:
2082: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss);
2083:
2084: int p2(Pname nn, Ptype t, Pclass cl, Pvirt vtab, char* s)
2085: {
2086: int init;
2087:
2088: if (t->base == FCT) {
2089: Pfct f = Pfct(t);
2090:
2091: //error('d',"p2 %n init %d inline %d virtual %d",nn,nn->n_initializer,f->f_inline,f->f_virtual);
2092: //error('d',"p2 %s expr %d imeasure %d body %d",s,f->f_expr,f->f_imeasure,f->body);
2093: //error('d',"sto %k",nn->n_sto);
2094: if (nn->n_initializer
2095: || nn->n_sto==STATIC
2096: || f->f_inline
2097: || f->f_imeasure
2098: || f->f_virtual==0) return 0;
2099: init = f->body!=0;
2100: }
2101: else
2102: init = nn->n_initializer!=0;
2103:
2104: int oo = vtbl_opt;
2105: vtbl_opt = 1; // make sure the name is universal
2106: char* sstr = cl->lex_level ? make_local_name(cl) : 0;
2107: char* ss = vtbl_name(vtab->string,sstr?sstr:cl->string);
2108:
2109: if (init) { // unique definition here
2110: really_really_print(cl,vtab,ss,s);
2111: }
2112: else { // unique definition elsewhere
2113: //error('d',"elsewhere %n %s",nn,ss);
2114: fprintf(out_file,"extern struct __mptr %s[];\n",ss);
2115: s[2] = 'p';
2116: fprintf(out_file,"struct __mptr* %s = ",s);
2117: fprintf(out_file,"%s;\n",ss);
2118: }
2119: vtbl_opt = oo;
2120:
2121: delete ss;
2122: delete sstr;
2123:
2124: return 1;
2125: }
2126:
2127: void classdef::really_print(Pvirt vtab)
2128: {
2129: //error('d',"really_print %t %d",this,vtbl_opt);
2130: int oo = vtbl_opt; // make `simulated static' name
2131: vtbl_opt = -1;
2132: char* str = lex_level ? make_local_name(this) : 0;
2133: char* s = vtbl_name(vtab->string,str?str:string);
2134: vtbl_opt = oo;
2135:
2136: // see if needed
2137: int i;
2138: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
2139: Ptype t = nn->tp;
2140: zse:
2141: if (t)
2142: switch (t->base) {
2143: case TYPE:
2144: t = Pbase(t)->b_name->tp;
2145: goto zse;
2146: /*
2147: case COBJ:
2148: if (nn->n_sto == EXTERN)
2149: { Pclass cl = Pclass(Pbase(t)->b_name->tp);
2150: if (cl->has_ctor()) {
2151: p2(nn,t,this,vtab,s);
2152: return;
2153: }
2154: }
2155: break;
2156: */
2157: case FCT:
2158: if (p2(nn,t,this,vtab,s)) return;
2159: break;
2160:
2161: case OVERLOAD:
2162: { for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l)
2163: if (p2(gl->f,gl->f->tp,this,vtab,s)) return;
2164: }
2165: }
2166: }
2167:
2168: if (vtbl_opt) {
2169: // make vtbl name according to option:
2170: char* sstr = lex_level ? make_local_name(this) : 0;
2171: char* ss = vtbl_name(vtab->string,str?str:string);
2172: really_really_print(this,vtab,ss,s);
2173:
2174: delete ss;
2175: delete sstr;
2176: }
2177:
2178: delete s;
2179: delete str;
2180: }
2181:
2182: void really_really_print(Pclass, Pvirt vtab, char* s, char* ss)
2183: {
2184: //error('d',"really %s",s);
2185: // make sure function is declared before using
2186: // it in vtbl initializer
2187: Pname nn;
2188: int i;
2189: for (i=0; nn = vtab->virt_init[i].n; i++) {
2190: Pfct f = Pfct(nn->tp);
2191: if (nn->n_initializer) { // pure virtual
2192: static pv;
2193: if (pv == 0) { // VCVC void->char assumed
2194: #ifdef sun
2195: fprintf(out_file,"void __pure_virtual_called();\n");
2196: #else
2197: fprintf(out_file,"char __pure_virtual_called();\n");
2198: #endif
2199: pv = 1;
2200: }
2201: continue;
2202: }
2203: if (f->base != FCT) error('i',"vtbl %n",nn);
2204: //void expand_dtor(Pclass cl);
2205: // if (f->f_inline == IDTOR) expand_dtor(f->memof);
2206:
2207: if (nn->n_dcl_printed==0 /*|| f->f_inline*/) {
2208: if (f->f_inline && vtbl_opt) puttok(STATIC);
2209: if (f->f_result == 0) make_res(f);
2210: Ptype r = f->s_returns ? f->s_returns : f->returns;
2211: r->print();
2212: nn->print();
2213: putstring("()");
2214: puttok(SM);
2215: nn->n_dcl_printed = 1;
2216: }
2217: }
2218:
2219: // if (vtbl_opt == -1) puttok(STATIC);
2220:
2221:
2222: fprintf(out_file,"struct __mptr %s[] = {0,0,0,\n",s);
2223:
2224: Pname n;
2225: for (i=0; n=vtab->virt_init[i].n; i++) {
2226: if (n->n_initializer)
2227: putstring("0,0,(__vptp)__pure_virtual_called,\n");
2228: else {
2229: fprintf(out_file,"%d,0,(__vptp)",-vtab->virt_init[i].offset);
2230: n->print();
2231: n->n_addr_taken = 1;
2232: putstring(",\n");
2233: }
2234: }
2235: putstring("0,0,0};\n");
2236:
2237: ss[2] = 'p';
2238: fprintf(out_file,"struct __mptr* %s = ",ss);
2239: s[2] = 'v';
2240: fprintf(out_file,"%s;\n",s);
2241:
2242: //error('d',"really-> %s",s);
2243: }
2244:
2245: #include <ctype.h>
2246: extern char* src_file_name;
2247: char* vtbl_name(char* s1, char* s2)
2248: {
2249: //extern Pname def_name;
2250: char* s3 = (vtbl_opt == -1 && src_file_name) ? src_file_name : 0;
2251: // if vtbl_opt == -1 fake a static (there are no portable
2252: // way of doing a forward declaration of a static in C)
2253: int ll = s1 ? strlen(s1) : 0;
2254: int ll2 = strlen(s2);
2255: int ll3 = s3 ? strlen(s3) : 0;
2256: // int ll4 = s3&&def_name ? strlen(def_name->string) : 0;
2257: // int sz = (ll+ll2+ll3+ll4+22)/32+1; // avoid fragmentation
2258: int sz = (ll+ll2+ll3+20)/32+1; // avoid fragmentation
2259:
2260: sz *= 32;
2261: //error('d',"vtbl_name(%s,%s,%s) %d",s1?s1:"",s2,s3?s3:"",sz);
2262: char* buf = new char[sz];
2263: if (s3) {
2264: // if (s1 && def_name)
2265: // sprintf(buf,"__vtbl__%d%s__%d%s__%s__%s",ll,s1,ll2,s2,s3,def_name->string);
2266: // else
2267: if (s1)
2268: sprintf(buf,"__vtbl__%d%s__%d%s__%s",ll,s1,ll2,s2,s3);
2269: // else if (def_name)
2270: // sprintf(buf,"__vtbl__%d%s__%s__%s",ll2,s2,s3,def_name->string);
2271: else
2272: sprintf(buf,"__vtbl__%d%s__%s",ll2,s2,s3);
2273: }
2274: else if (s1)
2275: sprintf(buf,"__vtbl__%d%s__%d%s",ll,s1,ll2,s2);
2276: else
2277: sprintf(buf,"__vtbl__%d%s",ll2,s2);
2278:
2279: if (vtbl_opt == -1) {
2280: for (char* p = buf+ll2+11; *p; p++)
2281: if (!isalpha(*p) && !isdigit(*p)) *p = '_';
2282: }
2283: #ifdef DENSE
2284: chop(buf);
2285: #endif
2286: return buf;
2287: }
2288:
2289: void classdef::print_all_vtbls(Pclass bcl)
2290: {
2291: //error('d',"%t->print_all_vtbls(%t) vlt %d bl %d",this,bcl,virt_list,baselist);
2292:
2293: for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
2294: if (this != blist->vclass) continue;
2295: if (blist->printed) continue;
2296: // if (blist->string==0 && find_vptr(this)==0) { //BSopt
2297: // continue;
2298: // }
2299: print_vtbl(blist);
2300: blist->printed = 1;
2301: }
2302:
2303: for (Pbcl b = bcl->baselist; b; b = b->next)
2304: print_all_vtbls(b->bclass);
2305:
2306: if (this==bcl) c_body = 0;
2307: }
2308:
2309: void classdef::dcl_print(Pname)
2310: {
2311: extern Pclass current_instantiation ;
2312: // Sam: this kludge needs to be there in the absence of a true tree
2313: // copy for templates, to ensure that template instantiations are
2314: // printed exactly once.
2315: if ((class_base != vanilla_class) && (current_instantiation != this))
2316: return ;
2317:
2318:
2319: if (c_body==0 || c_body==3 || (defined&DEFINED)==0) return;
2320: c_body = 3;
2321:
2322: int i;
2323: //error('d',"%t->classdef::dcl_print",this);
2324: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
2325: if (nn->base==NAME
2326: && nn->n_union==0
2327: && nn->tp->base==CLASS
2328: && Pclass(nn->tp)->c_body==1)
2329: Pclass(nn->tp)->dcl_print(nn);
2330: else if (nn->base == TNAME && Pbase(nn->tp)->base != COBJ)
2331: nn->dcl_print(0);
2332: else if (nn->tp && nn->tp->base == ENUM)
2333: Penum(nn->tp)->dcl_print(nn);
2334: }
2335:
2336: TOK lvl = lex_level ? LOCAL : 0;
2337: Pname n = ktbl->look(string,lvl);
2338: if (n==0) n = ktbl->look(string,HIDDEN);
2339:
2340: if (n) {
2341: if (n->where.line!=last_line.line
2342: || n->where.file!=last_line.file)
2343: if (last_ll = n->where.line)
2344: n->where.putline();
2345: else
2346: last_line.putline();
2347: }
2348:
2349: TOK c = csu==CLASS ? STRUCT : csu;
2350: puttok(c);
2351: // if (string[0]!='_' || string[1]!='_' || string[2]!='C')
2352:
2353: char *str = 0;
2354: if ( lex_level ) str = make_local_name( this );
2355: putst(str?str:string);
2356:
2357: int sm = 0;
2358: int sz = tsizeof();
2359: int dvirt = 0;
2360:
2361: fprintf(out_file,"{\t/* sizeof %s == %d */\n",str?str:string,obj_size);
2362: delete str;
2363:
2364: print_members();
2365: for (Pbcl b = baselist; b; b = b->next) { // declare virtual classes
2366: if (b->base != VIRTUAL) continue;
2367: Pclass bcl = b->bclass;
2368: dvirt += bcl->virt_count;
2369: //error('d',"%t in %t %d",b->bclass,this,b->allocated);
2370: if (b->allocated==0) continue;
2371: puttok(STRUCT); // struct bcl Obcl;
2372: putst(bcl->string);
2373: putcat('O',bcl->string);
2374: puttok(SM);
2375: }
2376: putstring("};\n");
2377:
2378: for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
2379: if (nn->base==NAME && nn->n_union==0) {
2380: Ptype t = nn->tp;
2381: switch (t->base) {
2382: case FCT:
2383: case OVERLOAD:
2384: break;
2385: default:
2386: if (nn->n_stclass == STATIC) {
2387: TOK b = nn->n_sto;
2388: //error('d',"print nn %n tp %t b %k eval %d",nn,nn->tp,b,nn->n_evaluated);
2389: /*
2390: Pname cn;
2391: TOK bb = ((cn=nn->tp->is_cl_obj())
2392: && Pclass(cn->tp)->has_ctor())==0
2393: ?0:b; // force explicit initialization
2394: nn->n_sto = (nn->n_evaluated) ? STATIC : bb;
2395: */
2396: nn->n_sto = (nn->n_evaluated) ? STATIC : b;
2397: nn->dcl_print(0);
2398: nn->n_sto = b;
2399: }
2400: }
2401: }
2402: }
2403: if (vtbl_opt != -1) print_all_vtbls(this); // force declaration
2404: //error('d',"dcl_print -> ");
2405: }
2406:
2407:
2408: #if OUTPUT_PAIR_FUNCTIONALITY
2409:
2410: static FILE *name_pairs = (FILE *) 0;
2411:
2412:
2413: static void output_pair (name *decl)
2414:
2415: /* This function can be used to remember an original name and
2416: its transformation. These pairs can then be used in a mapping
2417: function which maps the original name to the transformed name.
2418:
2419: Currently, this routine outputs the pairs to a file. At some
2420: point, the routine might be adapted to place the pair in the
2421: .o file or in the program database. However, it would be better
2422: if the information was simply kept on the database symbol
2423: (whatever that is) like it is currently kept on cfront names
2424: using the fields "expr::string" and "name::output_string". Should
2425: the database symbol provide this facility, then this function
2426: can be removed. */
2427:
2428: {
2429:
2430: extern char* file_name[];
2431: char function_member_string[100];
2432: char name[1024];
2433:
2434:
2435: if ( ! name_pairs) {
2436: if (src_file_name) {
2437: strcpy(name, src_file_name);
2438: strcat(name, "_pairs");
2439: if ( ! (name_pairs = fopen(name, "w")))
2440: error('i',"output_pair' ! (name_pairs = fopen())");
2441: }
2442: else if ( ! (name_pairs = stderr))
2443: error('i',"output_pair' ! (name_pairs = stderr)");
2444: }
2445:
2446: if (decl->output_string) {
2447:
2448:
2449: fprintf(name_pairs, "%s\n%s\n\n", decl->string, decl->output_string);
2450:
2451: #if 0
2452: fprintf(name_pairs, "\"%s\",\"%s\"\n", decl->string,
2453: decl->output_string);
2454: #endif
2455:
2456: delete decl->output_string;
2457: decl->output_string = (char *) 0;
2458:
2459: }
2460:
2461: #if 0
2462: else
2463: fprintf(name_pairs, "%s\n", decl->string);
2464: #endif
2465:
2466: new_string[0] = '\0';
2467: tmp_string[0] = '\0';
2468:
2469: } // output_pair
2470:
2471: #endif
2472:
2473:
2474:
2475:
2476: static Pname is_data_member (Pname p_name)
2477:
2478: /* Returns the member's class if the given name is a data member.
2479: Otherwise returns (Pname) 0. */
2480:
2481: {
2482:
2483: TOK base = p_name->tp->base;
2484: Ptable p_table;
2485: Pname table_name;
2486: char *table_string;
2487: Ptable outer_table;
2488: Pname class_name;
2489:
2490: /* If the name is any kind of function, return false. */
2491:
2492: if (base == FCT || base == INLINE || base == VIRTUAL ||
2493: base == OPERATOR || base == OVERLOAD)
2494: return (Pname) 0;
2495:
2496: /* Get the member's table. Get the table's name. Get the table's
2497: outer table. Lookup the table's name in the outer table.
2498: If the name is a class, struct, or union, then return the
2499: name. Otherwise, return (Pname) 0. */
2500:
2501: if ( ! (p_table = p_name->n_table)) return (Pname) 0;
2502: if ( ! (table_name = p_table->t_name)) return (Pname) 0;
2503: if ( ! (table_string = table_name->string)) return (Pname) 0;
2504:
2505: /* If there is no outer table, then assume that outer_table
2506: is gtbl (the module level table). In 1.2, no outer table implied
2507: that p_name was not a data member, that p_table == gtbl and
2508: p_name was a module level name. */
2509:
2510: if ( ! (outer_table = p_table->next)) {
2511: outer_table = gtbl;
2512: }
2513:
2514: /* Look for a class, struct, or union matching the table string.
2515: Verify that the table containing the given name (p_table) is
2516: the table associated with the class (class_name->tp->memtbl). */
2517:
2518: if ((class_name = outer_table->look(table_string, CLASS)) ||
2519: (class_name = outer_table->look(table_string, STRUCT)) ||
2520: (class_name = outer_table->look(table_string, UNION))) {
2521: if (((struct classdef *)(class_name->tp))->memtbl == p_table)
2522: return class_name;
2523: }
2524:
2525: return (Pname) 0;
2526:
2527: } // is_data_member
2528:
2529:
2530:
2531: static Pname matches_base_member (Pname p_name, Pclass class_)
2532:
2533: /* Returns the matching member if found, otherwise returns
2534: (Pname) 0. */
2535:
2536: {
2537:
2538: Pbcl base_class;
2539: Pname matching_member;
2540:
2541: /* For each base class, look for a matching member, if
2542: found return the member. Otherwise, return (Pname) 0. */
2543:
2544: // in 1.2, this used classdef.cl_base. Now it uses baselist --benson
2545:
2546: for (base_class = class_->baselist; base_class;
2547: base_class = base_class->next) {
2548: if ((matching_member
2549: = look_any(base_class->bclass->memtbl,
2550: p_name->string)))
2551: return matching_member;
2552: else if (matching_member
2553: = matches_base_member(p_name, base_class->bclass))
2554: return matching_member;
2555: }
2556:
2557: return (Pname) 0;
2558:
2559: } // matches_base_member
2560:
2561:
2562:
2563:
2564: static Pname look_any (Ptable p_table, char* s)
2565:
2566: /* This was ripped off from table.c:table::look. The TOK
2567: argument is not considered and has been removed. The first
2568: matching name is returned. If none are found, then (Pname) 0
2569: if returned.
2570:
2571: look for "s" in table,
2572: look and insert MUST be the same lookup algorithm */
2573: {
2574:
2575: Ptable t;
2576: register char * p;
2577: register char * q;
2578: register int i;
2579: Pname n;
2580: int rr;
2581:
2582: // if (s == 0) error('i',"%d->look(0)",p_table);
2583: // if (p_table == 0) error('i',"0->look(%s)",s);
2584: // if (base != TABLE) error('i',"(%d,%d)->look(%s)",p_table,base,s);
2585:
2586: /* use simple hashing with linear search for overflow */
2587:
2588: p = s;
2589: i = 0;
2590: while (*p) i += (i + *p++); /* i<<1 ^ *p++ better?*/
2591: rr = (0<=i) ? i : -i;
2592:
2593: for (t=p_table; t; t=t->next) {
2594: /* in this and all enclosing scopes look for name "s" */
2595: Pname* np = t->entries;
2596: int mx = t->hashsize;
2597: short* hash = t->hashtbl;
2598: int firsti = i = rr%mx;
2599:
2600: do {
2601: if (hash[i] == 0) goto not_found;
2602: n = np[hash[i]];
2603: if (n == 0) error('i',"hashed lookup");
2604: p = n->string; /* strcmp(n->n_string,s) */
2605: q = s;
2606: while (*p && *q)
2607: if (*p++ != *q++) goto nxt;
2608: if (*p == *q) goto found;
2609: nxt:
2610: if (mx <= ++i) i = 0; /* wrap around */
2611: } while (i != firsti);
2612:
2613: found:
2614: #if 0
2615: for (; n; n=n->n_tbl_list) { /* for all name "s"s look for a key
2616: match */
2617: if (n->n_key == k) return n;
2618: }
2619: #endif
2620: return n;
2621:
2622: not_found:;
2623: }
2624:
2625: return 0; /* not found && no enclosing scope */
2626:
2627: } // look_any
2628:
2629:
2630:
2631: char *
2632: make_local_name( Pclass cl, int ln )
2633: {
2634: char *buf;
2635: if ( cl->in_fct == 0 ) error( 'i', "localC %s missingFN", cl->string );
2636: char *fsig = Pfct(cl->in_fct->tp)->f_signature;
2637: if ( fsig == 0 ) fsig = local_sign( cl->in_fct->tp );
2638: char *fs = cl->in_fct->string;
2639: int class_len=cl->strlen+strlen(fsig)+strlen(fs)+strlen(cl->lcl)+4;
2640: int sz = (class_len+20)/32+1; // from vtbl_name()
2641:
2642: if ( Pfct(cl->in_fct->tp)->memof == 0 ) {
2643: sz *= 32;
2644: buf = new char[ sz ];
2645: // error('d', "make_local_name: sz: %d", sz );
2646:
2647: if (ln)
2648: sprintf(buf, "__%d%s__%s__%s%s", class_len, cl->string, fs, fsig, cl->lcl);
2649: else
2650: sprintf(buf, "%s__%s__%s%s", cl->string, fs, fsig, cl->lcl);
2651: }
2652: else
2653: {
2654: char *cs = Pclass(Pfct(cl->in_fct->tp)->memof)->string;
2655: int len = Pclass(Pfct(cl->in_fct->tp)->memof)->strlen;
2656: if ( len < 10 )
2657: ++class_len;
2658: else
2659: if ( len > 99 )
2660: class_len += 3;
2661: else class_len += 2;
2662: class_len += len;
2663: sz = (class_len+20)/32+1;
2664: sz *= 32;
2665: buf = new char[ sz ];
2666: // error('d', "make_local_name: sz: %d", sz );
2667:
2668: if ( ln )
2669: sprintf(buf, "__%d%s__%s__%d%s%s%s",class_len,cl->string,fs,len,cs,fsig,cl->lcl);
2670: else sprintf(buf, "%s__%s__%d%s%s%s",cl->string,fs,len,cs,fsig,cl->lcl);
2671: }
2672:
2673: #ifdef DENSE
2674: chop( buf );
2675: #endif
2676:
2677: return buf;
2678: }
2679:
2680: /* ODI notes
2681:
2682: template classes
2683:
2684: limit renaming
2685:
2686: on sun's print void as void.
2687: */
2688:
2689:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.