File contents

/*ident	"@(#)cls4:src/template.h	1.12" */
/*******************************************************************************
 
C++ source for the C++ Language System, Release 3.0.  This product
is a new release of the original cfront developed in the computer
science research center of AT&T Bell Laboratories.

Copyright (c) 1993  UNIX System Laboratories, Inc.
Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
Copyright (c) 1984, 1989, 1990 AT&T.  All Rights Reserved.

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
Laboratories, Inc.  The copyright notice above does not evidence
any actual or intended publication of such source code.

*******************************************************************************/
/******************************************************************************
*    Copyright (c) 1989 by Object Design, Inc., Burlington, Mass.
*    All rights reserved.
*******************************************************************************/

enum bool { false, true };
extern Pclass current_instantiation;
extern Pfct current_fct_instantiation;

// typedef unsigned char uchar; // sun's types.h: u_char
typedef class templ *Ptempl;
typedef class funct_inst *Pfunct_inst;
typedef class templ_inst *Ptempl_inst;
typedef class basic_inst *Pbase_inst;
typedef class basic_template *Ptempl_base;
typedef class function_template *Pfunt;
typedef class data_template *Pdata;
typedef class templ_state *Ptstate;
typedef class templ_classdef *Ptclass;
typedef class templ_fct *Ptfct;
typedef class Pslot *Pbinding;
typedef class cons *Pcons;

class cons {
/* A Lisp style cons cell to help build lists. 
 * The parameterized type facility should obviate 
 * the need for this type-unsafe nonsense. */
public:
  	void *car;
  	cons *cdr;
  	cons(void *pcar, cons *pcdr) { car=pcar; cdr=pcdr; };
};

/*****************************************************************************
* 									     *
* The class template_compilation holds the state, and the associated methods *
* used during template compilation. There is exactly one instance of the     *
* type, it is mainly a device used to enforce modularity.  In reality, it    *
* would never need to be instantiated since all it's members are static.     *
* However, since the type::mem for a reference is not supported as	     *
* yet(cfront 1.2), we need an instantiation to get to the members via	     *
* pointer syntax instead.						     *
* 									     *
*	***** should change to pure static class *****			     *
* 									     *
* A templ_compilation holds the state relevant to the syntax analysis of a   *
* class or member function template definition.				     *
* 									     *
*****************************************************************************/

/*****************************************************************************
* will merge class and function handling by having owner be a basic template *
* pointer -- first, let's get functions up and running.  then do it right    *
*****************************************************************************/

class templ_state {
/* save relevant information when parsing friend 
 * template within a class: currently, only instance
 * where a nested template can occur */
public:
	templ_state(); // save
	~templ_state(); // restore
private:
  	Plist param_end;  
  	Plist params;    
  	Pcons templ_refs; 
  	Pcons friend_templ_refs; 
  	Pcons last_cons;
  	Pcons last_friend_cons;
	Ptempl owner;
};

class templ_compilation {
/* A templ_compilation holds the state relevant to the syntax 
 * analysis of a class or member function template definition.				     *
 * There is exactly one instance of the type.  It mainly serves
 * as a device used to enforce modularity. */
public:
  	static Plist param_end;   // make append easier
  	static Ptempl  list;      // list of class templates for compilation
  	static Pfunt   f_list;    // list of function templates for compilation
  	static Pfunt   f_owner;   // template when compiling a function
  	static Ptempl  owner;     // template when compiling a member function
  	static Ptempl_base parsed_template; // template immediately parsed

  	static Plist   params;    // list of parameters to the template
  	static Pexpr   actuals;   // list of actuals for explicit class template
  	static Ptable  templates; // templates defined during compilation

  	static bool    in_progress; 
  	static Ptstate save_templ;

  	/* instantiation parameter parsing in progress. Used in the lexer 
         * to ensure that name string are consed in the heap, rather than 
         * being retained as pointers into the lex buffer. */
  	static int     parameters_in_progress;
  	static bool    formals_in_progress;

  	// the list of templates referenced by the top level definition being compiled.
  	static Pcons   templ_refs; 
  	static Pcons   friend_templ_refs; 
  	static Pcons   last_cons;
  	static Pcons   last_friend_cons;
  
  	void start(); // initialize templ_compilation state
  	void end(Pname class_name);
  	void end_of_compilation(); // Done with compilation, instantiate bodies

  	Pname forward_declaration(Pname class_name);
  	void introduce_class_templ(Pname cnamep);
  	void introduce_funct_templ(Pname fnamep);

  	void append_ref(Ptempl_inst ref); // add to templ_refs
  	void append_friend_ref(Ptempl_inst ref); // add to friend_templ_refs
  	void instantiate_ref_templ(); // instantiate templ_refs 
  	void clear_ref_templ(); // zero-out templ_refs
  	void clear_friend_ref_templ(); // zero-out friend_templ_refs

  	void collect(TOK parm_type, Pname namep); // collect type parameter
  	void collect(Pname); // collect expression parameter
  	void append_parameter(Pname); // place them in params
  	void enter_parameters();
  	int get_formals_count(); // how many formals

  	Pname check_tname(Pname p);
 	bool  current_template(Pname p, Pexpr actuals);
	bool  friend_template(Pexpr actuals);
  	Ptempl is_template(Pname);
  	Ptempl is_template(char*);
  	Pfunt  is_template(char*,TOK);
};

/* 
 * The canonical template_compilation instance. 
 * templ_compilation exists as a class simply to provide 
 * a code and data packaging mechanism. 
 * There is exactly one generated instance of it. 
 */
extern templ_compilation *templp;

// should actually be static member functions of templ_compilation
Pname parametrized_typename (Pname p, Pexpr actuals, bit=0) ;
Pbase parametrized_basetype (Pname p, Pexpr actuals) ;

void check_formals_for_dups(Plist formals);
void check_funct_formals(Plist formals, Pname namep);

class basic_template {
/* the basis for class and member function templates */
  	friend class templ_compilation;
	friend void display_templ_refs( basic_template* );
	friend void handle_bound_friend( Ptempl_base, Pname );
protected:
  	Plist       formals;        // The formal arguments to the template
  	Pcons       templ_refs;     // The templates referenced by this template

         /* Use these state variables to set up the correct state for error processing. 
	 * They are used by the "error" routines for statement numbers.  */
  	Pname       Cdcl;
  	Pstmt       Cstmt;

  	// used to detect loops during instantiation; a count greater than two is
  	// indicative of a non-terminating instantiation sequence
  	int 	    open_instantiations;
	int         extrapolated; // extrapolated friend declaration

  	// ensure that use of formals is consistent across, class, member and
  	// forward declarations
  	void check_formals(Plist formals) ;

public:
	virtual void dummy(); // for optimal vtbl laydown
	virtual int has_friend(Pname)=0;
	Plist get_formals() { return formals; }	
  	int get_formals_count(); // should probably define a member
	bool is_extrapolated() { return extrapolated ? true : false; }
};

class templ  : public basic_template { 
/* the template class representation */
  	friend class templ_inst;
  	friend class function_template;
  	friend class data_template;
	friend class classdef;

private:
  	Ptempl_inst insts;	// template instantiations 
  	Pbase 	basep;     	// template COBJ basetype 
  	Pfunt	fns;           	// member function declarations
  	Pfunt	fns_end;        
	Pdata  	data;		// static data member declarations
	Pdata  	data_end;
public:
  	Ptempl_inst get_match(Pexpr,Ptempl_inst,bool);
  	bool check_actual_args(Pexpr);
  	Ptempl      next; 	// connects all the class templates in the comp
  	Pname       namep;      // the TNAME for the template class
  	bool        defined;    // actual definition seen
  	Pname       members;    // note the members to catch redefinition errors

  	Ptempl_inst get_inst(Pexpr,Ptempl_inst=0);
  	templ(Plist,Pname);
  	void resolve_forward_decl(Plist,Pclass);
  	void instantiate_forward_decl();
  
  	Pbase basetype() {return basep; } // uninstantiated base type
  	Pbase inst_basetype(Pexpr actuals); // specific instantiation basetype 
  	Pclass classtype() { return Pclass(basep->b_name->tp); }
  	Pname typename(Pexpr actuals);
 	Pfunt collect_function_member(Pname); 
 	Pdata collect_data_member(Pname);
  	bool instantiate_bodies(); 
	int has_friend(Pname);
};

// Member function templates
class function_template : public basic_template {
/* SBL: go through these */
  friend Pbinding is_ftempl_match(Pexpr,Pfunt);
  friend Pname has_templ_instance(Pname,Pexpr,bit=0);
  friend class templ_compilation;
  friend class templ;
  friend class templ_inst;
  friend class funct_inst;
  friend class basic_inst;
  friend class templ_fct;

  	Pname fn;             // The name of the member function
  	Pfunt next;           // connects the list of functions
  	Pfunt gen_list;       // connects overloaded instances 
public:
  	Pfunct_inst insts;    // instantiations of the template
  	function_template(templ&,Plist,Pname); 	// member functions
  	function_template(Plist,Pname); 	// function templates
	Pname func_name() { return fn; }

  	void instantiate_forward_decl();
  	Pfunct_inst get_match(Pexpr,Pfunct_inst,bool); 
  	Pfunct_inst get_inst(Pexpr,Pfunct_inst=0);
	int has_friend(Pname);
};

class data_template : public basic_template 
{ // explicitly initialized static data members 
	friend class templ;
	friend class basic_inst;
	friend class templ_inst;
	Pname 	dat_mem;
	Pdata	next;
public:
  	data_template(templ&,Plist,Pname); 	
	int has_friend(Pname); // need override pure virtual
};

// Global state variables that must be saved around an instantiation. The
// saving of state was required in the implementstion that interspersed decl
// processing and instantiation, rather than the current strategy, which only
// forces instantiations at the top level outside of any dcl-processing
// context. It is retained in case we ever go back to the "interspersed" style
// of instantiation. 
class state {
public:
  Pname       Cdcl ;      // the global variables used by the error routines
  Pstmt       Cstmt ;
  Pname       dcl_list ;  // Holds the list of typedef names that are hidden
  Loc         curloc ;
  
  int         curr_file ;
  Pexpr       curr_expr ;
  Pin         curr_icall ;
  Pstmt       curr_loop;
  Pblock      curr_block;
  Pstmt       curr_switch;

  int         bound  ;   
  int         inline_restr ;
  Loc         last_line ;

  state() {} ; // prevent used before set warnings.
  void save() ;
  
  void init() ; 
  void restore() ; 
} ;


class pointer_hash ; 
class tree_copy_info ;

// A template starts out being uninstantiated, and is class_instantiated when
// there is a refrence to it with actual arguments. It is body_instantiated at
// the end of compilation, when all its function members are instantiated.
enum inst_status { uninstantiated, 
			function_instantiated, data_instantiated,
			class_instantiated, body_instantiated };

// templ_inst captures the arguments used in the instantiation of a template.
// These instantiations are rooted in the templ object. 
class basic_inst {
/* SBL: go through these */
	friend class template_instantiation;
	friend class templ;
	friend class function_template;
	friend class templ_classdef;
	friend Pcons make_ref_copy(pointer_hash&,tree_copy_info&,Pcons);
public:
  Pname get_tname() { return tname; }
  Pname get_namep() { return namep; }
  void print_error_loc(int=0);           // Wants to be a static function
  virtual void dummy();			 // for optimal vtbl laydown
  virtual void print_pretty_name() = 0;  // for nice error reporting
  virtual char *mangled_name(char*) = 0; // mangle template class/function names
  Pexpr      actuals;       	// instantiation arguments, chained using ELIST
			     	// as an expression "cons" node, e1 is the car
			     	// and e2 the cdr. The car points to a name node.
  Plist      inst_formals; 	// the instantiation's copy of the formals
  static Pbase_inst head;	// head of list of active instantiations.
protected:
  TOK	     isa;		// for the moment: CLASS,FCT
  Pname      tname;         	// name of instantiation 
  Pname      namep;         	// version of name in ktbl (class) or gtbl(funct)
  state      context;      	// the context of this instantiation
  Plist      hidden_globals; 	// list of globals hidden during instantiation
  // Plist      inst_formals; 	// the instantiation's copy of the formals
  inst_status status;
  Pbase_inst  next_active;  // list of currently active instantiations.

  char *instantiation_string();

  // The class correspondence table. This table is initialized 
  // when the class definition is instantiated. Subsequently, it is used to
  // initial member correspondence tables before copy process is initiated.
  pointer_hash *corr;

  Pcons ref_copy(pointer_hash&,tree_copy_info&,Pcons);

  // save and restore state around the template instantiation
  void save_state(Pname p) ;
  void restore_state() ;

  void expose_parameter_names();
  void hide_parameter_names();
  
  TOK isA() { return isa; }
};

struct Pslot {
	Pname param;
	Ptype typ;
};

class funct_inst : public basic_inst {
  	friend class template_instantiation;
	friend class function_template;
  	friend class templ_fct;
private:
  	Pfunct_inst next;         // list of template instantiations 
	Pfunct_inst tfct_copy(Pcons&,bool);
        void bind_formals();
public:
	funct_inst( Pexpr act, Pfunt owner );
	void instantiate( bool reinstantiate = false );
	void print_pretty_name();  // virtual
	char *mangled_name(char*); // virtual
	bool actuals_match(Pexpr);

  	Pfunt def;   // template definition; this is an instantiation.
  	bool refp;   // notes template references during a C++ definition
  	bool friend_refp;   // notes template references during a C++ definition
	Pbinding binding; // actual types binding to formals	
	bool f_copy_hook(Pnode&);
};

class templ_inst : public basic_inst  {
  	friend class template_instantiation;
  	friend class templ;
  	friend class classdef;
  	friend class templ_classdef;
  	friend Pcons make_ref_copy(pointer_hash&,tree_copy_info&,Pcons);
private:
  	Ptempl_inst next;     // linked list of template instantiations 
  	Ptempl_inst forward;  // this instantiation same as `forward'
public: 
  templ_inst (Pexpr act,  Ptempl owner);
  templ_inst (Pexpr act,  Ptempl owner, TOK csu);
  bool actuals_match(Pexpr check_actuals); /* merge this and function's */
  void instantiate_match(Ptempl_inst match) ;
  void kludge_copy(Pbase source_base) ;

  // create a copy of the class type subtree preparatory to the ensuing
  // instantiation. Return a non-zero value, only if there was no need to
  // create a copy, ie. an identical instantiation already existed.
  Ptempl_inst class_copy(Pcons &templ_refs, bool recopy) ;

  // Used to collect references to this template by a definition
  Ptempl_inst note_ref() ;
public:
  Ptempl        def;         // The template definition, for which this is an
			     // instantiation.
  bool         refp ;        // flag to note template references during a C++ 
			     // definition

  bool         friend_refp ;        // flag to note template references during a C++ 
	void explicit_inst(); 
  // Bind the formals before an instantiation
  void bind_formals() ;

  Ptempl_inst canonical_instantiation() {
    return ( forward ? forward : this ) ;
  }

  // get the class associated with this instantiation
  Pclass get_class() { return Pclass(Pbase(tname->tp)->b_name->tp) ;}
			      
  Ptempl_inst instantiate(bool reinstantiate = false) ;
  void print_pretty_name();		// virtual
  char *mangled_name(char *buffer);	// virtual
  // The uninstantiated basetype
  Pbase def_basetype() { return def->basep ; } ;

  // A general way of determining whether two template instantiations are
  // the same
  bool  same(Ptempl_inst t) ;

  bool copy_hook(Pnode&) ;
 	// return a copy of the function tree starting with it's name
  	Pname function_copy(Pfunt,Pcons&);
  	Pname data_copy(Pdata,Pcons&);

  // special check for instantiations used in qualifiers for template function
  // member declarations. 
  bool check_qualifier(Plist formals) ;
  Pname get_parameter(char *s) ;
} ;

// Experimental debugging toggle ???
extern int zdebug;

// The class node used for template classes.
// Rep invariant:
// class_base == UNINSTANTIATED ||
// class_base  == INSTANTIATED

class templ_classdef : public classdef {
public:
   	// a pointer to the instantiation; the instantiation 
	// also points back to it via tname->cobj->name->class 
   	Ptempl_inst inst; 
  	templ_classdef(Ptempl_inst i);
  	templ_classdef(Ptempl_inst i, TOK csu);
  	Pname unparametrized_tname() {return inst->def->namep;} 
};

class templ_fct : public fct {
public:
  	Pfunct_inst inst; // pointer to the instantiation
  	templ_fct(Pfunct_inst i);
  	Pname unparametrized_tname() {return inst->def->fn;} 
	void *operator new(size_t);
	void operator delete(void*,size_t);
	static Ptfct ptfct_free;
};

// Safe accessor functions for navigating through COBJ base classes
extern Templ_type get_class_base (Pbase b);
extern Ptclass get_template_class (Pbase b);
extern Ptempl_inst get_templ_inst(Pbase b);

// functions and data structures needed for directed instantiation

#include "Block.h"
Blockdeclare(Pchar);
extern Block(Pchar) instfct;
extern int noinst;
extern Block(Pchar) instdata;
extern int nodatainst;
extern bit tempdcl;
extern bit mk_zero_init_flag;
extern int first_file;
extern bit all_flag,alltc_flag,data_flag,ft_flag,none_flag;
extern void set_flags();
extern Pname righttname;