![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to template.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / optcfront|
Return to template.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / optcfront |
1.1 root 1: /* ident "@(#)ctrans:src/template.c 1.3" */
2: /*******************************************************************
3: * template.c
4: *
5: * This file contains most of the implementation for a subset of
6: * parametrized types as defined by the 1989 Stroustrup JOOP paper.
7: * The subset chosen here was the subset relevant to the
8: * implementation of aggregates in ObjectStore.
9: *
10: * The following is a list of features supported by the
11: * implementation. The list of features parallels the
12: * description of templates in the JOOP paper.
13: *
14: * a) Class templates supported.
15: *
16: * b) Member function templates supported.
17: * Type-specific member functions as described at the
18: * end of the "Outline of an implementation" section
19: * are also supported.
20: *
21: * Non-member function templates are not supported.
22: *
23: * c) Template arguments may be of type "type" or
24: * simple integral, real, double and pointer types
25: * that are compile-time constants.
26: *
27: * Default arguments are not suported.
28: *
29: *
30: * Restrictions:
31: *
32: * a) template definitions may not be nested.
33: *
34: * b) enums, or class definitions may not be
35: * nested within a template class definition.
36: *
37: * This file also supports an internal template facility
38: * to facilitate the implementation of ObjectStore data
39: * model features. The internal template facility is
40: * only used by compiler implementors, and is not user visible.
41: *
42: ************************************************************/
43:
44:
45: /***********************************************************
46: *
47: * TBD
48: *
49: * 1) Error recovery, a never ending task, could stand improvement.
50: *
51: * 2) The template copying process could probably be speeded up
52: * substantially, by only placing "graph-like" nodes in the hash
53: * table. The current implementation plays it safe, and places
54: * all nodes in the hash table.
55: *
56: * 3) Clean up $name processing, it needs to be remodularized
57: * so that class templates and tree templates share the code.
58: *
59: * 4) Permit parametrized name default names within member
60: * functions.
61: *
62: ****************************************************************/
63:
64: #include "tree_copy.h"
65: #include "cfront.h"
66: #include <string.h>
67: #include "tree_dump.h"
68: #include "template.h"
69: #include <stdlib.h>
70: #include <ctype.h>
71: #include "hash.h"
72:
73: extern int bound ; // is not mentioned in the header file
74:
75: const int max_string_size = 1024 ;
76:
77: const int default_copy_hash_size = 1000 ;
78:
79: // Save and restore global state around a template instantiation
80: void state::save() {
81:
82: Cdcl = ::Cdcl ;
83: Cstmt = ::Cstmt ;
84: curloc = ::curloc ;
85:
86: curr_file = ::curr_file ;
87: curr_expr = ::curr_expr ;
88: curr_icall = ::curr_icall ;
89: curr_loop = ::curr_loop;
90: curr_block = ::curr_block;
91: curr_switch = ::curr_switch;
92:
93: bound = ::bound ;
94: inline_restr = ::inline_restr ;
95: last_line = ::last_line ;
96:
97: no_of_badcall = ::no_of_badcall;
98: no_of_undcl = ::no_of_undcl ;
99:
100: badcall = ::badcall ;
101: undcl = ::undcl ;
102: } ;
103:
104:
105: void state::restore() {
106: ::Cdcl = Cdcl ;
107: ::Cstmt = Cstmt ;
108: ::curloc = curloc ;
109:
110: ::curr_file = curr_file ;
111: ::curr_expr = curr_expr ;
112: ::curr_icall = curr_icall ;
113: ::curr_loop = curr_loop;
114: ::curr_block = curr_block;
115: ::curr_switch = curr_switch;
116:
117: ::bound = bound ;
118: ::inline_restr = inline_restr ;
119: ::last_line = last_line ;
120:
121: ::no_of_badcall = no_of_badcall;
122: ::no_of_undcl = no_of_undcl ;
123:
124: ::badcall = badcall ;
125: ::undcl = undcl ;
126: } ;
127:
128:
129: void state::init() {
130: ::bound = 0 ;
131: ::inline_restr = 0 ;
132: ::no_of_badcall = ::no_of_undcl = 0 ;
133: ::undcl = ::badcall = NULL ;
134: // lastline needs to be initialized probaly via a call to putline
135:
136: }
137:
138:
139: bit basetype::parametrized_class()
140: { return ((base == COBJ) &&
141: Ptclass(Pbase(this)->b_name->tp)->class_base == uninstantiated_template_class) ;
142: }
143:
144: class_type_enum get_class_base (Pbase b) {
145: if (b->base != COBJ) error('i', "badA top ::get_class_type") ;
146: return Ptclass(Pbase(b)->b_name->tp)->class_base ;
147: }
148:
149: Ptclass get_template_class (Pbase b) {
150: class_type_enum t = get_class_base(b) ;
151:
152: if (! ((t == instantiated_template_class) ||
153: (t == uninstantiated_template_class)))
154: error ('i', "C is not aYC") ;
155:
156: return Ptclass(Pbase(b)->b_name->tp) ;
157: }
158:
159:
160: Ptempl_inst get_templ_inst(Pbase b) {
161:
162: return (get_template_class(b))->inst ;
163: }
164:
165:
166: bit classdef::parametrized_class()
167: { return (class_base == uninstantiated_template_class) ;
168: }
169:
170: // Predicate to determine whether two classes are indeed the same. cfront
171: // normally relies on pointer identity, however this test is insufficient when
172: // parametrized class instantiationa are involved, since there are potentially
173: // many instances of a COBJ and CLASS for a given instantiation.
174: bit classdef::same_class(Pclass pc)
175: {
176: if (this == pc) return true ;
177:
178: // An intermediate test to compensate for the fact that instantiations do
179: // not cause a copy of the syntax tree to be generated. This kludge should
180: // not be necessary once the template implementation is complete, and tree
181: // copying is implemented.
182: // Later, Sam: tree copying is now implemented, i need to remove the
183: // following two statements and rerun the test suite.
184:
185: if ((this->class_base == template_class) &&
186: (pc->class_base == instantiated_template_class) &&
187: (Ptclass(pc)->inst->def_basetype()->b_name->tp == this))
188: return true ;
189: // The inverse symmetric test
190: if ((pc->class_base == template_class) &&
191: (this->class_base == instantiated_template_class) &&
192: (Ptclass(this)->inst->def_basetype()->b_name->tp == pc))
193: return true ;
194:
195: // Check whether the templates were determined to be identical after
196: // instantiation.
197: if ((pc->class_base == instantiated_template_class) &&
198: (this->class_base == instantiated_template_class) &&
199: (Ptclass(this)->inst->same(Ptclass(pc)->inst)))
200: return true ;
201: return false ;
202: }
203:
204: // determine whether two instantiations are identical; the test asumes that
205: // the templates have been instantiated.
206: bool templ_inst::same(Ptempl_inst t)
207: {
208: return ((forward && (forward == t->forward)) ||
209: (forward == t) || (t->forward == this)) ? true : false ;
210: }
211:
212:
213: /* Template parsing support */
214:
215: // The canonical template compilation instance.
216:
217: templ_compilation *templp ;
218:
219: templ_compilation::templ_compilation()
220: { templates = new table(128, NULL, NULL) ;
221: any_type = new basetype(ANY, NULL);
222: PERM(any_type) ;
223: }
224:
225:
226: // determine whether the string corresponds to a tree formal parameter
227: Pname templ_compilation::tree_parameter(char *s) {
228: for (Plist formal = params ; formal ; formal = formal->l)
229: if (strcmp(formal->f->string, s) == 0) {
230: formal->f->n_used++ ;
231: return formal->f ;
232: }
233: return 0 ;
234: }
235:
236:
237: // Determine whether the name refers to the canonical template class during
238: // syntax analysis.
239: Ptempl templ_compilation::is_template(Pname p) {
240: if (p->tp && (p->tp->base == COBJ) &&
241: (get_class_base(Pbase(p->tp)) == template_class))
242: { Pname n = templates->look(p->string, 0) ;
243: return (n ? Ptempl(n->tp) : 0) ;
244: }
245: return 0 ;
246: }
247:
248:
249: // determine whether the string names a template
250: Ptempl templ_compilation::is_template(char *s) {
251: Pname n = templates->look(s,0) ;
252: return (n ? Ptempl(n->tp) : 0) ;
253: }
254:
255:
256: // Set up the environment for parsing a template. This involves setting up a
257: // new nesting level into which the "type type" parameters of the template can
258: // be entered, so that the lexer can find them as TNAMES. The scope is
259: // deallocated by end().
260: void templ_compilation::start()
261: { templp->in_progress = true ;
262: // Reinitialize the state.
263: params = param_end = NULL ; owner = NULL ;
264: modified_tn = 0 ; // Initialize it here, since ::collect adds new types
265: }
266:
267:
268:
269: // Collect each parameter as it is parsed, and add it to the list of parms.
270: // Validate each parameter to make sure that it is one of the acceptable
271: // types.
272: void templ_compilation::collect(TOK parm_type, Pname n)
273: {
274: switch (parm_type) {
275: case CLASS:
276: // A "type type" parameter, give it the "ANY" type normally used as a
277: // wildcard match internally by the compiler in cases of error.
278: n->tp = new basetype(ANY, 0);
279: n = n->tdef() ; // Set it up to be a typedef.
280: n->lex_level = bl_level + 1 ; // Inner scope, so restore() can hack it
281: n->n_template_arg = template_type_formal ;
282: PERM(n) ; PERM(n->tp) ;
283: break ;
284: case STATEMENT:
285: case EXPRESSION:
286: // the argument is a post-syntax expression tree
287: n->n_template_arg =
288: ((parm_type == EXPRESSION) ?
289: template_expr_tree_formal : template_stmt_tree_formal) ;
290: // canonical any_type is ok here
291: n->tp = any_type ;
292: PERM(n) ;
293: break ;
294: default:
295: error("theZT for%n must be CLASS, not %k", n,parm_type);
296: }
297: append_parameter(n) ;
298: }
299:
300: // append the "non-type" parameter to the end of the list
301: void templ_compilation::append_parameter(Pname n)
302: {
303: if (params){
304: param_end->l = new name_list(n, NULL) ;
305: param_end = param_end->l ;
306: }else params = param_end = new name_list(n, NULL) ;
307: PERM(n) ; PERM(n->tp) ;
308: }
309:
310:
311: // collect non "type type" parameters. The tp field of the name
312: // indicates the type of the formal parameter.
313: void templ_compilation::collect(Pname n)
314: {
315: // The grammar alone should be sufficient to protect against undesirable
316: // types. Any additional checks go here.
317: n->n_template_arg = template_expr_formal ;
318: append_parameter(n) ;
319: }
320:
321:
322:
323: // validate the type for a non-type formal, and make it a const.
324: static void check_non_type_formal(Pname n) {
325:
326: switch (n->tp->base) {
327: case ZTYPE:
328: case CHAR:
329: case SHORT:
330: case INT:
331: case LONG:
332: case FLOAT:
333: case DOUBLE:
334: case FIELD:
335: case EOBJ:
336: case COBJ:
337: case TYPE:
338: case ANY:
339: { // a basetype node
340: TOK bad_base = 0 ;
341:
342: if (Pbase(n->tp)->b_volatile)
343: bad_base = VOLATILE ;
344: if (Pbase(n->tp)->b_typedef)
345: bad_base = TYPEDEF ;
346: if (Pbase(n->tp)->b_inline)
347: bad_base = INLINE ;
348: if (Pbase(n->tp)->b_virtual)
349: bad_base = VIRTUAL ;
350: if (bad_base)
351: error ("bad %k declarator forY formal %n", bad_base,n);
352:
353: Pbase b = new basetype(0, 0) ;
354: *b= *Pbase(n->tp) ;
355: b->b_const = 1 ;
356: n->tp = b ;
357: break ;
358: }
359: case PTR:
360: { Pptr b = new ptr(0,0) ;
361: *b = *Pptr(n->tp) ;
362:
363: b->rdo = 1;
364: n->tp = b ;
365: break ;
366: }
367: case RPTR:
368: case VEC:
369: break; // constant by definition
370: default:
371: error ("badZT %t for formalZ %n", n->tp, n);
372: }
373: return ;
374: }
375:
376:
377:
378: // The template parameters if any, have been parsed. Member function templates
379: // may choose to default their template arguments to the class arguments, if
380: // so, make the defaulting happen.
381: void templ_compilation::enter_parameters()
382: {
383: for (Plist list = params ; list ; list = list->l) {
384: Pname n = list->f ;
385: switch(n->n_template_arg) {
386: case template_type_formal:
387: // Set them up for restoration
388: modified_tn = new name_list(n,modified_tn);
389: // Bring the names out of hiding
390: n->n_key = 0 ;
391: break ;
392: case template_expr_formal:
393: check_non_type_formal(n) ;
394: n->tp->dcl(gtbl) ;
395: break ;
396: case template_expr_tree_formal:
397: case template_stmt_tree_formal:
398: // simply note it, the guts of the processing takes place when the
399: // copy of the syntax tree is generated.
400: break ;
401: default:
402: error ('i', "badY formal" ) ;
403: }
404: }
405: // Save away the list of modified_tn, since the body processing will clobber
406: // it.
407: param_tn = modified_tn ;
408: modified_tn = 0 ;
409: }
410:
411:
412:
413: // Resolve the forward declaration of a template to its true definition. The
414: // template and class type data structures must be reused, since there may be
415: // outstanding references to them.
416: void templ::resolve_forward_decl(Plist params, Pclass c) {
417: check_formals(params) ;
418: formals = params ;
419: defined = true ;
420: definition_number = ++ definition_tick ;
421: members = c->mem_list ;
422: }
423:
424: void templ::instantiate_forward_decl() {
425: for (Ptempl_inst i = insts ; i ; i = i->next)
426: if (Ptclass(Pbase(i->tname->tp)->b_name->tp)->class_base ==
427: instantiated_template_class &&
428: ! i->forward)
429: { // reinstantiate it
430: i->instantiate(true) ;
431: }
432: }
433:
434:
435:
436: // verify thet the qualifier used to declare the member function matches the
437: // template arguments in name, ie.
438: // template <class P, class Q, ..> c<P,Q,..>::member_function() {}
439: // match it's Ps and Qs.
440: bool templ_inst::check_qualifier(Plist formals)
441: {
442: Pexpr actual = actuals ;
443: for (Plist formal = formals ; formal && actual ; formal = formal->l,
444: actual = actual->e2)
445:
446: switch (formal->f->n_template_arg) {
447:
448: case template_type_formal:
449: { Pbase b = Pbase(actual->e1->tp) ;
450:
451: if (! ((b->base == TYPE) &&
452: (b->b_name->base == TNAME) &&
453: (strcmp (Pname(b->b_name)->string, formal->f->string) == 0)))
454: return false ;
455: break ;
456: }
457:
458: case template_expr_formal:
459: if (! ((actual->e1->base == NAME) &&
460: (strcmp(Pname(actual->e1)->string, formal->f->string) == 0)))
461: return false ;
462: break ;
463:
464: case template_expr_tree_formal:
465: case template_stmt_tree_formal:
466: default:
467: error ('i',"badY formal") ;
468: }
469:
470: return true ;
471: }
472:
473:
474: // make the class template visible when compiling the template class
475: // defintion, so that it can be refernced while compiling the class body.
476: void templ_compilation::introduce_class_templ(Pname namep)
477: {
478: owner = is_template(namep) ;
479: // create a template definition if one did not already exist, due to a
480: // forward declaration
481: if (!owner){
482: owner = new templ(params, namep) ;
483: Pname lookup_name = templp->templates->insert(new name(namep->string), 0);
484: lookup_name->tp = Ptype(owner) ; // lie, to permit use of the table
485: }
486: }
487:
488:
489: // The body of the template has been parsed. Finish the definition of the
490: // template class.
491: void templ_compilation::end(Pname p)
492: {
493: bool forward_definition = false ;
494: // Restore the name environment to the state before the template parameters
495: // were processed.
496: modified_tn = param_tn ;
497: restore() ;
498: modified_tn = 0 ;
499:
500: if (curr_tree_template) {
501: // create an expression template
502: new tree_template(curr_tree_template,
503: p->string, params, p->n_initializer, templ_refs) ;
504: }else {
505: if (!p->tp) {
506: error ("aC, orMF definition wasX") ;
507: return ;
508: }
509: switch(p->tp->base){
510:
511: case CLASS:
512: // Create the template type to represent the parsed template, and enter it
513: // into the global table. This is achieved simply by modifying the TNAME
514: // that was entered into ktbl to represent the class definition.
515: Pname namep = ktbl->look(p->string, 0) ;
516:
517: // check for nested definitions, they aren't supported currently. 2.1 is
518: // a good time to start supporting them, since they are nested for real.
519: for (Pname nn = Pclass(p->tp)->mem_list ; nn ; nn = nn->n_list)
520: switch (nn->base) {
521: case NAME:
522: switch(nn->tp->base) {
523: case CLASS:
524: error("CD %s not permitted within a ZizedC", nn->string) ;
525: break ;
526: case ENUM:
527: error("enumD %s not permitted within a ZizedC", nn->string) ;
528: break ;
529: }
530: break ;
531:
532: case TNAME:
533: error("typedef %s not permitted within a ZizedC", nn->string) ;
534: break ;
535: }
536:
537: owner = is_template(namep);
538: if (owner) {
539: Pclass c = Pclass(owner->basetype()->b_name->tp) ;
540: // ignore it, if it is a forward declaration following a real
541: // definition
542: if (owner->defined && (Pclass(p->tp)->mem_list != owner->members))
543: error("YC %s multiply defined", p->string) ;
544:
545: forward_definition=bool((c->defined & DEF_SEEN) && (!owner->defined));
546: if (forward_definition) owner->resolve_forward_decl(params, c) ;
547: }else
548: // a forward declaration
549: introduce_class_templ(namep) ;
550:
551: if (templ_refs) owner->templ_refs = templ_refs ;
552: break ;
553:
554: case FCT:
555: { Pname qual = p->n_qualifier ;
556: // the function must belong to a declared template class
557: if (! qual) {
558: error('s', "onlyYMFs may beZized currently") ;
559: return ;
560: }
561: if (qual->tp && (qual->tp->base == COBJ))
562: switch (get_class_base(Pbase(qual->tp))) {
563: case uninstantiated_template_class:
564: owner = Ptclass(Pbase(qual->tp)->b_name->tp)->inst->def ;
565: // verify that the formals specified, match the template formals
566: // in name, note that the length was already matched when the
567: // instantiation was generated.
568: if (!get_template_class
569: (Pbase(qual->tp))->inst->check_qualifier(params))
570: error ("QrZs must match theY formals") ;
571: break ;
572: case template_class:
573: // the template reference was without any of the formals
574: owner = is_template(qual) ;
575: if (! owner->has_tree_expr_formals())
576: error('w',"Qr %n for %n must specifyYZs", qual, p) ;
577: break ;
578: default:
579: error ("Qr %n for %n wasn't aYC", qual, p) ;
580: return ;
581: }
582: Pfunt ft= owner->collect_function_member(p) ;
583: if (! Pfct(p->tp)->body)
584: error ("theYFM %n must have a body", p) ;
585: ft->templ_refs = templ_refs ;
586: ft->formals = params ;
587: owner->check_formals(params) ;
588: break ;
589: }
590: default: error ("C, or MF definitionX.") ;
591: }
592: }
593: // Note the template references from this definition
594:
595: clear_ref_templ() ;
596: param_end = params = 0; // Indicates the end of template processing.
597: curr_tree_template = 0 ;
598:
599: if (forward_definition) owner->instantiate_forward_decl() ;
600: owner = 0 ;
601: }
602:
603:
604:
605:
606: // Clear the list of templates referenced during the syntax analysis of a top
607: // level definition. Note that since this list is produced during syntax
608: // analysis, it does not recognize instantiations that may actualy turn out to
609: // be identical at instantiation after the substitution of actual parameters.
610: // Thus, the list may be longer than it would be after actual argument
611: // substitution.
612: void templ_compilation::clear_ref_templ() {
613: for (Pcons p = templ_refs ; p ; p = p->cdr)
614: Ptempl_inst(p->car)->refp = false ;
615: templ_refs = 0 ; last_cons = 0 ;
616: }
617:
618:
619: // Instantiate templates that were referenced by a non-template definition,
620: // after syntax analysis has been completed on it.
621: void templ_compilation::instantiate_ref_templ() {
622: for (Pcons p = templ_refs ; p ; p = p->cdr)
623: Ptempl_inst(p->car)->instantiate() ;
624: clear_ref_templ() ;
625: }
626:
627:
628:
629:
630: // Compile all template member body instantiations. Set in motion the
631: // compilation of the graph of instantiation bodies. Note that compilation of
632: // a body may in turn initiate the instantiation of templates that had not
633: // previously been instantiated.
634: void templ_compilation::end_of_compilation() {
635: bool change = false ;
636: do {
637: change = false ;
638: for (Ptempl p = list ; p ; p = p->next)
639: change = ( change | p->instantiate_bodies() ? true : false);
640: } while (change) ;
641: }
642:
643:
644: // A predicate to validate that a tname without template parameters is legit
645: // in the scope, ie. that it does not need actual template arguments.
646: // Currently, a tname without parameters is ok within the class definition,
647: // but parameters are required within the member definition. They should not
648: // be required within the member function either to be consonance with their
649: // use in the class definition.
650: Pname templ_compilation::check_tname(Pname p) {
651: Ptempl t = is_template(p) ;
652:
653: if (p->n_template_arg) p->n_used++ ;
654: if (!t) return p ;
655: if (in_progress && ((owner && (owner->namep == p)) ||
656: (!owner && t->basetype()->b_name->tp == ccl)))
657: return p ;
658: error ("%n needs Y instantiationAs.", p) ;
659: return p ;
660: }
661:
662:
663: // This function determine when the parameters specified to a template are
664: // redundant, and really refer to the current template class. Thus,
665: //
666: // template c<class p1, class p2> c<p1,p2>::foo { ... } ;
667: // has the redundant template specification c<p1, p2> and can simply be a
668: // reference to a "c" instead,
669: bool templ_compilation::current_template(Pname p, Pexpr actuals) {
670: if (in_progress &&
671: ((owner && (owner->namep == p)) ||
672: (!owner && ((p->tp->base == COBJ) &&
673: (Pbase(p->tp)->b_name->tp == ccl)))))
674: { // Check whether the formal and actual types are identical
675: Pexpr actual = actuals;
676: for (Plist formal = params ; formal && actual ; formal = formal->l,
677: actual = actual->e2)
678: if ((formal->f->tp == actual->e1->tp) ||
679: ((actual->e1->tp && (actual->e1->tp->base == TYPE)) &&
680: (Pbase(actual->e1->tp)->b_name->tp == formal->f->tp)))
681: continue ;
682: else break ;
683: if (!formal && !actual) return true ;
684: }
685: return false ;
686: }
687:
688:
689:
690: // Add a new member function to the list of functions for the template class.
691: Pfunt templ::collect_function_member(Pname fname) {
692: PERM(fname) ; PERM(fname->tp) ; PERM(Pfct(fname->tp)->body) ;
693: return new function_template (*this, templp->params, fname) ;
694: }
695:
696:
697: // Check the formals specified for a member function or a forward definition
698: // of a class, against the formals for the class.
699: void basic_template::check_formals(Plist f2) {
700:
701: for (Plist f1 = formals; f1 && f2 ; f1 = f1->l, f2 = f2->l)
702: if (f1->f->base != f2->f->base)
703: switch (f1->f->n_template_arg) {
704: case template_type_formal:
705: error ("Y formalZ mismatch,\
706: %n must be a type formal parameter.", f2->f) ;
707: break ;
708: case template_expr_formal:
709: error ("formalZ mismatch, %n must be aZ ofT %t",
710: f2->f, f2->f->tp) ;
711: break ;
712: case template_expr_tree_formal:
713: case template_stmt_tree_formal:
714: error ("formalZ mismatch, %n must be anE formalZ",
715: f2->f) ;
716: break ;
717: default:
718: error ("formalZ mismatch betweenC formal: %n andM formal: %n", f1->f, f2->f) ;
719: }else if (f1->f->n_template_arg == template_expr_formal) {
720: // the types should be identical
721: if (f1->f->tp->check(f2->f->tp, 0) == 1)
722: error ("type mismatch betweenM formal %n, andC formal %n", f2->f, f1->f) ;
723: }
724: if (f1)
725: error ("insufficient formalZs,CZ parameter %n onwards are missing", f1->f) ;
726: if (f2)
727: error ("excess formalZs,Z %n onwards not defined forC", f2->f) ;
728:
729: }
730:
731: // predicate to determine whether the template has expression tree formals
732: bool templ::has_tree_expr_formals() {
733:
734: for (Plist formal= formals; formal ; formal = formal->l)
735: if (formal->f->n_template_arg == template_expr_tree_formal)
736: return true ;
737:
738: return false ;
739: }
740:
741:
742: // Check that those formals that require class actual arguments, due to their
743: // use in member function bodies get them.
744: bool basic_template::check_constraints(Pexpr actual)
745:
746: {
747: bool ret = true ;
748:
749: for (Plist formal = formals ; formal && actual ; formal = formal->l,
750: actual = actual->e2)
751: if ((formal->f->n_template_arg == template_type_formal) &&
752: formal->f->n_template_formal_must_be_class) {
753:
754: Pname n = Pname(actual->e1) ;
755:
756: if (n && n->tp && n->tp->is_cl_obj())
757: continue ;
758: error("expected aCT actual, not %t, for the \"TT\" formal %s",
759: n->tp, formal->f->string);
760: ret = false ;
761: }
762: return ret ;
763: }
764:
765:
766: // Check actual template arguments, against the formals.
767: bool templ::check_actual_args(Pexpr actual)
768: {
769: for (Plist formal = formals ; formal && actual ; formal = formal->l,
770: actual = actual->e2)
771: switch (formal->f->n_template_arg) {
772: case template_type_formal:
773: {
774: // A "type type" parameter, any actual type that was accepted by the
775: // parse is acceptable here, just make sure that it is indeed a type.
776: // If it was parsed as a type, the grammar should have created a name
777: // node, and attached the type to it, having marked the name as a
778: // template_actual_arg_dummy.
779:
780: Pname n = Pname(actual->e1) ;
781:
782: if (!((n->base == NAME) &&
783: (n->n_template_arg == template_actual_arg_dummy))) {
784: error ("Y %s A mismatch, the Y formal:%n\
785: required aT actualZ.", namep->string, formal->f) ;
786: // recover from the error with a safe expression
787: n = new name("") ;
788: n->tp = any_type ;
789: actual->e1 = n ;
790: }
791: if ((formal->f->n_template_formal_must_be_class) &&
792: !(n->tp && n->tp->is_cl_obj()))
793: error("expected aCT actual, not %t, for the \"TT\" formal %s",
794: n->tp, formal->f->string) ;
795: break ;
796: }
797: case template_expr_formal:
798: // checking can only be done at instantiation, so postpone it
799: break ;
800: case template_expr_tree_formal:
801: case template_stmt_tree_formal:
802: // anything is acceptable, it is a case of "implementor beware". Any
803: // illegalities will only be detected when dcl processing takes place.
804: break ;
805: default:
806: error ('i',"badY formal") ;
807: }
808: // If we provide for optionals, this is where the processing should get done.
809: if (formal)
810: error ("too fewAs supplied forY %s", namep->string) ;
811: if (actual && actual->e1) {
812: error ("too manyAs supplied forY %s", namep->string) ;
813: }
814: return bool(~(formal || actual)) ;
815: }
816:
817:
818:
819:
820: // Append to the list of references.
821: void templ_compilation::append_ref(Ptempl_inst ref)
822: { cons *p = new cons(ref,0) ;
823: if (last_cons)
824: last_cons->cdr = p ;
825: else templ_refs = p ;
826: last_cons = p ;
827: } ;
828:
829:
830: // Note the reference by a definition to the template, so that the template
831: // can be instantiated before the definition is processed.
832: Ptempl_inst templ_inst::note_ref()
833: { if ((! refp)) {
834: refp = true ;
835: templp->append_ref(this) ;
836: }
837: return this ;
838: }
839:
840:
841:
842: // Get an instantiation for the template with the given set of actuals. If one
843: // exists, return it, otherwise create a new one.
844: Ptempl_inst templ::get_inst(Pexpr actuals, Ptempl_inst exclude)
845: { Ptempl_inst inst = get_match(actuals, exclude, false) ;
846:
847: return (inst ? inst : new templ_inst(actuals, this))->note_ref() ;
848: }
849:
850:
851: // Find an instantiation that has the same set of actuals, exclude the
852: // instantaition passed in from the set of candidates
853: Ptempl_inst templ::get_match(Pexpr actuals,
854: Ptempl_inst exclude, // don't match this one
855: // Only instantiated templates match
856: bool match_instantiated_only)
857: {
858: for (Ptempl_inst p = insts ; p ; p = p->next)
859: if ((p != exclude) &&
860: (p->actuals_match(actuals)) &&
861: (match_instantiated_only ?
862: (Pclass(Pbase(p->tname->tp)->b_name->tp)->class_base ==
863: instantiated_template_class)
864: : true))
865: return (p->forward ? p->forward : p) ;
866: return NULL ;
867: }
868:
869:
870: // provides the basetype created for a given set of actuals.
871: Pbase templ::inst_basetype(Pexpr actuals)
872: {
873: return (check_actual_args(actuals) ?
874: Pbase(get_inst(actuals)->tname->tp) : basep) ;
875: }
876:
877:
878: // Validate that the name denotes a parametrized type, and prodouce a TNAME
879: // for the instantiation.
880: Pname parametrized_typename (Pname p, Pexpr actuals)
881: {
882: Ptempl t = templp->is_template(p) ;
883: // A template instantiation with redundant actuals identical to the formals
884: // of the current template
885: if (templp->current_template(p, actuals)) return p ;
886: if (t) {
887: Pname tname = t->typename(actuals) ;
888: return (tname ? tname : p) ;
889: }
890: error ("%n hasTAs but is not aZizedC", p) ;
891: return p ;
892: }
893:
894:
895: Pbase parametrized_basetype (Pname p, Pexpr actuals)
896: { Ptempl t = templp->is_template(p) ;
897: // A template instantiation with redundant actuals identical to the formals
898: // of the current template
899: if (templp->current_template(p, actuals)) return Pbase(p->tp) ;
900: if (t) return t->inst_basetype(actuals) ;
901: error ("%n is not aZizedC", p) ;
902: return new basetype(TYPE, p);
903: }
904:
905:
906: // Similar primitive for obtaining the typename associated with an
907: // instantiation.
908: Pname templ::typename(Pexpr actuals)
909: {
910: return (check_actual_args(actuals) ? get_inst(actuals)->tname : 0) ;
911: }
912:
913: // predicate to get past all the type nodes
914: static Ptype real_type (Ptype t)
915: {
916: while (t->base == TYPE) t = Pbase(t)->b_name->tp ;
917: return t ;
918: }
919:
920: static int expr_match(Pexpr a1, Pexpr a2) ;
921:
922: // Check whether the actuals provided match the actuals for this instantiation.
923: // The actuals match the formals, iff they are the same type or parametrized
924: // type.
925: bool templ_inst::actuals_match(Pexpr check_actuals)
926: { Pexpr ae1, ae2 ; // the cons cells
927: Plist formal = def->formals ;
928:
929: // The lists should be the same length, since check_actuals will have taken
930: // appropriate action.
931: for (ae1=actuals, ae2=check_actuals ; formal && ae1 && ae2 ;
932: ae1=ae1->e2, ae2=ae2->e2, formal = formal->l)
933:
934: switch (formal->f->n_template_arg) {
935:
936: case template_type_formal:
937: { Ptype t1 = ae1->e1->tp, t2 = ae2->e1->tp ;
938: if (t1->check(t2,255) == 1)
939: return false ;
940: break ;
941: }
942: case template_expr_formal:
943: if (! expr_match(ae1->e1, ae2->e1)) return false ;
944: break ;
945:
946: case template_expr_tree_formal:
947: case template_stmt_tree_formal:
948: // these are internal instantiations and consequently never match
949: return false ;
950:
951: default:
952: error ('i', "bad template formal") ;
953: }
954: return true ;
955: }
956:
957:
958: extern char emode ;
959:
960:
961: // This set of overloaded fuctions are used to accumulate name strings
962: void stradd(char *&target, char *source) {
963: while (*target++ = *source++) ;
964: target-- ;
965: }
966:
967: void stradd(char *&p, long i) {
968: if (!emode) {
969: *p++ = 'L' ;
970: }
971: char s[16] ;
972:
973: sprintf(s,"%ld", i) ;
974: stradd(p,s) ;
975: }
976:
977: void stradd(char *&p, Pname n) {
978: if (!emode){
979: char s[256] ;
980:
981: sprintf(s,"%d", strlen(n->string)) ;
982: stradd(p,s) ;
983: }
984: stradd(p, n->string) ;
985: }
986:
987:
988:
989: // produce a unique string suitable for use within a name; if in emode ie.
990: // printing in the context of an error, print a pretty name instead.
991: char * mangled_expr(char *p, Pexpr e, bool mangle_for_address = false)
992: {
993: static int mangle_address = 0 ;
994: if (e == 0) return p;
995:
996: switch (e->base) {
997: case ADDROF:
998: case G_ADDROF:
999: // unary using e2
1000: // rely on the
1001: mangle_address++ ;
1002: p = mangled_expr(p, e->e2) ;
1003: mangle_address -- ;
1004: break ;
1005:
1006: case NAME:
1007: if (mangle_address || mangle_for_address)
1008: stradd(p, Pname(e)) ;
1009: else if (Pname(e)->n_evaluated)
1010: stradd(p, Pname(e)->n_val) ;
1011: else if (Pname(e)->n_initializer)
1012: p = mangled_expr(p, Pname(e)->n_initializer, mangle_for_address) ;
1013: else error ('i', "couldn't mangle %n", e) ;
1014: break ;
1015:
1016: case IVAL:
1017: stradd(p, ((ival *)e)->i1) ;
1018: break ;
1019:
1020: case CAST:
1021: { // an IVAL hiding below the cast ?
1022: if (e->e1->base == IVAL)
1023: stradd(p, ((ival *)e->e1)->i1) ;
1024: else error ('i', "unexpected cast") ;
1025: break ;
1026: }
1027: case ICON:
1028: case CCON:
1029: case FCON:
1030: *p++ = 'L' ;
1031: strcpy(p, e->string) ;
1032: // Sam: there needs to be a better encoding scheme, but it can wait.
1033: if (!emode)
1034: while (*p)
1035: if (! (isalnum(*p)))
1036: switch(*p) {
1037: case '+':
1038: *p++ = 'p' ;
1039: break ;
1040:
1041: case '-':
1042: *p++ = 'm' ;
1043: break ;
1044:
1045: case '.':
1046: *p++ = 'D' ;
1047: break ;
1048:
1049: case 'e':
1050: *p++ = 'E' ;
1051: break ;
1052:
1053: default:
1054: error ('i', "bad character in constant") ;
1055: break ;
1056: } else p++ ;
1057: break ;
1058:
1059: case ZERO:
1060: *p++ = '0' ;
1061: break ;
1062:
1063: default:
1064: error ('i', "can't mangle %k", e->base) ;
1065: }
1066: return p ;
1067: }
1068:
1069: // this function is invoked once at the top level
1070: char *mangled_expr(char *p, Pname n) {
1071: if (n->n_evaluated) {
1072: stradd(p, n->n_val) ;
1073: return p ;
1074: }
1075: return mangled_expr(p, n->n_initializer,
1076: (real_type(n->tp)->base == PTR ? true : false)) ;
1077: }
1078:
1079: // Generate a template instantiation name suitable for printing when it is
1080: // presented to the user.
1081: void templ_inst::print_pretty_name()
1082: {
1083: extern char emode ;
1084:
1085: fprintf(out_file, " %s<", (def->namep ? def->namep->string : "?")) ;
1086: Plist formal = inst_formals ;
1087: emode ++ ; // so that dcl_print generates c++ rather than c names
1088:
1089: for (Pexpr ae1=actuals; formal && ae1 ; ae1=ae1->e2, formal = formal->l) {
1090: switch (formal->f->n_template_arg) {
1091: case template_type_formal:
1092: ae1->e1->tp->dcl_print(0) ;
1093: break ;
1094: case template_expr_formal:
1095: { char buff[256] ;
1096:
1097: mangled_expr(buff, ae1->e1) ;
1098: fprintf(out_file, "%s", buff) ;
1099: break ;
1100: }
1101: case template_expr_tree_formal:
1102: case template_stmt_tree_formal:
1103: // doesn't participate in the name generation
1104: break ;
1105: default:
1106: error ('i', "unexpected formal") ;
1107: }
1108:
1109: // this comma is unfortunately misplaced, since it follows a space printed
1110: // out by dcl_print
1111: if (formal->l) fprintf(out_file, ", ") ;
1112: }
1113: fprintf(out_file, ">") ;
1114: emode -- ;
1115: }
1116:
1117:
1118:
1119: // there are different representations for ICON based upon whether it has been
1120: // evaluated.
1121: int check_for_const(Pexpr a1, Pexpr a2) {
1122: Neval = 0 ;
1123: if ((a1->base == NAME) &&
1124: ((a2->base == ICON) || (a2->base == IVAL) || (a2->base == ZERO)))
1125: { Pname n = Pname(a1) ;
1126: return (n->n_evaluated && (n->n_val == a2->eval())) ;
1127: }else if (((a1->base == ICON) || (a1->base == IVAL) || (a1->base == ZERO))
1128: && (a2->base == NAME))
1129: { Pname n = Pname(a2) ;
1130: return (n->n_evaluated && (n->n_val == a1->eval())) ;
1131: }
1132: return false ;
1133: }
1134:
1135:
1136: // get past the template parameter names to get the the real expression
1137: static Pexpr real_expression(Pexpr e)
1138: {
1139: while (e && (e->base == NAME) &&
1140: (Pname(e)->n_template_arg == template_expr_formal) &&
1141: (! Pname(e)->n_evaluated) && Pname(e)->n_initializer)
1142: e = Pname(e)->n_initializer ;
1143: return e ;
1144: }
1145:
1146:
1147: // determine whether two expressions supplied as actual arguments to
1148: // a "template_expr_formal" formal argument match.
1149: static int expr_match(Pexpr a1, Pexpr a2)
1150: {
1151: static int addr_of = 0 ;
1152:
1153: a1 = (addr_of ? a1 : real_expression(a1)) ;
1154: a2 = (addr_of ? a2 : real_expression(a2)) ;
1155:
1156: if (a1 == a2) return true;
1157:
1158: //
1159: if (a1->base != a2->base) return check_for_const(a1, a2) ;
1160:
1161: switch (a1->base) {
1162: case QUEST:
1163: // a ternary operator
1164: return ( expr_match(a1->cond, a2->cond) &&
1165: expr_match(a1->e1, a2->e1) &&
1166: expr_match(a1->e2, a2->e2)) ;
1167:
1168: case PLUS: case MINUS: case MUL: case DIV: case MOD:
1169: case ER: case OR: case ANDAND: case OROR:
1170: case LS: case RS:
1171: case EQ: case NE: case LT: case LE: case GT: case GE:
1172: // binary operator
1173: return (expr_match(a1->e1, a2->e1) &&
1174: expr_match(a1->e2, a2->e2)) ;
1175: case UMINUS: case UPLUS:
1176: case NOT: case COMPL:
1177: return (expr_match(a1->e2, a2->e2)) ;
1178: case ADDROF:
1179: {
1180: // unary using e2
1181: addr_of ++ ;
1182: int result = (expr_match(a1->e2, a2->e2)) ;
1183: addr_of -- ;
1184: return result ;
1185: }
1186: case CAST:
1187: return (expr_match(a1->e1, a2->e1)) ;
1188: case NAME:
1189: if (! addr_of) {
1190: Pname n1 = Pname(a1), n2 = Pname(a2) ;
1191:
1192: if ((n1->n_evaluated) && n2->n_evaluated && (n1->n_val == n2->n_val))
1193: return true ;
1194: if (n1->n_initializer && (! n2->n_initializer))
1195: return check_for_const(n2, n1->n_initializer) ;
1196: if (n2->n_initializer && (! n1->n_initializer))
1197: return check_for_const(n1, n2->n_initializer) ;
1198: if (n1->n_initializer && n2->n_initializer)
1199: return expr_match(n1->n_initializer, n2->n_initializer) ;
1200: }
1201: return false ;
1202: case DOT:
1203: return (expr_match(a1->e1, a2->e1)) ;
1204: case REF:
1205: return (expr_match(a1->e1, a2->e1)) ;
1206: case IVAL:
1207: return (ival *)a1->i1 == (ival *)a2->i1 ;
1208: case ICON:
1209: case CCON:
1210: case FCON:
1211: case STRING:
1212: return (strcmp (a1->string, a2->string) == 0) ;
1213: case ZERO:
1214: return true ;
1215: case SIZEOF:
1216: { long l1 = a1->eval(), l2 = a2->eval() ;
1217: return (l1 == l2) ;
1218: }
1219: }
1220: return false ;
1221: }
1222:
1223:
1224: static char * non_type_argument_signature(Pexpr e, char *p) {
1225: p = e->tp->signature(p) ;
1226: return mangled_expr(p, e) ;
1227: }
1228:
1229:
1230:
1231: // generate array suffix information for an array signature. cfront does not
1232: // normally generate this as part of the type signature, since it only deals
1233: // with argument signatures, and arrays can't be arguments.
1234: static void add_array_type_suffix(char *&s, Ptype t) {
1235: t = real_type(t) ;
1236: if (t->base == VEC) {
1237: Pvec v = Pvec(t);
1238: int dim;
1239: char a[32] ;
1240: Neval = 0 ;
1241: if(v->dim == 0)
1242: dim = v->size / v->typ->tsizeof();
1243: else dim = (int)v->dim->eval();
1244: sprintf(a, "A%d", dim) ;
1245: stradd(s,a) ;
1246: add_array_type_suffix(s, Pvec(t)->typ);
1247: }
1248: }
1249:
1250:
1251:
1252: // Generate a mangled template instantiation name. The syntax of as template
1253: // mangled class name is of the form:
1254: // original_name__<argument type signatures>__unique_id
1255: // Each non-type argument is replaced by a unique id.
1256: char *templ_inst::mangled_name(char *ip)
1257: { static tree_formal_id = 0 ;
1258:
1259: char *start = ip ;
1260: ip = start ;
1261: strcpy(ip, (def->namep ? def->namep->string : "?")) ;
1262: ip= start + strlen(start) ;
1263: stradd(ip, "__pt__") ;
1264:
1265: {
1266: char a [max_string_size], *p = a ;
1267:
1268: Plist formal = inst_formals ;
1269:
1270: for (Pexpr ae1=actuals ; ae1 ; ae1=ae1->e2, formal = formal->l)
1271: switch (formal->f->n_template_arg) {
1272: case template_expr_formal:
1273: *p++ = 'X' ;
1274: // the formal must have been bound
1275: p = non_type_argument_signature(formal->f, p) ;
1276: break ;
1277:
1278: case template_type_formal:
1279: p = ae1->e1->tp->signature(p) ;
1280: add_array_type_suffix(p,ae1->e1->tp) ;
1281: break ;
1282:
1283: case template_expr_tree_formal:
1284: case template_stmt_tree_formal:
1285: *p++ = 'Y' ;
1286: stradd(p, tree_formal_id++) ;
1287: break ;
1288:
1289: default:
1290: error ("bad template formal:%d", formal->f->base) ;
1291: break ;
1292: }
1293:
1294: *p = 0 ;
1295: sprintf(ip, "%d_", strlen(a)+1) ;
1296: ip = start + strlen(start) ;
1297: strcpy(ip,a) ;
1298: }
1299:
1300: return start ;
1301: }
1302:
1303:
1304:
1305: // The C compiler barfs when it is passed on through C++ as an automatic
1306: // variable
1307: const char leader[]= "\t" ;
1308:
1309: // Explain the location of an instantiation in greater detail, since it may be
1310: // far removed from it's textual definition.
1311: void templ_inst::print_error_loc() {
1312: if (! head) return ; // No active instantiations
1313:
1314: extern void print_loc() ;
1315: state current_state ;
1316: char buffer[max_string_size] ;
1317:
1318: for (int i = 0 ; i < max_string_size; i++) buffer[i] = 0 ;
1319:
1320: current_state.save() ;
1321: fprintf (out_file, "%sanomaly detected during the instantiation of",
1322: leader) ;
1323: print_pretty_name() ;
1324: fprintf(out_file, "\n") ;
1325: if (!head->next_active) {
1326: // A more compact message for a single level of instantiation
1327: context.restore() ;
1328: fprintf (out_file, leader) ;
1329: print_loc() ;
1330: fprintf (out_file, "was the site of the instantiation\n") ;
1331: }else {
1332: // The instantiation chain is longer than one
1333: fprintf (out_file, "%sthe instantiation path was:\n", leader) ;
1334: for (Ptempl_inst p = head ; p ; p = p->next_active) {
1335: p->context.restore() ;
1336: print_loc() ;
1337: fprintf (out_file, " template:") ;
1338: p->print_pretty_name() ;
1339: fprintf(out_file, "\n") ;
1340: }
1341: }
1342: current_state.restore() ;
1343: }
1344:
1345:
1346:
1347: // Generate a class name for the instantiated class. It is constructed in a
1348: // manner similar to the names used in the construction of overloaded functions
1349: char *templ_inst::instantiation_string() {
1350: char inst_name[max_string_size] ;
1351: for (int i = 0 ; i < max_string_size; i++) inst_name[i] = 0 ;
1352: mangled_name(inst_name) ;
1353: return strdup(inst_name) ;
1354: }
1355:
1356:
1357:
1358: // Change the names for the class, constructors, and destructors to reflect
1359: // the new class instantiation name.
1360: void classdef::modify_inst_names(char *s)
1361: {
1362: char *old = string ;
1363: string = s ; // Change the class name
1364: // Change the constructor names
1365: for (Pname p=mem_list; p; p=p->n_list)
1366: if (p->tp && (p->tp->base==FCT) && (!strcmp(old, p->string)))
1367: p->string = s ;
1368: }
1369:
1370: // Get past the fake template argument name typename types
1371: Ptype non_template_arg_type(Pbase t) {
1372: if ((t->base == TYPE) &&
1373: (t->b_name->n_template_arg == template_type_formal))
1374: return non_template_arg_type(Pbase(t->b_name->tp)) ;
1375: else return t ;
1376: }
1377:
1378: // follow the chain until we hit a non
1379: void non_template_arg_non_type(Pname n) {
1380: Pexpr i = n->n_initializer;
1381: while (i &&
1382: (i->base == NAME) &&
1383: (Pname(i)->n_template_arg == template_expr_formal))
1384: {
1385: if (Pname(i)->n_initializer) {
1386: n->n_initializer = Pname(i)->n_initializer ;
1387: i = n->n_initializer ;
1388: continue ;
1389: }
1390: if (Pname(i)->n_evaluated) {
1391: n->n_evaluated = 1 ;
1392: n->n_val = Pname(i)->n_val ;
1393: return ;
1394: }
1395: }
1396: return ;
1397: }
1398:
1399:
1400:
1401: // Now that the actuals are truly resolved, ie. semantics is complete, and the
1402: // template is about to be instantiated.
1403: void forward_template_arg_types(Plist formal, Pexpr actuals)
1404: {
1405: for (Pexpr actual = actuals ; formal && actual ;
1406: formal = formal->l, actual = actual->e2)
1407: switch(formal->f->n_template_arg){
1408: case template_type_formal:
1409: actual->e1->tp = non_template_arg_type(Pbase(actual->e1->tp)) ;
1410: break ;
1411: case template_expr_formal:
1412: break ;
1413: case template_expr_tree_formal:
1414: case template_stmt_tree_formal:
1415: break ;
1416: default:
1417: error ('i', "bad template formal") ;
1418: }
1419: }
1420:
1421: // determine whether the expression supplied as an actual argument to
1422: // atemplate formal of type "template_expr_formal" is suitable. We are nore
1423: // restrictive than we need to be, simply so that the debugger can have an
1424: // easier time. All expressions must be of the form constant integer
1425: // expression, a float or double literal, or the address of a variable, or an
1426: // array, or function
1427: static int suitable_const_expr(Pname n)
1428: {
1429: if (n->n_evaluated) return 1 ;
1430:
1431: if (!n->n_initializer) return 0 ;
1432:
1433: switch (n->n_initializer->base) {
1434:
1435: case CAST:
1436: { // if it is a cast of an integer value, it's fine.
1437: if (n->n_initializer->e1->base == IVAL)
1438: return 1 ;
1439: else return 0 ;
1440: }
1441:
1442: case FCON:
1443: case ZERO:
1444: return 1 ;
1445:
1446: case ADDROF:
1447: case G_ADDROF:
1448: {
1449: Pname an = Pname(n->n_initializer->e2) ;
1450: if (an->base != NAME) return 0 ;
1451: if (an->n_stclass == STATIC) return 1 ;
1452: return 0 ;
1453: }
1454: case NAME:
1455: {
1456: Pname an = Pname(n->n_initializer) ;
1457: if ((an->n_stclass == STATIC) &&
1458: (an->tp->base == VEC))
1459: // assumes that decl processing won, so that the formal could only
1460: // have been apointer
1461: return 1 ;
1462: return 0 ;
1463: }
1464: default:
1465: return 0 ;
1466: }
1467: }
1468:
1469:
1470:
1471: static bool is_stmt_node(Pnode p) {
1472: if (!p) return false ;
1473: switch(p->base) {
1474: case BREAK: case CONTINUE: case DEFAULT:
1475: case SM: case WHILE: case DO: case SWITCH: case RETURN: case CASE:
1476: case FOR:
1477: case IF:
1478: case BLOCK:
1479: case PAIR: // ?
1480: return true ;
1481: }
1482: return false ;
1483: }
1484:
1485:
1486:
1487: static void bind_tree_expr_formal(Pname f, Pexpr actual)
1488: {
1489: if (actual->e1->base == TNAME)
1490: error ('i', "a TNAME is not a valid argument for the formal %n",
1491: f) ;
1492: if (is_stmt_node(actual->e1)) {
1493: error ("an expression node was expected for the expression formal parameter %n", f) ;
1494: actual->e1 = zero ;
1495: }
1496: // bind the formal to the expression, it will be accessed from here by
1497: // the hook function during the copy
1498: f->n_initializer = actual->e1 ;
1499: }
1500:
1501:
1502:
1503: // Bind the formals to the types passed in as the actuals, for the
1504: // instantiation, bind the non-type names to their expressions.
1505: void templ_inst::bind_formals()
1506: { Pexpr actual ;
1507: Plist formal ;
1508:
1509: for (formal = inst_formals, actual = actuals ;
1510: formal && actual ; formal = formal->l, actual = actual->e2)
1511: switch (formal->f->n_template_arg) {
1512: case template_type_formal:
1513: {
1514: formal->f->tp = non_template_arg_type(Pbase(actual->e1->tp)) ;
1515: PERM(formal->f->tp) ;
1516: break ;
1517: }
1518:
1519: case template_expr_formal:
1520: {
1521: actual->e1 = actual->e1->typ(gtbl);
1522: if (formal->f->tp->check(actual->e1->tp,ASSIGN) == 1)
1523: error("template argument mismatch, expected %t for formal %n, not %t",
1524: formal->f->tp, formal->f, actual->e1->tp) ;
1525: // hide the global name around decl processing of the formal name
1526: Pname g = gtbl->look (formal->f->string, 0) ;
1527: if (g) g->n_key = HIDDEN ;
1528: // bind the non type arguments to their expressions
1529: // parameters that are bound at syntax analysis, these parameters are
1530: // bound during dcl processing, so ensure that they can be found.
1531: formal->f->n_initializer = actual->e1 ;
1532: formal->f->simpl() ;
1533: formal->f = formal->f->dcl(gtbl, STATIC) ;
1534: formal->f->n_key = HIDDEN ;
1535:
1536: PERM(formal->f) ;
1537: non_template_arg_non_type(formal->f) ;
1538: if (!suitable_const_expr(formal->f))
1539: error("template argument for formal:%s, is not a suitable constant.",
1540: formal->f->string) ;
1541: if (g) g->n_key = 0 ;
1542: break ;
1543: }
1544:
1545: case template_expr_tree_formal:
1546: {
1547: bind_tree_expr_formal(formal->f, actual) ;
1548: break ;
1549: }
1550: case template_stmt_tree_formal:
1551: {
1552: error("a statement tree may not be specified for a class template") ;
1553: break ;
1554: }
1555:
1556: default:
1557: error ('i', "bad template formal") ;
1558: }
1559:
1560: // now that the formals are bound, compute the instantiation string
1561: char *inst_name = instantiation_string() ;
1562: tname->string = instantiation_string() ;
1563:
1564: for (formal = inst_formals; formal ; formal = formal->l)
1565: if (formal->f->n_template_arg_string)
1566: error('i', "attempt to bind a template parameter multiple times") ;
1567: else
1568: formal->f->n_template_arg_string =
1569: strcat(strcpy(calloc(strlen(formal->f->string)+strlen(inst_name)+1,1),
1570: formal->f->string), inst_name) ;
1571: }
1572:
1573:
1574: // Expose the non-type parameter names so that they are visible during decl
1575: // processing. Conflicting global names are hidden, so that they are not
1576: // found.
1577: void templ_inst::expose_parameter_names() {
1578:
1579: if (hidden_globals)
1580: error ('i', "an expose without a hide of global names") ;
1581:
1582: for (Plist formal = inst_formals ; formal ; formal = formal->l)
1583: if (formal->f->n_template_arg == template_expr_formal) {
1584: // Hide any visible globals
1585: Pname gname = gtbl->look(formal->f->string, 0) ;
1586: if (gname) {
1587: // an existing global name, hide it
1588: gname->n_key = HIDDEN ;
1589: // note them for future restoration
1590: hidden_globals = new name_list(gname,hidden_globals);
1591: }
1592: formal->f->n_key = 0 ; // bring it out of hiding
1593: if (formal->f != gtbl->look(formal->f->string,0))
1594: error('i', "parameter could not be located in the global table") ;
1595: }
1596: }
1597:
1598:
1599: // Hide the non-type parameter names after an instantiation, and restore any
1600: // globals that may have been hidden during the process.
1601: void templ_inst::hide_parameter_names() {
1602:
1603: for (Plist formal = inst_formals ; formal ; formal = formal->l)
1604: if (formal->f->n_template_arg == template_expr_formal) {
1605: formal->f->n_key = HIDDEN ;
1606: }
1607: for (; hidden_globals; hidden_globals= hidden_globals->l)
1608: hidden_globals->f->n_key= 0 ;
1609: hidden_globals = 0 ;
1610: }
1611:
1612:
1613:
1614: // Primitives for saving and restoring the compilation state around a template
1615: // instantiation. It also maintains the stack of template instantiations.
1616: void templ_inst::save_state(Pname p) {
1617: if (next_active) error ('i', "circular instantiation of a template") ;
1618: context.save() ;
1619: if (templ_inst::head)
1620: templ_inst::head->hide_parameter_names() ;
1621: next_active = templ_inst::head ; templ_inst::head = this ;
1622: context.init() ;
1623: Cdcl = p ; Cstmt = NULL ;
1624: curr_file = (Cdcl) ? Cdcl->where.file : 0;
1625: expose_parameter_names() ;
1626: }
1627:
1628:
1629: void templ_inst::restore_state() {
1630: context.restore() ;
1631: hide_parameter_names() ;
1632: templ_inst::head = next_active ; next_active = NULL ;
1633: if (templ_inst::head)
1634: templ_inst::head->expose_parameter_names() ;
1635: }
1636:
1637:
1638: // Copy over the class definition subtree starting from COBJ down to the
1639: // CLASSDEF node. This minimal subtree has to exist during syntax analysis,
1640: // and already contains pointers into it.
1641: void templ_inst::kludge_copy(Pbase pbc)
1642: {
1643: // copy just the COBJ ->b_name NAME ->tp CLASS path for now, note that the
1644: // preceding path of the tree is pre-allocated, since syntax analysis needs
1645: // to generate pointers to these objects.
1646: Pbase pb = Pbase(tname->tp) ;
1647: Pname save_b_name = pb->b_name ;
1648: Ptype save_tp = pb->b_name->tp ;
1649:
1650: if ((pb->base != COBJ) || (pbc->base != COBJ))
1651: error ('i', "cobj nodes were expected here") ;
1652:
1653: *pb = *pbc ;
1654: pb->b_name = save_b_name ;
1655: *pb->b_name = *pbc->b_name ;
1656: pb->b_name->tp = save_tp ;
1657: *Pclass(pb->b_name->tp) = *Pclass(pbc->b_name->tp) ;
1658: Pclass(pb->b_name->tp)->class_base = instantiated_template_class ;
1659:
1660: }
1661:
1662:
1663: // these statics probably belong in templ_inst and shouldn't be dangling
1664: // around
1665:
1666: static Pbase cobj_node ;
1667: static Pname cname_node ;
1668: static Pclass class_node ;
1669:
1670: static void syntax_tree_copy_hook(void *,
1671: Pnode &,
1672: node_class,
1673: tree_node_action &action,
1674: int& never_see_again)
1675: {
1676: never_see_again = 1;
1677: action = tna_continue;
1678: return;
1679: }
1680:
1681:
1682: // create a copy of the expression tree
1683: static Pnode copy_syntax_tree(Pnode n, int no_types = 0) {
1684: pointer_hash cht(default_copy_hash_size) ;
1685:
1686: tree_copy_info info ;
1687:
1688: if(no_types) info.node_hook = syntax_tree_copy_hook;
1689:
1690: copy_tree (n, info, &cht);
1691:
1692: return n ;
1693: }
1694:
1695:
1696:
1697: // hook to perform the copying of the pre-allocated class subtree
1698: bool templ_inst::copy_hook(Pnode &node)
1699: {
1700: switch (node->base) {
1701: case COBJ:
1702: if (node == cobj_node) return false ;
1703:
1704: if (node == def->namep->tp) {
1705: *cobj_node = *Pbase(node) ;
1706: node = cobj_node ;
1707: }
1708: break ;
1709: case NAME:
1710: if (node == cname_node) return false ;
1711: if (node == sta_name) return false ;
1712:
1713: if (node == Pbase(def->namep->tp)->b_name) {
1714: *cname_node= *Pname(node) ;
1715: node = cname_node ;
1716: }else { // check for tree expression formals
1717: char *s = Pname(node)->string ;
1718: Pname f = 0 ;
1719: if (s && (*s == '$') && (f = get_parameter(s+1)))
1720: {
1721: if(Pname(node)->n_list)
1722: error ('i', "n_list set in tree template formal.");
1723: node = copy_syntax_tree(Pname(f)->n_initializer) ;
1724: return false ;
1725: }
1726: }
1727: break ;
1728: case CLASS:
1729: if (node == class_node) return false ;
1730:
1731: if (node == Pbase(def->namep->tp)->b_name->tp) {
1732: *class_node = *Pclass(node) ;
1733: node = class_node ;
1734: }
1735: break ;
1736: }
1737: return true ;
1738: }
1739:
1740:
1741: /*
1742:
1743: This hook function used during a class copy.
1744:
1745: */
1746: static void copy_hook(void /* Ptempl_inst */ *p, Pnode &node,
1747: node_class, tree_node_action &action,
1748: int& never_see_again)
1749: {
1750: action = (Ptempl_inst(p)->copy_hook(node) ? tna_continue : tna_stop ) ;
1751: never_see_again = (action != tna_stop);
1752: return ;
1753: }
1754:
1755:
1756:
1757: void establish_class_subtree_correspondence(pointer_hash &h, Pname key_tname,
1758: Pname value_tname)
1759: {
1760: h[int(key_tname)] = int(value_tname) ;
1761: h[int(key_tname->tp)] = int(value_tname->tp) ;
1762: h[int(Pbase(key_tname->tp)->b_name)] =
1763: int(Pbase(value_tname->tp)->b_name) ;
1764: h[int(Pbase(key_tname->tp)->b_name->tp)] =
1765: int(Pbase(value_tname->tp)->b_name->tp) ;
1766: }
1767:
1768:
1769:
1770:
1771: Pcons make_ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs)
1772: {
1773: cons dummy(0,0), *last = &dummy ;
1774:
1775: for (Pcons pc = old_templ_refs ; pc ; pc = pc->cdr) {
1776:
1777: Ptempl_inst t = Ptempl_inst(pc->car) ;
1778: // +**** this doesn't work without class instances of new and delete
1779: // +**** dtor places this onto free_list: ugh
1780: // +**** want to restore this once new/delete isntances are restored
1781: // expr dummy(ELIST, 0, 0) ;
1782: // elist list(&dummy) ;
1783: Pexpr dummy = new expr(ELIST, 0, 0);
1784: elist list(dummy);
1785:
1786: // copy the trees corresponding to the actuals
1787: for (Pexpr actual = t->actuals ; actual ; actual = actual->e2) {
1788: Pnode root = actual->e1 ;
1789: copy_tree (root, info, &h);
1790: // make sure that references to enclosing formals are resolved
1791: root = Pexpr(root)->typ(gtbl);
1792: list.add(new expr(ELIST, Pexpr(root), 0)) ;
1793: }
1794: Pexpr new_actuals = list.head->e2 ;
1795:
1796: // get one if it exists, create one otherwise.
1797: Ptempl_inst treal = t->def->get_inst(new_actuals, t) ;
1798: Pname new_tname = treal->tname ;
1799:
1800: last = last->cdr = new cons(treal,0);
1801:
1802: establish_class_subtree_correspondence(h, t->tname, new_tname) ;
1803: }
1804:
1805: return dummy.cdr ;
1806: }
1807:
1808:
1809:
1810:
1811: /*
1812: Remap the template references from within the body of the template. This
1813: action is similar to the normal tree copy operation; it would normally have
1814: been done during the syntax phase, that produced the tree, but since there
1815: isn't one, for the instantiated body, it must be done here.
1816:
1817: */
1818: Pcons templ_inst::ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs)
1819: {
1820: expose_parameter_names() ;
1821: Pcons new_refs = make_ref_copy(h,info,old_templ_refs) ;
1822: hide_parameter_names() ;
1823: return new_refs ;
1824: }
1825:
1826: static bool is_forward_instantiation(Pbase b_base, Pbase f_base)
1827: {
1828: return bool(b_base->b_name->tp->defined && f_base->b_name->tp->defined) ;
1829: }
1830:
1831:
1832: /*****************************************************************************
1833: * *
1834: * If the template instantiation is found to be unique after the decl *
1835: * processing of the actuals, create a copy of the post syntax graph for the *
1836: * class. The edges of the graph are determined by "type nodes" that have *
1837: * already been defined, and TNAME nodes that are in the global keyword *
1838: * table. Special care is also taken to avoid copying nodes whose identity *
1839: * must be maintained, since cfront uses them for fast type checks, these *
1840: * nodes always have the "defined" flag turned on and so are never copied. *
1841: * *
1842: * Copying of the pre-allocated class sub-tree for the template: COBJ *
1843: * ->b_name NAME ->tp CLASS *
1844: * *
1845: * is handled by the class_copy hook above, that is invoked during the course *
1846: * of the copy. *
1847: * *
1848: * *
1849: * Template references from within the class need special handling, since *
1850: * each instantiation of the class, results in a potentially new template *
1851: * instantiation. *
1852: * *
1853: *****************************************************************************/
1854: Ptempl_inst templ_inst::class_copy(Pcons &templ_refs, bool recopy)
1855: {
1856: bool forward = false ; // a forward class is instantiated twice
1857:
1858: // associate the formals with their types, and their expressions
1859: if (recopy) {
1860: // remove the class def node from the table, so that it's attributes are
1861: // copied.
1862: corr->del(int(Pbase(def->namep->tp)->b_name->tp)) ;
1863: corr->del(int(Pbase(def->namep->tp)->b_name)) ;
1864: corr->del(int(def->namep->tp)) ;
1865:
1866: corr->del(int(tname->tp)) ;
1867: corr->del(int(Pbase(tname->tp)->b_name)) ;
1868: corr->del(int(Pbase(tname->tp)->b_name->tp)) ;
1869: }else corr = new pointer_hash(default_copy_hash_size) ;
1870:
1871: { // copy the formals & install them in the correspondence table
1872: name_list dummy_formal(0,0) ;
1873: Plist last = &dummy_formal ;
1874:
1875: for (Plist formal = def->formals ; formal ; formal = formal->l) {
1876: Pname copy_name = new name("") ;
1877: *copy_name = *formal->f ;
1878: copy_name->n_tbl_list = 0 ;
1879: last = last->l = new name_list(copy_name, 0) ;
1880: (*corr)[int(formal->f)] = (int)copy_name ;
1881: }
1882: inst_formals = dummy_formal.l ;
1883: }
1884:
1885: bind_formals() ;
1886: if ( ! recopy && ktbl->look(tname->string, 0)) {
1887: // formal binding may result in detecting identical instantiations
1888: Ptempl_inst ti = def->get_match(actuals, this, true) ;
1889: if (ti) return ti ;
1890: error('i', "Generated template instantiation name %swas not unique",
1891: tname->string) ;
1892: }
1893:
1894: {
1895: tree_copy_info info ;
1896: info.node_hook = ::copy_hook ;
1897: info.hook_info = this ;
1898:
1899: (*corr)[int(def->namep)] = int(tname) ; // make the tnames correspond
1900:
1901: templ_refs = ref_copy(*corr, info, templ_refs) ;
1902: Pnode root = def->basep ; // start the copy at the cobj node
1903:
1904: // deal with these nodes differently during the copy, ie. the nodes
1905: // themselves are not copied, but their attributes are.
1906: cobj_node = (Pbase)tname->tp ;
1907: cname_node = Pbase( tname->tp)->b_name ;
1908: class_node = Pclass(Pbase( tname->tp)->b_name->tp) ;
1909:
1910: copy_tree (root, info, corr);
1911:
1912: { // dump the tree if the flag is set
1913: extern int dump_tree ;
1914: extern dcn_arg dump_tree_arg;
1915:
1916: if (dump_tree) display_cfront_node (dump_tree_arg, root);
1917: }
1918: }
1919: // Perform name modifications for the class, so that it is an
1920: // instantiation-specific name.
1921: cname_node->string = tname->string ;
1922: if (!recopy)
1923: namep = ktbl->insert(tname, 0) ;
1924: else class_node->defined &= ~(DEFINED|SIMPLIFIED) ;
1925: namep->tp = cobj_node;
1926:
1927: class_node->modify_inst_names(cname_node->string) ;
1928: return 0 ;
1929: }
1930:
1931:
1932: /*
1933: This hook function is responsible for the replacement of references to
1934: expression when copying function bodies
1935: */
1936: static void function_copy_hook(void *current_templ_inst,
1937: Pnode &node,
1938: node_class,
1939: tree_node_action &action,
1940: int& never_see_again)
1941: {
1942: never_see_again = 1;
1943:
1944: switch (node->base) {
1945: case SM_PARAM:
1946: error ('i', "statement parameters not permitted for member functions") ;
1947: break ;
1948:
1949: case NAME:
1950: {
1951: if(node == sta_name) {
1952: action = tna_stop;
1953: return;
1954: }
1955: char *s = Pname(node)->string ;
1956: Pname f = 0 ;
1957: if (s && (*s == '$') &&
1958: (f = Ptempl_inst(current_templ_inst)->get_parameter(s+1))) {
1959: if(Pname(node)->n_list)
1960: error ('i', "n_list set in tree template formal.");
1961: node = copy_syntax_tree(Pname(f)->n_initializer) ;
1962: action = tna_stop ;
1963: never_see_again = 0;
1964: }else action = tna_continue ;
1965: return ;
1966: }
1967: default:
1968: action = tna_continue ;
1969: return ;
1970: }
1971: }
1972:
1973:
1974:
1975: /*
1976:
1977: Create a copy of a function member, as part of the instantiation of a function
1978: body. The correspondence table is first initialized with the contents of the
1979: correspondence table used to instantiate the class. Copying is initiated
1980: in this context.
1981:
1982: */
1983:
1984: Pname templ_inst::function_copy(Pfunt fnt, Pcons &templ_refs)
1985: {
1986: pointer_hash fcorr(*corr) ; // initialize it with the old hash table
1987:
1988: {
1989: tree_copy_info info ;
1990: Pnode root = fnt->fn ;
1991:
1992: // establish a correspondence between the formals used for the class
1993: // template, andthe formals used for the function template, all references
1994: // to the function template formals will be replaced by references to the
1995: // instantiated class template formals after the copy has been completed.
1996:
1997: for (Plist fformal = fnt->formals, cformal = inst_formals ;
1998: fformal ; fformal = fformal->l, cformal = cformal->l)
1999: {
2000: fcorr[int(fformal->f)] = int(cformal->f) ;
2001: if (fcorr[int(fformal->f)] != int(cformal->f))
2002: error ('i', "hash table bug") ;
2003: }
2004:
2005: info.node_hook = ::function_copy_hook ;
2006: info.hook_info = this ;
2007:
2008: templ_refs = ref_copy(fcorr, info, templ_refs) ;
2009: if (fcorr[int(def->namep)] != int(tname))
2010: error ('i', "template to instantiation typename correspondence is missing") ;
2011:
2012: copy_tree (root, info, &fcorr);
2013:
2014: { // dump the tree if the flag is set
2015: extern int dump_tree ;
2016: extern dcn_arg dump_tree_arg;
2017:
2018: if (dump_tree)
2019: display_cfront_node (dump_tree_arg, root);
2020: }
2021: return Pname(root) ;
2022: }
2023: }
2024:
2025:
2026: /*****************************************************************************
2027: * *
2028: * A matching template was found at instantiation time, which was not *
2029: * detected at syntax analysis time. This can happen, when an instantiation *
2030: * has as its arguments not real types but template arguments, so that *
2031: * matches cannot be detected until the templates are bound. Note that it is *
2032: * also possible to match a template that is in the process of being *
2033: * instantiated further up the instantiation call chain. In such cases, the *
2034: * kludge_copy operation will copy over an incomplete class subtree, which *
2035: * will be recopied with the completed one after the instantiation is *
2036: * completed, in templ_inst::instantiate. *
2037: * *
2038: *****************************************************************************/
2039: void templ_inst::instantiate_match(Ptempl_inst match)
2040: { Pbase pb = Pbase(match->tname->tp) ;
2041: kludge_copy(pb) ;
2042: forward = match ; // Note the fact that this template was matched
2043: }
2044:
2045:
2046: Pclass current_instantiation = 0 ;
2047:
2048: // Do the class declaration instantiation.
2049: void templ_inst::instantiate(bool reinstantiate)
2050: {
2051: Pcons templ_refs = def->templ_refs ;
2052: if (! reinstantiate) {
2053: switch (Ptclass(Pbase(tname->tp)->b_name->tp)->class_base) {
2054: case instantiated_template_class:
2055: return ;
2056: case uninstantiated_template_class:
2057: break ;
2058: case vanilla_class:
2059: case template_class: // the canonical template class
2060: default:
2061: error ('i', "attempt to instantiate a non-template class") ;
2062: }
2063: status = class_instantiated ;
2064: // Check whether, the template has already been instantiated, if so use it.
2065: forward_template_arg_types(def->formals, actuals) ;
2066: Ptempl_inst match = def->get_match(actuals, this, true) ;
2067:
2068: if (match || (match = class_copy(templ_refs, false))){
2069: instantiate_match(match) ;
2070: return ;
2071: }
2072: }else class_copy(templ_refs, true) ;
2073:
2074: Pbase pb = Pbase(tname->tp) ;
2075:
2076: // Save the state around decl processing
2077: { save_state(def->namep) ;
2078:
2079: if (def->open_instantiations++ > 1) {
2080: error ("an infinite instantiation sequence was initiated") ;
2081: def->open_instantiations-- ;
2082: return ;
2083: }
2084: // Mark the class as instantiated so that there are no circular
2085: // instantiations.
2086: Pclass(pb->b_name->tp)->class_base = instantiated_template_class ;
2087:
2088: // if it is a forward reference, rely on the usual compilation to
2089: // provide an error message, if indeed it is an error, and not a
2090: // benign forward reference such as: friend class foo<X,Y>
2091:
2092: if (def->basep->b_name->tp->defined) {
2093:
2094: // Put out the typedefs for the template parameters do this before the
2095: // call to name::dcl below, since dcl processing will emit c declarations
2096: // that make use of the type
2097: for (Plist formal = inst_formals; formal ; formal = formal->l)
2098: switch(formal->f->n_template_arg) {
2099: case template_expr_tree_formal:
2100: case template_stmt_tree_formal:
2101: break ;
2102: default:
2103: formal->f->dcl_print(0) ;
2104: }
2105: // Instantiate the parametrized types referenced by this template
2106: for (Pcons pc = templ_refs ; pc ; pc = pc->cdr)
2107: Ptempl_inst(pc->car)->instantiate() ;
2108:
2109: if (!((pb->b_name->dcl(gtbl, EXTERN) == 0 ) || error_count)) {
2110: pb->b_name->simpl() ;
2111:
2112: if (pb->b_name->tp->base != CLASS)
2113: error('i', "a classdef was expected in templ_inst::instantiate") ;
2114:
2115: current_instantiation = Pclass(pb->b_name->tp) ;
2116: pb->b_name->dcl_print(0) ;
2117: if (! (pb->b_name->tp->defined & DEFINED))
2118: error ('i', "dcl class is not yet defined") ;
2119: current_instantiation = 0 ;
2120: }
2121: }
2122:
2123: // bash every template instantiation class that has been forwarded to
2124: // it, with the decl processed version.
2125: for (Ptempl_inst clone = def->insts ; clone ; clone = clone->next)
2126: if (clone != this) {
2127: if (clone->forward == this)
2128: clone->kludge_copy(Pbase(tname->tp)) ;
2129: else {
2130: // resolve references to forward declarations
2131: if (this == def->get_match(clone->actuals, clone, true)) {
2132: clone->kludge_copy(Pbase(tname->tp)) ;
2133: clone->forward = this ;
2134: }
2135: }
2136: }
2137: Pclass result = Pclass(pb->b_name->tp);
2138:
2139: // dcl_print the member functions, so that they can be referenced
2140: int i = 0 ;
2141: for (Pname fn= Pclass(pb->b_name->tp)->memtbl->get_mem(i=1); fn;
2142: fn=Pclass(pb->b_name->tp)->memtbl->get_mem(++i))
2143: if ((fn->base == NAME) && (fn->tp->base == FCT))
2144: fn->dcl_print(0) ;
2145:
2146: restore_state() ;
2147: def->open_instantiations-- ;
2148: }
2149: }
2150:
2151: /* Template Constructors */
2152:
2153:
2154: templ::templ(Plist parms, Pname p) {
2155: namep = p ;
2156: formals = parms ;
2157:
2158: if (!formals) error ("a parametrized type must have parameters !") ;
2159:
2160: basep = Pbase(namep->tp) ;
2161:
2162: Pclass(basep->b_name->tp)->class_base = template_class ;
2163: defined = ((basep->b_name->tp->defined & DEF_SEEN) ? true : false) ;
2164: if (defined)
2165: members = Pclass(basep->b_name->tp)->mem_list ;
2166:
2167: PERM(namep) ; PERM(namep->tp) ;
2168: // Chain on to the list of templates for the compilation.
2169: next = templp->list ;
2170: templp->list = this ;
2171: }
2172:
2173:
2174: templ_inst::templ_inst (Pexpr act, Ptempl owner)
2175: {
2176: // Set up the basetype for the class, so that nodes that need to point to it
2177: // during syntax processing can do so. Theese objects are merely
2178: // place-holders during syntax analysis, and are actually filled in during
2179: // the copy phase of instantiation.
2180: Pclass c ;
2181:
2182: def = owner ;
2183: tname = new name(def->namep->string) ;
2184: tname->base = TNAME ;
2185: tname->tp = new basetype(COBJ, new name(def->namep->string)) ;
2186: Pbase(tname->tp)->b_name->tp = c = new templ_classdef(this) ;
2187: PERM(tname) ; PERM(tname->tp) ; PERM(Pbase(tname->tp)->b_name) ;
2188: PERM(Pbase(tname->tp)->b_name->tp) ;
2189:
2190: // initialize the member list so that set_scope can do the right thing
2191: c->mem_list = Pclass(def->basetype()->b_name->tp)->mem_list ;
2192:
2193: actuals = act ;
2194: next = owner->insts ;
2195: owner->insts = this ;
2196: }
2197:
2198:
2199: templ_classdef::templ_classdef(Ptempl_inst i): classdef(CLASS) {
2200: inst = i ;
2201: class_base = uninstantiated_template_class ;
2202: string = unparametrized_tname()->string ;
2203: }
2204:
2205:
2206: // Create a new function template.
2207: function_template::function_template (templ &owner, Plist params, Pname n)
2208: {
2209: definition_number = ++definition_tick ;
2210:
2211: if (owner.fns_end)
2212: owner.fns_end->next = this ;
2213: else owner.fns = this ;
2214: owner.fns_end = this ;
2215: formals = params ;
2216: fn = n ;
2217: PERM(n) ; PERM(n->tp) ;
2218: }
2219:
2220:
2221: // create the tree template
2222: tree_template::tree_template(TOK tree_kind, char *s, Plist params, Pnode tree,
2223: Pcons references)
2224: {
2225: string = s ;
2226: formals = params;
2227: e = tree ;
2228: if (!e)
2229: error('w', "the internal template %s does not have an associated body", s);
2230: templ_refs = references ;
2231: kind = tree_kind ;
2232:
2233: // add the expression template too the list of known templates
2234: if (get(s)) {
2235: error ("duplicate definition of the internal template %s", s) ;
2236: return ;
2237: }
2238: // link it in
2239: next = templ_compilation::tree_templates ;
2240: templ_compilation::tree_templates = this ;
2241:
2242: // check that formals weren't misspelt
2243: for (Plist formal = formals ; formal ; formal = formal->l)
2244: if (! formal->f->n_used)
2245: error('w', "the formal parameter %n was not referenced within the template body",formal->f) ;
2246: }
2247:
2248:
2249: // lookup an internal expression template
2250: Ptreet tree_template::get(char *s) {
2251: for (Ptreet o = templ_compilation::tree_templates ; o ; o = o->next)
2252: if (strcmp(o->string, s) == 0) return o ;
2253: return 0 ;
2254: }
2255:
2256:
2257: Pname tree_template::get_parameter(char *s) {
2258: for (Plist formal = formals ; formal ; formal = formal->l) {
2259: if (strcmp(formal->f->string, s)== 0)
2260: return formal->f ;
2261: }
2262: return 0 ;
2263: }
2264:
2265:
2266:
2267: // Sam: some remodularization seems to be in order here, so that this method
2268: // can be shared
2269: Pname templ_inst::get_parameter(char *s) {
2270: for (Plist formal = inst_formals ; formal ; formal = formal->l) {
2271: if (strcmp(formal->f->string, s)== 0)
2272: return formal->f ;
2273: }
2274: return 0 ;
2275: }
2276:
2277: Pexpr tree_template::expand(Pexpr)
2278: {
2279: error('i', "no support for tree templates") ;
2280: return 0 ;
2281: }
2282:
2283:
2284: // Instantiate each function member body. It assumes that the class
2285: // declaration has been instantiated. The return value indicates whether an
2286: // instantiation of bodies actually took place. This function is only invoked
2287: // at the end of a file compilation, after all source text has been processed.
2288: bool templ::instantiate_bodies(){
2289: bool change = false ;
2290: // Perform the instantiation of the member function bodies.
2291: if (!fns) return change ;
2292:
2293: for (Ptempl_inst inst = insts ; inst ; inst = inst->next)
2294: if (!inst->forward && (inst->status == class_instantiated)) {
2295: // Set up the environment for the declaration, and subsequent compilation
2296: // of the function bodies.
2297: inst->status = body_instantiated ; change = true ;
2298:
2299: { Pclass ic = inst->get_class() ; int i ;
2300: // note all the overriding definitions explicitly provided by the user
2301: for (Pname fn= ic->memtbl->get_mem(i=1); fn; fn=ic->memtbl->get_mem(++i))
2302: if ((fn->base == NAME) && (fn->tp->base == FCT) && Pfct(fn->tp)->body)
2303: fn->n_redefined = 1 ;
2304: }
2305:
2306: for (Pfunt fnt = fns; fnt ; fnt = fnt->next) {
2307: Pcons templ_ref_copy = fnt->templ_refs ;
2308: Pname fn = inst->function_copy(fnt, templ_ref_copy) ;
2309:
2310: // Change the qualifier to be the name of the instantiated, rather than
2311: // the parametrized class name
2312: fn->n_qualifier = inst->namep ;
2313: if (fn->n_oper != TYPE ) // cond contains type information
2314: fn->n_table = 0;
2315: fn->n_tbl_list = 0 ;
2316:
2317: // Note that the formals were bound to the actuals when the class decl
2318: // was instantiated, so the binding is not redone.
2319:
2320: // Modify constructor and destructor names.
2321: if (!strcmp(fn->string, namep->string))
2322: fn->string = inst->namep->string ;
2323: { inst->save_state(fn) ;
2324: // Instantiate the parametrized types referenced by this template
2325: for (Pcons pc = templ_ref_copy ; pc ; pc = pc->cdr)
2326: Ptempl_inst(pc->car)->instantiate() ;
2327:
2328: // ensure that "type type" formals constrained to be class definitions are
2329: if (!fnt->check_constraints(inst->actuals))continue ;
2330:
2331: if ( ((fn = fn->dcl(gtbl, EXTERN)) == 0) || error_count) {
2332: inst->restore_state() ;
2333: continue ;
2334: }
2335: fn->simpl() ;
2336: fn->dcl_print(0) ;
2337: inst->restore_state() ;
2338: }
2339: }
2340: }
2341: return change ;
2342: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.