prop-src/constraint.ph

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  This file describes the interface of the constraint compiler.
   4 //
   5 ///////////////////////////////////////////////////////////////////////////////
   6 #ifndef constraint_compiler_h
   7 #define constraint_compiler_h
   8
   9 #include "basics.ph"
  10 #include "codegen.h"
  11 #include "matchcom.h"
  12
  13 ///////////////////////////////////////////////////////////////////////////////
  14 //
  15 //  Forward datatype declarations
  16 //
  17 ///////////////////////////////////////////////////////////////////////////////
  18 datatype Ty          //  Type expressions
  19      and Pat         //  Patterns
  20      and Exp         //  Expressions
  21      and Decl        //  Prop declarations
  22      and Def         //  Definitions
  23      and Stmt        //  Statements
  24      and Instness    //  Instantiatedness
  25      and Determinism //  Determinism of a predicate
  26 ;
  27
  28 class HashTable;
  29
  30 ///////////////////////////////////////////////////////////////////////////////
  31 //
  32 //  The grammar of the constraint rules is defined as follows:
  33 //
  34 ///////////////////////////////////////////////////////////////////////////////
  35 datatype ConstraintSet : Loc =
  36             CONSTRAINTset (ConstraintDefs)
  37
  38 and      ConstraintDef : Loc =
  39             CONSTRAINTruledef ConstraintRule            // rule definition
  40          |  CONSTRAINTtype     (Id, Ty)                 // type constraint
  41          |  CONSTRAINTinstness (Id, Pat)                // instness definition
  42          |  CONSTRAINTdet      (Id, Pats, Determinism)  // determinism const.
  43
  44 and      ConstraintRule    : Loc =
  45             CONSTRAINTrule { id   : Id,             // the functor name
  46                              pat  : Pat,            // pattern argument
  47                              body : ConstraintBody, // clause body
  48                              ty   : Ty = NOty       // optional type
  49                            }
  50
  51 and      ConstraintBody    : Loc =
  52             CONSTRAINTnone
  53          |  CONSTRAINTcut
  54          |  CONSTRAINTand     (ConstraintBody, ConstraintBody)
  55          |  CONSTRAINTif      (ConstraintBody, ConstraintBody, ConstraintBody)
  56          |  CONSTRAINTbody    (List<Decl>)
  57          |  CONSTRAINTcall    (Exp)
  58
  59 where type ConstraintDefs  = List<ConstraintDef>
  60        and ConstraintRules = List<ConstraintRule>
  61 ;
  62
  63 ///////////////////////////////////////////////////////////////////////////////
  64 //
  65 //  Pretty printing routines.
  66 //
  67 ///////////////////////////////////////////////////////////////////////////////
  68 extern std::ostream& operator << (std::ostream&, ConstraintSet);
  69 extern std::ostream& operator << (std::ostream&, ConstraintDef);
  70 extern std::ostream& operator << (std::ostream&, ConstraintDefs);
  71 extern std::ostream& operator << (std::ostream&, ConstraintRule);
  72 extern std::ostream& operator << (std::ostream&, ConstraintRules);
  73 extern std::ostream& operator << (std::ostream&, ConstraintBody);
  74
  75 ///////////////////////////////////////////////////////////////////////////////
  76 //
  77 //  Forward declaration.
  78 //
  79 ///////////////////////////////////////////////////////////////////////////////
  80 class ConstraintCompilerInternal;
  81
  82 ///////////////////////////////////////////////////////////////////////////////
  83 //
  84 //  The constraint compiler is inherited from the code generator.
  85 //
  86 ///////////////////////////////////////////////////////////////////////////////
  87 class ConstraintCompiler : virtual public CodeGen,
  88                            virtual public MatchCompiler {
  89
  90    ConstraintCompiler(const ConstraintCompiler&); // no copy constructor
  91    void operator = (const ConstraintCompiler&);   // no assignment
  92
  93 protected:
  94
  95    ConstraintCompilerInternal * internal;  // internal implementation
  96
  97 public:
  98    ////////////////////////////////////////////////////////////////////////////
  99    //
 100    //  Constructor and destructor
 101    //
 102    ////////////////////////////////////////////////////////////////////////////
 103             ConstraintCompiler();
 104    virtual ~ConstraintCompiler();
 105
 106    ////////////////////////////////////////////////////////////////////////////
 107    //
 108    //  Methods for compiling a set of constraint rules.
 109    //
 110    ////////////////////////////////////////////////////////////////////////////
 111    void compile_ruleset   (Id class_name, ConstraintSet rule_set);
 112
 113 private:
 114    ////////////////////////////////////////////////////////////////////////////
 115    //
 116    //  Private implementation methods.
 117    //
 118    ////////////////////////////////////////////////////////////////////////////
 119    void process_typing_rules (Id, List<.[Id,Ty]>);
 120    void process_ruleset      (Id, ConstraintRules);
 121    void add_predicate_type   (Id, Ty);
 122    void analyze_rule         (ConstraintBody);
 123 };
 124
 125
 126 #endif