![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcl3.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 dcl3.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/dcl3.c 1.6.5.29" */
2: /**************************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All Rights Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: dcl3.c:
11: Routines used by ::dcl fucntions: fct::dcl() etc.
12:
13: *****************************************************************************/
14:
15: #include "cfront.h"
16: #include "size.h"
17: #include "template.h"
18:
19: extern loc no_where;
20: static void vbase_pointers(Pname fn, Pclass cl)
21: /*
22: insert argument for virtual base pointers (if any)
23: after f_this and before f_argtype
24: */
25: {
26: //error('d',"vbase_pointers(%n,%t) %d %k",fn,cl,fn->tp,fn->n_oper);
27: Pfct f = Pfct(fn->tp);
28: if (fn->n_oper == CTOR) {
29: Pname d = 0;
30: for (Pbcl b = cl->baselist; b; b=b->next) {
31: if (b->base != VIRTUAL) continue;
32: Pname a = new name(b->bclass->string);
33: a->tp = b->bclass->this_type;
34: a->n_list = d;
35: a->n_table = f->body ? f->body->memtbl : 0;
36: a->where = no_where;
37: d = a;
38: }
39:
40: if (d) {
41: for (Pname dd =d;;) {
42: if (d->n_list == 0) {
43: d->n_list = f->f_args->n_list;
44: break;
45: }
46: d = d->n_list;
47: }
48: f->f_args->n_list = dd;
49: }
50: }
51: if (fn->n_oper == DTOR) { // add __free argument
52: //error('d',"add __free to %n",fn);
53: Pname fa = new name;
54: fa->tp = int_type;
55: fa->n_scope = ARG;
56: fa->where = no_where;
57:
58: Pname a = f->f_args;
59: if (a == 0)
60: f->f_args = fa;
61: else {
62: for(;;a = a->n_list) {
63: // error('d',"a %d %t",a,a->tp);
64: if (a->n_list == 0) {
65: a->n_list = fa;
66: break;
67: }
68: }
69: }
70: }
71: }
72:
73: void make_res(Pfct f)
74: /*
75: returns X where X(X&) has been declared
76: add "_result" argument of type X*
77: */
78: {
79: Pname cl = f->returns->is_cl_obj();
80: if (cl==0 || Pclass(cl->tp)->has_itor()==0) return;
81:
82: Pname rv = new name("_result");
83: rv->tp = f->returns->addrof();
84: rv->n_scope = FCT; // not a ``real'' argument
85: rv->n_used = 1;
86: rv->n_list = f->argtype;
87: if (f->f_this)
88: f->f_this->n_list = rv;
89: else
90: f->f_args = rv;
91: f->f_result = rv;
92: f->s_returns = void_type;
93: }
94:
95: void name::check_oper(Pname cn)
96: /*
97: check declarations of operators, ctors, dtors
98: */
99: {
100: switch (n_oper) {
101: case CALL:
102: case DEREF:
103: case REF:
104: if (cn == 0) error("operator%s must be aM",keys[n_oper]);
105: break;
106: // case ASPLUS:
107: // case ASMINUS:
108: // case ASMUL:
109: // case ASDIV:
110: // case ASMOD:
111: // case ASAND:
112: // case ASOR:
113: // case ASER:
114: // case ASLS:
115: // case ASRS:
116: case ASSIGN:
117: if (cn == 0) error('w',"operator%k() must be aM (thisD will soon cease to compile)",n_oper);
118: break;
119: case 0:
120: case TNAME: /* may be a constructor */
121: if (cn &&
122: ((strcmp(cn->string,string)==0) ||
123: ((Pclass(cn->tp)->class_base == instantiated_template_class)&&
124: (strcmp(string,
125: Ptclass(cn->tp)->unparametrized_tname()->string)
126: == 0))))
127:
128: {
129: if (tp->base == FCT) {
130: Pfct f = Pfct(tp);
131: if (f->returns!=defa_type)
132: error("%s::%s()W returnT",string,string);
133: f->returns = void_type;
134: string = "__ct";
135: n_oper = CTOR;
136: }
137: else
138: error('s',"struct%nM%n",cn,cn);
139: }
140: else
141: n_oper = 0;
142: break;
143: case DTOR: /* must be a destructor */
144: //error('d',"dtor %s",string);
145: if (cn == 0) {
146: n_oper = 0;
147: error("destructor ~%s() not inC",string);
148: }
149: else if ((strcmp(cn->string,string) == 0) ||
150: ((Pclass(cn->tp)->class_base ==
151: instantiated_template_class) &&
152: (strcmp(string,
153: Ptclass(cn->tp)->unparametrized_tname()->string)
154: == 0))){
155: dto:
156: Pfct f = (Pfct)tp;
157: string = "__dt";
158: if (tp->base != FCT) {
159: error("%s::~%s notF",cn->string,cn->string);
160: tp = new fct(void_type,0,1);
161: }
162: else if (f->returns!=defa_type/* && f->returns!=void_type*/)
163: error("%s::~%s()W returnT",cn->string,cn->string);
164: if (f->argtype) {
165: error("%s::~%s()WAs",cn->string,cn->string);
166: f->nargs = 0;
167: f->nargs_known = 1;
168: f->argtype = 0;
169: }
170: f->returns = void_type;
171: }
172: else {
173: if (strcmp(string,"__dt") == 0) goto dto;
174: error("~%s in %s",string,cn->string);
175: n_oper = 0;
176: }
177: break;
178: case TYPE:
179: //error('d',"type %t",n_initializer);
180: if (cn == 0) {
181: error("operator%t() not aM",Ptype(n_initializer));
182: n_oper = 0;
183: n_initializer = 0;
184: }
185: else {
186: Pfct f = Pfct(tp);
187: Ptype tx = Ptype(n_initializer);
188: n_initializer = 0;
189: if (f->base != FCT) error("badT for%n::operator%t()",cn,tx);
190: if (f->returns != defa_type) {
191: // if (f->returns->check(tx,0)) error("bad resultT for%n::operator%t()",cn,tx);
192: error("resultT for%n::operator%t()",cn,tx);
193: DEL(f->returns);
194: }
195: if (f->argtype) {
196: error("%n::operator%t()WAs",cn,tx);
197: f->argtype = 0;
198: }
199: f->returns = tx;
200: Pname nx = tx->is_cl_obj();
201: if (nx && can_coerce(tx,cn->tp)) error("both %n::%n(%n) and %n::operator%t()",cn,cn,nx,tx);
202: char buf[1024];
203: char* bb = tx->signature(buf);
204: int l2 = bb-buf;
205: if (1023<l2) error('i',"N::check_oper():N buffer overflow");
206: char* p = new char[l2+5];
207: p[0] = '_';
208: p[1] = '_';
209: p[2] = 'o';
210: p[3] = 'p';
211: strcpy(p+4,buf);
212: string = p;
213: }
214: break;
215: }
216: }
217:
218: Pexpr vbase_args(Pfct a, Pname bn)
219: /*
220: constructor a calls the constructor bn for a base class
221: generate argument list needed for virtual base arguments
222: */
223: {
224: Pfct b = Pfct(bn->tp);
225: //error('d',"vbase_args%n: %t %k",bn,b,b->base);
226: Pexpr args = 0;
227: Pexpr tail = 0;
228: if (b->base == OVERLOAD) b = Pfct(Pgen(b)->fct_list->f->tp); // doesn't matter which
229: for (Pname d = b->f_args->n_list; d!=b->argtype; d=d->n_list) {
230: for (Pname dd = a->f_args->n_list; dd; dd=dd->n_list)
231: // using strcmp is a trick
232: if (strcmp(dd->string,d->string)==0) break;
233:
234: Pexpr aa = new expr(ELIST,dd,0);
235: if (args == 0)
236: args = aa;
237: else
238: tail->e2 = aa;
239: tail = aa;
240: }
241: return args;
242: }
243:
244: void fct::init_bases(Pclass cl, Pexpr)
245: /*
246: in "cl"'s constructor "this" generate code to initialize base classes
247: and members using the initializers "f->f_init"
248:
249: this->f_init == list of names of classes to be initialized
250: COLON(b) => base class b
251: => constructor call in f_init->n_initializer
252: COLON() => unnamed base class
253: => constructor call in f_init->n_initializer
254: NAME(m) => member m
255: => constructor call in m->n_initializer
256: */
257: {
258: Ptable ftbl = body->memtbl;
259: //error('d',"init_bases %t init %d",cl,f_init);
260:
261: // explicit initializers
262: for (Pname nx, nn=f_init; nn; delete nn,(nn=nx) ) {
263: Pexpr i = nn->n_initializer;
264: nn->n_initializer = 0;
265: nx = nn->n_list;
266:
267: //error('d',"init_base %s %d",nn->string,i);
268: if (nn->string) {
269: if (nn->base == TNAME) { // base class
270: for (Pbcl l = cl->baselist; l; l=l->next) {
271: Pclass bcl = l->bclass;
272: if ((strcmp(bcl->string,nn->string) == 0) ||
273: ((bcl->class_base ==
274: instantiated_template_class) &&
275: ((strcmp(
276: Ptclass(bcl)->unparametrized_tname()->string, nn->string)) == 0)))
277:
278: {
279: if (l->init)
280: error("twoIrs for%t",bcl);
281: else
282: l->init = base_init(bcl,i,ftbl,l->obj_offset);
283: goto con;
284: }
285: }
286: error("unexpectedAL: noBC%n",nn);
287: con:
288: continue;
289: }
290: else { // member initializer
291: Pname m = cl->memtbl->look(nn->string,0);
292: if (m && m->n_table==cl->memtbl)
293: m->n_initializer = mem_init(m,i,ftbl);
294: else
295: error("%n not inC%n",m,nn);
296: }
297: }
298: else { // unnamed base class
299: Pbcl l = cl->baselist;
300: if (l == 0) {
301: error("unexpectedAL: noBC called");
302: continue;
303: }
304:
305: if (l->next) {
306: error("unnamedBCIr: multipleBCs");
307: continue;
308: }
309:
310: if (l->init)
311: error("twoIrs for%t",l->bclass);
312: else {
313: if (strict_opt) error("anachronism:N ofBC %t missing",l->bclass);
314: l->init = base_init(l->bclass,i,ftbl,l->obj_offset);
315: }
316: }
317: } // for
318:
319: for (Pbcl l = cl->baselist; l; l=l->next) {
320: // default initialization of base classes
321: Pname ctor;
322: Pclass bcl = l->bclass;
323: if (l->init==0 && (ctor=bcl->has_ctor()))
324: l->init = base_init(bcl,0,ftbl,l->obj_offset);
325: }
326: }
327:
328: int inline_restr; /* report use of constructs that the inline expanded
329: cannot handle here
330: */
331:
332: void fct::dcl(Pname n)
333: {
334: int nmem = TBLSIZE;
335: Pname a;
336: Pname ll;
337: Ptable ftbl;
338:
339: Pptr cct = 0;
340: int const_old = const_save;
341:
342: int bit_old = bit_offset;
343: int byte_old = byte_offset;
344: int max_old = max_align;
345:
346: if (base != FCT) error('i',"F::dcl(%d)",base);
347: if (body == 0) error('i',"F::dcl(body=%d)",body);
348: if (n==0 || n->base!=NAME) error('i',"F::dcl(N=%d %d)",n,(n)?n->base:0);
349: //error('d',"fct::dcl(%n) %k %d %t",n,n->n_scope,body->own_tbl,this);
350: if (body->own_tbl) return; // done already
351:
352: // if (f_inline==0 /*|| debug_opt*/) n->n_dcl_printed = 1; // beware of recursive calls, no decl needed
353: // if (f_inline && debug_opt) n->n_dcl_printed = 2;
354: if (body->memtbl == 0) body->memtbl = new table(nmem+3,gtbl,0);
355: body->own_tbl = 1;
356: ftbl = body->memtbl;
357: ftbl->real_block = body;
358:
359: max_align = 0;//AL_FRAME;
360: bit_offset = 0;
361:
362: cc->stack();
363: cc->nof = n;
364: cc->ftbl = ftbl;
365:
366: switch (n->n_scope) {
367: case 0:
368: case PUBLIC:
369: { cc->not = n->n_table->t_name;
370: cc->cot = Pclass(cc->not->tp);
371: cc->tot = cc->cot->this_type;
372: // if (f_this==0 || cc->tot==0) error('i',"F::dcl(%n): f_this=%d cc->tot=%d",n,f_this,cc->tot);
373: if (f_this) f_this->n_table = ftbl; // fake for inline printout
374: cc->c_this = f_this;
375:
376:
377: Pclass cl = Pclass(cc->not->tp);
378:
379: if (cl->c_body!=3
380: || n->n_initializer
381: || n->n_sto==STATIC
382: || f_inline
383: || f_imeasure
384: || f_virtual==0)
385: ;
386: else { // could be the function where we need to
387: // output the vtbl
388: int i;
389: for (Pname nn=cl->memtbl->get_mem(i=1); nn; nn=cl->memtbl->get_mem(++i) ) {
390: Ptype t = nn->tp;
391: if (t)
392: switch (t->base) {
393: case FCT:
394: if (nn == n) goto prnt;
395: if (nn->n_initializer
396: || nn->n_sto==STATIC
397: || Pfct(nn->tp)->f_inline
398: || Pfct(nn->tp)->f_imeasure
399: || Pfct(nn->tp)->f_virtual==0) break;
400: goto zaq;
401:
402: case OVERLOAD:
403: { for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) {
404: Pname nn = gl->f;
405: if (nn == n) goto prnt;
406: if (nn->n_initializer
407: || nn->n_sto==STATIC
408: || Pfct(nn->tp)->f_inline
409: || Pfct(nn->tp)->f_imeasure
410: || Pfct(nn->tp)->f_virtual==0) continue;
411: goto zaq;
412: }
413: }
414: }
415: }
416: goto zaq;
417: prnt:
418: cl->print_all_vtbls(cl);
419: goto zaq;
420: }
421: }
422: }
423: zaq:
424: // protect against: class x; x f(); class x { x(x&); ....
425: if (f_result == 0) make_res(this);
426: if (f_result) f_result->n_table = ftbl; // fake for inline printout
427:
428: returns->tsizeof(); // make sure size is known
429:
430: Pname ax;
431: for (a=argtype, ll=0; a; a=ax) {
432: ax = a->n_list;
433: Pname nn = a->dcl(ftbl,ARG);
434: Pname cn = nn->tp->is_cl_obj();
435: if (cn == 0) cn = cl_obj_vec;
436: if (cn) (void)cn->tp->tsizeof(); // make sure it is printed
437: nn->n_assigned_to = nn->n_used = nn->n_addr_taken = 0;
438: nn->n_list = 0;
439:
440: switch (nn->tp->base) {
441: case CLASS:
442: case ENUM: /* unlink types declared in arg list */
443: nn->dcl_print(0);
444: break;
445: default:
446: if (ll)
447: ll->n_list = nn;
448: else
449: f_args = argtype = nn;
450: ll = nn;
451: }
452: delete a;
453: }
454:
455: if (f_result) { // link in f_result
456: f_args = f_result;
457: f_result->n_list = argtype;
458: }
459:
460: if (f_this) { // link in f_this
461: f_args = f_this;
462: f_this->n_list = f_result ? f_result : argtype;
463: }
464:
465: if (n->n_oper==CTOR || n->n_oper==DTOR) vbase_pointers(n,cc->cot);
466:
467: if (n->n_oper == CTOR) {
468: const_save = 1;
469: init_bases(cc->cot,f_init);
470: }
471: else if (f_init)
472: error(0,"unexpectedAL: not aK");
473:
474: PERM(returns);
475: const_save = f_inline&&debug_opt==0;
476: inline_restr = 0;
477: body->dcl(ftbl);
478:
479: defined |= DEFINED;
480: if (f_inline && inline_restr && returns->base!=VOID) {
481: f_inline = 0;
482: char* s = (inline_restr & 32) ? "continue"
483: : (inline_restr & 16) ? "break"
484: : (inline_restr & 8) ? "loop"
485: : (inline_restr & 4) ? "switch"
486: : (inline_restr & 2) ? "goto"
487: : (inline_restr & 1) ? "label"
488: : "" ;
489: error('w', "\"inline\" ignored, %n contains %s",n,s);
490: // if (cc->cot)
491: n->simpl(); //BS6
492: n->dcl_print(0);
493: }
494: const_save = const_old;
495:
496: if (f_inline && debug_opt==0) isf_list = new name_list(n,isf_list);
497:
498: bit_offset = bit_old;
499: byte_offset = byte_old;
500: max_align = max_old;
501: cc->unstack();
502: //error('d',"fct-> returns %t",returns);
503: }
504:
505: Pexpr fct::base_init(Pclass bcl, Pexpr i, Ptable ftbl, int offset)
506: /*
507: have base class bcl and expr list i
508: return "( *(base*)this ) . ctor( i )"
509: ctor call generated in expr.typ()
510: */
511: {
512: Ptype ty = bcl->this_type;
513: Pexpr th = rptr(ty,f_this,offset); // base*
514: Pname ctor = bcl->has_ctor();
515:
516: //error('d',"fct::B_init(C %t, i %d, %d) ctor %n",bcl,i,i?i->tp:0,ctor);
517:
518: Pexpr ii = (i && i->base==ELIST)?i->e1:i;
519:
520: if (ii
521: && ii->base==DEREF
522: && ii->e1->base==CAST
523: && th->base==CAST) th->i2 = ii->e1->i2;
524:
525: if (ctor == 0) {
526: if (i && i->base!=ELIST) i = new expr(ELIST,i,0);
527:
528: Pexpr v = new texpr(VALUE,bcl,i); // ?.base(i)
529: v->e2 = new expr(DEREF,th,0); // (*(base*)this).base(i)
530: v = v->typ(ftbl); // *base(&*(base*)this,i)
531: //error('d',"v %k",v->base);
532: switch (v->base) {
533: case DEREF:
534: return v->e1; // base(&*(base*)this,i)
535: case ASSIGN: // degenerate base(base&): *(base*)this=i
536: th = new texpr(CAST,ty,f_this);
537: v = new expr(CM,v,th); // (*(base*)this=i,(base*)this);
538: return v->typ(ftbl);
539: default:
540: return 0;
541: }
542: }
543:
544:
545: Pname icn;
546: if (i) {
547: ii = ii->typ(ftbl);
548: if (bcl->has_itor()==0
549: && (icn=ii->tp->is_cl_obj())
550: && (Pclass(icn->tp)==bcl || Pclass(icn->tp)->has_base(bcl))) {
551: // degenerate base(base&): *(base*)this=i
552: // memberwise copy
553: //error('d',"copy %t",ty);
554: // th = new cast(ty,f_this);
555: // th = th->contents();
556: th = new texpr(CAST,ty,f_this);
557: th = th->contents();
558: th = th->typ(ftbl);
559: if (Pclass(icn->tp)!=bcl) { // cast needed
560: Pptr r = new ptr(RPTR,Pptr(ty)->typ);
561: ii = new texpr(CAST,r,ii);
562: ii = ii->typ(ftbl);
563: }
564: ii = new expr(ASSIGN,th,ii);
565: ii->tp = th->tp;
566: // simulate `return this':
567: // *(base*)this=i,(base*)this
568: ii = new expr(CM,ii,new cast(ty,f_this));
569: ii->tp = th->tp;
570: return ii;
571: // return ii->typ(ftbl); // don't find cl::operator=()
572: }
573: if (i->base == ELIST) i->e1 = ii;
574: }
575: //Pexpr x = call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor));
576: //error('d',"call %n %t -> %d %k",ctor,ctor->tp,x,x->base);
577: // return x;
578: return call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor));
579: }
580:
581:
582: Pexpr fct::mem_init(Pname mn, Pexpr i, Ptable ftbl)
583: /*
584: return "member_ctor( m, i )"
585: */
586: {
587: // a new entry for B::B_pub, in general, has no tp and no
588: // real info: all the tp-> only work on our systems because
589: // 0 pointer dereference isn't system memory. it core dumps
590: // in set_const since no test is made on this == 0.
591: //error('d',"mem_init %n",mn);
592:
593: // if (mn->n_stclass == STATIC) error('s',"MIr for static%n",mn);
594: switch (mn->n_stclass) {
595: case STATIC:
596: error("MIr for static%n",mn);
597: break;
598: case ENUM:
599: error("MIr for enumeration constant%n", mn);
600: break;
601: }
602:
603: Pname member = (mn->base==PUBLIC && mn->n_qualifier) ? mn->n_qualifier : mn;
604:
605: if (i) i = i->typ(ftbl);
606: Pname cn = member->tp->is_cl_obj(); // first find the class name
607:
608: // if (member->n_stclass == STATIC) error('s',"MIr for static%n",member);
609: // if (i) i = i->typ(ftbl);
610: // Pname cn = member->tp->is_cl_obj(); // first find the class name
611: Pref tn = new ref(REF,f_this,member);
612: tn->tp = member->tp;
613: //error('d',"MI for %n %t = %t",member,member->tp,i?i->tp:0);
614: //error('d',"fthis %d %t member %n tp %t",f_this,f_this->tp,member,tn->tp);
615: if (cn) {
616: Pclass mcl = Pclass(cn->tp); // then find the classdef
617: Pname ctor = mcl->has_ctor();
618: Pname icn;
619:
620: if (i
621: && mcl->has_itor()==0
622: && (icn=i->tp->is_cl_obj())
623: && Pclass(icn->tp)==mcl) { // bitwise copy
624: Pexpr init = new expr(ASSIGN,tn,i);
625: init->tp = tn->tp;
626: // return init->typ(ftbl); // don't look for mcl.operator=()
627: member->assign();
628: return init;
629: }
630:
631: if (ctor) return call_ctor(ftbl,tn,ctor,i,DOT);
632:
633: error("Ir forM%nW noK",member);
634: return 0;
635: }
636:
637: if (cl_obj_vec) {
638: error('s',"Ir forCM arrayWK");
639: return 0;
640: }
641:
642: if (i && i->base == ELIST) {
643: // if (i->base == ELIST) {
644: if (i->e2) error("Ir for%n not a simpleE",member);
645: i = i->e1;
646: }
647:
648:
649: // error( 'd', "fct_mem_init: %n %k", member, member->tp->base );
650:
651: if (member->tp->is_ref() && ( i == 0 )) {
652: error( "empty Ir for reference %n", member ) ;
653: return 0 ;
654: }
655: switch (member->tp->base) {
656: /* Sam: this test is inadequate, since an RPTR can hide behind a */
657: /* TNAME the new test above is the correct one */
658: /*
659: case RPTR:
660: if ( i == 0 ) {
661: error( "empty Ir for reference %n", member );
662: return 0;
663: }
664: break;
665: */
666: case VEC:
667: case FCT:
668: case OVERLOAD:
669: error("Ir for%n ofT %t",member,member->tp);
670: return 0;
671: }
672:
673: //error('d',"tp %t",member->tp);
674: if (member->tp->tconst()) {
675: extern ignore_const;
676: int save_ignore_const = ignore_const;
677: ignore_const = 1;
678: i = new expr(ASSIGN,tn,i);
679: i = i->typ(ftbl);
680: ignore_const = save_ignore_const;
681: return i;
682: }
683:
684: Pptr pt;
685: if (pt = member->tp->is_ref()) {
686: switch (pt->typ->base) {
687: case FCT:
688: case OVERLOAD:
689: i = ptr_init(pt,i,ftbl);
690: break;
691: default:
692: i = ref_init(pt,i,ftbl);
693: }
694: i = new expr(ASSIGN,tn,i);
695: i->tp = tn->tp;
696: member->assign(); // cannot call typ: would cause dereference
697: return i;
698: }
699:
700: i = new expr(ASSIGN,tn,i);
701: return i->typ(ftbl); // typ performs the type check on the assignment
702: }
703:
704: Pexpr replace_temp(Pexpr e, Pexpr n)
705: /*
706: e is on the form
707: f(&temp,arg) , temp
708: or
709: &temp->ctor(arg) , temp
710: or
711: x->f(&temp,arg) , temp
712: change it to
713: f(n,arg)
714: or
715: n->ctor(arg)
716: */
717: {
718: Pexpr c = e->e1; // f(&temp,arg) or &temp->ctor(args)
719: Pexpr ff = c->e1;
720: Pexpr a = c->e2; // maybe ELIST(&temp,arg)
721: Pexpr tmp = e->e2;
722:
723: //error('d',"suppress(%d %k) %n",tmp->base,tmp->base,tmp->base==NAME?tmp:0);
724: if (tmp->base==DEREF) tmp = tmp->e1;
725: if (tmp->base==CAST) tmp = tmp->e1;
726: if (tmp->base==ADDROF || tmp->base==G_ADDROF) tmp = tmp->e2;
727: if (tmp->base != NAME) return e; //error('i',"replace %k",tmp->base);
728: tmp->tp = any_type; // temporary not used: suppress it
729:
730: //error('d',"replace_temp(%k %k) c %k ff %k",e->base,n->base,c->base,ff->base);
731: switch (ff->base) {
732: case REF:
733: if (ff->e1->base==G_ADDROF && ff->e1->e2==tmp)
734: a = ff; // &tmp -> f()
735: break;
736: case DOT:
737: if (ff->e1->base==NAME && ff->e1==tmp) {
738: a = ff; // tmp . f()
739: a->base = REF;
740: }
741: break;
742: }
743: a->e1 = n;
744: return c;
745: }
746:
747: Pname classdef::has_ictor()
748: /*
749: does this class have a constructor taking no arguments?
750: */
751: {
752: Pname c = has_ctor();
753: if (c == 0) return 0;
754:
755: Pfct f = Pfct(c->tp);
756:
757: switch (f->base) {
758: default:
759: error('i',"%s: badK (%k)",string,c->tp->base);
760:
761: case FCT:
762: switch (f->nargs) {
763: case 0: return c;
764: default: if (f->argtype->n_initializer) return c;
765: }
766: return 0;
767:
768: case OVERLOAD:
769: { for (Plist l=Pgen(f)->fct_list; l; l=l->l) {
770: Pname n = l->f;
771: f = (Pfct)n->tp;
772: switch (f->nargs) {
773: case 0: return n;
774: default: if (f->argtype->n_initializer) return n;
775: }
776: }
777: return 0;
778: }
779: }
780: }
781:
782: int add_first; // fudge, use ctor arg instead
783: Pname gen::add(Pname n)
784: /*
785: add "n" to the tail of "fct_list"
786: (overloaded names are searched in declaration order)
787:
788: detect: multiple identical declarations
789: declaration after use
790: multiple definitions
791: */
792: {
793: extern linkage;
794: Pfct f = Pfct(n->tp);
795: Pname nx;
796: //error('d',"add(%n) %d",n,add_first);
797: if (f->base != FCT) error("%n: overloaded nonF",n);
798:
799: if ( fct_list && (nx=find(f,1)) ) {
800: //error('d',"found %n %t",nx,nx->tp);
801: if (linkage && Pfct(nx->tp)->f_signature && Pfct(nx->tp)->f_signature[0])
802: error("inconsistent linkage specifications for%n",n);
803: Nold = 1;
804: }
805: else {
806: //extern linkage;
807: if (add_first==0)
808: if (linkage==0 && f->f_signature==0) f->sign();
809: //error('d',"signature: %d \"%s\" fct_list %d",f->f_signature,f->f_signature,fct_list);
810: nx = new name;
811: *nx = *n;
812: nx->n_gen_fct_name = n->string;
813: PERM(nx);
814: Nold = 0;
815: if (fct_list) {
816: int clink = f->f_signature==0 || *f->f_signature==0; // function with C linkage
817: Plist gl=fct_list;
818: for(;;) {
819: if (clink
820: && (Pfct(gl->f->tp)->f_signature==0
821: || *Pfct(gl->f->tp)->f_signature==0)) {
822: error("two%ns with c linkage",n);
823: f->sign();
824: }
825: if (gl->l)
826: gl = gl->l;
827: else
828: break;
829: }
830: gl->l = new name_list(nx,0);
831: }
832: else
833: fct_list = new name_list(nx,0);
834: nx->n_list = 0;
835: }
836: return nx;
837: }
838:
839: void fct::sign()
840: {
841: char buf[1024];
842: char* bb = signature(buf);
843: int ll = bb-buf;
844: if (1023 < ll) error('i',"gen::add():N buffer overflow");
845: char* p = new char[ll+1];
846: strcpy(p,buf);
847: f_signature = p;
848: //error('d',"fct::sign %s",p);
849: }
850:
851: Pname gen::find(Pfct f, bit warn)
852: {
853: for (Plist gl=fct_list; gl; gl=gl->l) {
854: Pname n = match(gl->f,f,warn);
855: if (n) return n;
856: }
857: return 0;
858: }
859:
860: Pname gen::match(Pname nx, Pfct f, bit warn)
861: {
862: Pfct fx = Pfct(nx->tp);
863: Pname a, ax;
864: int op = 0; // overloading problem: const, ref, vec/ptr, or basetype
865: //error('d',"fx %d %d f %d %d",fx->nargs_known,fx->nargs,f->nargs_known,f->nargs);
866:
867: if (f->nargs_known != fx->nargs_known) return 0; // the bets are off
868: // must rely on checks at
869: // call points
870: if (f->f_const != fx->f_const) return 0;
871:
872: if (fx->nargs != f->nargs
873: && fx->nargs_known==1
874: && f->nargs_known==1) return 0; // no warning for potential
875: // problems due to default args
876:
877: for (ax=fx->argtype, a=f->argtype; a&&ax; ax=ax->n_list, a=a->n_list) {
878: Ptype at = ax->tp;
879: Ptype atp = a->tp;
880: //error('d',"at %t atp %t",at,atp);
881: if (at->check(atp,OVERLOAD) == 0) {
882: //error('d',"at %t atp %t cp %d vrp %d",at,atp,const_problem,vrp_equiv);
883: // if (vrp_equiv) op++; // or differ only by [] vs *
884: continue;
885: }
886: //error('d',"warn %d",warn);
887: if (warn == 0) goto xx;
888:
889: /*
890: warn against:
891: overload f(X&), f(X); error
892: overload f(int), f(const); error
893: overload f(int*), f(int[10]); warn
894: etc.
895: */
896:
897: //error('d',"vrp_equiv %d const_problem %d",vrp_equiv,const_problem);
898: if (const_problem) { // differ only in X vs const X
899: if (at->is_ptr_or_ref()) return 0;
900: op++;
901: continue;
902: }
903:
904: aaa:
905: switch (atp->base) {
906: case TYPE:
907: atp = Pbase(atp)->b_name->tp;
908: goto aaa;
909: // case EOBJ:
910: // atp = Penum(Pbase(atp)->b_name->tp)->e_type;
911: // goto aaa;
912: case RPTR: // differ only by X vs X& ?
913: if (Pptr(atp)->typ->check(at,0)==0) {
914: op++;
915: continue;
916: }
917: }
918:
919: atl:
920: switch (at->base) {
921: case TYPE:
922: at = Pbase(at)->b_name->tp;
923: goto atl;
924: // case EOBJ:
925: // at = Penum(Pbase(at)->b_name->tp)->e_type;
926: // goto atl;
927: case RPTR: // differ only by X& vs X ?
928: if (Pptr(at)->typ->check(atp,0)==0) {
929: op++;
930: continue;
931: }
932: break;
933: // case CHAR: // differ only by int vs char ?
934: // case SHORT:
935: // case INT:
936: // if (atp->base!=at->base && atp->base==EOBJ) {
937: // op++;
938: // continue;
939: // }
940: // break;
941: }
942: //error('d',"return 0");
943: //goto xx;
944: // some argument is really different
945: // e.g. f(int), f(char*);
946: return 0;
947: }
948:
949: // arguments checked. Now look at leftover args, return type,etc.
950:
951: // if (warn && a && fx->nargs_known==ELLIPSIS) error('w',"... in%n'sAT hidesATs from the overloading mechanism",nx);
952:
953: if (a || ax) return 0;
954:
955: if (op == 0) {
956: if (warn && fx->returns->check(f->returns,0))
957: error("two different return valueTs for%n: %t and %t",nx,fx->returns,f->returns);
958:
959: return nx;
960: }
961: xx:
962: if (warn && op)
963: error("the overloading mechanism cannot tell a%t from a%t",fx,f);
964:
965: return 0;
966: }
967:
968: int name::no_of_names()
969: {
970: register int i = 0;
971: register Pname n;
972: for (n=this; n; n=n->n_list) i++;
973: return i;
974: }
975:
976: static Pexpr lvec[20], *lll, *curr_e;
977: static Pexpr list_back = 0;
978:
979: void new_list(Pexpr lx)
980: {
981: if (lx->base != ILIST) error('i',"IrLX");
982:
983: lll = lvec;
984: lll++;
985: *lll = lx->e1;
986: }
987:
988: Pexpr next_elem()
989: {
990: Pexpr e;
991: Pexpr lx;
992:
993: if (lll == lvec) return 0;
994:
995: lx = *lll;
996:
997: if (list_back) {
998: e = list_back;
999: list_back = 0;
1000: return e;
1001: }
1002:
1003: if (lx == 0) { /* end of list */
1004: lll--;
1005: return 0;
1006: }
1007:
1008: switch (lx->base) {
1009: case ELIST:
1010: e = lx->e1;
1011: curr_e = &lx->e1;
1012: *lll = lx->e2;
1013: switch (e->base) {
1014: case ILIST:
1015: lll++;
1016: *lll = e->e1;
1017: return Pexpr(1); // start of new ILIST
1018: case ELIST:
1019: error("nestedEL");
1020: return 0;
1021: default:
1022: {
1023: int need_sti(Pexpr, Ptable tbl = 0);
1024: if (need_sti(e)) error('s',"generalIr inIrL");
1025: return e;
1026: }
1027: }
1028: case IVAL:
1029: case ZERO:
1030: lll--;
1031: return 0;
1032: default:
1033: error('i',"IrL %k",lx->base);
1034: }
1035: }
1036:
1037: void skip_ilist()
1038: // skip ilist use to represent pointer to member function literal
1039: {
1040: Pexpr e = next_elem();
1041: e = next_elem();
1042: }
1043:
1044: void list_check(Pname nn, Ptype t, Pexpr il)
1045: /*
1046: see if the list "lll" can be assigned to something of type "t"
1047: "nn" is the name of the variable for which the assignment is taking place.
1048: "il" is the last list element returned by next_elem()
1049: */
1050: {
1051: Pexpr e;
1052: bit lst = 0;
1053: int i;
1054: Pclass cl;
1055: int tdef = 0;
1056:
1057: //error('d',"list_check%n: %t (%d)",nn,t,il);
1058: if (il == Pexpr(1))
1059: lst = 1;
1060: else if (il)
1061: list_back = il;
1062:
1063: zzz:
1064: switch (t->base) {
1065: case TYPE:
1066: t = Pbase(t)->b_name->tp;
1067: tdef = 1;
1068: goto zzz;
1069:
1070: case VEC:
1071: { Pvec v = Pvec(t);
1072: Ptype vt = v->typ;
1073:
1074: if (v->size) { /* get at most v->size initializers */
1075: if (v->typ->base == CHAR) {
1076: e = next_elem();
1077: if (e->base == STRING) { // v[size] = "..."
1078: int isz = Pvec(e->tp)->size;
1079: if (v->size < isz) error("Ir too long (%d characters) for%n[%d]",isz,nn,v->size);
1080: break;
1081: }
1082: else
1083: list_back = e;
1084: }
1085: for (i=0; i<v->size; i++) { // check next list element type
1086: ee:
1087: e = next_elem();
1088: if (e == 0) goto xsw; // too few initializers are ok
1089: vtz:
1090: //error('d',"vtz: %d",vt->base);
1091: switch (vt->base) {
1092: case TYPE:
1093: vt = Pbase(vt)->b_name->tp;
1094: goto vtz;
1095: case VEC:
1096: case COBJ:
1097: list_check(nn,vt,e);
1098: break;
1099: case PTR:
1100: if (Pptr(vt)->memof
1101: && Pptr(vt)->typ->base==FCT
1102: && e==Pexpr(1)) {
1103: skip_ilist();
1104: break;
1105: }
1106: // no break
1107: default:
1108: {
1109: if (e == (Pexpr)1) {
1110: error("unexpectedIrL");
1111: goto ee;
1112: }
1113:
1114: if (vt->check(e->tp,ASSIGN))
1115: error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
1116:
1117: Pptr p;
1118: if (vt->check(e->tp,0)
1119: && (p=vt->is_ptr())
1120: && Ptype(p)!=zero_type
1121: && p->typ!=char_type)
1122: *curr_e = new cast(vt,e);
1123: }
1124: }
1125: }
1126: if ( lst && (e=next_elem()) ) error("end ofIrLX after array");
1127: xsw:;
1128: }
1129: else { /* determine v->size */
1130: i = 0;
1131: (void) v->typ->tsizeof();
1132: xx:
1133: while ( e=next_elem() ) { // get another initializer
1134: i++;
1135: vtzz:
1136: //error('d',"vtzz");
1137: switch (vt->base) {
1138: case TYPE:
1139: vt = Pbase(vt)->b_name->tp;
1140: goto vtzz;
1141: case VEC:
1142: case COBJ:
1143: list_check(nn,vt,e);
1144: break;
1145: case PTR:
1146: if (Pptr(vt)->memof
1147: && Pptr(vt)->typ->base==FCT
1148: && e==Pexpr(1)) {
1149: skip_ilist();
1150: break;
1151: }
1152: // no break
1153: default:
1154: { if (e == Pexpr(1)) {
1155: error("unexpectedIrL");
1156: goto xx;
1157: }
1158:
1159: if (vt->check(e->tp,ASSIGN))
1160: error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
1161:
1162: Pptr p;
1163: if (vt->check(e->tp,0)
1164: && (p=vt->is_ptr())
1165: && Ptype(p)!=zero_type
1166: && p->typ!=char_type)
1167: *curr_e = new cast(vt,e);
1168: }
1169: }
1170: }
1171: if (tdef==0) v->size = i;
1172: }
1173: break;
1174: }
1175:
1176: case CLASS:
1177: cl = Pclass(t);
1178: goto ccc;
1179:
1180: case COBJ: /* initialize members */
1181: cl = Pclass(Pbase(t)->b_name->tp);
1182: ccc:
1183: if (cl->defined == 0) {
1184: lll = lvec; // we are lost: ignore rest of list
1185: return;
1186: }
1187:
1188: if (cl->c_body == 1) cl->dcl_print(0);
1189:
1190: { Ptable tbl = cl->memtbl;
1191: Pname m;
1192:
1193: if (cl->baselist) {
1194: if (cl->baselist->next) error("IrL forO ofC with multipleBCs");
1195: list_check(nn,cl->baselist->bclass,0);
1196: }
1197:
1198: for (m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i)) {
1199: Ptype mt = m->tp;
1200: switch (mt->base) {
1201: case FCT:
1202: case OVERLOAD:
1203: case CLASS:
1204: case ENUM:
1205: continue;
1206: }
1207: if (m->n_stclass == STATIC) continue;
1208: /* check assignment to next member */
1209: dd:
1210: e = next_elem();
1211: if (e == 0) return; //break;
1212: mtz:
1213: //error('d',"mtz%n: %d",m,mt->base);
1214: switch (mt->base) {
1215: case TYPE:
1216: mt = Pbase(mt)->b_name->tp;
1217: goto mtz;
1218: case CLASS:
1219: case ENUM:
1220: break;
1221: case VEC:
1222: case COBJ:
1223: list_check(nn,m->tp,e);
1224: break;
1225: case PTR:
1226: if (Pptr(mt)->memof
1227: && Pptr(mt)->typ->base==FCT
1228: && e==Pexpr(1)) {
1229: skip_ilist();
1230: break;
1231: }
1232: // no break
1233: default:
1234: { if (e == Pexpr(1)) {
1235: error("unexpectedIrL");
1236: goto dd;
1237: }
1238:
1239: if (mt->check(e->tp,ASSIGN))
1240: error("badIrT for%n:%t (%tX)",m,e->tp,m->tp);
1241:
1242: Pptr p;
1243: if (mt->check(e->tp,0)
1244: && (p=mt->is_ptr())
1245: && Ptype(p)!=zero_type
1246: && p->typ!=char_type)
1247: *curr_e = new cast(mt,e);
1248: }
1249: }
1250: }
1251: if (lst && (e=next_elem()) ) error("end ofIrLX afterCO");
1252: break;
1253: }
1254: default:
1255: e = next_elem();
1256:
1257: if (e == 0) {
1258: error("noIr forO");
1259: break;
1260: }
1261:
1262: if (e == Pexpr(1)) {
1263: error("unexpectedIrL");
1264: break;
1265: }
1266: //error('d',"t %t e->tp %t",t,e->tp);
1267: if (t->check(e->tp,ASSIGN)) error("badIrT for%n:%t (%tX)",nn,e->tp,t);
1268: Pptr p;
1269: if (t->check(e->tp,0)
1270: && (p=t->is_ptr())
1271: && Ptype(p)!=zero_type
1272: && p->typ!=char_type)
1273: *curr_e = new cast(t,e);
1274: if (lst && (e=next_elem()) ) error("end ofIrLX afterO");
1275: break;
1276: }
1277: }
1278:
1279: Pname dclass(Pname n, Ptable tbl)
1280: {
1281: Pclass cl;
1282: Pbase bt;
1283: Pname bn;
1284: TOK t;
1285:
1286: //local class
1287: Pname nx = ktbl->look(n->string,0); // TNAME
1288: // error( 'd', "dclass n %n %d nx %d", n,n->lex_level, nx);
1289: if (nx == 0 || n->lex_level ) {
1290: /* search for hidden name for
1291: (1) nested class declaration
1292: (2) local class declaration
1293: */
1294: int tn = 0;
1295: t = n->lex_level ? LOCAL : HIDDEN;
1296: // error( 'd', "dclass t: %k", t );
1297: for (nx=ktbl->look(n->string,t); nx; nx=nx->n_tbl_list) {
1298: // error('d',"dclass: %n %t t: %s",n,n->tp, t==LOCAL?"Local":"Hidden");
1299: // error('d',"dclass: nx: %s %k t: %s",nx->string,nx->tp->base, t==LOCAL?"Local":"Hidden");
1300: if (nx->n_key != t) continue;
1301: if ( nx->lex_level != n->lex_level ) continue;
1302:
1303: if (nx->tp->base != COBJ) {
1304: tn = 1;
1305: continue;
1306: }
1307:
1308:
1309: bt = (Pbase)nx->tp;
1310: bn = bt->b_name;
1311: cl = (Pclass)bn->tp;
1312:
1313: if (cl == 0) continue;
1314:
1315: if ( n->lex_level &&
1316: (cl->lcl==0 || strcmp(cl->lcl,Pclass(n->tp)->lcl))) continue;
1317: //error('d',"goto bbb");
1318: goto bbb;
1319: }
1320:
1321: if (tn)
1322: error("%n redefined using typedef",n);
1323: else
1324: error('i',"%n is not aCN",n);
1325: }
1326: else {
1327: bt = Pbase(nx->tp); // COBJ
1328: // error ('d', "dclass: bt->base: %k", bt->base );
1329: if ( bt->base != COBJ ) {
1330: error("%n redefined using typedef",n);
1331: Pname tn = ktbl->look(n->string,HIDDEN);
1332: // error( 'd', "dclass: tn: %t", tn );
1333: if ( tn->tp->base == COBJ )
1334: bt = Pbase(tn->tp);
1335: else error('i',"%n is not a CN", n );
1336: }
1337: bn = bt->b_name;
1338: }
1339: bbb:
1340: Pname ln = tbl->look(bn->string,0);
1341: // if (ln && ln->n_table==tbl) error('w',"%n redefined",ln);
1342: //error('d',"ln %n",ln);
1343: bn->where = nx->where;
1344: Pname bnn = tbl->insert(bn,CLASS); // copy for member lookup
1345: cl = Pclass(bn->tp);
1346: if (cl->class_base == template_class)
1347: error ("class %n was previously defined as a template class",
1348: bn) ;
1349: // CLASS
1350: if (cl->defined&(DEFINED|SIMPLIFIED))
1351: error("C%n defined twice",n);
1352: else {
1353: if (bn->n_scope == ARG) bn->n_scope = ARGT;
1354: cl->dcl(bn,tbl);
1355: }
1356: n->tp = cl;
1357: //error('d'," -> ");
1358: return bnn;
1359: }
1360:
1361: Pname denum(Pname n, Ptable tbl)
1362: {
1363: Pname nx = ktbl->look(n->string,0); // TNAME
1364: if (nx == 0) nx = ktbl->look(n->string,HIDDEN); // hidden TNAME
1365: Pbase bt = (Pbase)nx->tp; // EOBJ
1366: Pname bn = bt->b_name;
1367: Pname bnn = tbl->insert(bn,CLASS);
1368: Penum en = (Penum)bn->tp; // ENUM
1369: if (en->defined&(DEFINED|SIMPLIFIED))
1370: error("enum%n defined twice",n);
1371: else {
1372: if (bn->n_scope == ARG) bn->n_scope = ARGT;
1373: en->dcl(bn,tbl);
1374: }
1375: n->tp = en;
1376: return bnn;
1377: }
1378:
1379: void dargs(Pname, Pfct f, Ptable tbl)
1380: {
1381: int oo = const_save;
1382: const_save = 1;
1383:
1384: for (Pname a=f->argtype; a; a=a->n_list) {
1385: Pexpr init;
1386:
1387: if (a->tp == 0) {
1388: error( "A has noT" );
1389: a->tp = any_type;
1390: continue;
1391: }
1392:
1393: Pname cln = a->tp->is_cl_obj();
1394: //error('d',"dargs %t",a->tp);
1395: if (cln && Pclass(cln->tp)->has_itor()) // mark X(X&) arguments
1396: a->n_xref = 1;
1397: else {
1398: Ptype t = a->tp;
1399: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
1400: if (t->base == FCT) a->tp = new ptr(PTR,a->tp);
1401: }
1402:
1403: if (init = a->n_initializer) { // default argument
1404: Pptr pt;
1405: if (init == dummy) {
1406: error("emptyIr");
1407: a->n_initializer = 0;
1408: continue;
1409: }
1410: if (cln) {
1411: if (init->base==VALUE) {
1412: switch (init->tp2->base) {
1413: case CLASS:
1414: if (Pclass(init->tp2)!=Pclass(cln->tp)) goto inin2;
1415: break;
1416: default:
1417: Pname n2 = init->tp2->is_cl_obj();
1418: if (n2==0 || Pclass(n2->tp)!=Pclass(cln->tp)) goto inin2;
1419: }
1420:
1421: a->n_initializer = init = 0;
1422: error('s',"K as defaultA");
1423: }
1424: else {
1425: inin2:
1426: if (init->base == ILIST) error("list as AIr");
1427: Pexpr i = init->typ(tbl);
1428: init = class_init(a,a->tp,i,tbl);
1429: if (i!=init && init->base==DEREF) {
1430: error('s',"K needed forAIr");
1431: init = 0;
1432: }
1433: else {
1434: void dosimpl(Pexpr,Pname);
1435: dosimpl(init,cc->nof);
1436: // init->simpl();
1437: init->permanent = 2;
1438: }
1439: a->n_initializer = init;
1440: }
1441: }
1442: else if (pt = a->tp->is_ref()) {
1443: extern ref_initializer;
1444: ref_initializer++;
1445: init = init->typ(tbl);
1446: ref_initializer--;
1447: int tcount = stcount;
1448: init = ref_init(pt,init,tbl);
1449: if (tcount != stcount) {
1450: error('s',"needs temporaryV to evaluateAIr");
1451: init = 0;
1452: }
1453: else {
1454: void dosimpl(Pexpr,Pname);
1455: dosimpl(init,cc->nof);
1456: // init->simpl();
1457: init->permanent = 2;
1458: }
1459: a->n_initializer = init;
1460: }
1461: else {
1462: Pptr p = a->tp->is_ptr();
1463: init = init->typ(tbl);
1464: if (p) init = ptr_init(p,init,tbl);
1465:
1466: if (a->tp->check(init->tp,ARG)) {
1467: int i = can_coerce(a->tp,init->tp);
1468:
1469: switch (i) {
1470: case 1:
1471: if (Ncoerce) {
1472: Pname cn = init->tp->is_cl_obj(); Pname xx = new name(Ncoerce->string);
1473: Pref r = new ref(DOT,init,xx);
1474: init = new expr(G_CALL,r,0);
1475: init = init->typ(tbl);
1476: }
1477: break;
1478: default:
1479: error("%d possible conversions for defaultA",i);
1480: case 0:
1481: error("badIrT%t forA%n",init->tp,a);
1482: DEL(init);
1483: a->n_initializer = init = 0;
1484: }
1485: }
1486:
1487: if (init) {
1488: void dosimpl(Pexpr,Pname);
1489: dosimpl(init,cc->nof);
1490: // init->simpl();
1491: init->permanent = 2;
1492: a->n_initializer = init;
1493: Neval = 0;
1494: long i = init->eval();
1495: if (Neval == 0) {
1496: a->n_evaluated = 1;
1497: a->n_val = i;
1498: }
1499: }
1500: }
1501: }
1502: }
1503: const_save = oo;
1504: }
1505:
1506: void merge_init(Pname nn, Pfct f, Pfct nf)
1507: {
1508: // Pname a1 = f->f_args; if (a1==0) a1 = f->argtype;
1509: // Pname a2 = nf->f_args;//nf->argtype;
1510: Pname a1 = f->argtype;
1511: Pname a2 = nf->argtype;
1512:
1513: for (; a1; a1=a1->n_list, a2=a2->n_list) {
1514: int i1 = a1->n_initializer || a1->n_evaluated;
1515: int i2 = a2->n_initializer || a2->n_evaluated;
1516:
1517: if (i1 && i2) error(&a1->where,"twoIrs for%nA%n",nn,a1);
1518:
1519: if (i1) {
1520: a2->n_initializer = a1->n_initializer;
1521: a2->n_evaluated = a1->n_evaluated;
1522: a2->n_val = a1->n_val;
1523: }
1524: if (i2) {
1525: a1->n_initializer = a2->n_initializer;
1526: a1->n_evaluated = a2->n_evaluated;
1527: a1->n_val = a2->n_val;
1528: }
1529:
1530: }
1531: }
1532:
1533: Pexpr try_to_coerce(Ptype rt, Pexpr e, char* s, Ptable tbl)
1534: /*
1535: ``e'' is of class ``cn'' coerce it to type ``rt''
1536: */
1537: {
1538: int i;
1539: Pname cn;
1540: //error('d',"try_to_coerce(%t, %t, %s, %d)",rt,e->tp,s,tbl);
1541:
1542: if ((cn=e->tp->is_cl_obj()) && (i=can_coerce(rt,e->tp)) && Ncoerce) {
1543: if (1 < i) error("%d possible conversions for %s",i,s);
1544: //error('d',"coerce %n",Ncoerce);
1545: Pclass cl = Pclass(cn->tp);
1546: // Pref r = new ref(DOT,e,Ncoerce);
1547: // Pexpr rr = r->typ(tbl);
1548: // Pexpr c = new expr(G_CALL,rr,0);
1549: // c->fct_name = Ncoerce;
1550: Pname xx = new name(Ncoerce->string);
1551: Pref r = new ref(DOT,e,xx);
1552: Pexpr c = new expr(G_CALL,r,0);
1553: // return c->typ(tbl);
1554: c = c->typ(tbl);
1555: //error('d',"coerce -> %k %t",c->base,c->tp);
1556:
1557: return c;
1558: }
1559: //error('d',"coerce ->0");
1560: return 0;
1561: }
1562:
1563: int in_class_dcl;
1564:
1565: Pname name::dofct(Ptable tbl, TOK scope)
1566: {
1567: Pfct f = Pfct(tp);
1568: Pname class_name;
1569: Ptable etbl;
1570: in_class_dcl = cc->not!=0;
1571: int just_made = 0;
1572: // int fvirt = 0; //BSopt
1573: //error('d',"dofct %n %d %t %s",this,tp,tp,tbl==gtbl?"global":"");
1574:
1575: if (f->f_inline) n_sto = STATIC;
1576:
1577: if (n_stclass)
1578: switch (n_stclass) {
1579: case EXTERN:
1580: case STATIC:
1581: case OVERLOAD:
1582: break;
1583: default:
1584: error("%n declared%k",this,n_stclass);
1585: n_stclass = EXTERN;
1586: }
1587:
1588: tp->dcl(tbl); // must be done before the type check
1589:
1590: if (n_qualifier) { // qualified name: c::f() checked above
1591: // ineffective
1592: // if (in_class_dcl) {
1593: // error("unexpectedQdN%n",this);
1594: // return 0;
1595: // }
1596:
1597: if (f->f_virtual) {
1598: error("virtual outsideCD (ignored)");
1599: f->f_virtual = 0;
1600: }
1601:
1602: if (n_sto
1603: && n_sto!=FRIEND // friend X::f();
1604: && f->f_inline==0) { // inline causes n_sto==STATIC
1605: error("%k specifed for QdN%n",n_sto,this);
1606: n_sto = 0;
1607: }
1608:
1609: class_name = Pbase(n_qualifier->tp)->b_name;
1610: etbl = Pclass(class_name->tp)->memtbl;
1611: }
1612: else {
1613: class_name = cc->not;
1614: // beware of local function declarations in member functions
1615: if (class_name && tbl!=cc->cot->memtbl) {
1616: class_name = 0;
1617: in_class_dcl = 0;
1618: }
1619:
1620: if (f->f_static && f->f_virtual) {
1621: error("virtual staticM");
1622: f->f_virtual = 0;
1623: }
1624:
1625: if (n_oper) check_oper(class_name);
1626: etbl = tbl;
1627: }
1628:
1629: // Pfct(tp)->memof = class_name ? Pclass(class_name->tp) : 0;
1630:
1631: Pname find_virtual(Pclass,Pname);
1632:
1633: if (class_name) {
1634: f->memof = Pclass(class_name->tp);
1635: if (f->f_virtual==0 && find_virtual(f->memof,this))
1636: f->f_virtual = VTOK;
1637: }
1638:
1639: if (etbl==0 || etbl->base!=TABLE) error('i',"N::dcl: etbl=%d",etbl);
1640:
1641: switch (n_oper) {
1642: case CTOR:
1643: if (f->f_virtual) {
1644: error("virtualK");
1645: f->f_virtual = 0;
1646: }
1647:
1648: // case DTOR:
1649: // f->f_const = 1;
1650: break;
1651:
1652: case REF:
1653: if (f->argtype)
1654: error("%n takes no argument",this);
1655: else if (f->returns->is_ptr() == 0) {
1656: Pname cn = f->returns->is_cl_obj();
1657: if (cn==0 && f->returns->base==RPTR) cn = Pptr(f->returns)->typ->is_cl_obj();
1658: if (cn==0 || Pclass(cn->tp)->has_oper(REF)==0)
1659: error("%n must return aP toCO, aR toCO, or aCO",this);
1660: }
1661: break;
1662:
1663: case NEW: // void* operator new(long)
1664: if (f->f_virtual)
1665: error("virtual%n (operator new() is static)",this);
1666: if (class_name) f->f_static = 1; // if member: static by default
1667: if (f->nargs_known != 1)
1668: error("ATs must be fully specified for%n",this);
1669: else if (f->nargs<1)
1670: error("%n requires a firstA ofT size_t",this);
1671: else if (f->argtype->tp->check(size_t_type,0)) {
1672: if (strict_opt==0
1673: && f->argtype->tp->check(long_type,0)==0) {
1674: error('w',"%n firstA should be size_t",this);
1675: f->argtype->tp = size_t_type;
1676: if (f->f_signature) f->sign();
1677: }
1678: else
1679: error("%n requires a firstA ofT size_t",this);
1680: }
1681: else {
1682: Ptype t = f->s_returns ? f->s_returns : f->returns;
1683: if (t->check(Pvoid_type,0)) error("bad returnT for %n",this);
1684: }
1685: break;
1686:
1687: case DELETE: // void operator delete(void*) or
1688: // void operator delete(void*, long)
1689: if (f->f_virtual)
1690: error("virtual%n (operator delete() is static)",this);
1691: if (class_name) f->f_static = 1; // if member: static by default
1692: if (f->nargs_known != 1)
1693: error("ATs must be fully specified for%n",this);
1694: else {
1695: Ptype t = f->s_returns ? f->s_returns : f->returns;
1696: if (t->base != VOID)
1697: error("bad returnT for %n", this);
1698: else {
1699: switch (f->nargs) {
1700: default:
1701: error("%n takes 1 or 2As",this);
1702: break;
1703: case 1:
1704: case 2:
1705: { Pname a = f->argtype;
1706: if (a->tp->check(Pvoid_type,0))
1707: error("%n's 1stA must be a void*",this);
1708: else if (a = a->n_list) {
1709: if (class_name == 0)
1710: error("%n takes only oneA",this);
1711: else if (a->tp->check(size_t_type,0)) {
1712: if (strict_opt==0
1713: && a->tp->check(long_type,0)==0) {
1714: error('w',"%n's 2ndA should be a size_t",this);
1715: a->tp = size_t_type;
1716: if (f->f_signature) f->sign();
1717: }
1718: else
1719: error("%n's 2ndA must be a size_t",this);
1720: }
1721: }
1722: }
1723: }
1724: }
1725: }
1726: break;
1727:
1728: case ASSIGN:
1729: if (class_name && f->nargs==1) {
1730: Ptype t = f->argtype->tp;
1731: Pname an = t->is_cl_obj(); // X::operator=(X) ?
1732: if (an==0 && (t=t->is_ref())) { // X::operator=(X&) ?
1733: t = Pptr(t)->typ;
1734: rx1:
1735: switch (t->base) {
1736: case TYPE: t = Pbase(t)->b_name->tp; goto rx1;
1737: case COBJ: an = Pbase(t)->b_name;
1738: }
1739: }
1740: if (an && an==class_name) Pclass(an->tp)->c_xref |= C_ASS;
1741: }
1742: else if (f->nargs == 2) {
1743: Ptype t = f->argtype->tp;
1744: Pname an1;
1745: if (t=t->is_ref()) { // operator=(X&,?) ?
1746: t = Pptr(t)->typ;
1747: rx2:
1748: switch (t->base) {
1749: case TYPE: t = Pbase(t)->b_name->tp; goto rx2;
1750: case COBJ: an1 = Pbase(t)->b_name;
1751: }
1752: }
1753: t = f->argtype->n_list->tp;
1754: Pname an2 = t->is_cl_obj(); // operator=(X&,X) ?
1755: if (an2==0 && (t=t->is_ref())) { // operator=(X&,X&) ?
1756: t = Pptr(t)->typ;
1757: rx3:
1758: switch (t->base) {
1759: case TYPE: t = Pbase(t)->b_name->tp; goto rx3;
1760: case COBJ: an2 = Pbase(t)->b_name;
1761: }
1762: }
1763: if (an1 && an1==an2) Pclass(an1->tp)->c_xref |= C_ASS;
1764: }
1765: }
1766:
1767: switch (scope) {
1768: case FCT:
1769: case ARG:
1770: if (n_sto == STATIC) error("D of staticF in aF");
1771: }
1772:
1773: Pname nn = etbl->insert(this,0);
1774: nn->assign();
1775: n_table = etbl;
1776: //error('d',"nn %n %t %d %d",nn,nn->tp,nn->tp,f);
1777:
1778: if (n_initializer) {
1779: if (f->f_virtual == 0) error("Ir for non-virtualF%n",this);
1780: if (n_initializer != zero) error("virtualFIr must be 0");
1781: }
1782:
1783: if (Nold) {
1784: Pfct nf = Pfct(nn->tp);
1785: //error('d',"old %n: %t and %t",nn,nf,tp);
1786: if (nf->base==ANY || f->base==ANY)
1787: ;
1788: else if (nf->base == OVERLOAD) {
1789: string = nn->string;
1790: nn = Pgen(nf)->add(this);
1791:
1792: if (Nold == 0) {
1793: if (f->body && n_qualifier) {
1794: error("badAL for %n::%s()",n_qualifier,string);
1795: return 0;
1796: }
1797: goto thth;
1798: }
1799: // else {
1800: // if (f->body==0 && friend_in_class==0) error('w',"%n redeclared",nn);
1801: // }
1802:
1803: nf = Pfct(nn->tp);
1804:
1805: if (nf->body && f->body) {
1806: // Preserve the original definition in the case of a
1807: // PT class, it is the one that was supplied by the user
1808: if (!(class_name &&
1809: (Pclass(class_name->tp)->class_base ==
1810: instantiated_template_class) && nn->n_redefined))
1811: {
1812: error("two definitions of%n",this);
1813: f->body = 0;
1814: }
1815: return 0;
1816: }
1817:
1818: if (f->body) goto bdbd;
1819:
1820: goto stst;
1821: }
1822: else if (nf->base != FCT) {
1823: error("%n declared both as%t and asF",this,nf);
1824: f->body = 0;
1825: }
1826: else {
1827: //error('d',"%t->check(%t) -> %d %d",nf,f,nf->check(f,OVERLOAD)/*,vrp_equiv*/);
1828: if (nf->check(f,OVERLOAD)/* || vrp_equiv */|| const_problem) {
1829: if (f->body && n_qualifier) {
1830: error("%nT mismatch: %t and %t",nn,nf,f);
1831: return 0;
1832: }
1833: Pgen g = new gen;
1834: add_first = 1;
1835: Pname n1 = g->add(nn);
1836: add_first = 0;
1837: string = nn->string;
1838: Pname n2 = g->add(this);
1839: nn->tp = g;
1840: nn = n2;
1841: goto thth;
1842: }
1843:
1844: if (in_class_dcl) {
1845: // error("twoDs of%n",this);
1846: // f->body = 0;
1847: // return 0;
1848: }
1849: else if (nf->f_static && f->f_inline==0 && n_sto==STATIC) {
1850: //error('d',"MF%n declared static outsideF",this);
1851: n_sto = 0;
1852: }
1853: else if (n_sto && n_sto!=nn->n_scope) {
1854: if (n_sto==EXTERN && nn->n_scope==STATIC)
1855: error('w',"%n declared extern after being declared static",this);
1856: else if (nf->f_inline==0 && f->f_inline==0) {
1857: extern Pname new_fct; // beware of pre-defined functions
1858: extern Pname del_fct;
1859: if (nn->tp==new_fct->tp || nn->tp==del_fct->tp)
1860: nn->n_sto = n_sto;
1861: else
1862: error("%n declared as both%k and%k",this,n_sto,(nn->n_sto)?nn->n_sto:EXTERN);
1863: }
1864: }
1865:
1866: //error('d',"fct %n: %k %k scope %k",this,n_sto,nn->n_sto,nn->n_scope);
1867:
1868: extern linkage;
1869: //error('d',"link %d lcount %d sig %s",linkage,lcount,nf->f_signature);
1870: if (linkage && nf->f_signature && nf->f_signature[0])
1871: error("inconsistent linkage specifications for%n",this);
1872: if (nf->body && f->body) {
1873: // Preserve the original definition in the case of a
1874: // PT class, it is the one that was supplied by the user
1875: if (!(class_name &&
1876: (Pclass(class_name->tp)->class_base ==
1877: instantiated_template_class) && nn->n_redefined))
1878: {
1879: error("two definitions of%n",this);
1880: f->body = 0;
1881: }
1882: return 0;
1883: }
1884:
1885: if (f->body) goto bdbd;
1886:
1887: goto stst;
1888:
1889: bdbd:
1890: if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf);
1891: f->f_virtual = nf->f_virtual;
1892: f->f_this = nf->f_this;
1893: f->f_result = nf->f_result;
1894: f->s_returns = nf->s_returns;
1895: f->f_args = nf->f_args;
1896: // f->argtype = nf->argtype;
1897: f->f_signature = nf->f_signature;
1898: f->f_const = nf->f_const;
1899: f->f_static = nf->f_static;
1900: nn->tp = f;
1901: if (f->f_inline) {
1902: if (nf->f_inline==0) {
1903: if (nn->n_used && nn->n_sto!=STATIC)
1904: error("%n declared with external linkage and called before defined as inline",nn);
1905: // else if (nf->memof)
1906: // error('w',"%n declared as non-inline but defined as inline",nn);
1907: else if (nn->n_used) {
1908: nn->take_addr(); // force printout
1909: if (warning_opt) error('w',"%n called before defined as inline",nn);
1910: }
1911: }
1912: nf->f_inline = 1;
1913: nn->n_sto = STATIC;
1914: }
1915: else if (nf->f_inline) {
1916: // error('w',"%n defined as inline but not declared as inline",this);
1917: f->f_inline = 1;
1918: }
1919: goto stst2;
1920:
1921: stst:
1922: //error('d',"stst");
1923: if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf);
1924: f->f_args = nf->f_args;
1925: // f->argtype = nf->argtype;
1926: stst2:
1927: //error('d',"stst2 %n printed %d",nn,nn->n_dcl_printed);
1928: if (f->f_inline) n_sto = STATIC;
1929: if (n_sto
1930: && nn->n_scope!=n_sto
1931: && friend_in_class==0
1932: && f->f_inline==0){ // allow re-def to "static"
1933: if (n_sto == STATIC)
1934: nn->n_sto = STATIC;
1935: else {
1936: error("%n both%k and%k",this,n_sto,nn->n_scope);
1937: }
1938: }
1939: n_scope = nn->n_scope; // first specifier wins
1940: n_sto = nn->n_sto;
1941: }
1942: }
1943: else { // new function: make f_this for member functions
1944: thth:
1945: just_made = 1;
1946: if (f->f_inline)
1947: nn->n_sto = STATIC;
1948: else if (class_name==0 && n_sto==0 && f->body==0)
1949: nn->n_sto = EXTERN;
1950: //error('d',"thth %n %t static %d sto %k",nn,f,f->f_static,nn->n_sto);
1951: if (f->f_static)
1952: switch (n_oper) { // what about + ??
1953: case CTOR:
1954: case DTOR:
1955: case TYPE:
1956: case CALL:
1957: case DEREF:
1958: case REF:
1959: error("%n cannot be a staticMF",nn);
1960: f->f_static = 0;
1961: }
1962:
1963: if (class_name
1964: && f->f_static==0 // no ``this'' in static members
1965: && n_oper!=NEW // X::operator new() static by default
1966: && n_oper!=DELETE // X::operator delete() static by default
1967: && etbl!=gtbl) { /* beware of implicit declatation */
1968: Pname cn = nn->n_table->t_name;
1969: Pname tt = new name("this");
1970: tt->n_scope = ARG;
1971: tt->where = no_where;
1972: // tt->n_sto = ARG;
1973: tt->tp = Pclass(class_name->tp)->this_type;
1974: PERM(tt);
1975: Pfct(nn->tp)->f_this = f->f_this = Pfct(nn->tp)->f_args = f->f_args = tt;
1976: tt->n_list = f->argtype;
1977: //error('d',"nn %n tp %t const %d",nn,nn->tp,f->f_const);
1978: if (f->f_const /*&& n_oper!=CTOR && n_oper!=DTOR*/) {
1979: Pbase x = Pbase(Pptr(tt->tp)->typ);
1980: Pbase y = new basetype(COBJ,0);
1981: *y = *x;
1982: y->b_const = 1;
1983: tt->tp = new ptr(PTR,y);
1984: PERM(tt->tp);
1985: }
1986:
1987: }
1988: else {
1989: Pfct(nn->tp)->f_args = f->f_args = f->f_result?f->f_result:f->argtype;
1990: Pfct(nn->tp)->f_signature = f->f_signature;
1991: Pfct(nn->tp)->f_const = f->f_const;
1992: Pfct(nn->tp)->f_static = f->f_static;
1993: }
1994:
1995: extern linkage;
1996: // if C++ linkage encode type in function name
1997: if (linkage==0 && Pfct(nn->tp)->f_signature==0) Pfct(nn->tp)->sign();
1998:
1999: if (f->f_result == 0) {
2000: //error('d',"re1 %n %t %d",this,f,f);
2001: make_res(f);
2002: }
2003: else if (f->f_this)
2004: f->f_this->n_list = f->f_result;
2005:
2006: if (nn->n_oper==CTOR || nn->n_oper==DTOR) vbase_pointers(nn,Pclass(class_name->tp));
2007:
2008: if (f->f_virtual) {
2009: switch (nn->n_scope) {
2010: default:
2011: error("nonC virtual%n",this);
2012: break;
2013: case 0:
2014: case PUBLIC:
2015: // if (fvirt) //BSopt
2016: cc->cot->virt_count = 1;
2017: Pfct(nn->tp)->f_virtual = f->f_virtual;
2018: break;
2019: }
2020: }
2021: }
2022:
2023: /* an operator must take at least one class object or
2024: reference to class object argument
2025: */
2026:
2027: if (just_made)
2028: switch (n_oper) {
2029: case CTOR:
2030: switch (f->nargs) { // check for X(X) and X(X&)
2031: case 0:
2032: break;
2033: default: // handle X(X&, int i = 0)
2034: { Pname n2 = f->argtype->n_list;
2035: if (n2->n_initializer==0 && n2->n_evaluated==0) break;
2036: }
2037: case 1:
2038: {
2039: Ptype t = f->argtype->tp;
2040: clll:
2041: switch (t->base) {
2042: case TYPE:
2043: t = Pbase(t)->b_name->tp;
2044: goto clll;
2045: case RPTR: /* X(X&) ? */
2046: t = Pptr(t)->typ;
2047: cxll:
2048: switch (t->base) {
2049: case TYPE:
2050: t = Pbase(t)->b_name->tp;
2051: goto cxll;
2052: case COBJ:
2053: if (class_name == Pbase(t)->b_name)
2054: Pclass(class_name->tp)->c_itor = nn;
2055: }
2056: break;
2057: case COBJ: /* X(X) ? */
2058: if (class_name == Pbase(t)->b_name) {
2059: error("badK %s(%s) use %s(%s&)",class_name->string,class_name->string,class_name->string,class_name->string);
2060: f->argtype->tp = any_type;
2061: }
2062: }
2063: }
2064: }
2065: if (Pclass(class_name->tp)->c_ctor == 0) Pclass(class_name->tp)->c_ctor = nn;
2066: break;
2067:
2068: case TYPE:
2069: // somewhat simple minded solution to the inheritance of
2070: // conversion operator problem
2071: nn->n_list = Pclass(class_name->tp)->conv;
2072: Pclass(class_name->tp)->conv = nn;
2073: break;
2074:
2075: case DTOR:
2076: Pclass(class_name->tp)->c_dtor = nn;
2077: break;
2078:
2079: case NEW: // void* operator new(long)
2080: /*
2081: if (Pfct(nn->tp)->f_virtual)
2082: error("virtual%n (operator new() is static)",this);
2083: if (class_name) Pfct(nn->tp)->f_static = f->f_static = 1; // if member: static by default
2084: if (f->nargs_known != 1)
2085: error("ATs must be fully specified for%n",nn);
2086: else if (f->nargs<1)
2087: error("%n requires a firstA ofT size_t", nn);
2088: else if (f->argtype->tp->check(size_t_type,0)) {
2089: if (strict_opt==0
2090: && f->argtype->tp->check(long_type,0)==0) {
2091: error('w',"%n firstA should be size_t",nn);
2092: f->argtype->tp = size_t_type;
2093: if (f->f_signature) Pfct(nn->tp)->sign();
2094: }
2095: else
2096: error("%n requires a firstA ofT size_t",nn);
2097: }
2098: else {
2099: Ptype t = f->s_returns ? f->s_returns : f->returns;
2100: if (t->check(Pvoid_type,0)) error("bad returnT for %n", nn);
2101: }
2102: break;
2103: */
2104: case DELETE: // void operator delete(void*) or
2105: // void operator delete(void*, long)
2106: /*
2107: //error('d',"delete %n %t",nn,nn->tp);
2108: if (Pfct(nn->tp)->f_virtual)
2109: error("virtual%n (operator delete() is static)",this);
2110: if (class_name) Pfct(nn->tp)->f_static = f->f_static = 1; // if member: static by default
2111: if (f->nargs_known != 1)
2112: error("ATs must be fully specified for%n",nn);
2113: else {
2114: Ptype t = f->s_returns ? f->s_returns : f->returns;
2115: if (t->base != VOID)
2116: error("bad returnT for %n", nn);
2117: else {
2118: switch (f->nargs) {
2119: default:
2120: error("%n takes 1 or 2As",nn);
2121: break;
2122: case 1:
2123: case 2:
2124: { Pname a = f->argtype;
2125: if (a->tp->check(Pvoid_type,0))
2126: error("%n's 1stA must be a void*",nn);
2127: else if (a = a->n_list) {
2128: if (class_name == 0)
2129: error("%n takes only oneA",nn);
2130: else if (a->tp->check(size_t_type,0)) {
2131: if (strict_opt==0
2132: && a->tp->check(long_type,0)==0) {
2133: error('w',"%n's 2ndA should be a size_t",nn);
2134: a->tp = size_t_type;
2135: if (f->f_signature) Pfct(nn->tp)->sign();
2136: }
2137: else
2138: error("%n's 2ndA must be a size_t", nn);
2139: }
2140: }
2141: }
2142: }
2143: }
2144: }
2145: break;
2146: */
2147: case CALL:
2148: case 0:
2149: break;
2150:
2151: default:
2152: if (f->nargs_known != 1) {
2153: error("ATs must be fully specified for%n",nn);
2154: }
2155: else if (class_name == 0) {
2156: Pname a;
2157: switch (f->nargs) {
2158: case 1:
2159: case 2:
2160: for (a=f->argtype; a; a=a->n_list) {
2161: Ptype tx = a->tp;
2162: while (tx->base == TYPE) tx = Pbase(tx)->b_name->tp;
2163: if (tx->is_ref()) tx = Pptr(tx)->typ;
2164: if (tx->is_cl_obj()) goto cok;
2165: }
2166: error("%n must take at least oneCTA",nn);
2167: break;
2168: default:
2169: error("%n must take 1 or 2As",nn);
2170: }
2171: }
2172: else {
2173: switch (f->nargs) {
2174: case 0:
2175: case 1:
2176: break;
2177: default:
2178: error("%n must take 0 or 1As",nn);
2179: }
2180: }
2181: cok:;
2182: }
2183:
2184: int i = 0; // check that every argument after an argument with
2185: // initializer have an initializer
2186: for (Pname a = f->f_args/*f->argtype*/; a; a=a->n_list) {
2187: if (a->n_initializer)
2188: i = 1;
2189: else if (i)
2190: error("trailingA%n withoutIr",a);
2191: }
2192:
2193: /*
2194: the body cannot be checked until the name
2195: has been checked and entered into its table
2196: */
2197: if (f->body) f->dcl(nn);
2198: return nn;
2199: }
2200: /* ODI notes -
2201: template classes
2202: n_gen_fct_name -- this used to be an invalid pun on
2203: another field.
2204: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.