prop-src/datatype.ph

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  The following classes are used to generate C++ class definitions
   4 //  for algebraic datatypes.
   5 //
   6 //////////////////////////////////////////////////////////////////////////////
   7 #ifndef datatype_class_definition
   8 #define datatype_class_definition
   9
  10 #include "classdef.h"
  11 #include "ast.ph"
  12 #include "basics.ph"
  13
  14 //////////////////////////////////////////////////////////////////////////////
  15 //
  16 //  Forward type definitions.
  17 //
  18 //////////////////////////////////////////////////////////////////////////////
  19 class DatatypeClass;
  20 class DatatypeHierarchy;
  21
  22 //////////////////////////////////////////////////////////////////////////////
  23 //
  24 //  This class represents one subclass in an algebraic datatype class
  25 //  hierarchy.
  26 //
  27 //////////////////////////////////////////////////////////////////////////////
  28 class DatatypeClass : public ClassDefinition
  29 {  DatatypeClass();
  30    DatatypeClass(const DatatypeClass&);
  31    void operator = (const DatatypeClass&);
  32
  33 protected:
  34    Id                  constructor_name; // name of constructor
  35    Id                  is_const;         // a const type?
  36    Cons                cons;             // the constructor descriptor
  37    DatatypeHierarchy * root;             // root of the hierarchy
  38    Bool                generating_list_special_forms;
  39    Ty                  cons_arg_ty;      // current constructor argument type
  40    Bool                is_list;          // is it a list
  41    Bool                is_array;         // is it an array
  42    Bool                has_destructor;
  43 public:
  44    ///////////////////////////////////////////////////////////////////////////
  45    //
  46    //  Constructors and destructors
  47    //
  48    ///////////////////////////////////////////////////////////////////////////
  49             DatatypeClass(CLASS_TYPE,
  50                           Id, Id, TyVars, Inherits, TyQual, Decls, Cons,
  51                           DatatypeHierarchy *);
  52    virtual ~DatatypeClass();
  53
  54    void instantiate_datatype(CodeGen&, TyVars);
  55    void generate_forward_declarations(CodeGen&);
  56    void generate_datatype_constructor(CodeGen&,
  57           Tys, DefKind = INLINE_IMPLEMENTATION);
  58
  59    virtual void visualize(PropVisualizer&);
  60
  61 protected:
  62
  63    friend class DatatypeHierarchy;
  64
  65    // Methods that adhere to the ClassDefinition protocol
  66    virtual void gen_class_destructor_body(CodeGen&, Tys, DefKind);
  67
  68    virtual void gen_class_predefinition(CodeGen&);
  69    virtual void gen_class_interface(CodeGen&);
  70    virtual void gen_class_postdefinition(CodeGen&);
  71    virtual void gen_class_implementation(CodeGen&, Tys, DefKind);
  72
  73    virtual void gen_class_instantiation(CodeGen&, Tys, DefKind);
  74
  75    // Methods for generating the functionality for various features
  76    void generate_persistence_interface(CodeGen&);
  77    void generate_logic_interface(CodeGen&);
  78    void generate_gc_interface(CodeGen&);
  79    void generate_inference_interface(CodeGen&);
  80    virtual void generate_print_interface(CodeGen&);
  81
  82    void generate_persistence_implementation(CodeGen&, Tys, DefKind);
  83    void generate_logic_implementation(CodeGen&, Tys, DefKind);
  84    void generate_gc_implementation(CodeGen&, Tys, DefKind);
  85    void generate_inference_implementation(CodeGen&, Tys, DefKind);
  86    virtual void generate_print_implementation(CodeGen&, Tys, DefKind);
  87
  88 private:
  89    //
  90    // Methods for generating class constructor code.
  91    virtual void gen_class_constructor(CodeGen&, Tys, DefKind);
  92    virtual void gen_class_constructor_parameters(CodeGen&, Tys, DefKind);
  93    virtual void gen_class_constructor_initializers(CodeGen&, Tys, DefKind);
  94    virtual void gen_class_constructor_body(CodeGen&, Tys, DefKind);
  95    void gen_constructor_initializers(CodeGen&, Tys, DefKind, Ty, Id, Id);
  96    void gen_array_initializer(CodeGen&, Tys, DefKind, Id, Ty, Id);
  97
  98    //
  99    // Methods for generating garbage collection code
 100    //
 101    void gen_super_class_tracing_methods(CodeGen&, Tys, DefKind);
 102    void gen_field_tracing_methods(CodeGen&, Exp, Ty, Tys, DefKind, Bool=false);
 103
 104    //
 105    // Methods for generating persistence I/O code
 106    //
 107    void gen_super_class_persist_IO(CodeGen&, Tys, DefKind, Id);
 108    void gen_field_persist_IO(CodeGen&, Exp, Ty, Tys, DefKind, Id, Bool=false);
 109 };
 110
 111 //////////////////////////////////////////////////////////////////////////////
 112 //
 113 //  This class is responsible for generating a class hierarchy for a
 114 //  algebraic datatype.
 115 //
 116 //////////////////////////////////////////////////////////////////////////////
 117 class DatatypeHierarchy : public DatatypeClass
 118 {
 119    DatatypeHierarchy(const DatatypeHierarchy&);
 120    void operator = (const DatatypeHierarchy&);
 121
 122 protected:
 123    friend class DatatypeClass;
 124    const Id         datatype_name; // name of datatype
 125    const TermDefs   term_defs;     // datatype terms
 126    DatatypeClass ** subclasses;    // subclasses of the hierarchy
 127    int              number_of_subclasses;
 128    int              arity;             // total number of constructors
 129    int              unit_constructors; // number of unit constructors
 130    int              arg_constructors;  // number of argument constructors
 131    Cons *           constructor_terms; // constructor descriptors
 132    TyOpt            optimizations;     // optimizations?
 133    Bool             inline_methods;    // should be inline the methods?
 134    Bool             has_variant_tag;   // do we have a variant tag?
 135    Bool             use_gc_base;       // do we need to trace base class?
 136    Bool             use_persist_base;  // do we need to print base class?
 137    Ty               datatype_ty;       // type of the datatype
 138    Bool             got_info;
 139
 140    void get_info();
 141 public:
 142             DatatypeHierarchy(Id,TyVars,Inherits,TyQual,TermDefs, Decls);
 143    virtual ~DatatypeHierarchy();
 144
 145    void generate_forward_declarations(CodeGen&);
 146    void generate_datatype_definitions(CodeGen&);
 147    void generate_datatype_instantiations(CodeGen&, Tys, Bool);
 148
 149    virtual void gen_class_instantiation(CodeGen&, Tys, DefKind);
 150
 151    virtual void visualize(PropVisualizer&);
 152 protected:
 153
 154    // Methods to generate code
 155    void generate_forward_class_declarations(CodeGen&);
 156    void generate_forward_constructor_declarations(CodeGen&);
 157    void generate_unit_constructors(CodeGen&);
 158    void generate_constructor_tags(CodeGen&, Id, Id, int, Cons []);
 159    void generate_define_tags(CodeGen&, int, Cons []);
 160    void generate_untagging_member_functions(CodeGen&);
 161    void generate_untagging_functions(CodeGen&);
 162    void generate_downcasting_functions(CodeGen&);
 163    void generate_datatype_constructors(CodeGen&, Tys, DefKind);
 164
 165    // Methods to instantiate templates
 166    void gen_untagging_function_instantiation(CodeGen&, Tys, DefKind);
 167    void gen_downcasting_function_instantiation(CodeGen&, Tys, DefKind);
 168
 169    // Methods that adhere to the ClassDefinition protocol
 170    virtual void gen_class_interface(CodeGen&);
 171    virtual void gen_class_implementation(CodeGen&, Tys, DefKind);
 172    virtual void gen_class_postdefinition(CodeGen&);
 173
 174 private:
 175    // Methods to constructor the class hierarchy
 176    void build_class_hierarchy();
 177    DatatypeClass * build_one_subclass(Cons);
 178    void build_inheritance_list();
 179
 180    // Methods for generating pretty printers
 181    virtual void generate_print_interface(CodeGen&);
 182    virtual void generate_print_implementation(CodeGen&, Tys, DefKind);
 183    void generate_printer(CodeGen&, Tys, DefKind, Ty, Cons);
 184    void generate_default_printer(CodeGen&, Tys, DefKind, Ty, Cons, Ty);
 185    void generate_formatted_printer(CodeGen&, Tys, DefKind, Ty, Cons, Ty,
 186                                    PrintFormats);
 187    void gen_print_field(CodeGen&, Exp, Ty);
 188 };
 189
 190 #endif