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