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