start of new file

[IRC.git] / Robust / src / Runtime / SimpleHash.c

diff --git a/Robust/src/Runtime/SimpleHash.c b/Robust/src/Runtime/SimpleHash.c
index 69055bb7bfaa63b29d5c2d8460c2f682e3e96f2c..92fe695f1905ce2e9e4516a68d4524d95c23c5d8 100755 (executable)
--- a/Robust/src/Runtime/SimpleHash.c
+++ b/Robust/src/Runtime/SimpleHash.c
@@ -1,5 +1,9 @@
 #include "SimpleHash.h"
+#ifdef RAW
+#include <raw.h>
+#else
 #include <stdio.h>
+#endif
 #ifdef DMALLOC
 #include "dmalloc.h"
 #endif
@@ -18,11 +22,16 @@ struct RuntimeHash * noargallocateRuntimeHash() {
 }
 
 struct RuntimeHash * allocateRuntimeHash(int size) {
-    struct RuntimeHash *thisvar=(struct RuntimeHash *)RUNMALLOC(sizeof(struct RuntimeHash));
+    struct RuntimeHash *thisvar;//=(struct RuntimeHash *)RUNMALLOC(sizeof(struct RuntimeHash));
     if (size <= 0) {
+#ifdef RAW
+               raw_test_done(0xb001);
+#else
         printf("Negative Hashtable size Exception\n");
-        exit(-1);
+               exit(-1);
+#endif
     }
+       thisvar=(struct RuntimeHash *)RUNMALLOC(sizeof(struct RuntimeHash));
     thisvar->size = size;
     thisvar->bucket = (struct RuntimeNode **) RUNMALLOC(sizeof(struct RuntimeNode *)*size);
     /* Set allocation blocks*/
@@ -53,6 +62,38 @@ int RuntimeHashfirstkey(struct RuntimeHash *thisvar) {
   return ptr->key;
 }
 
+int RuntimeHashremovekey(struct RuntimeHash *thisvar, int key) {
+    unsigned int hashkey = (unsigned int)key % thisvar->size;
+
+    struct RuntimeNode **ptr = &thisvar->bucket[hashkey];
+    int i;
+
+    while (*ptr) {
+        if ((*ptr)->key == key) {
+         struct RuntimeNode *toremove=*ptr;
+         *ptr=(*ptr)->next;
+
+         if (toremove->lprev!=NULL) {
+           toremove->lprev->lnext=toremove->lnext;
+         } else {
+           thisvar->listhead=toremove->lnext;
+         }
+         if (toremove->lnext!=NULL) {
+           toremove->lnext->lprev=toremove->lprev;
+         } else{
+           thisvar->listtail=toremove->lprev;
+         }
+         RUNFREE(toremove);
+
+         thisvar->numelements--;
+         return 1;
+        }
+        ptr = &((*ptr)->next);
+    }
+
+    return 0;
+}
+
 int RuntimeHashremove(struct RuntimeHash *thisvar, int key, int data) {
     unsigned int hashkey = (unsigned int)key % thisvar->size;
 
@@ -64,14 +105,16 @@ int RuntimeHashremove(struct RuntimeHash *thisvar, int key, int data) {
          struct RuntimeNode *toremove=*ptr;
          *ptr=(*ptr)->next;
 
-         if (toremove->lprev!=NULL)
+         if (toremove->lprev!=NULL) {
            toremove->lprev->lnext=toremove->lnext;
-         else
+         } else {
            thisvar->listhead=toremove->lnext;
-         if (toremove->lnext!=NULL)
+         }
+         if (toremove->lnext!=NULL) {
            toremove->lnext->lprev=toremove->lprev;
-         else
+         } else {
            thisvar->listtail=toremove->lprev;
+         }
          RUNFREE(toremove);
 
          thisvar->numelements--;
@@ -162,6 +205,68 @@ int RuntimeHashadd(struct RuntimeHash * thisvar,int key, int data) {
   return 1;
 }
 
+#ifdef RAW
+int RuntimeHashadd_I(struct RuntimeHash * thisvar,int key, int data) {
+  /* Rehash code */
+  unsigned int hashkey;
+  struct RuntimeNode **ptr;
+
+  if (thisvar->numelements>=thisvar->size) {
+    int newsize=2*thisvar->size+1;
+    struct RuntimeNode ** newbucket = (struct RuntimeNode **) RUNMALLOC_I(sizeof(struct RuntimeNode *)*newsize);
+    int i;
+    for(i=thisvar->size-1;i>=0;i--) {
+        struct RuntimeNode *ptr;
+        for(ptr=thisvar->bucket[i];ptr!=NULL;) {
+            struct RuntimeNode * nextptr=ptr->next;
+            unsigned int newhashkey=(unsigned int)ptr->key % newsize;
+            ptr->next=newbucket[newhashkey];
+            newbucket[newhashkey]=ptr;
+            ptr=nextptr;
+        }
+    }
+    thisvar->size=newsize;
+    RUNFREE(thisvar->bucket);
+    thisvar->bucket=newbucket;
+  }
+
+  hashkey = (unsigned int)key % thisvar->size;
+  ptr = &thisvar->bucket[hashkey];
+
+  /* check that thisvar key/object pair isn't already here */
+  /* TBD can be optimized for set v. relation */
+
+  while (*ptr) {
+    if ((*ptr)->key == key && (*ptr)->data == data) {
+      return 0;
+    }
+    ptr = &((*ptr)->next);
+  }
+
+  {
+    struct RuntimeNode *node=RUNMALLOC_I(sizeof(struct RuntimeNode));
+    node->data=data;
+    node->key=key;
+    node->next=(*ptr);
+    *ptr=node;
+    if (thisvar->listhead==NULL) {
+      thisvar->listhead=node;
+      thisvar->listtail=node;
+      node->lnext=NULL;
+      node->lprev=NULL;
+    } else {
+      node->lprev=NULL;
+      node->lnext=thisvar->listhead;
+      thisvar->listhead->lprev=node;
+      thisvar->listhead=node;
+    }
+  }
+
+  thisvar->numelements++;
+  return 1;
+}
+#endif
+
 bool RuntimeHashcontainskey(struct RuntimeHash *thisvar,int key) {
     unsigned int hashkey = (unsigned int)key % thisvar->size;
 
@@ -251,7 +356,8 @@ inline int RunhasNext(struct RuntimeIterator *thisvar) {
 
 inline int Runnext(struct RuntimeIterator *thisvar) {
   int curr=thisvar->cur->data;
-  thisvar->cur=thisvar->cur->next;
+  thisvar->cur=thisvar->cur->lnext;
+  return curr;
 }
 
 inline int Runkey(struct RuntimeIterator *thisvar) {