![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to template.h 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.h CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /* -*- Mode:C++ -*- */
2: /*
3: $Source: /usr3/lang/benson/work/stripped_cfront/RCS/template.h,v $ $RCSfile: template.h,v $
4: $Revision: 1.4 $ $Date: 90/04/02 11:31:35 $
5: $Author: sam $ $Locker: $
6: $State: Exp $
7: */
8: /*
9: $Header: /usr3/lang/benson/work/stripped_cfront/RCS/template.h,v 1.4 90/04/02 11:31:35 sam Exp $
10:
11: Copyright 1989 by Object Design, Inc., Burlington, Mass.
12: All rights reserved.
13:
14: */
15:
16:
17: /*****************************************************************************
18: * *
19: * This file contains types pertinent to the implementation of the *
20: * parametrized type facility. *
21: * *
22: *****************************************************************************/
23:
24: enum bool { true = 1, false = 0 } ;
25:
26: typedef class templ *Ptempl ;
27:
28: typedef class templ_inst *Ptempl_inst ;
29:
30: typedef class function_template *Pfunt ;
31:
32: typedef class templ_classdef *Ptclass ;
33:
34: typedef class tree_template *Ptreet ;
35:
36:
37: // A Lisp style cons cell to help build lists. The parametrized type facility,
38: // should obviate the need for this type-unsafe nonsense.
39: class cons {
40: public:
41: void *car ;
42: cons *cdr ;
43: cons (void *pcar, cons *pcdr) { car = pcar ; cdr = pcdr ; } ;
44: } ;
45:
46: typedef cons *Pcons ;
47:
48:
49:
50: /*****************************************************************************
51: * *
52: * The class template_compilation holds the state, and the associated methods *
53: * used during template compilation. There is exactly one instance of the *
54: * type, it is mainly a device used to enforce modularity. In reality, it *
55: * would never need to be instantiated since all it's members are static. *
56: * However, since the type::mem for of reference is not supported as *
57: * yet(cfront 1.2), we need an instantiation to get to the members via *
58: * pointer syntax instead. *
59: * *
60: * A templ_compilation holds the state relevant to the syntax analysis of a *
61: * class or member function template definition. *
62: * *
63: *****************************************************************************/
64:
65: class templ_compilation {
66: static Plist param_end, // make append easier
67: param_tn ; // The type names introduced by the parameters
68:
69: public:
70: static Ptempl list ; // The list of templates for the compilation
71: static Plist params ; // The list of parameters to the template
72: static Ptempl owner ; // The template when compiling a member
73: // function.
74: static table *templates ; // The templates defined during this compilation
75:
76: static Ptreet tree_templates; // The list of tree templates
77:
78: static bool in_progress; // a template compilation is in progress
79: // instantiation parameter parsing in progress. Used in the lexer to ensure
80: // that name string are consed in the heap, rather than being retained as
81: // pointers into the lex buffer.
82: static int parameters_in_progress ;
83:
84: // the list of templates referenced by the top level definition being compiled.
85: static Pcons templ_refs ;
86: static Pcons last_cons ;
87: static Ptype any_type ; // canonical "ANY" type for formal parms
88:
89: // true, if currently compiling an expression tree template
90: static TOK curr_tree_template ;
91:
92: void append_ref(Ptempl_inst ref) ;
93: void start() ;
94:
95: void collect(TOK parm_type, Pname namep) ;
96: void collect(Pname namep) ;
97:
98: void enter_parameters() ;
99: void introduce_class_templ(Pname cnamep) ;
100: void end(Pname class_name) ;
101: Pname forward_declaration(Pname class_name) ;
102: void instantiate_ref_templ() ;
103: void clear_ref_templ() ;
104:
105: Pname check_tname(Pname p) ;
106: bool current_template(Pname p, Pexpr actuals) ;
107: Ptempl is_template(Pname p) ;
108: Ptempl is_template(char *s);
109: void end_of_compilation() ; // Done with compilation, instantiate bodies
110: templ_compilation() ;
111:
112: static Pname tree_parameter(char *s) ; // return true if the name is a tree parameter
113:
114: private:
115: void append_parameter(Pname p) ;
116:
117: } ;
118:
119:
120:
121: // The canonical template_compilation instance. templ_compilation exists as a
122: // class simply to provide a code and data packaging mechanism. There is
123: // exactly one generated instance of it.
124:
125: extern templ_compilation *templp ;
126:
127: // should actually be static member functions of templ_compilation
128: Pname parametrized_typename (Pname p, Pexpr actuals) ;
129: Pbase parametrized_basetype (Pname p, Pexpr actuals) ;
130:
131:
132:
133:
134: // the basis for class and member function templates
135: class basic_template {
136: friend templ_compilation ;
137: protected:
138: Plist formals ; // The formal arguments to the template
139: Pcons templ_refs ; // The templates referenced by this template
140:
141: // check class constraints placed on formals while processing member
142: // function bodies.
143: bool check_constraints(Pexpr actuals) ;
144:
145: // ensure that use of formals is consistent across, class, member and
146: // forward declarations
147: void check_formals(Plist formals) ;
148:
149: public:
150: // used to order template class definitions for instantiations. Not being
151: // used as yet.
152: int definition_number ;
153:
154: // used to generate the definition numbers, used by the above member.
155: static int definition_tick ;
156:
157: Plist get_formals() {return formals ;}
158: } ;
159:
160:
161:
162: // the template for a class
163: class templ : public basic_template {
164: Pbase basep ; // COBJ basetype for the template
165: Ptempl_inst insts ; // instantiations of the template
166: Pfunt fns ; // member function declarations
167: Pfunt fns_end ; // last fun in the above list
168:
169: // Use these state variables to set up the correct state for error
170: // processing. They are used by the "error" routines for statement numbers.
171: Pname Cdcl ;
172: Pstmt Cstmt ;
173:
174: friend templ_inst ;
175: friend function_template ;
176:
177: // used to detect loops during instantiation; a count greater than two is
178: // indicative of a non-terminating instantiation sequence
179: int open_instantiations ;
180:
181: Ptempl_inst get_match(Pexpr actuals,
182: Ptempl_inst exclude,
183: bool match_instantiated_only) ;
184: bool check_actual_args (Pexpr actuals) ;
185:
186: public:
187: Ptempl next ; // connects all the class templates in the comp
188: Pname namep ; // the TNAME for the template class
189: bool defined ; // the actual definition, not just a forward
190: // declaration has been seen.
191:
192: Pname members ; // note the members to catch redefinition errors
193:
194: Ptempl_inst get_inst(Pexpr actuals, Ptempl_inst exclude = 0) ;
195: templ(Plist parms, Pname p) ;
196: void resolve_forward_decl(Plist parms, Pclass c) ;
197: void instantiate_forward_decl() ;
198:
199: // The uninstantiated base type
200: Pbase basetype() {return basep; }
201: // The basetype for a specific instantiation
202: Pbase inst_basetype(Pexpr actuals) ;
203:
204: Pname typename(Pexpr actuals) ;
205:
206: Pfunt collect_function_member(Pname fname) ;
207: bool has_tree_expr_formals() ;
208: bool instantiate_bodies() ;
209: } ;
210:
211:
212:
213: // Member function templates
214: class function_template : public basic_template {
215: Pname fn ; // The name of the member function
216: Pfunt next ; // connects the list of member functions
217:
218: friend templ ;
219: friend templ_inst ;
220:
221: public:
222: function_template (templ & owner, Plist params, Pname n) ;
223: } ;
224:
225:
226:
227: // compiler internal expression templates, used to implement Objectstore constructs
228: class tree_template : public basic_template {
229: TOK kind ; // STATEMENT or EXPRESSION
230: Pnode e ; // the post-syntax tree representing the
231: // expression or statement constituting the
232: // template.
233: Ptreet next ; // the next expression template
234: static int count ; // the number of instantiations
235:
236: public:
237: char *string ; // the name used for template lookup
238: tree_template(TOK tree_kind, char *s, Plist params, Pnode tree,
239: Pcons references) ;
240: static Ptreet get(char *s) ;
241: Pname get_parameter(char *s) ;
242: static void test() ;
243: Pexpr expand(Pexpr actuals) ;
244: } ;
245:
246:
247:
248:
249: // Global state variables that must be saved around an instantiation. The
250: // saving of state was required in the implementstion that interspersed decl
251: // processing and instantiation, rather than the current strategy, which only
252: // forces instantiations at the top level outside of any dcl-processing
253: // context. It is retained in case we ever go back to the "interspersed" style
254: // of instantiation.
255: class state {
256:
257: public:
258: Pname Cdcl ; // the global variables used by the error routines
259: Pstmt Cstmt ;
260: Pname dcl_list ; // Holds the list of typedef names that are hidden
261: Loc curloc ;
262:
263: int curr_file ;
264: Pexpr curr_expr ;
265: Pin curr_icall ;
266: Pstmt curr_loop;
267: Pblock curr_block;
268: Pstmt curr_switch;
269:
270: int bound ;
271: int inline_restr ;
272: Loc last_line ;
273:
274: int no_of_badcall;
275: int no_of_undcl ;
276:
277: Pname badcall ;
278: Pname undcl ;
279:
280: state() {} ; // prevent used before set warnings.
281: void save() ;
282:
283: void init() ;
284: void restore() ;
285: } ;
286:
287:
288: class pointer_hash ;
289: class tree_copy_info ;
290:
291:
292: // A template starts out being uninstantiated, and is class_instantiated when
293: // there is a refrence to it with actual arguments. It is body_instantiated at
294: // the end of compilation, when all its function members are instantiated.
295: enum inst_status { uninstantiated, class_instantiated, body_instantiated };
296:
297: // templ_inst captures the arguments used in the instantiation of a template.
298: // These instantiations are rooted in the templ object.
299: class templ_inst {
300:
301: friend class template_instantiation ;
302:
303: Pname tname ; // The instantiation name, it is the TNAME that
304: // leads up to an actual instantiation of the class
305: Pname namep ; // The version of TNAME in the ktbl
306: Pexpr actuals ; // instantiation arguments, chained using ELIST
307: // as an expression "cons" node, e1 is the car
308: // and e2 the cdr. The car points to a name node.
309: Ptempl_inst next ; // The linked list of instantiations for this
310: // template.
311: Ptempl_inst next_active ; // The list of currently active instantiations.
312: state context ; // the context of this instantiation
313: Ptempl_inst forward ; // This instantiation is the same as the one
314: // pointed to.
315:
316: // Contains the list of global names that are hidden during an
317: // instantiation.
318: Plist hidden_globals ;
319:
320: // The class correspondence table. This table is initialized
321: // when the class definition is instantiated. Subsequently, it is used to
322: // initial member correspondence tables before the copy process is
323: // initiated.
324: pointer_hash *corr ;
325:
326: // the instantiation's copy of the formals
327: Plist inst_formals ;
328:
329: inst_status status ;
330:
331: friend class templ ;
332: friend class templ_classdef ;
333: friend class tree_template ;
334: friend Pcons make_ref_copy(pointer_hash &h, tree_copy_info &info,
335: Pcons old_templ_refs);
336:
337: templ_inst (Pexpr act, Ptempl owner) ;
338: bool actuals_match(Pexpr check_actuals) ;
339: void instantiate_match(Ptempl_inst match) ;
340: void kludge_copy(Pbase source_base) ;
341: // create a copy of the class type subtree preparatory to the ensuing
342: // instantiation. Return a non-zero value, only if there was no need to
343: // create a copy, ie. an identical instantiation already existed.
344: Ptempl_inst class_copy(Pcons &templ_refs, bool recopy) ;
345: Pcons ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs) ;
346:
347: // save and restore state around the template instantiation
348: void save_state(Pname p) ;
349: void restore_state() ;
350:
351: // Used to collect references to this template by a definition
352: Ptempl_inst note_ref() ;
353: char *instantiation_string() ;
354:
355: void expose_parameter_names() ;
356: void hide_parameter_names() ;
357:
358: public:
359: Ptempl def ; // The template definition, for which this is an
360: // instantiation.
361: bool refp ; // A flag used to note template references during
362: // a C++ definition
363: void print_error_loc() ; // Wants to be a static function
364: // Bind the formals before an instantiation
365: void bind_formals() ;
366:
367: Ptempl_inst canonical_instantiation() {
368: return ( forward ? forward : this ) ;
369: }
370:
371: // get the class associated with this instantiation
372: Pclass get_class() { return Pclass(Pbase(tname->tp)->b_name->tp) ;}
373:
374: void instantiate(bool reinstantiate = false) ;
375: static Ptempl_inst head ; // Head of the list of active instantiations.
376: void print_pretty_name() ;
377: char *mangled_name(char *buffer) ;
378: // The uninstantiated basetype
379: Pbase def_basetype() { return def->basep ; } ;
380: // A general way of determining whether two template instantiations are
381: // the same
382: bool same(Ptempl_inst t) ;
383: bool copy_hook(Pnode&) ;
384: // return a copy of the function tree starting with it's name
385: Pname function_copy(Pfunt fnt, Pcons &templ_refs) ;
386:
387: // special check for instantiations used in qualifiers for template function
388: // member declarations.
389: bool check_qualifier(Plist formals) ;
390: Pname get_parameter(char *s) ;
391: } ;
392:
393:
394:
395: // Experimental debugging toggle
396: extern int zdebug ;
397:
398:
399: // The class node used for template classes.
400: // Rep invariant:
401: // class_base == uninstantiated_template_class ||
402: // class_base == instantiated_template_class
403:
404: class templ_classdef : public classdef {
405: public:
406: Ptempl_inst inst ; // a pointer to the instantiation; the
407: // instantiation also points back to it via
408: // the tname ->cobj->name->class path
409: templ_classdef(Ptempl_inst i) ;
410: Pname unparametrized_tname() { return inst->def->namep ; }
411: void instantiate() { inst->instantiate() ; }
412:
413: } ;
414:
415:
416: // Safe accessor functions for navigating through COBJ base classes
417:
418: extern class_type_enum get_class_base (Pbase b) ;
419:
420: extern Ptclass get_template_class (Pbase b) ;
421:
422: extern Ptempl_inst get_templ_inst(Pbase b) ;
423:
424:
425: /*
426: $Log: template.h,v $
427: * Revision 1.4 90/04/02 11:31:35 sam
428: * Made comments current.
429: *
430: * Revision 1.3 90/03/30 18:50:55 sam
431: * 1) Added the introduce_class_templ member function to the templ_compilation
432: * class.
433: * 2) Rationalized the definition of class templ. Made basic_template be it's
434: * base class, instead of type. The latter was the base type, simply so that
435: * it could be stored in a table associating strings with types. Don't have
436: * to resolve to such kludgery in the PT world.
437: * 3) Added the member open_instantiations to detect non-terminating
438: * instantiations
439: *
440: * Revision 1.2 90/03/27 10:16:27 sam
441: * > Merged in revision 1.13 from the main line of development
442: *
443: * Revision 1.1 89/11/20 08:50:58 benson
444: * Initial revision
445: *
446: * Revision 1.11 89/10/16 15:25:00 sam
447: * use pointer_hash rather than Hash as the type of the correspondence table.
448: *
449: * Revision 1.10 89/09/26 16:44:34 sam
450: * fix the forward declaration of template classes
451: *
452: * Revision 1.9 89/09/18 16:37:37 sam
453: * provide for error recovery upon argument mismatch in a template instantiation
454: *
455: *
456: * Revision 1.8 89/09/15 09:31:50 benson
457: * move tree_template.string into the public section.
458: *
459: * Revision 1.7 89/08/30 13:02:12 sam
460: * added support for dealing with __expressions in class formal templates
461: *
462: * Revision 1.6 89/08/28 09:42:05 sam
463: * Support for nested references in internal templates. These nested
464: * references are instantiated whenever an expansion takes place.
465: *
466: * Revision 1.5 89/08/23 10:26:00 sam
467: * support for BS style formal syntax. refer to 1.5 templates.c for more
468: * detailed comments.
469: *
470: * Revision 1.4 89/08/11 14:57:09 sam
471: * implementation of multiple instantiation templates.
472: *
473: * Revision 1.3 89/07/27 11:33:40 sam
474: * the comments in template.c 1.3 describe the modifications.
475: *
476: * Revision 1.2 89/07/07 14:34:11 sam
477: * Added the templ_classdef::unparametrized_type_name() function member, as part
478: * of the base init fix.
479: *
480: * Revision 1.1 89/06/29 09:21:32 benson
481: * Initial revision
482: *
483: * Revision 1.1 89/06/22 16:29:29 sam
484: * Initial revision
485: *
486:
487:
488: end_log
489: */
490:
491:
492:
493: /*
494: $Log $
495:
496:
497: end_log
498: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.