Fix tabbing on everything
authorbdemsky <bdemsky@uci.edu>
Fri, 16 Jun 2017 18:38:56 +0000 (11:38 -0700)
committerbdemsky <bdemsky@uci.edu>
Fri, 16 Jun 2017 18:38:56 +0000 (11:38 -0700)
src/AST/boolean.h
src/AST/function.h
src/AST/order.h
src/AST/predicate.h
src/Collections/hashset.h
src/Collections/hashtable.h
src/Collections/vector.h
src/Encoders/functionencoder.h
src/csolver.c
src/csolver.h

index f1d2127..030e1d9 100644 (file)
@@ -4,11 +4,11 @@
 #include "mymemory.h"
 #include "ops.h"
 struct  Boolean {
-    VarType vtype;
-    enum BooleanType btype;
-    Order* order;
-    uint64_t first;
-    uint64_t second;
+       VarType vtype;
+       enum BooleanType btype;
+       Order* order;
+       uint64_t first;
+       uint64_t second;
 };
 
 Boolean* allocBoolean(VarType t);
index f023f4a..1ea2069 100644 (file)
@@ -4,7 +4,7 @@
 #include "mymemory.h"
 
 struct Function {
-    
-    Table* table;
+
+       Table* table;
 };
 #endif
index 08bc2a7..2bb13b2 100644 (file)
@@ -5,9 +5,9 @@
 #include "structs.h"
 #include "ops.h"
 struct Order {
-    enum OrderType type;
-    Set * set;
-    VectorBoolean* constraints;
+       enum OrderType type;
+       Set * set;
+       VectorBoolean* constraints;
 };
 
 Order* allocOrder(enum OrderType type, Set * set);
index 06c54bb..a4dd7ed 100644 (file)
@@ -6,8 +6,8 @@
 #include "structs.h"
 
 struct Predicate {
-    enum CompOp op;
-    VectorSet* domains;
+       enum CompOp op;
+       VectorSet* domains;
 };
 
 
index 6d87078..a0f0c9e 100644 (file)
 #define HASH_SET_H
 #include "hashtable.h"
 
-#define HashSetDef(Name, _Key, hash_function, equals)                                                                          \
-       struct LinkNode ## Name {                                                                                                                                                                                       \
-               _Key key;                                                                                                                                                                                                                                               \
-               struct LinkNode ## Name *prev;                                                                                                                                                  \
-               struct LinkNode ## Name *next;                                                                                                                                                  \
-       };                                                                                                                                                                                                                                                                              \
-       typedef struct LinkNode ## Name LinkNode ## Name;                                                                                       \
-       struct HashSet ## Name;                                                                                                                                                                                         \
-       typedef struct HashSet ## Name HashSet ## Name;                                                                                         \
-       struct HSIterator ## Name {                                                                                                                                                                             \
-               LinkNode ## Name *curr;                                                                                                                                                                                 \
-               LinkNode ## Name *last;                                                                                                                                                                                 \
-               HashSet ## Name * set;                                                                                                                                                                                  \
-       };                                                                                                                                                                                                                                                                              \
-       typedef struct HSIterator ## Name HSIterator ## Name;                                                                   \
+#define HashSetDef(Name, _Key, hash_function, equals)                   \
+       struct LinkNode ## Name {                                             \
+               _Key key;                                                           \
+               struct LinkNode ## Name *prev;                                      \
+               struct LinkNode ## Name *next;                                      \
+       };                                                                    \
+       typedef struct LinkNode ## Name LinkNode ## Name;                     \
+       struct HashSet ## Name;                                               \
+       typedef struct HashSet ## Name HashSet ## Name;                       \
+       struct HSIterator ## Name {                                           \
+               LinkNode ## Name *curr;                                             \
+               LinkNode ## Name *last;                                             \
+               HashSet ## Name * set;                                              \
+       };                                                                    \
+       typedef struct HSIterator ## Name HSIterator ## Name;                 \
        HashTableDef(Name ## Set, _Key, LinkNode ## Name *, hash_function, equals); \
        HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name *_curr, HashSet ## Name * _set); \
-       void deleteIter ## Name(HSIterator ## Name *hsit);                                                                                      \
-       bool hasNext ## Name(HSIterator ## Name *hsit);                                                                                         \
-       _Key next ## Name(HSIterator ## Name *hsit);                                                                                                    \
-       _Key currKey ## Name(HSIterator ## Name *hsit);                                                                                         \
-       void removeIter ## Name(HSIterator ## Name *hsit);                                                                                              \
-       struct HashSet ## Name {                                                                                                                                                                                        \
-               HashTable ## Name ## Set * table;                                                                                                                                               \
-               LinkNode ## Name *list;                                                                                                                                                                                 \
-               LinkNode ## Name *tail;                                                                                                                                                                                 \
-       };                                                                                                                                                                                                                                                                              \
-       typedef struct HashSet ## Name HashSet ## Name;                                                                                         \
-                                                                                                                                                                                                                                                                                               \
-       HashSet ## Name * allocHashSet ## Name (unsigned int initialcapacity, double factor);   \
-       void deleteHashSet ## Name(struct HashSet ## Name * set);                                                               \
-       HashSet ## Name * copy ## Name(HashSet ## Name * set);                                                          \
-       void resetSet ## Name(HashSet ## Name * set);                                                                                                   \
-       bool add ## Name(HashSet ## Name * set,_Key key);                                                                                       \
-       _Key getSet ## Name(HashSet ## Name * set,_Key key);                                                                    \
-       _Key getFirstKey ## Name(HashSet ## Name * set);                                                                                        \
-       bool containsSet ## Name(HashSet ## Name * set,_Key key);                                                       \
-       bool removeSet ## Name(HashSet ## Name * set,_Key key);                                                         \
-       unsigned int getSizeSet ## Name(HashSet ## Name * set);                                                         \
-       bool isEmpty ## Name(HashSet ## Name * set);                                                                                                    \
+       void deleteIter ## Name(HSIterator ## Name *hsit);                      \
+       bool hasNext ## Name(HSIterator ## Name *hsit);                       \
+       _Key next ## Name(HSIterator ## Name *hsit);                          \
+       _Key currKey ## Name(HSIterator ## Name *hsit);                       \
+       void removeIter ## Name(HSIterator ## Name *hsit);                        \
+       struct HashSet ## Name {                                              \
+               HashTable ## Name ## Set * table;                                   \
+               LinkNode ## Name *list;                                             \
+               LinkNode ## Name *tail;                                             \
+       };                                                                    \
+       typedef struct HashSet ## Name HashSet ## Name;                       \
+                                                                        \
+       HashSet ## Name * allocHashSet ## Name (unsigned int initialcapacity, double factor); \
+       void deleteHashSet ## Name(struct HashSet ## Name * set);               \
+       HashSet ## Name * copy ## Name(HashSet ## Name * set);                \
+       void resetSet ## Name(HashSet ## Name * set);                         \
+       bool add ## Name(HashSet ## Name * set,_Key key);                     \
+       _Key getSet ## Name(HashSet ## Name * set,_Key key);                  \
+       _Key getFirstKey ## Name(HashSet ## Name * set);                      \
+       bool containsSet ## Name(HashSet ## Name * set,_Key key);             \
+       bool removeSet ## Name(HashSet ## Name * set,_Key key);               \
+       unsigned int getSizeSet ## Name(HashSet ## Name * set);               \
+       bool isEmpty ## Name(HashSet ## Name * set);                          \
        HSIterator ## Name * iterator ## Name(HashSet ## Name * set);
 
 
-#define HashSetImpl(Name, _Key, hash_function, equals)                                                                 \
+#define HashSetImpl(Name, _Key, hash_function, equals)                  \
        HashTableImpl(Name ## Set, _Key, LinkNode ## Name *, hash_function, equals); \
        HSIterator ## Name * allocHSIterator ## Name(LinkNode ## Name *_curr, HashSet ## Name * _set) { \
-               HSIterator ## Name * hsit = (HSIterator ## Name *) ourmalloc(sizeof(HSIterator ## Name)); \
-               hsit->curr=_curr;                                                                                                                                                                                                               \
-               hsit->set=_set;                                                                                                                                                                                                                 \
-               return hsit;                                                                                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void deleteIter ## Name(HSIterator ## Name *hsit) {                                                                             \
-               ourfree(hsit);                                                                                                                                                                                                                  \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       bool hasNext ## Name(HSIterator ## Name *hsit) {                                                                                        \
-               return hsit->curr!=NULL;                                                                                                                                                                                \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Key next ## Name(HSIterator ## Name *hsit) {                                                                                                   \
-               _Key k=hsit->curr->key;                                                                                                                                                                                 \
-               hsit->last=hsit->curr;                                                                                                                                                                                  \
-               hsit->curr=hsit->curr->next;                                                                                                                                                            \
-               return k;                                                                                                                                                                                                                                               \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Key currKey ## Name(HSIterator ## Name *hsit) {                                                                                        \
-               return hsit->last->key;                                                                                                                                                                                 \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void removeIter ## Name(HSIterator ## Name *hsit) {                                                                             \
-               _Key k=hsit->last->key;                                                                                                                                                                                 \
-               removeSet ## Name(hsit->set, k);                                                                                                                                                \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
+               HSIterator ## Name * hsit = (HSIterator ## Name *)ourmalloc(sizeof(HSIterator ## Name)); \
+               hsit->curr=_curr;                                                   \
+               hsit->set=_set;                                                     \
+               return hsit;                                                        \
+       }                                                                     \
+                                                                        \
+       void deleteIter ## Name(HSIterator ## Name *hsit) {                   \
+               ourfree(hsit);                                                      \
+       }                                                                     \
+                                                                        \
+       bool hasNext ## Name(HSIterator ## Name *hsit) {                      \
+               return hsit->curr!=NULL;                                            \
+       }                                                                     \
+                                                                        \
+       _Key next ## Name(HSIterator ## Name *hsit) {                         \
+               _Key k=hsit->curr->key;                                             \
+               hsit->last=hsit->curr;                                              \
+               hsit->curr=hsit->curr->next;                                        \
+               return k;                                                           \
+       }                                                                     \
+                                                                        \
+       _Key currKey ## Name(HSIterator ## Name *hsit) {                      \
+               return hsit->last->key;                                             \
+       }                                                                     \
+                                                                        \
+       void removeIter ## Name(HSIterator ## Name *hsit) {                   \
+               _Key k=hsit->last->key;                                             \
+               removeSet ## Name(hsit->set, k);                                    \
+       }                                                                     \
+                                                                        \
        HashSet ## Name * allocHashSet ## Name (unsigned int initialcapacity, double factor) { \
-               HashSet ## Name * set = (HashSet ## Name *) ourmalloc(sizeof(struct HashSet ## Name));  \
-               set->table=allocHashTable ## Name ## Set(initialcapacity, factor);                                      \
-               set->list=NULL;                                                                                                                                                                                                                 \
-               set->tail=NULL;                                                                                                                                                                                                                 \
-               return set;                                                                                                                                                                                                                                     \
-}                                                                                                                                                                                                                                                                                              \
-                                                                                                                                                                                                                                                                                               \
-       void deleteHashSet ## Name(struct HashSet ## Name * set) {                                              \
-               LinkNode ## Name *tmp=set->list;                                                                                                                                                \
-               while(tmp!=NULL) {                                                                                                                                                                                                      \
-                       LinkNode ## Name *tmpnext=tmp->next;                                                                                                                    \
-                       ourfree(tmp);                                                                                                                                                                                                                   \
-                       tmp=tmpnext;                                                                                                                                                                                                                    \
-               }                                                                                                                                                                                                                                                                               \
-               deleteHashTable ## Name ## Set(set->table);                                                                                                     \
-               ourfree(set);                                                                                                                                                                                                                           \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       HashSet ## Name * copy ## Name(HashSet ## Name * set) {                                                         \
+               HashSet ## Name * set = (HashSet ## Name *)ourmalloc(sizeof(struct HashSet ## Name));  \
+               set->table=allocHashTable ## Name ## Set(initialcapacity, factor);          \
+               set->list=NULL;                                                     \
+               set->tail=NULL;                                                     \
+               return set;                                                         \
+       }                                                                       \
+                                                                        \
+       void deleteHashSet ## Name(struct HashSet ## Name * set) {            \
+               LinkNode ## Name *tmp=set->list;                                    \
+               while(tmp!=NULL) {                                                  \
+                       LinkNode ## Name *tmpnext=tmp->next;                              \
+                       ourfree(tmp);                                                     \
+                       tmp=tmpnext;                                                      \
+               }                                                                   \
+               deleteHashTable ## Name ## Set(set->table);                         \
+               ourfree(set);                                                       \
+       }                                                                     \
+                                                                        \
+       HashSet ## Name * copy ## Name(HashSet ## Name * set) {               \
                HashSet ## Name *copy=allocHashSet ## Name(getCapacity ## Name ## Set(set->table), getLoadFactor ## Name ## Set(set->table)); \
-               HSIterator ## Name * it=iterator ## Name(set);                                                                                  \
-               while(hasNext ## Name(it))                                                                                                                                                                      \
-                       add ## Name(copy, next ## Name(it));                                                                                                                    \
-               deleteIter ## Name(it);                                                                                                                                                                                 \
-               return copy;                                                                                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void resetSet ## Name(HashSet ## Name * set) {                                                                                          \
-               LinkNode ## Name *tmp=set->list;                                                                                                                                                \
-               while(tmp!=NULL) {                                                                                                                                                                                                      \
-                       LinkNode ## Name *tmpnext=tmp->next;                                                                                                                    \
-                       ourfree(tmp);                                                                                                                                                                                                                   \
-                       tmp=tmpnext;                                                                                                                                                                                                                    \
-               }                                                                                                                                                                                                                                                                               \
-               set->list=set->tail=NULL;                                                                                                                                                                               \
-               reset ## Name ## Set(set->table);                                                                                                                                               \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       bool add ## Name(HashSet ## Name * set,_Key key) {                                                                              \
-               LinkNode ## Name * val=get ## Name ## Set(set->table, key);                                     \
-               if (val==NULL) {                                                                                                                                                                                                                \
+               HSIterator ## Name * it=iterator ## Name(set);                      \
+               while(hasNext ## Name(it))                                          \
+                       add ## Name(copy, next ## Name(it));                              \
+               deleteIter ## Name(it);                                             \
+               return copy;                                                        \
+       }                                                                     \
+                                                                        \
+       void resetSet ## Name(HashSet ## Name * set) {                        \
+               LinkNode ## Name *tmp=set->list;                                    \
+               while(tmp!=NULL) {                                                  \
+                       LinkNode ## Name *tmpnext=tmp->next;                              \
+                       ourfree(tmp);                                                     \
+                       tmp=tmpnext;                                                      \
+               }                                                                   \
+               set->list=set->tail=NULL;                                           \
+               reset ## Name ## Set(set->table);                                   \
+       }                                                                     \
+                                                                        \
+       bool add ## Name(HashSet ## Name * set,_Key key) {                    \
+               LinkNode ## Name * val=get ## Name ## Set(set->table, key);         \
+               if (val==NULL) {                                                    \
                        LinkNode ## Name * newnode=(LinkNode ## Name *)ourmalloc(sizeof(struct LinkNode ## Name)); \
-                       newnode->prev=set->tail;                                                                                                                                                                        \
-                       newnode->next=NULL;                                                                                                                                                                                             \
-                       newnode->key=key;                                                                                                                                                                                                       \
-                       if (set->tail!=NULL)                                                                                                                                                                                    \
-                               set->tail->next=newnode;                                                                                                                                                                \
-                       else                                                                                                                                                                                                                                                    \
-                               set->list=newnode;                                                                                                                                                                                      \
-                       set->tail=newnode;                                                                                                                                                                                              \
-                       put ## Name ## Set(set->table, key, newnode);                                                                                   \
-                       return true;                                                                                                                                                                                                                    \
-               } else                                                                                                                                                                                                                                                  \
-                       return false;                                                                                                                                                                                                                   \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Key getSet ## Name(HashSet ## Name * set,_Key key) {                                                                   \
-               LinkNode ## Name * val=get ## Name ## Set(set->table, key);                                     \
-               if (val!=NULL)                                                                                                                                                                                                                  \
-                       return val->key;                                                                                                                                                                                                        \
-               else                                                                                                                                                                                                                                                            \
-                       return NULL;                                                                                                                                                                                                                    \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Key getFirstKey ## Name(HashSet ## Name * set) {                                                                                       \
-               return set->list->key;                                                                                                                                                                                  \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       bool containsSet ## Name(HashSet ## Name * set,_Key key) {                                              \
-               return get ## Name ## Set(set->table, key)!=NULL;                                                                               \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       bool removeSet ## Name(HashSet ## Name * set,_Key key) {                                                        \
-               LinkNode ## Name * oldlinknode;                                                                                                                                                 \
-               oldlinknode=get ## Name ## Set(set->table, key);                                                                                \
-               if (oldlinknode==NULL) {                                                                                                                                                                                \
-                       return false;                                                                                                                                                                                                                   \
-               }                                                                                                                                                                                                                                                                               \
-               remove ## Name ## Set(set->table, key);                                                                                                                 \
-                                                                                                                                                                                                                                                                                               \
-               if (oldlinknode->prev==NULL)                                                                                                                                                            \
-                       set->list=oldlinknode->next;                                                                                                                                                    \
-               else                                                                                                                                                                                                                                                            \
-                       oldlinknode->prev->next=oldlinknode->next;                                                                                              \
-               if (oldlinknode->next!=NULL)                                                                                                                                                            \
-                       oldlinknode->next->prev=oldlinknode->prev;                                                                                              \
-               else                                                                                                                                                                                                                                                            \
-                       set->tail=oldlinknode->prev;                                                                                                                                                    \
-               ourfree(oldlinknode);                                                                                                                                                                                           \
-               return true;                                                                                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       unsigned int getSizeSet ## Name(HashSet ## Name * set) {                                                        \
-               return getSizeTable ## Name ## Set(set->table);                                                                                 \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       bool isEmpty ## Name(HashSet ## Name * set) {                                                                                                   \
-               return getSizeSet ## Name(set)==0;                                                                                                                                      \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       HSIterator ## Name * iterator ## Name(HashSet ## Name * set) {                          \
-               return allocHSIterator ## Name(set->list, set);                                                                                 \
-       }       
+                       newnode->prev=set->tail;                                          \
+                       newnode->next=NULL;                                               \
+                       newnode->key=key;                                                 \
+                       if (set->tail!=NULL)                                              \
+                               set->tail->next=newnode;                                        \
+                       else                                                              \
+                               set->list=newnode;                                              \
+                       set->tail=newnode;                                                \
+                       put ## Name ## Set(set->table, key, newnode);                     \
+                       return true;                                                      \
+               } else                                                              \
+                       return false;                                                     \
+       }                                                                     \
+                                                                        \
+       _Key getSet ## Name(HashSet ## Name * set,_Key key) {                 \
+               LinkNode ## Name * val=get ## Name ## Set(set->table, key);         \
+               if (val!=NULL)                                                      \
+                       return val->key;                                                  \
+               else                                                                \
+                       return NULL;                                                      \
+       }                                                                     \
+                                                                        \
+       _Key getFirstKey ## Name(HashSet ## Name * set) {                     \
+               return set->list->key;                                              \
+       }                                                                     \
+                                                                        \
+       bool containsSet ## Name(HashSet ## Name * set,_Key key) {            \
+               return get ## Name ## Set(set->table, key)!=NULL;                   \
+       }                                                                     \
+                                                                        \
+       bool removeSet ## Name(HashSet ## Name * set,_Key key) {              \
+               LinkNode ## Name * oldlinknode;                                     \
+               oldlinknode=get ## Name ## Set(set->table, key);                    \
+               if (oldlinknode==NULL) {                                            \
+                       return false;                                                     \
+               }                                                                   \
+               remove ## Name ## Set(set->table, key);                             \
+                                                                        \
+               if (oldlinknode->prev==NULL)                                        \
+                       set->list=oldlinknode->next;                                      \
+               else                                                                \
+                       oldlinknode->prev->next=oldlinknode->next;                        \
+               if (oldlinknode->next!=NULL)                                        \
+                       oldlinknode->next->prev=oldlinknode->prev;                        \
+               else                                                                \
+                       set->tail=oldlinknode->prev;                                      \
+               ourfree(oldlinknode);                                               \
+               return true;                                                        \
+       }                                                                     \
+                                                                        \
+       unsigned int getSizeSet ## Name(HashSet ## Name * set) {              \
+               return getSizeTable ## Name ## Set(set->table);                     \
+       }                                                                     \
+                                                                        \
+       bool isEmpty ## Name(HashSet ## Name * set) {                         \
+               return getSizeSet ## Name(set)==0;                                  \
+       }                                                                     \
+                                                                        \
+       HSIterator ## Name * iterator ## Name(HashSet ## Name * set) {        \
+               return allocHSIterator ## Name(set->list, set);                     \
+       }
 #endif
index e0db665..c9ea34f 100644 (file)
  * @tparam _Val    Type name for the values to be stored
  */
 #define HashTableDef(Name, _Key, _Val, hash_function, equals)\
-       struct hashlistnode ## Name {                                                                                                                                                                   \
-       _Key key;                                                                                                                                                                                                                                                       \
-       _Val val;                                                                                                                                                                                                                                                       \
-       };                                                                                                                                                                                                                                                                              \
-                                                                                                                                                                                                                                                                                               \
-       struct HashTable ## Name {                                                                                                                                                                              \
-       struct hashlistnode ## Name *table;                                                                                                                                             \
-       struct hashlistnode ## Name  *zero;                                                                                                                                             \
-       unsigned int capacity;                                                                                                                                                                                          \
-       unsigned int size;                                                                                                                                                                                                              \
-       unsigned int capacitymask;                                                                                                                                                                              \
-       unsigned int threshold;                                                                                                                                                                                         \
-       double loadfactor;                                                                                                                                                                                                              \
-       };                                                                                                                                                                                                                                                                              \
-                                                                                                                                                                                                                                                                                               \
-       typedef struct HashTable ## Name HashTable ## Name;                                                                             \
+       struct hashlistnode ## Name {                                         \
+               _Key key;                                                             \
+               _Val val;                                                             \
+       };                                                                    \
+                                                                        \
+       struct HashTable ## Name {                                            \
+               struct hashlistnode ## Name *table;                                   \
+               struct hashlistnode ## Name  *zero;                                   \
+               unsigned int capacity;                                                \
+               unsigned int size;                                                    \
+               unsigned int capacitymask;                                            \
+               unsigned int threshold;                                               \
+               double loadfactor;                                                    \
+       };                                                                    \
+                                                                        \
+       typedef struct HashTable ## Name HashTable ## Name;                   \
        HashTable ## Name * allocHashTable ## Name(unsigned int initialcapacity, double factor); \
-       void deleteHashTable ## Name(HashTable ## Name * tab);                                                                  \
-       void reset ## Name(HashTable ## Name * tab);                                                                                                    \
-       void resetandfree ## Name(HashTable ## Name * tab);                                                                             \
-       void put ## Name(HashTable ## Name * tab, _Key key, _Val val);                          \
-       _Val get ## Name(const HashTable ## Name * tab, _Key key);                                              \
-       _Val remove ## Name(HashTable ## Name * tab, _Key key);                                                         \
-       unsigned int getSizeTable ## Name(const HashTable ## Name * tab);                       \
-       bool contains ## Name(const HashTable ## Name * tab, _Key key);                         \
-       void resize ## Name(HashTable ## Name * tab, unsigned int newsize);             \
-       double getLoadFactor ## Name(HashTable ## Name * tab);                                                          \
+       void deleteHashTable ## Name(HashTable ## Name * tab);                  \
+       void reset ## Name(HashTable ## Name * tab);                          \
+       void resetandfree ## Name(HashTable ## Name * tab);                   \
+       void put ## Name(HashTable ## Name * tab, _Key key, _Val val);        \
+       _Val get ## Name(const HashTable ## Name * tab, _Key key);            \
+       _Val remove ## Name(HashTable ## Name * tab, _Key key);               \
+       unsigned int getSizeTable ## Name(const HashTable ## Name * tab);     \
+       bool contains ## Name(const HashTable ## Name * tab, _Key key);       \
+       void resize ## Name(HashTable ## Name * tab, unsigned int newsize);   \
+       double getLoadFactor ## Name(HashTable ## Name * tab);                \
        unsigned int getCapacity ## Name(HashTable ## Name * tab);
 
 #define HashTableImpl(Name, _Key, _Val, hash_function, equals) \
-       HashTable ## Name * allocHashTable ## Name(unsigned int initialcapacity, double factor) {       \
-               HashTable ## Name * tab = (HashTable ## Name *) ourmalloc(sizeof(HashTable ## Name));   \
-               tab -> table = (struct hashlistnode ## Name *) ourcalloc(initialcapacity, sizeof(struct hashlistnode ## Name)); \
-               tab->zero = NULL;                                                                                                                                                                                                               \
-               tab->loadfactor = factor;                                                                                                                                                                               \
-               tab->capacity = initialcapacity;                                                                                                                                                \
-               tab->capacitymask = initialcapacity - 1;                                                                                                                \
-                                                                                                                                                                                                                                                                                               \
-               tab->threshold = (unsigned int)(initialcapacity * factor);                                      \
-               tab->size = 0;                                                                                                                                                                                                                  \
-               return tab;                                                                                                                                                                                                                                     \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void deleteHashTable ## Name(HashTable ## Name * tab) {                                                                 \
-               ourfree(tab->table);                                                                                                                                                                                            \
-               if (tab->zero)                                                                                                                                                                                                                  \
-                       ourfree(tab->zero);                                                                                                                                                                                             \
-               ourfree(tab);                                                                                                                                                                                                                           \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void reset ## Name(HashTable ## Name * tab) {                                                                                                   \
+       HashTable ## Name * allocHashTable ## Name(unsigned int initialcapacity, double factor) { \
+               HashTable ## Name * tab = (HashTable ## Name *)ourmalloc(sizeof(HashTable ## Name)); \
+               tab->table = (struct hashlistnode ## Name *)ourcalloc(initialcapacity, sizeof(struct hashlistnode ## Name)); \
+               tab->zero = NULL;                                                   \
+               tab->loadfactor = factor;                                           \
+               tab->capacity = initialcapacity;                                    \
+               tab->capacitymask = initialcapacity - 1;                            \
+                                                                        \
+               tab->threshold = (unsigned int)(initialcapacity * factor);          \
+               tab->size = 0;                                                      \
+               return tab;                                                         \
+       }                                                                     \
+                                                                        \
+       void deleteHashTable ## Name(HashTable ## Name * tab) {                 \
+               ourfree(tab->table);                                                \
+               if (tab->zero)                                                      \
+                       ourfree(tab->zero);                                               \
+               ourfree(tab);                                                       \
+       }                                                                     \
+                                                                        \
+       void reset ## Name(HashTable ## Name * tab) {                         \
                memset(tab->table, 0, tab->capacity * sizeof(struct hashlistnode ## Name)); \
-               if (tab->zero) {                                                                                                                                                                                                                \
-                       ourfree(tab->zero);                                                                                                                                                                                             \
-                       tab->zero = NULL;                                                                                                                                                                                                       \
-               }                                                                                                                                                                                                                                                                               \
-               tab->size = 0;                                                                                                                                                                                                                  \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void resetandfree ## Name(HashTable ## Name * tab) {                                                                    \
-               for(unsigned int i=0;i<tab->capacity;i++) {                                                                                                     \
-                       struct hashlistnode ## Name *bin = &tab->table[i];                                                              \
-                       if (bin->key != NULL) {                                                                                                                                                                         \
-                               bin->key = NULL;                                                                                                                                                                                                \
-                               if (bin->val != NULL) {                                                                                                                                                                 \
-                                       ourfree(bin->val);                                                                                                                                                                              \
-                                       bin->val = NULL;                                                                                                                                                                                        \
-                               }                                                                                                                                                                                                                                                               \
-                       }                                                                                                                                                                                                                                                                       \
-               }                                                                                                                                                                                                                                                                               \
-               if (tab->zero) {                                                                                                                                                                                                                \
-                       if (tab->zero->val != NULL)                                                                                                                                                             \
-                               ourfree(tab->zero->val);                                                                                                                                                                \
-                       ourfree(tab->zero);                                                                                                                                                                                             \
-                       tab->zero = NULL;                                                                                                                                                                                                       \
-               }                                                                                                                                                                                                                                                                               \
-               tab->size = 0;                                                                                                                                                                                                                  \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void put ## Name(HashTable ## Name * tab, _Key key, _Val val) {                         \
-               if (!key) {                                                                                                                                                                                                                                     \
-                       if (!tab->zero) {                                                                                                                                                                                                       \
+               if (tab->zero) {                                                    \
+                       ourfree(tab->zero);                                               \
+                       tab->zero = NULL;                                                 \
+               }                                                                   \
+               tab->size = 0;                                                      \
+       }                                                                     \
+                                                                        \
+       void resetandfree ## Name(HashTable ## Name * tab) {                  \
+               for(unsigned int i=0;i<tab->capacity;i++) {                         \
+                       struct hashlistnode ## Name *bin = &tab->table[i];                \
+                       if (bin->key != NULL) {                                           \
+                               bin->key = NULL;                                                \
+                               if (bin->val != NULL) {                                         \
+                                       ourfree(bin->val);                                            \
+                                       bin->val = NULL;                                              \
+                               }                                                               \
+                       }                                                                 \
+               }                                                                   \
+               if (tab->zero) {                                                    \
+                       if (tab->zero->val != NULL)                                       \
+                               ourfree(tab->zero->val);                                        \
+                       ourfree(tab->zero);                                               \
+                       tab->zero = NULL;                                                 \
+               }                                                                   \
+               tab->size = 0;                                                      \
+       }                                                                     \
+                                                                        \
+       void put ## Name(HashTable ## Name * tab, _Key key, _Val val) {       \
+               if (!key) {                                                         \
+                       if (!tab->zero) {                                                 \
                                tab->zero=(struct hashlistnode ## Name *)ourmalloc(sizeof(struct hashlistnode ## Name)); \
-                               tab->size++;                                                                                                                                                                                                            \
-                       }                                                                                                                                                                                                                                                                       \
-                       tab->zero->key=key;                                                                                                                                                                                             \
-                       tab->zero->val=val;                                                                                                                                                                                             \
-                       return;                                                                                                                                                                                                                                         \
-               }                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-               if (tab->size > tab->threshold)                                                                                                                                                 \
-                       resize ## Name (tab, tab->capacity << 1);                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-               struct hashlistnode ## Name *search;                                                                                                                            \
-                                                                                                                                                                                                                                                                                               \
-               unsigned int index = hash_function(key);                                                                                                                \
-               do {                                                                                                                                                                                                                                                            \
-                       index &= tab->capacitymask;                                                                                                                                                             \
-                       search = &tab->table[index];                                                                                                                                                    \
-                       if (!search->key) {                                                                                                                                                                                             \
-                               break;                                                                                                                                                                                                                                  \
-                       }                                                                                                                                                                                                                                                                       \
-                       if (equals(search->key, key)) {                                                                                                                                         \
-                               search->val = val;                                                                                                                                                                                      \
-                               return;                                                                                                                                                                                                                                 \
-                       }                                                                                                                                                                                                                                                                       \
-                       index++;                                                                                                                                                                                                                                        \
-               } while (true);                                                                                                                                                                                                                 \
-                                                                                                                                                                                                                                                                                               \
-               search->key = key;                                                                                                                                                                                                      \
-               search->val = val;                                                                                                                                                                                                      \
-               tab->size++;                                                                                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Val get ## Name(const HashTable ## Name * tab, _Key key) {                                     \
-               struct hashlistnode ## Name *search;                                                                                                                            \
-                                                                                                                                                                                                                                                                                               \
-               if (!key) {                                                                                                                                                                                                                                     \
-                       if (tab->zero)                                                                                                                                                                                                          \
-                               return tab->zero->val;                                                                                                                                                                  \
-                       else                                                                                                                                                                                                                                                    \
-                               return (_Val) 0;                                                                                                                                                                                                \
-               }                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-               unsigned int oindex = hash_function(key) & tab->capacitymask;                           \
-               unsigned int index=oindex;                                                                                                                                                                      \
-               do {                                                                                                                                                                                                                                                            \
-                       search = &tab->table[index];                                                                                                                                                    \
-                       if (!search->key) {                                                                                                                                                                                             \
-                               if (!search->val)                                                                                                                                                                                               \
-                                       break;                                                                                                                                                                                                                          \
-                       } else                                                                                                                                                                                                                                          \
-                               if (equals(search->key, key))                                                                                                                                           \
-                                       return search->val;                                                                                                                                                                             \
-                       index++;                                                                                                                                                                                                                                        \
-                       index &= tab->capacitymask;                                                                                                                                                             \
-                       if (index==oindex)                                                                                                                                                                                              \
-                               break;                                                                                                                                                                                                                                  \
-               } while (true);                                                                                                                                                                                                                 \
-               return (_Val)0;                                                                                                                                                                                                                 \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       _Val remove ## Name(HashTable ## Name * tab, _Key key) {                                                        \
-               struct hashlistnode ## Name *search;                                                                                                                            \
-                                                                                                                                                                                                                                                                                               \
-               if (!key) {                                                                                                                                                                                                                                     \
-                       if (!tab->zero) {                                                                                                                                                                                                       \
-                               return (_Val)0;                                                                                                                                                                                                 \
-                       } else {                                                                                                                                                                                                                                        \
-                               _Val v=tab->zero->val;                                                                                                                                                                  \
-                               ourfree(tab->zero);                                                                                                                                                                                     \
-                               tab->zero=NULL;                                                                                                                                                                                                 \
-                               tab->size--;                                                                                                                                                                                                            \
-                               return v;                                                                                                                                                                                                                               \
-                       }                                                                                                                                                                                                                                                                       \
-               }                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-               unsigned int index = hash_function(key);                                                                                                                \
-               do {                                                                                                                                                                                                                                                            \
-                       index &= tab->capacitymask;                                                                                                                                                             \
-                       search = &tab->table[index];                                                                                                                                                    \
-                       if (!search->key) {                                                                                                                                                                                             \
-                               if (!search->val)                                                                                                                                                                                               \
-                                       break;                                                                                                                                                                                                                          \
-                       } else                                                                                                                                                                                                                                          \
-                               if (equals(search->key, key)) {                                                                                                                                 \
-                                       _Val v=search->val;                                                                                                                                                                             \
-                                       search->val=(_Val) 1;                                                                                                                                                                   \
-                                       search->key=0;                                                                                                                                                                                          \
-                                       tab->size--;                                                                                                                                                                                                    \
-                                       return v;                                                                                                                                                                                                                       \
-                               }                                                                                                                                                                                                                                                               \
-                       index++;                                                                                                                                                                                                                                        \
-               } while (true);                                                                                                                                                                                                                 \
-               return (_Val)0;                                                                                                                                                                                                                 \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       unsigned int getSizeTable ## Name(const HashTable ## Name * tab) {              \
-               return tab->size;                                                                                                                                                                                                               \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-       bool contains ## Name(const HashTable ## Name * tab, _Key key) {                        \
-               struct hashlistnode ## Name *search;                                                                                                                            \
-               if (!key) {                                                                                                                                                                                                                                     \
-                       return tab->zero!=NULL;                                                                                                                                                                         \
-               }                                                                                                                                                                                                                                                                               \
-               unsigned int index = hash_function(key);                                                                                                                \
-               do {                                                                                                                                                                                                                                                            \
-                       index &= tab->capacitymask;                                                                                                                                                             \
-                       search = &tab->table[index];                                                                                                                                                    \
-                       if (!search->key) {                                                                                                                                                                                             \
-                               if (!search->val)                                                                                                                                                                                               \
-                                       break;                                                                                                                                                                                                                          \
-                       } else                                                                                                                                                                                                                                          \
-                               if (equals(search->key, key))                                                                                                                                           \
-                                       return true;                                                                                                                                                                                                    \
-                       index++;                                                                                                                                                                                                                                        \
-               } while (true);                                                                                                                                                                                                                 \
-               return false;                                                                                                                                                                                                                           \
-       }                                                                                                                                                                                                                                                                                       \
-                                                                                                                                                                                                                                                                                               \
-       void resize ## Name(HashTable ## Name * tab, unsigned int newsize) {    \
-               struct hashlistnode ## Name *oldtable = tab->table;                                                                     \
-               struct hashlistnode ## Name *newtable;                                                                                                                  \
-               unsigned int oldcapacity = tab->capacity;                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
+                               tab->size++;                                                    \
+                       }                                                                 \
+                       tab->zero->key=key;                                               \
+                       tab->zero->val=val;                                               \
+                       return;                                                           \
+               }                                                                   \
+                                                                        \
+               if (tab->size > tab->threshold)                                     \
+                       resize ## Name (tab, tab->capacity << 1);                         \
+                                                                        \
+               struct hashlistnode ## Name *search;                                \
+                                                                        \
+               unsigned int index = hash_function(key);                            \
+               do {                                                                \
+                       index &= tab->capacitymask;                                       \
+                       search = &tab->table[index];                                      \
+                       if (!search->key) {                                               \
+                               break;                                                          \
+                       }                                                                 \
+                       if (equals(search->key, key)) {                                   \
+                               search->val = val;                                              \
+                               return;                                                         \
+                       }                                                                 \
+                       index++;                                                          \
+               } while (true);                                                     \
+                                                                        \
+               search->key = key;                                                  \
+               search->val = val;                                                  \
+               tab->size++;                                                        \
+       }                                                                     \
+                                                                        \
+       _Val get ## Name(const HashTable ## Name * tab, _Key key) {         \
+               struct hashlistnode ## Name *search;                                \
+                                                                        \
+               if (!key) {                                                         \
+                       if (tab->zero)                                                    \
+                               return tab->zero->val;                                          \
+                       else                                                              \
+                               return (_Val) 0;                                                \
+               }                                                                   \
+                                                                        \
+               unsigned int oindex = hash_function(key) & tab->capacitymask;       \
+               unsigned int index=oindex;                                          \
+               do {                                                                \
+                       search = &tab->table[index];                                      \
+                       if (!search->key) {                                               \
+                               if (!search->val)                                               \
+                                       break;                                                        \
+                       } else                                                            \
+                       if (equals(search->key, key))                                   \
+                               return search->val;                                           \
+                       index++;                                                          \
+                       index &= tab->capacitymask;                                       \
+                       if (index==oindex)                                                \
+                               break;                                                          \
+               } while (true);                                                     \
+               return (_Val)0;                                                     \
+       }                                                                     \
+                                                                        \
+       _Val remove ## Name(HashTable ## Name * tab, _Key key) {              \
+               struct hashlistnode ## Name *search;                                \
+                                                                        \
+               if (!key) {                                                         \
+                       if (!tab->zero) {                                                 \
+                               return (_Val)0;                                                 \
+                       } else {                                                          \
+                               _Val v=tab->zero->val;                                          \
+                               ourfree(tab->zero);                                             \
+                               tab->zero=NULL;                                                 \
+                               tab->size--;                                                    \
+                               return v;                                                       \
+                       }                                                                 \
+               }                                                                   \
+                                                                        \
+               unsigned int index = hash_function(key);                            \
+               do {                                                                \
+                       index &= tab->capacitymask;                                       \
+                       search = &tab->table[index];                                      \
+                       if (!search->key) {                                               \
+                               if (!search->val)                                               \
+                                       break;                                                        \
+                       } else                                                            \
+                       if (equals(search->key, key)) {                                 \
+                               _Val v=search->val;                                           \
+                               search->val=(_Val) 1;                                         \
+                               search->key=0;                                                \
+                               tab->size--;                                                  \
+                               return v;                                                     \
+                       }                                                               \
+                       index++;                                                          \
+               } while (true);                                                     \
+               return (_Val)0;                                                     \
+       }                                                                     \
+                                                                        \
+       unsigned int getSizeTable ## Name(const HashTable ## Name * tab) {    \
+               return tab->size;                                                   \
+       }                                                                     \
+                                                                        \
+                                                                        \
+       bool contains ## Name(const HashTable ## Name * tab, _Key key) {      \
+               struct hashlistnode ## Name *search;                                \
+               if (!key) {                                                         \
+                       return tab->zero!=NULL;                                           \
+               }                                                                   \
+               unsigned int index = hash_function(key);                            \
+               do {                                                                \
+                       index &= tab->capacitymask;                                       \
+                       search = &tab->table[index];                                      \
+                       if (!search->key) {                                               \
+                               if (!search->val)                                               \
+                                       break;                                                        \
+                       } else                                                            \
+                       if (equals(search->key, key))                                   \
+                               return true;                                                  \
+                       index++;                                                          \
+               } while (true);                                                     \
+               return false;                                                       \
+       }                                                                     \
+                                                                        \
+       void resize ## Name(HashTable ## Name * tab, unsigned int newsize) {  \
+               struct hashlistnode ## Name *oldtable = tab->table;                 \
+               struct hashlistnode ## Name *newtable;                              \
+               unsigned int oldcapacity = tab->capacity;                           \
+                                                                        \
                if ((newtable = (struct hashlistnode ## Name *)ourcalloc(newsize, sizeof(struct hashlistnode ## Name))) == NULL) { \
-                       model_print("calloc error %s %d\n", __FILE__, __LINE__);                                        \
-                       exit(EXIT_FAILURE);                                                                                                                                                                                             \
-               }                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-               tab->table = newtable;                                                                                                                                                                                  \
-               tab->capacity = newsize;                                                                                                                                                                                \
-               tab->capacitymask = newsize - 1;                                                                                                                                                \
-                                                                                                                                                                                                                                                                                               \
-               tab->threshold = (unsigned int)(newsize * tab->loadfactor);                                     \
-                                                                                                                                                                                                                                                                                               \
-               struct hashlistnode ## Name *bin = &oldtable[0];                                                                                \
-               struct hashlistnode ## Name *lastbin = &oldtable[oldcapacity];                  \
-               for (;bin < lastbin;bin++) {                                                                                                                                                            \
-                       _Key key = bin->key;                                                                                                                                                                                    \
-                                                                                                                                                                                                                                                                                               \
-                       struct hashlistnode ## Name *search;                                                                                                                    \
-                       if (!key)                                                                                                                                                                                                                                       \
-                               continue;                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-                       unsigned int index = hash_function(key);                                                                                                        \
-                       do {                                                                                                                                                                                                                                                    \
-                               index &= tab->capacitymask;                                                                                                                                                     \
-                               search = &tab->table[index];                                                                                                                                            \
-                               index++;                                                                                                                                                                                                                                \
-                       } while (search->key);                                                                                                                                                                          \
-                                                                                                                                                                                                                                                                                               \
-                       search->key = key;                                                                                                                                                                                              \
-                       search->val = bin->val;                                                                                                                                                                         \
-               }                                                                                                                                                                                                                                                                               \
-                                                                                                                                                                                                                                                                                               \
-               ourfree(oldtable);                                                                                                                                                                                                      \
-       }                                                                                                                                                                                                                                                                                       \
+                       model_print("calloc error %s %d\n", __FILE__, __LINE__);          \
+                       exit(EXIT_FAILURE);                                               \
+               }                                                                   \
+                                                                        \
+               tab->table = newtable;                                              \
+               tab->capacity = newsize;                                            \
+               tab->capacitymask = newsize - 1;                                    \
+                                                                        \
+               tab->threshold = (unsigned int)(newsize * tab->loadfactor);         \
+                                                                        \
+               struct hashlistnode ## Name *bin = &oldtable[0];                    \
+               struct hashlistnode ## Name *lastbin = &oldtable[oldcapacity];      \
+               for (;bin < lastbin;bin++) {                                        \
+                       _Key key = bin->key;                                              \
+                                                                        \
+                       struct hashlistnode ## Name *search;                              \
+                       if (!key)                                                         \
+                               continue;                                                       \
+                                                                        \
+                       unsigned int index = hash_function(key);                          \
+                       do {                                                              \
+                               index &= tab->capacitymask;                                     \
+                               search = &tab->table[index];                                    \
+                               index++;                                                        \
+                       } while (search->key);                                            \
+                                                                        \
+                       search->key = key;                                                \
+                       search->val = bin->val;                                           \
+               }                                                                   \
+                                                                        \
+               ourfree(oldtable);                                                  \
+       }                                                                     \
        double getLoadFactor ## Name(HashTable ## Name * tab) {return tab->loadfactor;} \
        unsigned int getCapacity ## Name(HashTable ## Name * tab) {return tab->capacity;}
 
index d131a27..08c540c 100644 (file)
@@ -2,60 +2,60 @@
 #define VECTOR_H
 #include <string.h>
 
-#define VectorDef(name, type, defcap)                                                                                                                                          \
-       struct Vector ## name {                                                                                                                                                                                         \
-               uint size;                                                                                                                                                                                                                                      \
-               uint capacity;                                                                                                                                                                                                                  \
-               type * array;                                                                                                                                                                                                                           \
-       };                                                                                                                                                                                                                                                                              \
-       typedef struct Vector ## name Vector ## name;                                                                                                   \
-       Vector ## name * allocVector ## name(uint capacity);                                                                    \
-       Vector ## name * allocDefVector ## name();                                                                                                              \
+#define VectorDef(name, type, defcap)                                   \
+       struct Vector ## name {                                               \
+               uint size;                                                          \
+               uint capacity;                                                      \
+               type * array;                                                       \
+       };                                                                    \
+       typedef struct Vector ## name Vector ## name;                         \
+       Vector ## name * allocVector ## name(uint capacity);                  \
+       Vector ## name * allocDefVector ## name();                            \
        Vector ## name * allocVectorArray ## name(uint capacity, type * array); \
-       void pushVector ## name(Vector ## name *vector, type item);                                             \
-       type getVector ## name(Vector ## name *vector, uint index);                                             \
+       void pushVector ## name(Vector ## name *vector, type item);           \
+       type getVector ## name(Vector ## name *vector, uint index);           \
        void setVector ## name(Vector ## name *vector, uint index, type item); \
-       uint getSizeVector ##name(Vector ##name *vector);                                                                                       \
-       void deleteVector ##name(Vector ##name *vector);                                                                                                \
-       void clearVector ##name(Vector ## name *vector);
+       uint getSizeVector ## name(Vector ## name *vector);                     \
+       void deleteVector ## name(Vector ## name *vector);                        \
+       void clearVector ## name(Vector ## name *vector);
 
-#define VectorImpl(name, type, defcap)                                                                                                                                 \
-       Vector ## name * allocDefVector ## name() {                                                                                                             \
-               return allocVector ## name(defcap);                                                                                                                                     \
-       }                                                                                                                                                                                                                                                                                       \
-       Vector ## name * allocVector ## name(uint capacity)     {                                                                       \
-               Vector ## name * tmp = (Vector ## name *) ourmalloc(sizeof(type));      \
-               tmp->size = 0;                                                                                                                                                                                                                  \
-               tmp->capacity = capacity;                                                                                                                                                                               \
-               tmp->array = (type *) ourcalloc(1, sizeof(type) * capacity);                                    \
-               return tmp;                                                                                                                                                                                                                                     \
-       }                                                                                                                                                                                                                                                                                       \
-       Vector ## name * allocVectorArray ## name(uint capacity, type * array)  {       \
-               Vector ## name * tmp = allocVector ## name(capacity);                                                           \
-               memcpy(tmp->array, array, capacity * sizeof(type));                                                                     \
-               return tmp;                                                                                                                                                                                                                                     \
-       }                                                                                                                                                                                                                                                                                       \
-       void pushVector ## name(Vector ## name *vector, type item) {                                    \
-               if (vector->size >= vector->capacity) {                                                                                                                 \
-                       uint newcap=vector->capacity * 2;                                                                                                                                       \
-                       vector->array=(type *)ourrealloc(vector->array, newcap);                                        \
-               }                                                                                                                                                                                                                                                                               \
-               vector->array[vector->size++] = item;                                                                                                                           \
-       }                                                                                                                                                                                                                                                                                       \
-       type getVector ## name(Vector ## name * vector, uint index) {                                   \
-               return vector->array[index];                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
+#define VectorImpl(name, type, defcap)                                  \
+       Vector ## name * allocDefVector ## name() {                           \
+               return allocVector ## name(defcap);                                 \
+       }                                                                     \
+       Vector ## name * allocVector ## name(uint capacity) {                 \
+               Vector ## name * tmp = (Vector ## name *)ourmalloc(sizeof(type));  \
+               tmp->size = 0;                                                      \
+               tmp->capacity = capacity;                                           \
+               tmp->array = (type *) ourcalloc(1, sizeof(type) * capacity);          \
+               return tmp;                                                         \
+       }                                                                     \
+       Vector ## name * allocVectorArray ## name(uint capacity, type * array)  { \
+               Vector ## name * tmp = allocVector ## name(capacity);               \
+               memcpy(tmp->array, array, capacity * sizeof(type));                 \
+               return tmp;                                                         \
+       }                                                                     \
+       void pushVector ## name(Vector ## name *vector, type item) {          \
+               if (vector->size >= vector->capacity) {                             \
+                       uint newcap=vector->capacity * 2;                                 \
+                       vector->array=(type *)ourrealloc(vector->array, newcap);          \
+               }                                                                   \
+               vector->array[vector->size++] = item;                               \
+       }                                                                     \
+       type getVector ## name(Vector ## name * vector, uint index) {         \
+               return vector->array[index];                                        \
+       }                                                                     \
        void setVector ## name(Vector ## name * vector, uint index, type item) { \
-               vector->array[index]=item;                                                                                                                                                                      \
-       }                                                                                                                                                                                                                                                                                       \
-       uint getSizeVector ## name(Vector ## name *vector) {                                                                    \
-               return vector->size;                                                                                                                                                                                            \
-       }                                                                                                                                                                                                                                                                                       \
-       void deleteVector ##name(Vector ##name *vector) {                                                                                       \
-               ourfree(vector->array);                                                                                                                                                                                 \
-               ourfree(vector);                                                                                                                                                                                                                \
-       }                                                                                                                                                                                                                                                                                       \
-       void clearVector ##name(Vector ## name *vector) {                                                                                       \
-               vector->size=0;                                                                                                                                                                                                                 \
+               vector->array[index]=item;                                          \
+       }                                                                     \
+       uint getSizeVector ## name(Vector ## name *vector) {                  \
+               return vector->size;                                                \
+       }                                                                     \
+       void deleteVector ## name(Vector ## name *vector) {                     \
+               ourfree(vector->array);                                             \
+               ourfree(vector);                                                    \
+       }                                                                     \
+       void clearVector ## name(Vector ## name *vector) {                     \
+               vector->size=0;                                                     \
        }
 #endif
index 4a6ba80..18a8f4b 100644 (file)
@@ -17,7 +17,7 @@ typedef union ElementPredicate ElementPredicate;
 
 struct FunctionEncoder {
        FunctionEncoderType type;
-       bool isFunction; //true for function, false for predicate
+       bool isFunction;//true for function, false for predicate
        ElementPredicate op;
 };
 
index c9b0633..26a4be9 100644 (file)
@@ -24,7 +24,7 @@ void deleteSolver(CSolver *this) {
        for(uint i=0;i<size;i++) {
                deleteBoolean(getVectorBoolean(this->allBooleans, i));
        }
-       
+
        deleteVectorBoolean(this->allBooleans);
 
        size=getSizeVectorSet(this->allSets);
@@ -78,22 +78,17 @@ Element * getElementVar(CSolver *this, Set * set) {
 }
 
 Boolean * getBooleanVar(CSolver *solver, VarType type) {
-    Boolean* boolean= allocBoolean(type);
-    pushVectorBoolean(solver->allBooleans, boolean);
-    return boolean;
+       Boolean* boolean= allocBoolean(type);
+       pushVectorBoolean(solver->allBooleans, boolean);
+       return boolean;
 }
 
-Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range,
-        enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) {
+Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) {
        return NULL;
 }
 
-//Function * createFunctionOperatorPure(CSolver *solver, enum ArithOp op) {
-//     return NULL;
-//}
-
 Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain, uint numDomain) {
-    return allocPredicate(op, domain,numDomain);
+       return allocPredicate(op, domain,numDomain);
 }
 
 Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range) {
@@ -124,11 +119,11 @@ void addBoolean(CSolver *this, Boolean * constraint) {
 }
 
 Order * createOrder(CSolver *solver, enum OrderType type, Set * set) {
-    return allocOrder(type, set);
+       return allocOrder(type, set);
 }
 
 Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64_t second) {
-    Boolean* constraint = allocBooleanOrder(order, first, second);
-    pushVectorBoolean(solver->allBooleans,constraint);
-    return constraint;
+       Boolean* constraint = allocBooleanOrder(order, first, second);
+       pushVectorBoolean(solver->allBooleans,constraint);
+       return constraint;
 }
index 66c2d7e..15d3f47 100644 (file)
@@ -32,8 +32,8 @@ MutableSet * createMutableSet(CSolver *, VarType type);
 void addItem(CSolver *, MutableSet * set, uint64_t element);
 
 /** This function adds a new unique item to the set and returns it.
-               This function cannot be used in conjunction with manually adding
-               items to the set. */
+    This function cannot be used in conjunction with manually adding
+    items to the set. */
 
 uint64_t createUniqueItem(CSolver *, MutableSet * set);
 
@@ -48,7 +48,7 @@ Boolean * getBooleanVar(CSolver *, VarType type);
 /** This function creates a function operator. */
 
 Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range,
-        enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus);
+                                                                                                                                       enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus);
 
 /** This function creates a predicate operator. */
 
@@ -79,7 +79,7 @@ Boolean * applyPredicate(CSolver *, Predicate * predicate, Element ** inputs);
 Boolean * applyLogicalOperation(CSolver *, enum LogicOp op, Boolean ** array);
 
 /** This function adds a boolean constraint to the set of constraints
-               to be satisfied */
+    to be satisfied */
 
 void addBoolean(CSolver *, Boolean * constraint);