Repair/RepairCompiler/MCC/Runtime/SimpleHash.h

   1 #ifndef SIMPLEHASH_H
   2 #define SIMPLEHASH_H
   3
   4 #ifndef bool
   5 #define bool int
   6 #endif
   7
   8 #ifndef true
   9 #define true 1
  10 #endif
  11
  12 #ifndef false
  13 #define false 0
  14 #endif
  15
  16
  17 #include <stdarg.h>
  18 #include <stdlib.h>
  19
  20 /* LinkedHashNode *****************************************************/
  21
  22 struct LinkedHashNode * allocateLinkedHashNode(int key, int data, struct LinkedHashNode *next);
  23 struct LinkedHashNode * noargallocateLinkedHashNode();
  24
  25 struct LinkedHashNode {
  26     struct LinkedHashNode *next;
  27     struct LinkedHashNode *lnext,*lprev;
  28     int data;
  29     int key;
  30 };
  31
  32 /* SimpleList *********************************************************/
  33
  34 struct SimpleList * allocateSimpleList();
  35 void SimpleListadd(struct SimpleList *, int data);
  36 int SimpleListcontains(struct SimpleList *,int data);
  37 void SimpleListreset(struct SimpleList *);
  38 int SimpleListhasMoreElements(struct SimpleList *);
  39 int SimpleListnextElement(struct SimpleList *);
  40
  41 struct SimpleList {
  42     struct LinkedHashNode head;
  43     struct LinkedHashNode *ptr;
  44 };
  45
  46
  47 /* WorkList *********************************************************/
  48 #define WLISTSIZE 4*100
  49
  50 struct WorkList * allocateWorkList();
  51 void freeWorkList(struct WorkList *);
  52 void WorkListreset(struct WorkList *);
  53 void WorkListadd(struct WorkList *,int id, int type, int lvalue, int rvalue);
  54 int WorkListhasMoreElements(struct WorkList *);
  55 int WorkListgetid(struct WorkList *);
  56 int WorkListgettype(struct WorkList *);
  57 int WorkListgetlvalue(struct WorkList *);
  58 int WorkListgetrvalue(struct WorkList *);
  59 void WorkListpop(struct WorkList *);
  60
  61
  62 struct WorkList {
  63   struct ListNode *head;
  64   struct ListNode *tail;
  65   int headoffset;
  66   int tailoffset;
  67 };
  68
  69 struct ListNode {
  70   int data[WLISTSIZE];
  71   struct ListNode *next;
  72 };
  73
  74 /* SimpleHash *********************************************************/
  75
  76 struct SimpleHash * noargallocateSimpleHash();
  77 struct SimpleHash * allocateSimpleHash(int size);
  78 void SimpleHashaddChild(struct SimpleHash *thisvar, struct SimpleHash * child);
  79 void freeSimpleHash(struct SimpleHash *);
  80
  81
  82 int SimpleHashadd(struct SimpleHash *, int key, int data);
  83 int SimpleHashremove(struct SimpleHash *,int key, int data);
  84 bool SimpleHashcontainskey(struct SimpleHash *,int key);
  85 bool SimpleHashcontainskeydata(struct SimpleHash *,int key, int data);
  86 int SimpleHashget(struct SimpleHash *,int key, int* data);
  87 int SimpleHashcountdata(struct SimpleHash *,int data);
  88 void SimpleHashaddParent(struct SimpleHash *,struct SimpleHash* parent);
  89 int SimpleHashfirstkey(struct SimpleHash *);
  90 struct SimpleIterator* SimpleHashcreateiterator(struct SimpleHash *, struct SimpleHash *);
  91 void SimpleHashiterator(struct SimpleHash *, struct SimpleIterator * it);
  92 int SimpleHashcount(struct SimpleHash *, int key);
  93 void SimpleHashaddAll(struct SimpleHash *, struct SimpleHash * set);
  94 struct SimpleHash * SimpleHashimageSet(struct SimpleHash *, int key);
  95
  96 struct SimpleHash {
  97     int numelements;
  98     int size;
  99     struct SimpleNode **bucket;
 100     struct ArraySimple *listhead;
 101     struct ArraySimple *listtail;
 102     int numparents;
 103     int numchildren;
 104     struct SimpleHash* parents[10];
 105     struct SimpleHash* children[10];
 106     int tailindex;
 107 };
 108
 109 inline int count(struct SimpleHash * thisvar) {
 110     return thisvar->numelements;
 111 }
 112
 113
 114 /* SimpleHashExcepion  *************************************************/
 115
 116
 117 /* SimpleIterator *****************************************************/
 118 #define ARRAYSIZE 100
 119
 120 struct SimpleNode {
 121   struct SimpleNode *next;
 122   int data;
 123   int key;
 124   int inuse;
 125 };
 126
 127 struct ArraySimple {
 128   struct SimpleNode nodes[ARRAYSIZE];
 129   struct ArraySimple * nextarray;
 130 };
 131
 132
 133 struct SimpleIterator {
 134   struct ArraySimple *cur, *tail;
 135   int index,tailindex;
 136 };
 137
 138 inline struct SimpleIterator * noargallocateSimpleIterator() {
 139     return (struct SimpleIterator*)malloc(sizeof(struct SimpleIterator));
 140 }
 141
 142 inline struct SimpleIterator * allocateSimpleIterator(struct ArraySimple *start, struct ArraySimple *tl, int tlindex) {
 143     struct SimpleIterator *thisvar=(struct SimpleIterator*)malloc(sizeof(struct SimpleIterator));
 144     thisvar->cur = start;
 145     thisvar->index=0;
 146     thisvar->tailindex=tlindex;
 147     thisvar->tail=tl;
 148     return thisvar;
 149 }
 150
 151 inline int hasNext(struct SimpleIterator *thisvar) {
 152     if (thisvar->cur==thisvar->tail &&
 153         thisvar->index==thisvar->tailindex)
 154         return 0;
 155     while((thisvar->index==ARRAYSIZE)||!thisvar->cur->nodes[thisvar->index].inuse) {
 156         if (thisvar->index==ARRAYSIZE) {
 157             thisvar->index=0;
 158             thisvar->cur=thisvar->cur->nextarray;
 159         } else
 160             thisvar->index++;
 161     }
 162     if (thisvar->cur->nodes[thisvar->index].inuse)
 163         return 1;
 164     else
 165         return 0;
 166 }
 167
 168 inline int next(struct SimpleIterator *thisvar) {
 169     return thisvar->cur->nodes[thisvar->index++].data;
 170 }
 171
 172 inline int key(struct SimpleIterator *thisvar) {
 173     return thisvar->cur->nodes[thisvar->index].key;
 174 }
 175
 176
 177 struct RepairHashNode * allocateRepairHashNode(int setrelation, int rule, int lvalue, int rvalue, int data, int data2,int ismodify);
 178
 179 struct RepairHashNode {
 180     struct RepairHashNode *next;
 181     struct RepairHashNode *lnext;
 182     int data;
 183     int data2;
 184     int setrelation;
 185     int lvalue;
 186     int rvalue;
 187     int rule;
 188     int ismodify;
 189 };
 190
 191 struct RepairHash * noargallocateRepairHash();
 192 struct RepairHash * allocateRepairHash(int size);
 193 void freeRepairHash(struct RepairHash *);
 194 int addset(struct RepairHash *, int setv, int rule, int value, int data);
 195 int addrelation(struct RepairHash *, int relation, int rule, int lvalue, int rvalue, int data);
 196 int addrelation2(struct RepairHash *, int relation, int rule, int lvalue, int rvalue, int data, int data2);
 197 bool containsset(struct RepairHash *, int setv, int rule, int value);
 198 bool containsrelation(struct RepairHash *, int relation, int rule, int lvalue, int rvalue);
 199 int getset(struct RepairHash *, int setv, int rule, int value);
 200 int getrelation(struct RepairHash *, int relation, int rule, int lvalue, int rvalue);
 201 int getrelation2(struct RepairHash *, int relation, int rule, int lvalue, int rvalue);
 202 int ismodify(struct RepairHash *, int relation, int rule, int lvalue, int rvalue);
 203
 204 struct RepairHash {
 205     int numelements;
 206     int size;
 207     struct RepairHashNode **bucket;
 208     struct RepairHashNode *nodelist;
 209
 210 };
 211
 212 #endif