From 8757e01aecc2e4eb4b253609b4b9affca672e903 Mon Sep 17 00:00:00 2001 From: bdemsky Date: Fri, 16 Jun 2017 11:38:56 -0700 Subject: [PATCH] Fix tabbing on everything --- src/AST/boolean.h | 10 +- src/AST/function.h | 4 +- src/AST/order.h | 6 +- src/AST/predicate.h | 4 +- src/Collections/hashset.h | 340 ++++++++++++------------ src/Collections/hashtable.h | 466 ++++++++++++++++----------------- src/Collections/vector.h | 102 ++++---- src/Encoders/functionencoder.h | 2 +- src/csolver.c | 25 +- src/csolver.h | 8 +- 10 files changed, 481 insertions(+), 486 deletions(-) diff --git a/src/AST/boolean.h b/src/AST/boolean.h index f1d2127..030e1d9 100644 --- a/src/AST/boolean.h +++ b/src/AST/boolean.h @@ -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); diff --git a/src/AST/function.h b/src/AST/function.h index f023f4a..1ea2069 100644 --- a/src/AST/function.h +++ b/src/AST/function.h @@ -4,7 +4,7 @@ #include "mymemory.h" struct Function { - - Table* table; + + Table* table; }; #endif diff --git a/src/AST/order.h b/src/AST/order.h index 08bc2a7..2bb13b2 100644 --- a/src/AST/order.h +++ b/src/AST/order.h @@ -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); diff --git a/src/AST/predicate.h b/src/AST/predicate.h index 06c54bb..a4dd7ed 100644 --- a/src/AST/predicate.h +++ b/src/AST/predicate.h @@ -6,8 +6,8 @@ #include "structs.h" struct Predicate { - enum CompOp op; - VectorSet* domains; + enum CompOp op; + VectorSet* domains; }; diff --git a/src/Collections/hashset.h b/src/Collections/hashset.h index 6d87078..a0f0c9e 100644 --- a/src/Collections/hashset.h +++ b/src/Collections/hashset.h @@ -11,184 +11,184 @@ #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 diff --git a/src/Collections/hashtable.h b/src/Collections/hashtable.h index e0db665..c9ea34f 100644 --- a/src/Collections/hashtable.h +++ b/src/Collections/hashtable.h @@ -32,246 +32,246 @@ * @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;icapacity;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;icapacity;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;} diff --git a/src/Collections/vector.h b/src/Collections/vector.h index d131a27..08c540c 100644 --- a/src/Collections/vector.h +++ b/src/Collections/vector.h @@ -2,60 +2,60 @@ #define VECTOR_H #include -#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 diff --git a/src/Encoders/functionencoder.h b/src/Encoders/functionencoder.h index 4a6ba80..18a8f4b 100644 --- a/src/Encoders/functionencoder.h +++ b/src/Encoders/functionencoder.h @@ -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; }; diff --git a/src/csolver.c b/src/csolver.c index c9b0633..26a4be9 100644 --- a/src/csolver.c +++ b/src/csolver.c @@ -24,7 +24,7 @@ void deleteSolver(CSolver *this) { for(uint i=0;iallBooleans, 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; } diff --git a/src/csolver.h b/src/csolver.h index 66c2d7e..15d3f47 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -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); -- 2.34.1