X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FRuntime%2FSimpleHash.c;h=92fe695f1905ce2e9e4516a68d4524d95c23c5d8;hb=4cb63e913202459da4fe9d01feb7c02f1b98dd6f;hp=69055bb7bfaa63b29d5c2d8460c2f682e3e96f2c;hpb=a2f532eb59b72c0f54f57500f813417035a60c40;p=IRC.git

diff --git a/Robust/src/Runtime/SimpleHash.c b/Robust/src/Runtime/SimpleHash.c
index 69055bb7..92fe695f 100755
--- 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) {