src/AST/predicate.cc

   1 #include "predicate.h"
   2 #include "boolean.h"
   3 #include "set.h"
   4 #include "table.h"
   5 #include "csolver.h"
   6
   7 PredicateOperator::PredicateOperator(CompOp _op) : Predicate(OPERATORPRED), op(_op) {
   8 }
   9
  10 PredicateTable::PredicateTable(Table *_table, UndefinedBehavior _undefBehavior) : Predicate(TABLEPRED), table(_table), undefinedbehavior(_undefBehavior) {
  11 }
  12
  13 bool PredicateOperator::evalPredicateOperator(uint64_t *inputs) {
  14         switch (op) {
  15         case SATC_EQUALS:
  16                 return inputs[0] == inputs[1];
  17         case SATC_LT:
  18                 return inputs[0] < inputs[1];
  19         case SATC_GT:
  20                 return inputs[0] > inputs[1];
  21         case SATC_LTE:
  22                 return inputs[0] <= inputs[1];
  23         case SATC_GTE:
  24                 return inputs[0] >= inputs[1];
  25         }
  26         ASSERT(0);
  27         return false;
  28 }
  29
  30 Predicate *PredicateOperator::clone(CSolver *solver, CloneMap *map) {
  31         Predicate *p = (Predicate *) map->get(this);
  32         if (p != NULL)
  33                 return p;
  34
  35         p = solver->createPredicateOperator(op);
  36         map->put(this, p);
  37         return p;
  38 }
  39
  40 Predicate *PredicateTable::clone(CSolver *solver, CloneMap *map) {
  41         Predicate *p = (Predicate *) map->get(this);
  42         if (p != NULL)
  43                 return p;
  44
  45         p = solver->createPredicateTable(table->clone(solver, map), undefinedbehavior);
  46         map->put(this, p);
  47         return p;
  48 }
  49
  50 void PredicateTable::serialize(Serializer *serializer) {
  51         if (serializer->isSerialized(this))
  52                 return;
  53         serializer->addObject(this);
  54
  55         table->serialize(serializer);
  56
  57         ASTNodeType type = PREDTABLETYPE;
  58         serializer->mywrite(&type, sizeof(ASTNodeType));
  59         PredicateTable *This = this;
  60         serializer->mywrite(&This, sizeof(PredicateTable *));
  61         serializer->mywrite(&table, sizeof(Table *));
  62         serializer->mywrite(&undefinedbehavior, sizeof(UndefinedBehavior));
  63 }
  64
  65 void PredicateTable::print() {
  66         model_print("{PredicateTable:\n");
  67         table->print();
  68         model_print("}\n");
  69 }
  70
  71 void PredicateOperator::serialize(Serializer *serializer) {
  72         if (serializer->isSerialized(this))
  73                 return;
  74         serializer->addObject(this);
  75
  76         ASTNodeType type = PREDOPERTYPE;
  77         serializer->mywrite(&type, sizeof(ASTNodeType));
  78         PredicateOperator *This = this;
  79         serializer->mywrite(&This, sizeof(PredicateOperator *));
  80         serializer->mywrite(&op, sizeof(CompOp));
  81 }
  82
  83 void PredicateOperator::print() {
  84         const char *names[] = {"==", "<", ">", "<=", ">="};
  85
  86         model_print("PredicateOperator: %s\n", names[(int)op]);
  87 }
  88
  89
  90