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