X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FRuntime%2Ftask.c;h=a3027dbc65797a0a5735b1faf3d69c1421911e3d;hb=bdc086e2ec7fcc674a604906627b52e16fba7eb3;hp=4e5a79c6b2f9445c51e6484c5eedcf175c485451;hpb=24f4e575e7d74134ca6418fd4b06af8500bf812e;p=IRC.git

diff --git a/Robust/src/Runtime/task.c b/Robust/src/Runtime/task.c
index 4e5a79c6..a3027dbc 100644
--- a/Robust/src/Runtime/task.c
+++ b/Robust/src/Runtime/task.c
@@ -16,17 +16,23 @@ extern int injectfailures;
 extern float failurechance;
 extern int debugtask;
 extern int instaccum;
+extern int errors;
 
 #ifdef CONSCHECK
 #include "instrument.h"
 #endif
 
+#ifdef FASTCHECK
+struct ___Object___ * ___fcrevert___;
+#include "localobjects.h"
+#endif
+
 struct genhashtable * activetasks;
 struct parameterwrapper * objectqueues[NUMCLASSES];
 struct genhashtable * failedtasks;
 struct taskparamdescriptor * currtpd;
-struct RuntimeHash * forward;
-struct RuntimeHash * reverse;
+struct ctable * forward;
+struct ctable * reverse;
 
 int main(int argc, char **argv) {
 #ifdef BOEHM_GC
@@ -38,12 +44,12 @@ int main(int argc, char **argv) {
   processOptions();
   initializeexithandler();
   /* Create table for failed tasks */
-  failedtasks=genallocatehashtable((unsigned int (*)(void *)) &hashCodetpd, 
-				   (int (*)(void *,void *)) &comparetpd);
+  failedtasks=genallocatehashtable((unsigned int (*)(void *)) &hashCodetpd,
+                                   (int (*)(void *,void *)) &comparetpd);
   /* Create queue of active tasks */
-  activetasks=genallocatehashtable((unsigned int (*)(void *)) &hashCodetpd, 
-				   (int (*)(void *,void *)) &comparetpd);
-  
+  activetasks=genallocatehashtable((unsigned int (*)(void *)) &hashCodetpd,
+                                   (int (*)(void *,void *)) &comparetpd);
+
   /* Process task information */
   processtasks();
 
@@ -56,35 +62,36 @@ int main(int argc, char **argv) {
 
 void createstartupobject(int argc, char ** argv) {
   int i;
-  
+
   /* Allocate startup object     */
 #ifdef PRECISE_GC
   struct ___StartupObject___ *startupobject=(struct ___StartupObject___*) allocate_new(NULL, STARTUPTYPE);
-  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1); 
+  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);
 #else
   struct ___StartupObject___ *startupobject=(struct ___StartupObject___*) allocate_new(STARTUPTYPE);
-  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1); 
+  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);
 #endif
   /* Build array of strings */
   startupobject->___parameters___=stringarray;
-  for(i=1;i<argc;i++) {
+  for(i=1; i<argc; i++) {
     int length=strlen(argv[i]);
 #ifdef PRECISE_GC
     struct ___String___ *newstring=NewString(NULL, argv[i],length);
 #else
     struct ___String___ *newstring=NewString(argv[i],length);
 #endif
-    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;
+    ((void **)(((char *)&stringarray->___length___)+sizeof(int)))[i-1]=newstring;
   }
-  
+
   /* Set initialized flag for startup object */
   flagorand(startupobject,1,0xFFFFFFFF);
+  enqueueObject(startupobject);
 }
 
 int hashCodetpd(struct taskparamdescriptor *ftd) {
   int hash=(int)ftd->task;
-  int i;						
-  for(i=0;i<ftd->numParameters;i++){ 
+  int i;
+  for(i=0; i<ftd->numParameters; i++) {
     hash^=(int)ftd->parameterArray[i];
   }
   return hash;
@@ -94,11 +101,11 @@ int comparetpd(struct taskparamdescriptor *ftd1, struct taskparamdescriptor *ftd
   int i;
   if (ftd1->task!=ftd2->task)
     return 0;
-  for(i=0;i<ftd1->numParameters;i++)
+  for(i=0; i<ftd1->numParameters; i++)
     if(ftd1->parameterArray[i]!=ftd2->parameterArray[i])
       return 0;
 #ifdef OPTIONAL
-  for(i=0;i<ftd1->numParameters;i++) {
+  for(i=0; i<ftd1->numParameters; i++) {
     if(ftd1->failed[i]!=ftd2->failed[i])
       return 0;
   }
@@ -120,7 +127,7 @@ void tagset(struct ___Object___ * obj, struct ___TagDescriptor___ * tagd) {
     if (tagptr->type==TAGTYPE) {
       struct ___TagDescriptor___ * td=(struct ___TagDescriptor___ *) tagptr;
       if (td==tagd)
-	return;
+        return;
 #ifdef PRECISE_GC
       int ptrarray[]={2, (int) ptr, (int) obj, (int)tagd};
       struct ArrayObject * ao=allocate_newarray(&ptrarray,TAGARRAYTYPE,TAGARRAYINTERVAL);
@@ -138,29 +145,29 @@ void tagset(struct ___Object___ * obj, struct ___TagDescriptor___ * tagd) {
       /* Array Case */
       int i;
       struct ArrayObject *ao=(struct ArrayObject *) tagptr;
-      for(i=0;i<ao->___cachedCode___;i++) {
-	struct ___TagDescriptor___ * td=ARRAYGET(ao, struct ___TagDescriptor___*, i);
-	if (td==tagd)
-	  return;
+      for(i=0; i<ao->___cachedCode___; i++) {
+        struct ___TagDescriptor___ * td=ARRAYGET(ao, struct ___TagDescriptor___*, i);
+        if (td==tagd)
+          return;
       }
       if (ao->___cachedCode___<ao->___length___) {
-	ARRAYSET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___, tagd);
-	ao->___cachedCode___++;
+        ARRAYSET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___, tagd);
+        ao->___cachedCode___++;
       } else {
 #ifdef PRECISE_GC
-	int ptrarray[]={2,(int) ptr, (int) obj, (int) tagd};
-	struct ArrayObject * aonew=allocate_newarray(&ptrarray,TAGARRAYTYPE,TAGARRAYINTERVAL+ao->___length___);
-	obj=(struct ___Object___ *)ptrarray[2];
-	tagd=(struct ___TagDescriptor___ *) ptrarray[3];
-	ao=(struct ArrayObject *)obj->___tags___;
+        int ptrarray[]={2,(int) ptr, (int) obj, (int) tagd};
+        struct ArrayObject * aonew=allocate_newarray(&ptrarray,TAGARRAYTYPE,TAGARRAYINTERVAL+ao->___length___);
+        obj=(struct ___Object___ *)ptrarray[2];
+        tagd=(struct ___TagDescriptor___ *) ptrarray[3];
+        ao=(struct ArrayObject *)obj->___tags___;
 #else
-	struct ArrayObject * aonew=allocate_newarray(TAGARRAYTYPE,TAGARRAYINTERVAL+ao->___length___);
+        struct ArrayObject * aonew=allocate_newarray(TAGARRAYTYPE,TAGARRAYINTERVAL+ao->___length___);
 #endif
-	aonew->___cachedCode___=ao->___length___+1;
-	for(i=0;i<ao->___length___;i++) {
-	  ARRAYSET(aonew, struct ___TagDescriptor___*, i, ARRAYGET(ao, struct ___TagDescriptor___*, i));
-	}
-	ARRAYSET(aonew, struct ___TagDescriptor___ *, ao->___length___, tagd);
+        aonew->___cachedCode___=ao->___length___+1;
+        for(i=0; i<ao->___length___; i++) {
+          ARRAYSET(aonew, struct ___TagDescriptor___*, i, ARRAYGET(ao, struct ___TagDescriptor___*, i));
+        }
+        ARRAYSET(aonew, struct ___TagDescriptor___ *, ao->___length___, tagd);
       }
     }
   }
@@ -185,24 +192,24 @@ void tagset(struct ___Object___ * obj, struct ___TagDescriptor___ * tagd) {
     } else {
       struct ArrayObject *ao=(struct ArrayObject *) tagset;
       if (ao->___cachedCode___<ao->___length___) {
-	ARRAYSET(ao, struct ___Object___*, ao->___cachedCode___++, obj);
+        ARRAYSET(ao, struct ___Object___*, ao->___cachedCode___++, obj);
       } else {
-	int i;
+        int i;
 #ifdef PRECISE_GC
-	int ptrarray[]={2, (int) ptr, (int) obj, (int)tagd};
-	struct ArrayObject * aonew=allocate_newarray(&ptrarray,OBJECTARRAYTYPE,OBJECTARRAYINTERVAL+ao->___length___);
-	obj=(struct ___Object___ *)ptrarray[2];
-	tagd=(struct ___TagDescriptor___ *)ptrarray[3];
-	ao=(struct ArrayObject *)tagd->flagptr;
+        int ptrarray[]={2, (int) ptr, (int) obj, (int)tagd};
+        struct ArrayObject * aonew=allocate_newarray(&ptrarray,OBJECTARRAYTYPE,OBJECTARRAYINTERVAL+ao->___length___);
+        obj=(struct ___Object___ *)ptrarray[2];
+        tagd=(struct ___TagDescriptor___ *)ptrarray[3];
+        ao=(struct ArrayObject *)tagd->flagptr;
 #else
-	struct ArrayObject * aonew=allocate_newarray(OBJECTARRAYTYPE,OBJECTARRAYINTERVAL);
+        struct ArrayObject * aonew=allocate_newarray(OBJECTARRAYTYPE,OBJECTARRAYINTERVAL);
 #endif
-	aonew->___cachedCode___=ao->___cachedCode___+1;
-	for(i=0;i<ao->___length___;i++) {
-	  ARRAYSET(aonew, struct ___Object___*, i, ARRAYGET(ao, struct ___Object___*, i));
-	}
-	ARRAYSET(aonew, struct ___Object___ *, ao->___cachedCode___, obj);
-	tagd->flagptr=(struct ___Object___ *) aonew;
+        aonew->___cachedCode___=ao->___cachedCode___+1;
+        for(i=0; i<ao->___length___; i++) {
+          ARRAYSET(aonew, struct ___Object___*, i, ARRAYGET(ao, struct ___Object___*, i));
+        }
+        ARRAYSET(aonew, struct ___Object___ *, ao->___cachedCode___, obj);
+        tagd->flagptr=(struct ___Object___ *) aonew;
       }
     }
   }
@@ -226,50 +233,50 @@ void tagclear(struct ___Object___ * obj, struct ___TagDescriptor___ * tagd) {
   } else {
     struct ArrayObject *ao=(struct ArrayObject *) tagptr;
     int i;
-    for(i=0;i<ao->___cachedCode___;i++) {
+    for(i=0; i<ao->___cachedCode___; i++) {
       struct ___TagDescriptor___ * td=ARRAYGET(ao, struct ___TagDescriptor___ *, i);
       if (td==tagd) {
-	ao->___cachedCode___--;
-	if (i<ao->___cachedCode___)
-	  ARRAYSET(ao, struct ___TagDescriptor___ *, i, ARRAYGET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___));
-	ARRAYSET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___, NULL);
-	if (ao->___cachedCode___==0)
-	  obj->___tags___=NULL;
-	goto PROCESSCLEAR;
+        ao->___cachedCode___--;
+        if (i<ao->___cachedCode___)
+          ARRAYSET(ao, struct ___TagDescriptor___ *, i, ARRAYGET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___));
+        ARRAYSET(ao, struct ___TagDescriptor___ *, ao->___cachedCode___, NULL);
+        if (ao->___cachedCode___==0)
+          obj->___tags___=NULL;
+        goto PROCESSCLEAR;
       }
     }
     printf("ERROR 2 in tagclear\n");
   }
- PROCESSCLEAR:
+PROCESSCLEAR:
   {
     struct ___Object___ *tagset=tagd->flagptr;
     if (tagset->type!=OBJECTARRAYTYPE) {
       if (tagset==obj)
-	tagd->flagptr=NULL;
+        tagd->flagptr=NULL;
       else
-	printf("ERROR 3 in tagclear\n");
+        printf("ERROR 3 in tagclear\n");
     } else {
       struct ArrayObject *ao=(struct ArrayObject *) tagset;
       int i;
-      for(i=0;i<ao->___cachedCode___;i++) {
-	struct ___Object___ * tobj=ARRAYGET(ao, struct ___Object___ *, i);
-	if (tobj==obj) {
-	  ao->___cachedCode___--;
-	  if (i<ao->___cachedCode___)
-	    ARRAYSET(ao, struct ___Object___ *, i, ARRAYGET(ao, struct ___Object___ *, ao->___cachedCode___));
-	  ARRAYSET(ao, struct ___Object___ *, ao->___cachedCode___, NULL);
-	  if (ao->___cachedCode___==0)
-	    tagd->flagptr=NULL;
-	  goto ENDCLEAR;
-	}
+      for(i=0; i<ao->___cachedCode___; i++) {
+        struct ___Object___ * tobj=ARRAYGET(ao, struct ___Object___ *, i);
+        if (tobj==obj) {
+          ao->___cachedCode___--;
+          if (i<ao->___cachedCode___)
+            ARRAYSET(ao, struct ___Object___ *, i, ARRAYGET(ao, struct ___Object___ *, ao->___cachedCode___));
+          ARRAYSET(ao, struct ___Object___ *, ao->___cachedCode___, NULL);
+          if (ao->___cachedCode___==0)
+            tagd->flagptr=NULL;
+          goto ENDCLEAR;
+        }
       }
       printf("ERROR 4 in tagclear\n");
     }
   }
- ENDCLEAR:
+ENDCLEAR:
   return;
 }
- 
+
 /* This function allocates a new tag. */
 #ifdef PRECISE_GC
 struct ___TagDescriptor___ * allocate_tag(void *ptr, int index) {
@@ -281,7 +288,7 @@ struct ___TagDescriptor___ * allocate_tag(int index) {
   v->type=TAGTYPE;
   v->flag=index;
   return v;
-} 
+}
 
 
 
@@ -292,65 +299,66 @@ void flagbody(struct ___Object___ *ptr, int flag);
 #ifdef OPTIONAL
 void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * failedfses, struct taskdescriptor * task, int index);
 #endif
- 
- int flagcomp(const int *val1, const int *val2) {
-   return (*val1)-(*val2);
- } 
+
+int flagcomp(const int *val1, const int *val2) {
+  return (*val1)-(*val2);
+}
 
 void flagorand(void * ptr, int ormask, int andmask) {
 #ifdef OPTIONAL
   struct ___Object___ * obj = (struct ___Object___ *)ptr;
-  if(obj->numfses){/*store the information about fses*/
+  if(obj->numfses) { /*store the information about fses*/
     int flag, i, j,counter, offset=0;
-    for(i=0;i<obj->numfses;i++) {
+    for(i=0; i<obj->numfses; i++) {
       int oldoffset;
       counter=obj->fses[offset++];
       oldoffset=offset;
-      for(j=0;j<counter;j++) {
-	flag=obj->fses[offset];
-	obj->fses[offset++]=(flag|ormask)&andmask;
+      for(j=0; j<counter; j++) {
+        flag=obj->fses[offset];
+        obj->fses[offset++]=(flag|ormask)&andmask;
       }
       qsort(&obj->fses[oldoffset], sizeof(int), counter, (int (*)(const void *, const void *)) &flagcomp);
     }
     enqueueoptional(obj, 0, NULL, NULL, 0);
-  }
-  else
+  } else
 #endif
-    {
-      int oldflag=((int *)ptr)[1];
-      int flag=ormask|oldflag;
-      flag&=andmask;
-      flagbody(ptr, flag);
-    }
+  {
+    int oldflag=((int *)ptr)[1];
+    int flag=ormask|oldflag;
+    flag&=andmask;
+    flagbody(ptr, flag);
+  }
 }
- 
-void intflagorand(void * ptr, int ormask, int andmask) {
+
+bool intflagorand(void * ptr, int ormask, int andmask) {
 #ifdef OPTIONAL
   struct ___Object___ * obj = (struct ___Object___ *)ptr;
-  if(obj->numfses) {/*store the information about fses*/
+  if(obj->numfses) { /*store the information about fses*/
     int flag, i, j,counter, offset=0;
-    for(i=0;i<obj->numfses;i++) {
+    for(i=0; i<obj->numfses; i++) {
       int oldoffset;
       counter=obj->fses[offset++];
       oldoffset=offset;
-      for(j=0;j<counter;j++) {
-	flag=obj->fses[offset];
-	obj->fses[offset++]=(flag|ormask)&andmask;
+      for(j=0; j<counter; j++) {
+        flag=obj->fses[offset];
+        obj->fses[offset++]=(flag|ormask)&andmask;
       }
       qsort(&obj->fses[oldoffset], sizeof(int), counter, (int (*)(const void *, const void *)) &flagcomp);
     }
     enqueueoptional(obj, 0, NULL, NULL, 0);
-  }
-  else
+  } else
 #endif
-    {
-      int oldflag=((int *)ptr)[1];
-      int flag=ormask|oldflag;
-      flag&=andmask;
-      if (flag==oldflag) /* Don't do anything */
-	return;
-      else flagbody(ptr, flag);
+  {
+    int oldflag=((int *)ptr)[1];
+    int flag=ormask|oldflag;
+    flag&=andmask;
+    if (flag==oldflag)   /* Don't do anything */
+      return false;
+    else {
+      flagbody(ptr, flag);
+      return true;
     }
+  }
 }
 
 void flagorandinit(void * ptr, int ormask, int andmask) {
@@ -363,103 +371,110 @@ void flagorandinit(void * ptr, int ormask, int andmask) {
 void flagbody(struct ___Object___ *ptr, int flag) {
   struct parameterwrapper *flagptr=(struct parameterwrapper *)ptr->flagptr;
   ptr->flag=flag;
-  
+
   /*Remove object from all queues */
   while(flagptr!=NULL) {
     struct parameterwrapper *next;
-    int UNUSED, UNUSED2, UNUSED3;
-    ObjectHashget(flagptr->objectset, (int) ptr, (int *) &next, &UNUSED, &UNUSED2, &UNUSED3);
+    int UNUSED, UNUSED2;
+    int * enterflags;
+    ObjectHashget(flagptr->objectset, (int) ptr, (int *) &next, (int *) &enterflags, &UNUSED, &UNUSED2);
     ObjectHashremove(flagptr->objectset, (int)ptr);
+    if (enterflags!=NULL)
+      free(enterflags);
     flagptr=next;
   }
-  
+}
+
+void enqueueObject(void *vptr) {
+  struct ___Object___ *ptr = (struct ___Object___ *)vptr;
+
   {
     struct QueueItem *tmpptr;
     struct parameterwrapper * parameter=objectqueues[ptr->type];
     int i;
     struct parameterwrapper * prevptr=NULL;
     struct ___Object___ *tagptr=ptr->___tags___;
-    
+
     /* Outer loop iterates through all parameter queues an object of
        this type could be in.  */
-    
+
     while(parameter!=NULL) {
       /* Check tags */
       if (parameter->numbertags>0) {
-	if (tagptr==NULL)
-	  goto nextloop;//that means the object has no tag but that param needs tag
-	else if(tagptr->type==TAGTYPE) {//one tag
-	  struct ___TagDescriptor___ * tag=(struct ___TagDescriptor___*) tagptr;
-	  for(i=0;i<parameter->numbertags;i++) {
-	    //slotid is parameter->tagarray[2*i];
-	    int tagid=parameter->tagarray[2*i+1];
-	    if (tagid!=tagptr->flag)
-	      goto nextloop; /*We don't have this tag */	  
-	   }
-	} else {//multiple tags
-	  struct ArrayObject * ao=(struct ArrayObject *) tagptr;
-	  for(i=0;i<parameter->numbertags;i++) {
-	    //slotid is parameter->tagarray[2*i];
-	    int tagid=parameter->tagarray[2*i+1];
-	    int j;
-	    for(j=0;j<ao->___cachedCode___;j++) {
-	      if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, j)->flag)
-		goto foundtag;
-	    }
-	    goto nextloop;
-	  foundtag:
-	    ;
-	  }
-	}
+        if (tagptr==NULL)
+          goto nextloop;  //that means the object has no tag but that param needs tag
+        else if(tagptr->type==TAGTYPE) { //one tag
+          struct ___TagDescriptor___ * tag=(struct ___TagDescriptor___*) tagptr;
+          for(i=0; i<parameter->numbertags; i++) {
+            //slotid is parameter->tagarray[2*i];
+            int tagid=parameter->tagarray[2*i+1];
+            if (tagid!=tagptr->flag)
+              goto nextloop;  /*We don't have this tag */
+          }
+        } else { //multiple tags
+          struct ArrayObject * ao=(struct ArrayObject *) tagptr;
+          for(i=0; i<parameter->numbertags; i++) {
+            //slotid is parameter->tagarray[2*i];
+            int tagid=parameter->tagarray[2*i+1];
+            int j;
+            for(j=0; j<ao->___cachedCode___; j++) {
+              if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, j)->flag)
+                goto foundtag;
+            }
+            goto nextloop;
+foundtag:
+            ;
+          }
+        }
       }
-      
+
       /* Check flags */
-      for(i=0;i<parameter->numberofterms;i++) {
-	int andmask=parameter->intarray[i*2];
-	int checkmask=parameter->intarray[i*2+1];
-	if ((flag&andmask)==checkmask) {
-	  enqueuetasks(parameter, prevptr, ptr, NULL, 0);
-	  prevptr=parameter;
-	  break;
-	}
+      for(i=0; i<parameter->numberofterms; i++) {
+        int andmask=parameter->intarray[i*2];
+        int checkmask=parameter->intarray[i*2+1];
+        if ((ptr->flag&andmask)==checkmask) {
+          enqueuetasks(parameter, prevptr, ptr, NULL, 0);
+          prevptr=parameter;
+          break;
+        }
       }
-    nextloop:
+nextloop:
       parameter=parameter->next;
     }
     ptr->flagptr=prevptr;
   }
 }
- 
+
 #ifdef OPTIONAL
 
 int checktags(struct ___Object___ * currobj, struct fsanalysiswrapper * fswrapper) {
   /* Check Tags */
   struct ___Object___ * tagptr = currobj->___tags___;
-  if(fswrapper->numtags>0){
+  if(fswrapper->numtags>0) {
     if (tagptr==NULL)
-      return 0; //that means the object has no tag but that param
+      return 0;  //that means the object has no tag but that param
     //needs tag
-    else if(tagptr->type==TAGTYPE) {//one tag
-      if(fswrapper->numtags!=1) 
-	return 0; //we don't have the right number of tags
+    else if(tagptr->type==TAGTYPE) { //one tag
+      if(fswrapper->numtags!=1)
+        return 0;  //we don't have the right number of tags
       struct ___TagDescriptor___ * tag=(struct ___TagDescriptor___*) tagptr;
       if (fswrapper->tags[0]!=tagptr->flag)
-	return 0;
+        return 0;
     } else {  //multiple tags
       struct ArrayObject * ao=(struct ArrayObject *) tagptr;
       int tag_counter=0;
       int foundtag=0;
-      
-      if(ao->___length___!=fswrapper->numtags) 
-	return 0;//we don't have the right number of tags
-      for(tag_counter=0;tag_counter<fswrapper->numtags;tag_counter++) {
-	int tagid=fswrapper->tags[tag_counter];
-	int j;
-	for(j=0;j<ao->___cachedCode___;j++) {
-	  if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, tag_counter)->flag)
-	    return 1;
-	}
-	return 0;
+
+      if(ao->___length___!=fswrapper->numtags)
+        return 0;  //we don't have the right number of tags
+      for(tag_counter=0; tag_counter<fswrapper->numtags; tag_counter++) {
+        int tagid=fswrapper->tags[tag_counter];
+        int j;
+        for(j=0; j<ao->___cachedCode___; j++) {
+          if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, tag_counter)->flag)
+            return 1;
+        }
+        return 0;
       }
     }
   }
@@ -469,7 +484,7 @@ int checktags(struct ___Object___ * currobj, struct fsanalysiswrapper * fswrappe
 int getlength(int *flist, int len) {
   int count=0;
   int i;
-  for(i=0;i<len;i++) {
+  for(i=0; i<len; i++) {
     int size=flist[count];
     count+=1+size;
   }
@@ -492,19 +507,19 @@ int domerge(int * flist1, int len1, int *flist2, int len2, int *merge) {
   while(i<len1||j<len2) {
     if (i<len1&&(j==len2||flist1[i]<flist2[j])) {
       if(merge!=NULL) {
-	merge[count]=flist1[i];
+        merge[count]=flist1[i];
       }
       i++;
       count++;
     } else if (j<len2&&(i==len1||flist2[j]<flist1[i])) {
       if(merge!=NULL) {
-	merge[count]=flist2[j];
+        merge[count]=flist2[j];
       }
       j++;
       count++;
     } else if (i<len1&&j<len2&&flist1[i]==flist2[j]) {
       if(merge!=NULL) {
-	merge[count]=flist1[i];
+        merge[count]=flist1[i];
       }
       i++;
       j++;
@@ -520,10 +535,10 @@ void mergeitems(struct failedtasklist *ftl, struct failedtasklist *ftlmerge) {
   int i,j;
   int *mergedlist;
   int offset=0;
-  for(i=0;i<ftl->numflags;i++) {
+  for(i=0; i<ftl->numflags; i++) {
     int len=ftl->flags[offset++];
     int offsetmerge=0;
-    for(j=0;j<ftlmerge->numflags;j++) {
+    for(j=0; j<ftlmerge->numflags; j++) {
       int lenmerge=ftlmerge->flags[offsetmerge++];
       length+=1+domerge(&ftl->flags[offset],len,&ftlmerge->flags[offsetmerge],lenmerge, NULL);
       offsetmerge+=lenmerge;
@@ -531,13 +546,13 @@ void mergeitems(struct failedtasklist *ftl, struct failedtasklist *ftlmerge) {
     offset+=len;
   }
   mergedlist=RUNMALLOC(sizeof(int)*length);
-  
+
   offset=0;
   length=0;
-  for(i=0;i<ftl->numflags;i++) {
+  for(i=0; i<ftl->numflags; i++) {
     int len=ftl->flags[offset++];
     int offsetmerge=0;
-    for(j=0;j<ftlmerge->numflags;j++) {
+    for(j=0; j<ftlmerge->numflags; j++) {
       int lenmerge=ftlmerge->flags[offsetmerge++];
       int size=domerge(&ftl->flags[offset],len,&ftlmerge->flags[offsetmerge],lenmerge,&mergedlist[length+1]);
       mergedlist[length]=size;
@@ -555,16 +570,16 @@ void mergefailedlists(struct failedtasklist **andlist, struct failedtasklist *li
     struct failedtasklist *searchftl=list;
     while(searchftl!=NULL) {
       if ((*andlist)->task==searchftl->task&&
-	  (*andlist)->index==searchftl->index) {
-	mergeitems(*andlist, searchftl);
-	break;
+          (*andlist)->index==searchftl->index) {
+        mergeitems(*andlist, searchftl);
+        break;
       }
       searchftl=searchftl->next;
     }
     if (searchftl==NULL) {
       //didn't find andlist
       tmpptr=*andlist;
-      *andlist=(*andlist)->next;//splice item out of list
+      *andlist=(*andlist)->next; //splice item out of list
       RUNFREE(tmpptr->flags); //free the item
       RUNFREE(tmpptr);
     } else {
@@ -584,7 +599,7 @@ struct failedtasklist * processfailstate(struct classanalysiswrapper * classwrap
   struct failedtasklist *list=NULL;
   int i,h;
   struct fsanalysiswrapper *fswrapper=NULL;
-  for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
+  for(h=0; h<classwrapper->numfsanalysiswrappers; h++) {
     struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
     if (tmp->flags==flagstate&&checktags(currobj, tmp)) {
       //we only match exactly here
@@ -594,44 +609,44 @@ struct failedtasklist * processfailstate(struct classanalysiswrapper * classwrap
   }
   if (fswrapper==NULL)
     return list;
-  for(i=0;i<fswrapper->numtaskfailures;i++) {
+  for(i=0; i<fswrapper->numtaskfailures; i++) {
     int j;
     struct taskfailure * taskfail=fswrapper->taskfailurearray[i];
     if (taskfail->task==task&&taskfail->index==index) {
       int start=0;
       while(start<taskfail->numoptionaltaskdescriptors) {
-	struct taskdescriptor *currtask=NULL;
-	struct failedtasklist *tmpftl;
-	int currindex;
-	int totallength=0;
-	int *enterflags;
-	int numenterflags, offset;
-	struct parameterwrapper *pw;
-	for(j=start;j<taskfail->numoptionaltaskdescriptors;j++) {
-	  struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
-	  if(currtask==NULL) {
-	    currtask=otd->task;
-	    currindex=otd->index;
-	  } else if (currtask!=otd->task||currindex!=otd->index)
-	    break;
-	  totallength+=otd->numenterflags;
-	}
-	pw=currtask->descriptorarray[currindex]->queue;
-	enterflags=RUNMALLOC(totallength*sizeof(int));
-	numenterflags=j-start;
-	offset=0;
-	for(start;start<j;start++) {
-	  struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
-	  enterflags[offset++]=otd->numenterflags;
-	  memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
-	  offset+=otd->numenterflags;
-	}
-	tmpftl=RUNMALLOC(sizeof(struct failedtasklist));
-	tmpftl->next=list;
-	tmpftl->task=currtask;
-	tmpftl->numflags=numenterflags;
-	tmpftl->flags=enterflags;
-	list=tmpftl;
+        struct taskdescriptor *currtask=NULL;
+        struct failedtasklist *tmpftl;
+        int currindex;
+        int totallength=0;
+        int *enterflags;
+        int numenterflags, offset;
+        struct parameterwrapper *pw;
+        for(j=start; j<taskfail->numoptionaltaskdescriptors; j++) {
+          struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
+          if(currtask==NULL) {
+            currtask=otd->task;
+            currindex=otd->index;
+          } else if (currtask!=otd->task||currindex!=otd->index)
+            break;
+          totallength+=otd->numenterflags;
+        }
+        pw=currtask->descriptorarray[currindex]->queue;
+        enterflags=RUNMALLOC(totallength*sizeof(int));
+        numenterflags=j-start;
+        offset=0;
+        for(start; start<j; start++) {
+          struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
+          enterflags[offset++]=otd->numenterflags;
+          memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
+          offset+=otd->numenterflags;
+        }
+        tmpftl=RUNMALLOC(sizeof(struct failedtasklist));
+        tmpftl->next=list;
+        tmpftl->task=currtask;
+        tmpftl->numflags=numenterflags;
+        tmpftl->flags=enterflags;
+        list=tmpftl;
       }
     }
   }
@@ -643,7 +658,7 @@ struct failedtasklist * processnormfailstate(struct classanalysiswrapper * class
   int i,h;
   int start=0;
   struct fsanalysiswrapper *fswrapper=NULL;
-  for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
+  for(h=0; h<classwrapper->numfsanalysiswrappers; h++) {
     struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
     if (tmp->flags==flagstate&&checktags(currobj, tmp)) {
       //we only match exactly here
@@ -663,20 +678,20 @@ struct failedtasklist * processnormfailstate(struct classanalysiswrapper * class
     int *enterflags;
     int numenterflags, offset;
     struct parameterwrapper *pw;
-    for(j=start;j<fswrapper->numoptionaltaskdescriptors;j++) {
+    for(j=start; j<fswrapper->numoptionaltaskdescriptors; j++) {
       struct optionaltaskdescriptor *otd=fswrapper->optionaltaskdescriptorarray[j];
       if(currtask==NULL) {
-	currtask=otd->task;
-	currindex=otd->index;
+        currtask=otd->task;
+        currindex=otd->index;
       } else if (currtask!=otd->task||currindex!=otd->index)
-	break;
+        break;
       totallength+=otd->numenterflags;
     }
     pw=currtask->descriptorarray[currindex]->queue;
     enterflags=RUNMALLOC(totallength*sizeof(int));
     numenterflags=j-start;
     offset=0;
-    for(start;start<j;start++) {
+    for(start; start<j; start++) {
       struct optionaltaskdescriptor *otd=fswrapper->optionaltaskdescriptorarray[start];
       enterflags[offset++]=otd->numenterflags;
       memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
@@ -702,26 +717,26 @@ void enqueuelist(struct ___Object___ * currobj, struct failedtasklist * andlist)
     int * flags;
     int numflags;
     int isnonfailed;
-    
+
     if (enqueuetasks(pw, currobj->flagptr, currobj, tmp->flags, tmp->numflags))
       currobj->flagptr=pw;
-    
+
     andlist=andlist->next;
     RUNFREE(tmp);
   }
 }
 
 void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * failedfses, struct taskdescriptor * task, int index) {
-  struct classanalysiswrapper * classwrapper=NULL; 
-  
+  struct classanalysiswrapper * classwrapper=NULL;
+
   /*test what optionaltaskdescriptors are available, find the class
-    corresponding*/
+     corresponding*/
   if (classanalysiswrapperarray[currobj->type]!=NULL) {
     classwrapper = classanalysiswrapperarray[currobj->type];
   } else
     return;
-  
-  if(task!=NULL) { 
+
+  if(task!=NULL) {
     /* We have a failure */
     if (failedfses==NULL) {
       /* Failed in normal state */
@@ -729,71 +744,71 @@ void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * fai
       int i,h;
       struct fsanalysiswrapper *fswrapper=NULL;
 
-      for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
-	struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
-	if (tmp->flags==currobj->flag&&checktags(currobj, tmp)) {
-	  //we only match exactly here
-	  fswrapper=tmp;
-	  break;
-	}
+      for(h=0; h<classwrapper->numfsanalysiswrappers; h++) {
+        struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
+        if (tmp->flags==currobj->flag&&checktags(currobj, tmp)) {
+          //we only match exactly here
+          fswrapper=tmp;
+          break;
+        }
       }
       if(fswrapper==NULL) //nothing to do in this state
-	return;
-      for(i=0;i<fswrapper->numtaskfailures;i++) {
-	int j;
-	struct taskfailure * taskfail=fswrapper->taskfailurearray[i];
-	if (taskfail->task==task&&taskfail->index==index) {
-	  int start=0;
-	  while(start<taskfail->numoptionaltaskdescriptors) {
-	    struct taskdescriptor *currtask=NULL;
-	    int currindex;
-	    int totallength=0;
-	    int *enterflags;
-	    int numenterflags, offset;
-	    struct parameterwrapper *pw;
-	    for(j=start;j<taskfail->numoptionaltaskdescriptors;j++) {
-	      struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
-	      if(currtask==NULL) {
-		currtask=otd->task;
-		currindex=otd->index;
-	      } else if (currtask!=otd->task||currindex!=otd->index)
-		break;
-	      totallength+=otd->numenterflags;
-	    }
-	    pw=currtask->descriptorarray[currindex]->queue;
-	    enterflags=RUNMALLOC(totallength*sizeof(int));
-	    numenterflags=j-start;
-
-	    offset=0;
-	    for(start;start<j;start++) {
-	      struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
-	      enterflags[offset++]=otd->numenterflags;
-	      memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
-	      offset+=otd->numenterflags;
-	    }
-	    //Enqueue this one
-	    if (enqueuetasks(pw, currobj->flagptr, currobj, enterflags, numenterflags))
-	      currobj->flagptr=pw;
-	  }
-	}
+        return;
+      for(i=0; i<fswrapper->numtaskfailures; i++) {
+        int j;
+        struct taskfailure * taskfail=fswrapper->taskfailurearray[i];
+        if (taskfail->task==task&&taskfail->index==index) {
+          int start=0;
+          while(start<taskfail->numoptionaltaskdescriptors) {
+            struct taskdescriptor *currtask=NULL;
+            int currindex;
+            int totallength=0;
+            int *enterflags;
+            int numenterflags, offset;
+            struct parameterwrapper *pw;
+            for(j=start; j<taskfail->numoptionaltaskdescriptors; j++) {
+              struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
+              if(currtask==NULL) {
+                currtask=otd->task;
+                currindex=otd->index;
+              } else if (currtask!=otd->task||currindex!=otd->index)
+                break;
+              totallength+=otd->numenterflags; //1 is to store the lengths
+            }
+            pw=currtask->descriptorarray[currindex]->queue;
+            numenterflags=j-start;
+            enterflags=RUNMALLOC((totallength+numenterflags)*sizeof(int));
+
+            offset=0;
+            for(start; start<j; start++) {
+              struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
+              enterflags[offset++]=otd->numenterflags;
+              memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
+              offset+=otd->numenterflags;
+            }
+            //Enqueue this one
+            if (enqueuetasks(pw, currobj->flagptr, currobj, enterflags, numenterflags))
+              currobj->flagptr=pw;
+          }
+        }
       }
     } else {
       /* Failed in failed state */
       int i;
       int offset=0;
-      for(i=0;i<numfailedfses;i++) {
-	int numfses=failedfses[offset++];
-	int j;
-	struct failedtasklist *andlist=NULL;
-	for(j=0;j<numfses;j++) {
-	  int flagstate=failedfses[offset++];
-	  struct failedtasklist *currlist=processfailstate(classwrapper, task, index, currobj, flagstate);
-	  if (andlist==NULL)
-	    andlist=currlist;
-	  else
-	    mergefailedlists(&andlist, currlist);
-	}
-	enqueuelist(currobj, andlist);
+      for(i=0; i<numfailedfses; i++) {
+        int numfses=failedfses[offset++];
+        int j;
+        struct failedtasklist *andlist=NULL;
+        for(j=0; j<numfses; j++) {
+          int flagstate=failedfses[offset++];
+          struct failedtasklist *currlist=processfailstate(classwrapper, task, index, currobj, flagstate);
+          if (andlist==NULL)
+            andlist=currlist;
+          else
+            mergefailedlists(&andlist, currlist);
+        }
+        enqueuelist(currobj, andlist);
       }
     }
   } else {
@@ -803,35 +818,38 @@ void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * fai
     /*Remove object from all queues */
     while(flagptr!=NULL) {
       struct parameterwrapper *next;
-      int UNUSED, UNUSED2, UNUSED3;
-      ObjectHashget(flagptr->objectset, (int) currobj, (int *) &next, &UNUSED, &UNUSED2, &UNUSED3);
+      int UNUSED, UNUSED2;
+      int * enterflags;
+      ObjectHashget(flagptr->objectset, (int) currobj, (int *) &next, (int *) &enterflags, &UNUSED, &UNUSED2);
       ObjectHashremove(flagptr->objectset, (int)currobj);
+      if (enterflags!=NULL)
+        free(enterflags);
       flagptr=next;
     }
 
     /* Failed in failed state */
     int i;
     int offset=0;
-    for(i=0;i<currobj->numfses;i++) {
+    for(i=0; i<currobj->numfses; i++) {
       int numfses=currobj->fses[offset++];
       int j;
       struct failedtasklist *andlist=NULL;
-      for(j=0;j<numfses;j++) {
-	int flagstate=currobj->fses[offset++];
-	struct failedtasklist *currlist=processnormfailstate(classwrapper, currobj, flagstate);
-	if (andlist==NULL)
-	  andlist=currlist;
-	else
-	  mergefailedlists(&andlist, currlist);
+      for(j=0; j<numfses; j++) {
+        int flagstate=currobj->fses[offset++];
+        struct failedtasklist *currlist=processnormfailstate(classwrapper, currobj, flagstate);
+        if (andlist==NULL)
+          andlist=currlist;
+        else
+          mergefailedlists(&andlist, currlist);
       }
       enqueuelist(currobj, andlist);
     }
   }
-} 
- 
- 
+}
+
+
 #endif
- 
+
 int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *prevptr, struct ___Object___ *ptr, int * enterflags, int numenterflags) {
   void * taskpointerarray[MAXTASKPARAMS];
 #ifdef OPTIONAL
@@ -846,7 +864,7 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
 
   struct taskdescriptor * task=parameter->task;
 
-#ifdef OPTIONAL  
+#ifdef OPTIONAL
   if (ObjectHashcontainskey(parameter->objectset, (int) ptr)) {
     /* The object is already here...or it with the existing item */
     int * oldflags;
@@ -854,7 +872,7 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
     int oldptr;
     int oldstatus;
     int *mergedflags;
-    ObjectHashget(parameter->objectset, (int) ptr, & oldptr, (int *) &oldflags, &oldnumflags, &oldstatus);
+    ObjectHashget(parameter->objectset, (int) ptr, &oldptr, (int *) &oldflags, &oldnumflags, &oldstatus);
     mergedflags=domergeor(oldflags, oldnumflags, enterflags, numenterflags);
     ObjectHashupdate(parameter->objectset, (int) ptr, oldptr, mergedflags, oldnumflags+numenterflags, oldstatus||(enterflags==NULL));
 
@@ -870,11 +888,11 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
     retval=0;
   } else {
 #endif
-    ObjectHashadd(parameter->objectset, (int) ptr, (int) prevptr, (int) enterflags, numenterflags, enterflags==NULL);//this add the object to parameterwrapper
+  ObjectHashadd(parameter->objectset, (int) ptr, (int) prevptr, (int) enterflags, numenterflags, enterflags==NULL);  //this add the object to parameterwrapper
 #ifdef OPTIONAL
-  }
+}
 #endif
- 
+
   /* Add enqueued object to parameter vector */
   taskpointerarray[parameter->slot]=ptr;
 #ifdef OPTIONAL
@@ -882,16 +900,16 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
 #endif
 
   /* Reset iterators */
-  for(j=0;j<numiterators;j++) {
+  for(j=0; j<numiterators; j++) {
     toiReset(&parameter->iterators[j]);
   }
 
   /* Find initial state */
-  for(j=0;j<numiterators;j++) {
-  backtrackinit:
-    if(toiHasNext(&parameter->iterators[j], taskpointerarray OPTARG(failed)))
+  for(j=0; j<numiterators; j++) {
+backtrackinit:
+    if(toiHasNext(&parameter->iterators[j], taskpointerarray OPTARG(failed))) {
       toiNext(&parameter->iterators[j], taskpointerarray OPTARG(failed));
-    else if (j>0) {
+    } else if (j>0) {
       /* Need to backtrack */
       toiReset(&parameter->iterators[j]);
       j--;
@@ -902,7 +920,7 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
     }
   }
 
-  
+
   while(1) {
     /* Enqueue current state */
     int launch = 0;
@@ -913,10 +931,13 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
 #ifdef OPTIONAL
     tpd->failed=RUNMALLOC(sizeof(int)*(numiterators+1));
 #endif
-    for(j=0;j<=numiterators;j++){
-      tpd->parameterArray[j]=taskpointerarray[j];//store the actual parameters
+    for(j=0; j<=numiterators; j++) {
+      tpd->parameterArray[j]=taskpointerarray[j]; //store the actual parameters
 #ifdef OPTIONAL
       tpd->failed[j]=failed[j];
+      if (failed[j]!=0&&failed[j]!=1) {
+        printf("BAD\n");
+      }
 #endif
     }
     /* Enqueue task */
@@ -924,31 +945,34 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr
       genputtable(activetasks, tpd, tpd);
     } else {
       RUNFREE(tpd->parameterArray);
+#ifdef OPTIONAL
+      RUNFREE(tpd->failed);
+#endif
       RUNFREE(tpd);
     }
-    
+
     /* This loop iterates to the next parameter combination */
     if (numiterators==0)
       return retval;
 
-    for(j=numiterators-1; j<numiterators;j++) {
-    backtrackinc:
-      if(toiHasNext(&parameter->iterators[j], taskpointerarray OPTARG(failed)))
-	toiNext(&parameter->iterators[j], taskpointerarray OPTARG(failed));
-      else if (j>0) {
-	/* Need to backtrack */
-	toiReset(&parameter->iterators[j]);
-	j--;
-	goto backtrackinc;
+    for(j=numiterators-1; j<numiterators; j++) {
+backtrackinc:
+      if(toiHasNext(&parameter->iterators[j], taskpointerarray OPTARG(failed))) {
+        toiNext(&parameter->iterators[j], taskpointerarray OPTARG(failed));
+      } else if (j>0) {
+        /* Need to backtrack */
+        toiReset(&parameter->iterators[j]);
+        j--;
+        goto backtrackinc;
       } else {
-	/* Nothing more to enqueue */
-	return retval;
+        /* Nothing more to enqueue */
+        return retval;
       }
     }
   }
   return retval;
 }
- 
+
 /* Handler for signals. The signals catch null pointer errors and
    arithmatic errors. */
 
@@ -960,7 +984,7 @@ void myhandler(int sig, siginfo_t *info, void *uap) {
 #endif
   sigemptyset(&toclear);
   sigaddset(&toclear, sig);
-  sigprocmask(SIG_UNBLOCK, &toclear,NULL); 
+  sigprocmask(SIG_UNBLOCK, &toclear,NULL);
   longjmp(error_handler,1);
 }
 
@@ -990,14 +1014,14 @@ void removereadfd(int fd) {
 #endif
 
 #ifdef OPTIONAL
- int * fsescopy(int *src, int len) {
-   int *dst;
-   if (src==NULL)
-     return NULL;
-   dst=RUNMALLOC(len*sizeof(int));
-   memcpy(dst, src, len*sizeof(int));
-   return dst;
- }
+int * fsescopy(int *src, int len) {
+  int *dst;
+  if (src==NULL)
+    return NULL;
+  dst=RUNMALLOC(len*sizeof(int));
+  memcpy(dst, src, len*sizeof(int));
+  return dst;
+}
 #endif
 
 void executetasks() {
@@ -1006,7 +1030,7 @@ void executetasks() {
   int * fsesarray[MAXTASKPARAMS];
   int * oldfsesarray[MAXTASKPARAMS];
   int numfsesarray[MAXTASKPARAMS];
-#endif  
+#endif
 
   /* Set up signal handlers */
   struct sigaction sig;
@@ -1015,10 +1039,12 @@ void executetasks() {
   sigemptyset(&sig.sa_mask);
 
   /* Catch bus errors, segmentation faults, and floating point exceptions*/
-  sigaction(SIGBUS,&sig,0);
-  sigaction(SIGSEGV,&sig,0);
-  sigaction(SIGFPE,&sig,0);
-  sigaction(SIGPIPE,&sig,0);
+  if (!errors) {
+    sigaction(SIGBUS,&sig,0);
+    sigaction(SIGSEGV,&sig,0);
+    sigaction(SIGFPE,&sig,0);
+    sigaction(SIGPIPE,&sig,0);
+  }
 
   /* Zero fd set */
   FD_ZERO(&readfds);
@@ -1028,7 +1054,7 @@ void executetasks() {
   /* Map first block of memory to protected, anonymous page */
   mmap(0, 0x1000, 0, MAP_SHARED|MAP_FIXED|MAP_ANON, -1, 0);
 
-  newtask:
+newtask:
   while((hashsize(activetasks)>0)||(maxreadfd>0)) {
 
     /* Check if any filedescriptors have IO pending */
@@ -1040,18 +1066,20 @@ void executetasks() {
       tmpreadfds=readfds;
       numselect=select(maxreadfd, &tmpreadfds, NULL, NULL, &timeout);
       if (numselect>0) {
-	/* Process ready fd's */
-	int fd;
-	for(fd=0;fd<maxreadfd;fd++) {
-	  if (FD_ISSET(fd, &tmpreadfds)) {
-	    /* Set ready flag on object */
-	    void * objptr;
-	    //	    printf("Setting fd %d\n",fd);
-	    if (RuntimeHashget(fdtoobject, fd,(int *) &objptr)) {
-	      intflagorand(objptr,1,0xFFFFFFFF); /* Set the first flag to 1 */
-	    }
-	  }
-	}
+        /* Process ready fd's */
+        int fd;
+        for(fd=0; fd<maxreadfd; fd++) {
+          if (FD_ISSET(fd, &tmpreadfds)) {
+            /* Set ready flag on object */
+            void * objptr;
+            //	    printf("Setting fd %d\n",fd);
+            if (RuntimeHashget(fdtoobject, fd,(int *) &objptr)) {
+              if(intflagorand(objptr,1,0xFFFFFFFF)) { /* Set the first flag to 1 */
+                enqueueObject(objptr);
+              }
+            }
+          }
+        }
       }
     }
 
@@ -1060,168 +1088,196 @@ void executetasks() {
       int i;
       currtpd=(struct taskparamdescriptor *) getfirstkey(activetasks);
       genfreekey(activetasks, currtpd);
-      
+
       /* Check if this task has failed, allow a task that contains optional objects to fire */
       if (gencontains(failedtasks, currtpd)) {
-	// Free up task parameter descriptor
-	RUNFREE(currtpd->parameterArray);
-	RUNFREE(currtpd);
-	goto newtask;
+        // Free up task parameter descriptor
+        RUNFREE(currtpd->parameterArray);
+#ifdef OPTIONAL
+        RUNFREE(currtpd->failed);
+#endif
+        RUNFREE(currtpd);
+        goto newtask;
       }
       int numparams=currtpd->task->numParameters;
       int numtotal=currtpd->task->numTotal;
-      
+
       /* Make sure that the parameters are still in the queues */
-      for(i=0;i<numparams;i++) {
-	void * parameter=currtpd->parameterArray[i];
-	struct parameterdescriptor * pd=currtpd->task->descriptorarray[i];
-	struct parameterwrapper *pw=(struct parameterwrapper *) pd->queue;
-	int j;
-	/* Check that object is still in queue */
+      for(i=0; i<numparams; i++) {
+        void * parameter=currtpd->parameterArray[i];
+        struct parameterdescriptor * pd=currtpd->task->descriptorarray[i];
+        struct parameterwrapper *pw=(struct parameterwrapper *) pd->queue;
+        int j;
+        /* Check that object is still in queue */
 #ifdef OPTIONAL
-	{
-	  int UNUSED, UNUSED2;
-	  int *flags;
-	  int numflags, isnonfailed;
-	  int failed=currtpd->failed[i];
-	  if (!ObjectHashget(pw->objectset, (int) parameter, &UNUSED, (int *) &flags, &numflags, &isnonfailed)) {
-	    RUNFREE(currtpd->parameterArray);
-	    RUNFREE(currtpd->failed);
-	    RUNFREE(currtpd);
-	    goto newtask;
-	  } else {
-	    if (failed&&(flags!=NULL)) {
-	      //Failed parameter
-	      fsesarray[i]=flags;
-	      numfsesarray[i]=numflags;
-	    } else if (!failed && isnonfailed) {
-	      //Non-failed parameter
-	      fsesarray[i]=NULL;
-	      numfsesarray[i]=0;
-	    } else {
-	      RUNFREE(currtpd->parameterArray);
-	      RUNFREE(currtpd->failed);
-	      RUNFREE(currtpd);
-	      goto newtask;
-	    }
-	  }
-	}
+        {
+          int UNUSED, UNUSED2;
+          int *flags;
+          int numflags, isnonfailed;
+          int failed=currtpd->failed[i];
+          if (!ObjectHashget(pw->objectset, (int) parameter, &UNUSED, (int *) &flags, &numflags, &isnonfailed)) {
+            RUNFREE(currtpd->parameterArray);
+            RUNFREE(currtpd->failed);
+            RUNFREE(currtpd);
+            goto newtask;
+          } else {
+            if (failed&&(flags!=NULL)) {
+              //Failed parameter
+              fsesarray[i]=flags;
+              numfsesarray[i]=numflags;
+            } else if (!failed && isnonfailed) {
+              //Non-failed parameter
+              fsesarray[i]=NULL;
+              numfsesarray[i]=0;
+            } else {
+              RUNFREE(currtpd->parameterArray);
+              RUNFREE(currtpd->failed);
+              RUNFREE(currtpd);
+              goto newtask;
+            }
+          }
+        }
 #else
-	{
-	  if (!ObjectHashcontainskey(pw->objectset, (int) parameter)) {
-	    RUNFREE(currtpd->parameterArray);
-	    RUNFREE(currtpd);
-	    goto newtask;
-	  }
-	}
+        {
+          if (!ObjectHashcontainskey(pw->objectset, (int) parameter)) {
+            RUNFREE(currtpd->parameterArray);
+            RUNFREE(currtpd);
+            goto newtask;
+          }
+        }
+#endif
+parameterpresent:
+        ;
+        /* Check that object still has necessary tags */
+        for(j=0; j<pd->numbertags; j++) {
+          int slotid=pd->tagarray[2*j]+numparams;
+          struct ___TagDescriptor___ *tagd=currtpd->parameterArray[slotid];
+          if (!containstag(parameter, tagd)) {
+            RUNFREE(currtpd->parameterArray);
+#ifdef OPTIONAL
+            RUNFREE(currtpd->failed);
 #endif
-      parameterpresent:
-	;
-	/* Check that object still has necessary tags */
-	for(j=0;j<pd->numbertags;j++) {
-	  int slotid=pd->tagarray[2*j]+numparams;
-	  struct ___TagDescriptor___ *tagd=currtpd->parameterArray[slotid];
-	  if (!containstag(parameter, tagd)) {
-	    RUNFREE(currtpd->parameterArray);
-	    RUNFREE(currtpd);
-	    goto newtask;
-	  }
-	}
-	
-	taskpointerarray[i+OFFSET]=parameter;
+            RUNFREE(currtpd);
+            goto newtask;
+          }
+        }
+
+        taskpointerarray[i+OFFSET]=parameter;
       }
       /* Copy the tags */
-      for(;i<numtotal;i++) {
-	taskpointerarray[i+OFFSET]=currtpd->parameterArray[i];
+      for(; i<numtotal; i++) {
+        taskpointerarray[i+OFFSET]=currtpd->parameterArray[i];
       }
 
       {
-	/* Checkpoint the state */
-	forward=allocateRuntimeHash(100);
-	reverse=allocateRuntimeHash(100);
-	void ** checkpoint=makecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, forward, reverse);
-	int x;
-	if (x=setjmp(error_handler)) {
-	  int counter;
-	  /* Recover */
+        /* Checkpoint the state */
+#ifdef FASTCHECK
+        ___fcrevert___=NULL;
+#else
+        forward=cCreate(256, 0.4);
+        reverse=cCreate(256, 0.4);
+        void ** checkpoint=makecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, forward, reverse);
+#endif
+        int x;
+        if (x=setjmp(error_handler)) {
+          int counter;
+          /* Recover */
 #ifdef DEBUG
-	  printf("Fatal Error=%d, Recovering!\n",x);
+          printf("Fatal Error=%d, Recovering!\n",x);
+#endif
+          genputtable(failedtasks,currtpd,currtpd);
+#ifdef FASTCHECK
+          REVERT_OBJ(___fcrevert___);
+#else
+          restorecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, checkpoint, forward, reverse);
 #endif
-	  genputtable(failedtasks,currtpd,currtpd);
-	  restorecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, checkpoint, forward, reverse);
 
 #ifdef OPTIONAL
-	  for(counter=0; counter<currtpd->task->numParameters; counter++){
-	    //enqueue as failed
-	    enqueueoptional(currtpd->parameterArray[counter], numfsesarray[counter], fsesarray[counter], currtpd->task, counter);
-
-	    //free fses copies
-	    if (fsesarray[counter]!=NULL)
-	      RUNFREE(fsesarray[counter]);
-	  }
+          for(counter=0; counter<currtpd->task->numParameters; counter++) {
+            //enqueue as failed
+            enqueueoptional(currtpd->parameterArray[counter], numfsesarray[counter], fsesarray[counter], currtpd->task, counter);
+
+            //free fses copies
+            if (fsesarray[counter]!=NULL)
+              RUNFREE(fsesarray[counter]);
+          }
 #endif
-	  freeRuntimeHash(forward);
-	  freeRuntimeHash(reverse);
-	  freemalloc();
-	  forward=NULL;
-	  reverse=NULL;
-	} else {
-	  if (injectfailures) {
-	    if ((((double)random())/RAND_MAX)<failurechance) {
-	      printf("\nINJECTING TASK FAILURE to %s\n", currtpd->task->name);
-	      longjmp(error_handler,10);
-	    }
-	  }
-	  /* Actually call task */
+#ifndef FASTCHECK
+          cDelete(forward);
+          cDelete(reverse);
+          freemalloc();
+          forward=NULL;
+          reverse=NULL;
+#endif
+
+        } else {
+          if (injectfailures) {
+            if ((((double)random())/RAND_MAX)<failurechance) {
+              printf("\nINJECTING TASK FAILURE to %s\n", currtpd->task->name);
+              longjmp(error_handler,10);
+            }
+          }
+          /* Actually call task */
 #ifdef PRECISE_GC
-	  ((int *)taskpointerarray)[0]=currtpd->numParameters;
-	  taskpointerarray[1]=NULL;
+          ((int *)taskpointerarray)[0]=currtpd->numParameters;
+          taskpointerarray[1]=NULL;
 #endif
 #ifdef OPTIONAL
-	  //get the task flags set
-	  for(i=0;i<numparams;i++) {
-	    oldfsesarray[i]=((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses;
-	    fsesarray[i]=fsescopy(fsesarray[i], numfsesarray[i]);
-	    ((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses=fsesarray[i];	    
-	  }
+          //get the task flags set
+          for(i=0; i<numparams; i++) {
+            oldfsesarray[i]=((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses;
+            fsesarray[i]=fsescopy(fsesarray[i], numfsesarray[i]);
+            ((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses=fsesarray[i];
+          }
+#endif
+          if(debugtask) {
+            printf("ENTER %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
+            ((void (*)(void **))currtpd->task->taskptr)(taskpointerarray);
+            printf("EXIT %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
+          } else
+            ((void (*)(void **))currtpd->task->taskptr)(taskpointerarray);
+
+#ifdef OPTIONAL
+          for(i=0; i<numparams; i++) {
+            //free old fses
+            if(oldfsesarray[i]!=NULL)
+              RUNFREE(oldfsesarray[i]);
+          }
 #endif
-	  if(debugtask){
-	    printf("ENTER %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
-	    ((void (*) (void **)) currtpd->task->taskptr)(taskpointerarray);
-	    printf("EXIT %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
-	  } else
-	    ((void (*) (void **)) currtpd->task->taskptr)(taskpointerarray);
 
+#ifdef FASTCHECK
+          while(___fcrevert___) {
+            struct ___Object___ *tmpptr=___fcrevert___->___nextobject___;
+            COMMIT_OBJ(___fcrevert___);
+            ___fcrevert___=tmpptr;
+          }
+#else
+          cDelete(forward);
+          cDelete(reverse);
+          freemalloc();
+#endif
+          // Free up task parameter descriptor
+          RUNFREE(currtpd->parameterArray);
 #ifdef OPTIONAL
-	  for(i=0;i<numparams;i++) {
-	    //free old fses
-	    if(oldfsesarray[i]!=NULL)
-	      RUNFREE(oldfsesarray[i]);
-	  }
+          RUNFREE(currtpd->failed);
 #endif
-	  
-	  freeRuntimeHash(forward);
-	  freeRuntimeHash(reverse);
-	  freemalloc();
-	  // Free up task parameter descriptor
-	  RUNFREE(currtpd->parameterArray);
-	  RUNFREE(currtpd);
-	  forward=NULL;
-	  reverse=NULL;
-	}
+          RUNFREE(currtpd);
+          forward=NULL;
+          reverse=NULL;
+        }
       }
     }
   }
 }
- 
+
 /* This function processes an objects tags */
 void processtags(struct parameterdescriptor *pd, int index, struct parameterwrapper *parameter, int * iteratorcount, int *statusarray, int numparams) {
   int i;
-  
-  for(i=0;i<pd->numbertags;i++) {
+
+  for(i=0; i<pd->numbertags; i++) {
     int slotid=pd->tagarray[2*i];
     int tagid=pd->tagarray[2*i+1];
-    
+
     if (statusarray[slotid+numparams]==0) {
       parameter->iterators[*iteratorcount].istag=1;
       parameter->iterators[*iteratorcount].tagid=tagid;
@@ -1244,7 +1300,7 @@ void processobject(struct parameterwrapper *parameter, int index, struct paramet
   parameter->iterators[*iteratorcount].objectset=objectset;
   statusarray[index]=1;
 
-  for(i=0;i<pd->numbertags;i++) {
+  for(i=0; i<pd->numbertags; i++) {
     int slotid=pd->tagarray[2*i];
     int tagid=pd->tagarray[2*i+1];
     if (statusarray[slotid+numparams]!=0) {
@@ -1265,52 +1321,52 @@ void builditerators(struct taskdescriptor * task, int index, struct parameterwra
   int i;
   int numparams=task->numParameters;
   int iteratorcount=0;
-  for(i=0;i<MAXTASKPARAMS;i++) statusarray[i]=0;
+  for(i=0; i<MAXTASKPARAMS; i++) statusarray[i]=0;
 
   statusarray[index]=1; /* Initial parameter */
   /* Process tags for initial iterator */
-  
-  processtags(task->descriptorarray[index], index, parameter, & iteratorcount, statusarray, numparams);
-  
+
+  processtags(task->descriptorarray[index], index, parameter, &iteratorcount, statusarray, numparams);
+
   while(1) {
-  loopstart:
+loopstart:
     /* Check for objects with existing tags */
-    for(i=0;i<numparams;i++) {
+    for(i=0; i<numparams; i++) {
       if (statusarray[i]==0) {
-	struct parameterdescriptor *pd=task->descriptorarray[i];
-	int j;
-	for(j=0;j<pd->numbertags;j++) {
-	  int slotid=pd->tagarray[2*j];
-	  if(statusarray[slotid+numparams]!=0) {
-	    processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
-	    processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
-	    goto loopstart;
-	  }
-	}
+        struct parameterdescriptor *pd=task->descriptorarray[i];
+        int j;
+        for(j=0; j<pd->numbertags; j++) {
+          int slotid=pd->tagarray[2*j];
+          if(statusarray[slotid+numparams]!=0) {
+            processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
+            processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
+            goto loopstart;
+          }
+        }
       }
     }
 
     /* Next do objects w/ unbound tags*/
 
-    for(i=0;i<numparams;i++) {
+    for(i=0; i<numparams; i++) {
       if (statusarray[i]==0) {
-	struct parameterdescriptor *pd=task->descriptorarray[i];
-	if (pd->numbertags>0) {
-	  processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
-	  processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
-	  goto loopstart;
-	}
+        struct parameterdescriptor *pd=task->descriptorarray[i];
+        if (pd->numbertags>0) {
+          processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
+          processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
+          goto loopstart;
+        }
       }
     }
 
     /* Nothing with a tag enqueued */
 
-    for(i=0;i<numparams;i++) {
+    for(i=0; i<numparams; i++) {
       if (statusarray[i]==0) {
-	struct parameterdescriptor *pd=task->descriptorarray[i];
-	processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
-	processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
-	goto loopstart;
+        struct parameterdescriptor *pd=task->descriptorarray[i];
+        processobject(parameter, i, pd, &iteratorcount, statusarray, numparams);
+        processtags(pd, i, parameter, &iteratorcount, statusarray, numparams);
+        goto loopstart;
       }
     }
 
@@ -1319,51 +1375,59 @@ void builditerators(struct taskdescriptor * task, int index, struct parameterwra
   }
 }
 
- void printdebug() {
-   int i;
-   int j;
-   for(i=0;i<numtasks;i++) {
-     struct taskdescriptor * task=taskarray[i];
-     printf("%s\n", task->name);
-     for(j=0;j<task->numParameters;j++) {
-       struct parameterdescriptor *param=task->descriptorarray[j];
-       struct parameterwrapper *parameter=param->queue;
-       struct ObjectHash * set=parameter->objectset;
-       struct ObjectIterator objit;
-       printf("  Parameter %d\n", j);
-       ObjectHashiterator(set, &objit);
-       while(ObjhasNext(&objit)) {
-	 struct ___Object___ * obj=(struct ___Object___ *)Objkey(&objit);
-	 struct ___Object___ * tagptr=obj->___tags___;
-	 Objnext(&objit);
-	 printf("    Contains %lx\n", obj);
-	 printf("      flag=%d\n", obj->flag); 
-	 if (tagptr==NULL) {
-	 } else if (tagptr->type==TAGTYPE) {
-	   printf("      tag=%lx\n",tagptr);
-	 } else {
-	   int tagindex=0;
-	   struct ArrayObject *ao=(struct ArrayObject *)tagptr;
-	   for(;tagindex<ao->___cachedCode___;tagindex++) {
-	     printf("      tag=%lx\n",ARRAYGET(ao, struct ___TagDescriptor___*, tagindex));
-	   }
-	 }
-       }
-     }
-   }
- }
- 
+void printdebug() {
+  int i;
+  int j;
+  for(i=0; i<numtasks; i++) {
+    struct taskdescriptor * task=taskarray[i];
+    printf("%s\n", task->name);
+    for(j=0; j<task->numParameters; j++) {
+      struct parameterdescriptor *param=task->descriptorarray[j];
+      struct parameterwrapper *parameter=param->queue;
+      struct ObjectHash * set=parameter->objectset;
+      struct ObjectIterator objit;
+      printf("  Parameter %d\n", j);
+      ObjectHashiterator(set, &objit);
+      while(ObjhasNext(&objit)) {
+        struct ___Object___ * obj=(struct ___Object___ *)Objkey(&objit);
+        struct ___Object___ * tagptr=obj->___tags___;
+        int nonfailed=Objdata4(&objit);
+        int numflags=Objdata3(&objit);
+        int flags=Objdata2(&objit);
+        Objnext(&objit);
+        printf("    Contains %lx\n", obj);
+        printf("      flag=%d\n", obj->flag);
+#ifdef OPTIONAL
+        printf("      flagsstored=%x\n",flags);
+        printf("      numflags=%d\n", numflags);
+        printf("      nonfailed=%d\n",nonfailed);
+#endif
+        if (tagptr==NULL) {
+        } else if (tagptr->type==TAGTYPE) {
+          printf("      tag=%lx\n",tagptr);
+        } else {
+          int tagindex=0;
+          struct ArrayObject *ao=(struct ArrayObject *)tagptr;
+          for(; tagindex<ao->___cachedCode___; tagindex++) {
+            printf("      tag=%lx\n",ARRAYGET(ao, struct ___TagDescriptor___*, tagindex));
+          }
+        }
+      }
+    }
+  }
+}
+
 
 /* This function processes the task information to create queues for
    each parameter type. */
 
 void processtasks() {
   int i;
-  for(i=0;i<numtasks;i++) {
+  for(i=0; i<numtasks; i++) {
     struct taskdescriptor * task=taskarray[i];
     int j;
 
-    for(j=0;j<task->numParameters;j++) {
+    for(j=0; j<task->numParameters; j++) {
       struct parameterdescriptor *param=task->descriptorarray[j];
       struct parameterwrapper * parameter=RUNMALLOC(sizeof(struct parameterwrapper));
       struct parameterwrapper ** ptr=&objectqueues[param->type];
@@ -1375,17 +1439,17 @@ void processtasks() {
       parameter->numbertags=param->numbertags;
       parameter->tagarray=param->tagarray;
       parameter->task=task;
+      parameter->slot=j;
       /* Link new queue in */
       while((*ptr)!=NULL)
-	ptr=&((*ptr)->next);
+        ptr=&((*ptr)->next);
       (*ptr)=parameter;
     }
 
     /* Build iterators for parameters */
-    for(j=0;j<task->numParameters;j++) {
+    for(j=0; j<task->numParameters; j++) {
       struct parameterdescriptor *param=task->descriptorarray[j];
-      struct parameterwrapper *parameter=param->queue;      
-      parameter->slot=j;
+      struct parameterwrapper *parameter=param->queue;
       builditerators(task, j, parameter);
     }
   }
@@ -1415,19 +1479,19 @@ int toiHasNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * fa
     struct ___Object___ *tagptr=obj->___tags___;
     if (tagptr->type==TAGTYPE) {
       if ((it->tagobjindex==0)&& /* First object */
-	  (it->tagid==((struct ___TagDescriptor___ *)tagptr)->flag)) /* Right tag type */
-	return 1;
+          (it->tagid==((struct ___TagDescriptor___ *)tagptr)->flag)) /* Right tag type */
+        return 1;
       else
-	return 0;
+        return 0;
     } else {
       struct ArrayObject *ao=(struct ArrayObject *) tagptr;
       int tagindex=it->tagobjindex;
-      for(;tagindex<ao->___cachedCode___;tagindex++) {
-	struct ___TagDescriptor___ *td=ARRAYGET(ao, struct ___TagDescriptor___ *, tagindex);
-	if (td->flag==it->tagid) {
-	  it->tagobjindex=tagindex; /* Found right type of tag */
-	  return 1;
-	}
+      for(; tagindex<ao->___cachedCode___; tagindex++) {
+        struct ___TagDescriptor___ *td=ARRAYGET(ao, struct ___TagDescriptor___ *, tagindex);
+        if (td->flag==it->tagid) {
+          it->tagobjindex=tagindex; /* Found right type of tag */
+          return 1;
+        }
       }
       return 0;
     }
@@ -1438,38 +1502,38 @@ int toiHasNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * fa
     int i;
     if (objptr->type!=OBJECTARRAYTYPE) {
       if (it->tagobjindex>0)
-	return 0;
+        return 0;
       if (!ObjectHashcontainskey(it->objectset, (int) objptr))
-	return 0;
-      for(i=1;i<it->numtags;i++) {
-	struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
-	if (!containstag(objptr,tag2))
-	  return 0;
+        return 0;
+      for(i=1; i<it->numtags; i++) {
+        struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
+        if (!containstag(objptr,tag2))
+          return 0;
       }
 #ifdef OPTIONAL
       if (it->failedstate==1) {
-	int UNUSED, UNUSED2;
-	int * flags;
-	int isnonfailed;
-	ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
-	if (flags!=NULL) {
-	  return 1;
-	} else {
-	  it->tagobjindex++;
-	  it->failedstate=0;
-	  return 0;
-	}
+        int UNUSED, UNUSED2;
+        int * flags;
+        int isnonfailed;
+        ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+        if (flags!=NULL) {
+          return 1;
+        } else {
+          it->tagobjindex++;
+          it->failedstate=0;
+          return 0;
+        }
       } else {
-	int UNUSED, UNUSED2;
-	int * flags;
-	int isnonfailed;
-	ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
-	if (!isnonfailed) {
-	  it->failedstate=1;
-	}
-	return 1;
+        int UNUSED, UNUSED2;
+        int * flags;
+        int isnonfailed;
+        ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+        if (!isnonfailed) {
+          it->failedstate=1;
+        }
+        return 1;
       }
-#endif      
+#endif
       return 1;
     } else {
       struct ArrayObject *ao=(struct ArrayObject *) objptr;
@@ -1477,43 +1541,43 @@ int toiHasNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * fa
       int i;
 #ifdef OPTIONAL
       if (it->failedstate==1) {
-	int UNUSED, UNUSED2;
-	int * flags;
-	int isnonfailed;
-	struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, it->tagobjindex);
-	ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
-	if (flags!=NULL) {
-	  return 1;
-	} else {
-	  it->failedstate=0;
-	  it->tagobjindex++;
-	}
+        int UNUSED, UNUSED2;
+        int * flags;
+        int isnonfailed;
+        struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, it->tagobjindex);
+        ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+        if (flags!=NULL) {
+          return 1;
+        } else {
+          it->failedstate=0;
+          it->tagobjindex++;
+        }
       }
 #endif
-      for(tagindex=it->tagobjindex;tagindex<ao->___cachedCode___;tagindex++) {
-	struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
-	if (!ObjectHashcontainskey(it->objectset, (int) objptr))
-	  continue;
-	for(i=1;i<it->numtags;i++) {
-	  struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
-	  if (!containstag(objptr,tag2))
-	    goto nexttag;
-	}
+      for(tagindex=it->tagobjindex; tagindex<ao->___cachedCode___; tagindex++) {
+        struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
+        if (!ObjectHashcontainskey(it->objectset, (int) objptr))
+          continue;
+        for(i=1; i<it->numtags; i++) {
+          struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
+          if (!containstag(objptr,tag2))
+            goto nexttag;
+        }
 #ifdef OPTIONAL
-	{
-	  int UNUSED, UNUSED2;
-	  int flags, isnonfailed;
-	  struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
-	  ObjectHashget(it->objectset, (int) objptr, &UNUSED, &flags, &UNUSED2, &isnonfailed);
-	  if (!isnonfailed) {
-	    it->failedstate=1;
-	  }
-	}
+        {
+          int UNUSED, UNUSED2;
+          int flags, isnonfailed;
+          struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
+          ObjectHashget(it->objectset, (int) objptr, &UNUSED, &flags, &UNUSED2, &isnonfailed);
+          if (!isnonfailed) {
+            it->failedstate=1;
+          }
+        }
 #endif
-	it->tagobjindex=tagindex;
-	return 1;
-      nexttag:
-	;
+        it->tagobjindex=tagindex;
+        return 1;
+nexttag:
+        ;
       }
       it->tagobjindex=tagindex;
       return 0;
@@ -1522,16 +1586,16 @@ int toiHasNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * fa
 #ifdef OPTIONAL
     if (it->failedstate==1) {
       if (Objdata2(&it->it))
-	return 1;
+        return 1;
       else {
-	it->failedstate=0;
-	Objnext(&it->it);
+        it->failedstate=0;
+        Objnext(&it->it);
       }
     }
     if (ObjhasNext(&it->it)) {
       if (!Objdata4(&it->it)) {
-	//failed state only
-	it->failedstate=1;
+        //failed state only
+        it->failedstate=1;
       }
       return 1;
     } else
@@ -1547,22 +1611,25 @@ int containstag(struct ___Object___ *ptr, struct ___TagDescriptor___ *tag) {
   struct ___Object___ * objptr=tag->flagptr;
   if (objptr->type==OBJECTARRAYTYPE) {
     struct ArrayObject *ao=(struct ArrayObject *)objptr;
-    for(j=0;j<ao->___cachedCode___;j++) {
+    for(j=0; j<ao->___cachedCode___; j++) {
       if (ptr==ARRAYGET(ao, struct ___Object___*, j))
-	return 1;
+        return 1;
     }
     return 0;
   } else
     return objptr==ptr;
 }
 
-void toiNext(struct tagobjectiterator *it , void ** objectarray OPTARG(int * failed)) {
+void toiNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * failed)) {
   /* hasNext has all of the intelligence */
   if(it->istag) {
     /* Iterate tag */
     /* Get object with tags */
     struct ___Object___ *obj=objectarray[it->tagobjectslot];
     struct ___Object___ *tagptr=obj->___tags___;
+#ifdef OPTIONAL
+    failed[it->slot]=0; //have to set it to something
+#endif
     if (tagptr->type==TAGTYPE) {
       it->tagobjindex++;
       objectarray[it->slot]=tagptr;
@@ -1576,14 +1643,14 @@ void toiNext(struct tagobjectiterator *it , void ** objectarray OPTARG(int * fai
     struct ___Object___ *objptr=tag->flagptr;
     if (objptr->type!=OBJECTARRAYTYPE) {
 #ifdef OPTIONAL
-    failed[it->slot]=it->failedstate;
-    objectarray[it->slot]=objptr;
-    if (it->failedstate==0) {
-      it->failedstate=1;
-    } else {
-      it->failedstate=0;
-      it->tagobjindex++;
-    }
+      failed[it->slot]=it->failedstate;
+      objectarray[it->slot]=objptr;
+      if (it->failedstate==0) {
+        it->failedstate=1;
+      } else {
+        it->failedstate=0;
+        it->tagobjindex++;
+      }
 #else
       it->tagobjindex++;
       objectarray[it->slot]=objptr;
@@ -1591,21 +1658,22 @@ void toiNext(struct tagobjectiterator *it , void ** objectarray OPTARG(int * fai
     } else {
       struct ArrayObject *ao=(struct ArrayObject *) objptr;
 #ifdef OPTIONAL
-    failed[it->slot]=it->failedstate;
-    objectarray[it->slot]=ARRAYGET(ao, struct ___Object___ *, it->tagobjindex);
-    if (it->failedstate==0) {
-      it->failedstate=1;
-    } else {
-      it->failedstate=0;
-      it->tagobjindex++;
-    }
+      failed[it->slot]=it->failedstate;
+      objectarray[it->slot]=ARRAYGET(ao, struct ___Object___ *, it->tagobjindex);
+      if (it->failedstate==0) {
+        it->failedstate=1;
+      } else {
+        it->failedstate=0;
+        it->tagobjindex++;
+      }
 #else
       objectarray[it->slot]=ARRAYGET(ao, struct ___Object___ *, it->tagobjindex++);
 #endif
     }
   } else {
     /* Iterate object */
-    objectarray[it->slot]=(void *)Objkey(&it->it);
+    void * tmpp = (void *) Objkey(&it->it);
+    objectarray[it->slot]=tmpp;
 #ifdef OPTIONAL
     failed[it->slot]=it->failedstate;
     if (it->failedstate==0) {