prop-src/funmap.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.6),
   3 //  last updated on Nov 2, 1999.
   4 //  The original source file is "funmap.ph".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #line 1 "funmap.ph"
   8 ///////////////////////////////////////////////////////////////////////////////
   9 //
  10 //  This file decribes the functor map data structure, which is
  11 //  used internally during rewriting compilation.
  12 //
  13 ///////////////////////////////////////////////////////////////////////////////
  14 #ifndef functor_map_h
  15 #define functor_map_h
  16
  17 #include <AD/automata/treegram.h>
  18 #include "ir.h"
  19 #include "ast.h"
  20 #include "type.h"
  21 #include "hashtab.h"
  22 #include "functortab.h"
  23 #include <iostream>
  24
  25 ///////////////////////////////////////////////////////////////////////////////
  26 //
  27 //  Import some type definitions from the tree grammar and hash table
  28 //  classes.
  29 //
  30 ///////////////////////////////////////////////////////////////////////////////
  31 class TreeAutomaton;
  32 class TopDownGen;
  33 typedef TreeGrammar::Functor        Functor;
  34 typedef TreeGrammar::Variable       Variable;
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 //
  38 //  Vector Id
  39 //
  40 ///////////////////////////////////////////////////////////////////////////////
  41 #line 34 "funmap.ph"
  42 #line 34 "funmap.ph"
  43 ///////////////////////////////////////////////////////////////////////////////
  44 //
  45 // Forward class definition for VectorId
  46 //
  47 ///////////////////////////////////////////////////////////////////////////////
  48 #ifndef datatype_VectorId_defined
  49 #define datatype_VectorId_defined
  50    class a_VectorId;
  51    typedef a_VectorId * VectorId;
  52 #endif
  53
  54 ///////////////////////////////////////////////////////////////////////////////
  55 //
  56 // Class for datatype constructor VectorId::vector_id
  57 //
  58 ///////////////////////////////////////////////////////////////////////////////
  59 class a_VectorId : public MEM {
  60 public:
  61 #line 34 "funmap.ph"
  62    Cons cons; Ty ty; int arity;
  63    a_VectorId (Cons x_cons, Ty x_ty, int x_arity);
  64 };
  65 inline int boxed(const a_VectorId *) { return 1; }
  66 inline int untag(const a_VectorId *) { return 0; }
  67 ///////////////////////////////////////////////////////////////////////////////
  68 //
  69 // Datatype constructor functions for VectorId
  70 //
  71 ///////////////////////////////////////////////////////////////////////////////
  72 extern a_VectorId * vector_id (Cons x_cons, Ty x_ty, int x_arity);
  73
  74 #line 34 "funmap.ph"
  75 #line 34 "funmap.ph"
  76
  77
  78 ///////////////////////////////////////////////////////////////////////////////
  79 //
  80 //  Functor mapping table.
  81 //
  82 ///////////////////////////////////////////////////////////////////////////////
  83 class FunctorMap {
  84    FunctorMap(const FunctorMap&);      // no copy constructor
  85    void operator = (const FunctorMap&);  // no assignment
  86 public:
  87    ////////////////////////////////////////////////////////////////////////////
  88    //  Internals
  89    ////////////////////////////////////////////////////////////////////////////
  90    FunctorTable   literal_map;  // mapping from literals to Functors
  91    FunctorTable   type_map;     // mapping from types to Functors
  92    FunctorTable   vector_map;   // mapping from vector constructors to Functors
  93    FunctorTable   var_map;      // mapping from non-terminals to Functors
  94    HashTable      rule_map;     // mapping from types to rule lists
  95    HashTable      topdown_rule_map; // mapping from types to topdown rules
  96    HashTable      before_rule_map;  // mapping from types to before rules
  97    HashTable      preorder_rule_map;  // mapping from types to preorder rules
  98    HashTable      postorder_rule_map; // mapping from types to postorder rules
  99    HashTable*     rule_maps[MatchRuleInfo::LAST_REWRITING_MODE]; // rule maps
 100    HashTable      protocols;    // mapping from type to type
 101    HashTable      nonterm_map;  // mapping from (lhs) nonterminal to type
 102    HashTable      nonterm_rules;// mapping from (lhs) nonterminal to rules.
 103    HashTable      nonterm_rules_bits;// mapping from (lhs) nonterminal to size of rules.
 104    HashTable      chain_rules;  // mapping of rhs to rules of form lhs -> rhs
 105    TreeGrammar     G;           // the current tree grammar
 106    TreeGrammar::Functor         functors;    // number of functors
 107    TreeGrammar::Variable        variables;   // number of variables
 108    TreeAutomaton * tree_gen;    // the tree automaton generator
 109    TopDownGen *    topdown_gen; // topdown tree automaton generator
 110    Bool        use_compression; // should we use index compression?
 111    Bool        has_guard;       // the set of rules contain guards?
 112    Bool        has_cost;        // the set of rules contain costs?
 113    Bool        has_cost_exp;    // the set of rules contain cost exprs?
 114    Bool        has_syn_attrib;  // are we using synthesized attributes?
 115    Bool        has_replacement; // the set of rules have replacements?
 116    Bool        is_applicative;  // Is rewriting done applicatively?
 117    Bool        gen_reducers;    // Should we generate a reducer?
 118    Bool        dynamic_search;  // Use runtime search?
 119    int         N;               // number of rules
 120    int         max_arity;       // maximum arity of patterns.
 121    Id          class_name;      // name of rewrite class
 122    Id *        functor_names;   // names of functors
 123    Id *        variable_names;  // names of variables
 124    Bool        is_ok;           // no errors found?
 125    MatchRules  bottomup_rules;  // only the bottomup rules are here
 126
 127    ////////////////////////////////////////////////////////////////////////////
 128    //
 129    //  Constructor
 130    //
 131    ////////////////////////////////////////////////////////////////////////////
 132    FunctorMap(Id name, MatchRules rules);
 133
 134    ////////////////////////////////////////////////////////////////////////////
 135    //
 136    //  Check whether we have an error
 137    //
 138    ////////////////////////////////////////////////////////////////////////////
 139    inline Bool ok() const { return is_ok; }
 140
 141    ////////////////////////////////////////////////////////////////////////////
 142    //
 143    //  Check whether a type known to the compiler?
 144    //
 145    ////////////////////////////////////////////////////////////////////////////
 146    Bool is_known_type      (Ty);
 147    Bool is_rewritable_type (Ty);
 148
 149    ////////////////////////////////////////////////////////////////////////////
 150    //
 151    //  Methods to compute the cost expression of a pattern.
 152    //
 153    ////////////////////////////////////////////////////////////////////////////
 154    Exp cost_expr (Id, Pat);
 155    Exp cost_expr (Id, Pat,     Exp);
 156    Exp cost_expr (Id, Pats,    Exp);
 157    Exp cost_expr (Id, LabPats, Exp);
 158
 159    ////////////////////////////////////////////////////////////////////////////
 160    //
 161    //  Method to print a report detailing the functor/variable encoding,
 162    //  the tree grammar and the generated table size
 163    //
 164    ////////////////////////////////////////////////////////////////////////////
 165    void print_report(std::ostream&);
 166
 167 private:
 168    ////////////////////////////////////////////////////////////////////////////
 169    //
 170    //  Methods to build the protocol list
 171    //
 172    ////////////////////////////////////////////////////////////////////////////
 173    void enter_protocols ();
 174    void check_for_missing_protocols ();
 175
 176    ////////////////////////////////////////////////////////////////////////////
 177    //
 178    //  Methods to convert literal patterns into guards
 179    //
 180    ////////////////////////////////////////////////////////////////////////////
 181    void    make_guard (MatchRules);
 182    Pat     make_guard (Pat, Exp&);
 183    Pats    make_guard (Pats, Exp&);
 184    LabPats make_guard (LabPats, Exp&);
 185
 186    ////////////////////////////////////////////////////////////////////////////
 187    //
 188    //  Method to build the tree grammar
 189    //
 190    ////////////////////////////////////////////////////////////////////////////
 191    void build_tree_grammar (MatchRules);
 192
 193    ////////////////////////////////////////////////////////////////////////////
 194    //
 195    //  Encoding methods
 196    //
 197    ////////////////////////////////////////////////////////////////////////////
 198    void encode (Ty);  // encode a type
 199    void encode (Pat); // encode a pattern
 200    void encode (Id);  // encode a non-terminal
 201    Id   chain_rule_rhs (Pat);
 202
 203    ////////////////////////////////////////////////////////////////////////////
 204    //
 205    //  Translation methods
 206    //
 207    ////////////////////////////////////////////////////////////////////////////
 208    TreeTerm trans(Pat);
 209
 210    ////////////////////////////////////////////////////////////////////////////
 211    //
 212    //  Method to partition a set of rules according to the types of the
 213    //  top level pattern, also encode the pattern in the process.
 214    //
 215    ////////////////////////////////////////////////////////////////////////////
 216    MatchRules partition_rules (MatchRules);
 217
 218    ////////////////////////////////////////////////////////////////////////////
 219    //
 220    //  Method to compute the functor and variable names
 221    //
 222    ////////////////////////////////////////////////////////////////////////////
 223    void compute_names ();
 224 };
 225
 226 #endif
 227 #line 185 "funmap.ph"
 228 /*
 229 ------------------------------- Statistics -------------------------------
 230 Merge matching rules         = yes
 231 Number of DFA nodes merged   = 0
 232 Number of ifs generated      = 0
 233 Number of switches generated = 0
 234 Number of labels             = 0
 235 Number of gotos              = 0
 236 Adaptive matching            = enabled
 237 Fast string matching         = disabled
 238 Inline downcasts             = enabled
 239 --------------------------------------------------------------------------
 240 */