template.h

/*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 type_name(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);
    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;