Merge branch 'master' of ssh://plrg.eecs.uci.edu/home/git/constraint_compiler

diff --cc src/AST/boolean.c
index 13070fa502d786a6aa13003bf271450e513377e6,0000000000000000000000000000000000000000..ce6fad950d39d66d85dac78a28358ec72e0318b6
mode 100644,000000..100644
--- 1/src/AST/boolean.c
--- /dev/null
+++ b/src/AST/boolean.c
@@@ -1,1 -1,0 +1,16 @@@
 +#include "boolean.h"
++
++Boolean* allocBoolean(VarType t){
++    Boolean* tmp = (Boolean*) ourmalloc(sizeof (Boolean));
++    tmp->vtype=t;
++    tmp->btype=_BOOLEAN;
++    return tmp;
++}
++
++Boolean* allocBooleanOrder(Order* order,uint64_t first, uint64_t second){
++    Boolean* tmp = (Boolean*) ourmalloc(sizeof (Boolean));
++    tmp ->btype= _ORDER;
++    tmp->order = order;
++    tmp->first=first;
++    tmp->second=second;
++}

diff --cc src/AST/boolean.h
index 5e8c5a5e6f9a225af80543f9d1fc4b2f1411cd14,0000000000000000000000000000000000000000..fcd4751dad5cbaa57b8f1d5df8d8788a32b9f735
mode 100644,000000..100644
--- 1/src/AST/boolean.h
--- /dev/null
+++ b/src/AST/boolean.h
@@@ -1,8 -1,0 +1,16 @@@
- 
 +#ifndef BOOLEAN_H
 +#define BOOLEAN_H
 +#include "classlist.h"
 +#include "mymemory.h"
++#include "ops.h"
 +struct  Boolean {
++    VarType vtype;
++    enum BooleanType btype;
++    Order* order;
++    uint64_t first;
++    uint64_t second;
 +};
++
++Boolean* allocBoolean(VarType t);
++Boolean* allocBooleanOrder(Order* order,uint64_t first, uint64_t second);
 +#endif

diff --cc src/AST/function.h
index da5087b579e06373e3e25c193f2f37d79c5f77d2,0000000000000000000000000000000000000000..f023f4aad8dda58bdcae205a83432bcd7e54d309
mode 100644,000000..100644
--- 1/src/AST/function.h
--- /dev/null
+++ b/src/AST/function.h
@@@ -1,8 -1,0 +1,10 @@@
 +#ifndef FUNCTION_H
 +#define FUNCTION_H
 +#include "classlist.h"
 +#include "mymemory.h"
 +
 +struct Function {
++    
++    Table* table;
 +};
 +#endif

diff --cc src/AST/ops.h
index 40e6f9933a05180f45614b433a6b3094dc406169,0000000000000000000000000000000000000000..3990aec8080b666088ed96ba1d151a0e5a7692b4
mode 100644,000000..100644
--- 1/src/AST/ops.h
--- /dev/null
+++ b/src/AST/ops.h
@@@ -1,17 -1,0 +1,19 @@@
 +#ifndef OPS_H
 +#define OPS_H
 +enum LogicOp {AND, OR, NOT, XOR, IMPLIES};
 +enum ArithOp {ADD, SUB};
 +enum CompOp {EQUALS};
 +enum OrderType {PARTIAL, TOTAL};
 +
 +/**
 + *    FLAGFORCESOVERFLOW forces the operation to overflow if the boolean flag is true
 + *  OVERFLOWSETSFLAG -- sets the flag if the operation overflows
 + *  FLAGIFFOVERFLOW -- flag is set iff the operation overflows
 + *  IGNORE -- doesn't constrain output if the result cannot be represented
 + *  WRAPAROUND -- wraps around like stand integer arithmetic
 + */
 +enum OverFlowBehavior {IGNORE, WRAPAROUND, FLAGFORCESOVERFLOW, OVERFLOWSETSFLAG, FLAGIFFOVERFLOW};
 +
++enum BooleanType {_ORDER, _BOOLEAN};
++
 +#endif

diff --cc src/AST/order.c
index 727b2dd3888d35a3bf45fd292a4a9142f2d7feba,0000000000000000000000000000000000000000..2f8381e234e59d0c698fbba314dccf69c6c9dbab
mode 100644,000000..100644
--- 1/src/AST/order.c
--- /dev/null
+++ b/src/AST/order.c
@@@ -1,1 -1,0 +1,29 @@@
 +#include "order.h"
++#include "structs.h"
++#include "set.h"
++
++
++Order* allocOrder(enum OrderType type, Set * set){
++    Order* order = (Order*)ourmalloc(sizeof(Order));
++    order->set=set;
++    order->constraints = allocDefVectorBoolean();
++    order->type=type;
++    return order;
++}
++
++Boolean* getOrderConstraint(Order* order, uint64_t first, uint64_t second){
++    uint size = getSizeVectorInt(order->set->members);
++    //First we need to make sure that first and second are part of the list!
++    bool exist1=false, exist2=false;
++    for(int i=0; i<size; i++){
++        if(getVectorInt(order->set->members, i)==first){
++            exist1=true;
++        }else if(getVectorInt(order->set->members, i) == second){
++            exist2=true;
++        }else if(exist1 && exist2){
++            break;
++        }
++    }
++    ASSERT(exist1 && exist2);
++    
++}

diff --cc src/AST/order.h
index b164a11bb651b5903ecf38faedf63d848702304a,0000000000000000000000000000000000000000..08bc2a776e2c82a454fa1c6c746ec8736aeb82a6
mode 100644,000000..100644
--- 1/src/AST/order.h
--- /dev/null
+++ b/src/AST/order.h
@@@ -1,8 -1,0 +1,15 @@@
- 
 +#ifndef ORDER_H
 +#define ORDER_H
 +#include "classlist.h"
 +#include "mymemory.h"
++#include "structs.h"
++#include "ops.h"
 +struct Order {
++    enum OrderType type;
++    Set * set;
++    VectorBoolean* constraints;
 +};
++
++Order* allocOrder(enum OrderType type, Set * set);
++Boolean* getOrderConstraint(Order* order,uint64_t first, uint64_t second);
 +#endif

diff --cc src/AST/predicate.c
index dcec97af1dbd2b13a997a244cfc6bbecf8a1b10c,0000000000000000000000000000000000000000..2beef617d2c5ec9a5b1dee7c7289ccd79c14d14a
mode 100644,000000..100644
--- 1/src/AST/predicate.c
--- /dev/null
+++ b/src/AST/predicate.c
@@@ -1,1 -1,0 +1,12 @@@
 +#include "predicate.h"
++#include "structs.h"
++
++
++Predicate* allocPredicate(enum CompOp op, Set ** domain, uint numDomain){
++    Predicate* predicate = (Predicate*) ourmalloc(sizeof(Predicate));
++    predicate->domains = allocDefVectorSet();
++    for(uint i=0; i<numDomain; i++)
++        pushVectorSet(predicate->domains,domain[i]);
++    predicate->op=op;
++    return predicate;
++}

diff --cc src/AST/predicate.h
index 9a1766962392fc36c70c9a9427792481b204cd3e,0000000000000000000000000000000000000000..06c54bb21f02d457ea50622df6b31f7547051709
mode 100644,000000..100644
--- 1/src/AST/predicate.h
--- /dev/null
+++ b/src/AST/predicate.h
@@@ -1,9 -1,0 +1,15 @@@
- 
 +#ifndef PREDICATE_H
 +#define PREDICATE_H
 +#include "classlist.h"
 +#include "mymemory.h"
++#include "ops.h"
++#include "structs.h"
 +
 +struct Predicate {
++    enum CompOp op;
++    VectorSet* domains;
 +};
++
++
++Predicate* allocPredicate(enum CompOp op, Set ** domain, uint numDomain);
 +#endif