From: bdemsky <bdemsky>
Date: Fri, 16 Oct 2009 21:35:22 +0000 (+0000)
Subject: parses
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=5a3994ddcf01e11c7d557baa00cf3f9d24bee269;p=IRC.git

parses
---

diff --git a/Robust/src/Benchmarks/SingleTM/Yada/coordinate.java b/Robust/src/Benchmarks/SingleTM/Yada/coordinate.java
index e4b329ec..6585df0e 100644
--- a/Robust/src/Benchmarks/SingleTM/Yada/coordinate.java
+++ b/Robust/src/Benchmarks/SingleTM/Yada/coordinate.java
@@ -76,7 +76,7 @@ public class coordinate {
       return 1;
     } else if (aPtr.y < bPtr.y) {
       return -1;
-    } else if (aPt.>y > bPtr.y) {
+    } else if (aPtr.y > bPtr.y) {
       return 1;
     }
     return 0;
diff --git a/Robust/src/Benchmarks/SingleTM/Yada/element.java b/Robust/src/Benchmarks/SingleTM/Yada/element.java
index 5ec24c5a..0573795a 100644
--- a/Robust/src/Benchmarks/SingleTM/Yada/element.java
+++ b/Robust/src/Benchmarks/SingleTM/Yada/element.java
@@ -69,23 +69,20 @@
  */
 
 public class element {
-    coordinate coordinates[];
-    int numCoordinate;
-    coordinate_t circumCenter;
-    double circumRadius;
-    double minAngle;
-    edge edges[3];
-    int numEdge;
-    coordinate_t midpoints[3]; /* midpoint of each edge */
-    double radii[3];           /* half of edge length */
-    edge encroachedEdgePtr; /* opposite obtuse angle */
-    boolean isSkinny;
-    list_t neighborListPtr;
-    boolean isGarbage;
-    boolean isReferenced;
-
-
-  extern double global_angleConstraint;
+  coordinate coordinates[];
+  int numCoordinate;
+  coordinate circumCenter;
+  double circumRadius;
+  double minAngle;
+  edge edges[];
+  int numEdge;
+  coordinate midpoints[]; /* midpoint of each edge */
+  double radii[];           /* half of edge length */
+  edge encroachedEdgePtr; /* opposite obtuse angle */
+  boolean isSkinny;
+  List_t neighborListPtr;
+  boolean isGarbage;
+  boolean isReferenced;
 
 
 
@@ -121,11 +118,11 @@ public class element {
  * -- Sets isSkinny to TRUE if the angle constraint is not met
  * =============================================================================
  */
-  void checkAngles () {
-    double angleConstraint = global_angleConstraint;
+  void checkAngles (double angleConstraint) {
+    //double angleConstraint = global_angleConstraint;
     minAngle = 180.0;
 
-    assert(numCoordinate == 2 || numCoordinate == 3);
+    yada.Assert(numCoordinate == 2 || numCoordinate == 3);
     isReferenced = false;
     isSkinny = false;
     encroachedEdgePtr = null;
@@ -136,8 +133,8 @@ public class element {
 	  double angle = coordinate_angle(coordinates[i],
 					  coordinates[(i + 1) % 3],
 					  coordinates[(i + 2) % 3]);
-	  assert(angle > 0.0);
-	  assert(angle < 180.0);
+	  yada.Assert(angle > 0.0);
+	  yada.Assert(angle < 180.0);
 	  if (angle > 90.0) {
 	    encroachedEdgePtr = edges[(i + 1) % 3];
 	  }
@@ -148,7 +145,7 @@ public class element {
 	    minAngle = angle;
 	  }
         }
-        assert(minAngle < 180.0);
+        yada.Assert(minAngle < 180.0);
     }
 }
 
@@ -187,7 +184,7 @@ public class element {
   void calculateCircumCircle() {
     coordinate circumCenterPtr = this.circumCenter;
 
-    assert(numCoordinate == 2 || numCoordinate == 3);
+    yada.Assert(numCoordinate == 2 || numCoordinate == 3);
 
     if (numCoordinate == 2) {
       circumCenterPtr.x = (coordinates[0].x + coordinates[1].x) / 2.0;
@@ -210,7 +207,7 @@ public class element {
       double denominator = 2 * ((bxDelta * cyDelta) - (cxDelta * byDelta));
       double rx = ax - (xNumerator / denominator);
       double ry = ay + (yNumerator / denominator);
-      assert(fabs(denominator) > DBL_MIN); /* make sure not colinear */
+      yada.Assert(fabs(denominator) > DBL_MIN); /* make sure not colinear */
       circumCenterPtr.x = rx;
       circumCenterPtr.y = ry;
     }
@@ -232,7 +229,7 @@ public class element {
     
     edge edgePtr = edges[i];
     int cmp = coordinate_compare(firstPtr, secondPtr);
-    assert(cmp != 0);
+    yada.Assert(cmp != 0);
     if (cmp < 0) {
       edgePtr.firstPtr  = firstPtr;
       edgePtr.secondPtr = secondPtr;
@@ -326,6 +323,10 @@ int element_compare (element aElementPtr, element bElementPtr) {
    */
   public element(coordinate[] coordinates, int numCoordinate) {
     this.coordinates=new coordinate[3];
+    this.midpoints=new coordinate[3]; /* midpoint of each edge */
+    this.radii=new double[3];           /* half of edge length */
+
+    this.edges=new edge[3];
     for (int i = 0; i < numCoordinate; i++) {
       this.coordinates[i] = coordinates[i];
     }
@@ -383,9 +384,9 @@ int element_compare (element aElementPtr, element bElementPtr) {
  * For use in list_t
  * ============================================================================
  */
-  int element_listCompareEdge (const void* aPtr, const void* bPtr) {
-    edge_t* aEdgePtr = (edge_t*)(aPtr);
-    edge_t* bEdgePtr = (edge_t*)(bPtr);
+  int element_listCompareEdge (Object aPtr, Object bPtr) {
+    edge aEdgePtr = (edge)(aPtr);
+    edge bEdgePtr = (edge)(bPtr);
     
     return compareEdge(aEdgePtr, bEdgePtr);
   }
@@ -423,7 +424,7 @@ int element_compare (element aElementPtr, element bElementPtr) {
       }
     }
     
-    if (bElementPtr->encroachedEdgePtr) {
+    if (bElementPtr.encroachedEdgePtr) {
       return -1;
     }
     
@@ -588,7 +589,7 @@ int element_compare (element aElementPtr, element bElementPtr) {
 	  return midpoints[e];
 	}
       }
-      assert(0);
+      yada.Assert(0);
     }
     return circumCenter;
   }
@@ -600,8 +601,8 @@ int element_compare (element aElementPtr, element bElementPtr) {
  * Return FALSE if minimum angle constraint not met
  * =============================================================================
  */
-  boolean element_checkAngles() {
-    double angleConstraint = global_angleConstraint;
+  boolean element_checkAngles(double angleConstraint) {
+    //    double angleConstraint = global_angleConstraint;
     if (numCoordinate == 3) {
       for (int i = 0; i < 3; i++) {
 	double angle = coordinate_angle(coordinates[i],
diff --git a/Robust/src/Benchmarks/SingleTM/Yada/mesh.java b/Robust/src/Benchmarks/SingleTM/Yada/mesh.java
index 5ec0f674..d2c41ef4 100644
--- a/Robust/src/Benchmarks/SingleTM/Yada/mesh.java
+++ b/Robust/src/Benchmarks/SingleTM/Yada/mesh.java
@@ -72,7 +72,7 @@ public class mesh {
     element rootElementPtr;
     Queue_t initBadQueuePtr;
     int size;
-    SET_T* boundarySetPtr;
+    SET_T boundarySetPtr;
 
 /* =============================================================================
  * mesh_alloc
@@ -82,7 +82,7 @@ public class mesh {
     rootElementPtr = null;
     initBadQueuePtr = new Queue_t(-1);
     size = 0;
-    boundarySetPtr = SET_ALLOC(null, &element_listCompareEdge);
+    boundarySetPtr = SET_ALLOC(null, element_listCompareEdge);
   }
 
 
@@ -97,7 +97,7 @@ public class mesh {
      * for checking the validity of the final mesh.
      */
     if (rootElementPtr==null) {
-      rootElementPtr=elementPtr);
+      rootElementPtr=elementPtr;
   }
 
     /*
@@ -106,26 +106,26 @@ public class mesh {
   int numEdge = elementPtr.element_getNumEdge();
   for (int i = 0; i < numEdge; i++) {
     edge edgePtr = elementPtr.element_getEdge(i);
-    if (!MAP_CONTAINS(edgeMapPtr, (void*)edgePtr)) {
+    if (!MAP_CONTAINS(edgeMapPtr, edgePtr)) {
       /* Record existance of this edge */
       boolean isSuccess =
-	PMAP_INSERT(edgeMapPtr, (void*)edgePtr, (void*)elementPtr);
-      assert(isSuccess);
+	PMAP_INSERT(edgeMapPtr, edgePtr, elementPtr);
+      yada.Assert(isSuccess);
     } else {
       /*
        * Shared edge; update each element's neighborList
        */
       boolean isSuccess;
-      element sharerPtr = (element_t*)MAP_FIND(edgeMapPtr, edgePtr);
-      assert(sharerPtr); /* cannot be shared by >2 elements */
+      element sharerPtr = (element)MAP_FIND(edgeMapPtr, edgePtr);
+      yada.Assert(sharerPtr!=null); /* cannot be shared by >2 elements */
       elementPtr.element_addNeighbor(sharerPtr);
       sharerPtr.element_addNeighbor(elementPtr);
       isSuccess = PMAP_REMOVE(edgeMapPtr, edgePtr);
-      assert(isSuccess);
+      yada.Assert(isSuccess);
       isSuccess = PMAP_INSERT(edgeMapPtr,
 			      edgePtr,
-			      NULL); /* marker to check >2 sharers */
-      assert(isSuccess);
+			      null); /* marker to check >2 sharers */
+      yada.Assert(isSuccess);
     }
   }
 
@@ -147,7 +147,7 @@ public class mesh {
  * =============================================================================
  */
 public void TMmesh_remove(element elementPtr) {
-  assert(!elementPtr.element_isGarbage());
+  yada.Assert(!elementPtr.element_isGarbage());
 
   /*
    * If removing root, a new root is selected on the next mesh_insert, which
@@ -161,13 +161,13 @@ public void TMmesh_remove(element elementPtr) {
    * Remove from neighbors
    */
   list_iter_t it;
-  List neighborListPtr = elementPtr.element_getNeighborListPtr();
-  TMLIST_ITER_RESET(&it, neighborListPtr);
-  while (TMLIST_ITER_HASNEXT(&it, neighborListPtr)) {
-      element neighborPtr = (element)TMLIST_ITER_NEXT(&it, neighborListPtr);
+  List_t neighborListPtr = elementPtr.element_getNeighborListPtr();
+  TMLIST_ITER_RESET(it, neighborListPtr);
+  while (TMLIST_ITER_HASNEXT(it, neighborListPtr)) {
+      element neighborPtr = (element)TMLIST_ITER_NEXT(it, neighborListPtr);
       List_t neighborNeighborListPtr = neighborPtr.element_getNeighborListPtr();
       boolean status = neighborNeighborListPtr.remove(elementPtr);
-      assert(status);
+      yada.Assert(status);
   }
 
   elementPtr.element_isGarbage(true);
@@ -178,7 +178,7 @@ public void TMmesh_remove(element elementPtr) {
  * TMmesh_insertBoundary
  * =============================================================================
  */
-boolean TMmesh_insertBoundary (meshPtr, edge boundaryPtr) {
+boolean TMmesh_insertBoundary(edge boundaryPtr) {
   return TMSET_INSERT(boundarySetPtr, boundaryPtr);
 }
 
@@ -187,7 +187,7 @@ boolean TMmesh_insertBoundary (meshPtr, edge boundaryPtr) {
  * TMmesh_removeBoundary
  * =============================================================================
  */
-boolean TMmesh_removeBoundary (meshPtr, edge boundaryPtr) {
+boolean TMmesh_removeBoundary(edge boundaryPtr) {
   return TMSET_REMOVE(boundarySetPtr, boundaryPtr);
 }
 
@@ -200,19 +200,19 @@ static void createElement (coordinate coordinates,
                int numCoordinate,
 			   MAP_T edgeMapPtr) {
     element elementPtr = new element(coordinates, numCoordinate);
-    assert(elementPtr);
+    yada.Assert(elementPtr);
 
     if (numCoordinate == 2) {
         edge boundaryPtr = elementPtr.element_getEdge(0);
         boolean status = SET_INSERT(boundarySetPtr, boundaryPtr);
-        assert(status);
+        yada.Assert(status);
     }
 
     mesh_insert(elementPtr, edgeMapPtr);
 
     if (elementPtr.element_isBad()) {
         boolean status = initBadQueuePtr.queue_push(elementPtr);
-        assert(status);
+        yada.Assert(status);
     }
 }
 
@@ -226,11 +226,11 @@ static void createElement (coordinate coordinates,
  * =============================================================================
  */
 int mesh_read(String fileNamePrefix) {
-    FILE* inputFile;
-    coordinate_t* coordinates;
-    char fileName[256];
+    FILE inputFile;
+    coordinate coordinates;
+    char fileName[]=new char[256];
     int fileNameSize = sizeof(fileName) / sizeof(fileName[0]);
-    char inputBuff[256];
+    char inputBuff[]=new char[256];
     int inputBuffSize = sizeof(inputBuff) / sizeof(inputBuff[0]);
     int numEntry;
     int numDimension;
@@ -238,21 +238,20 @@ int mesh_read(String fileNamePrefix) {
     int i;
     int numElement = 0;
 
-    MAP_T* edgeMapPtr = MAP_ALLOC(NULL, &element_mapCompareEdge);
-    assert(edgeMapPtr);
+    MAP_T edgeMapPtr = MAP_ALLOC(NULL, element_mapCompareEdge);
+    yada.Assert(edgeMapPtr);
 
     /*
      * Read .node file
      */
     snprintf(fileName, fileNameSize, "%s.node", fileNamePrefix);
     inputFile = fopen(fileName, "r");
-    assert(inputFile);
+    yada.Assert(inputFile);
     fgets(inputBuff, inputBuffSize, inputFile);
-    sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
-    assert(numDimension == 2); /* must be 2-D */
+    sscanf(inputBuff, "%li %li", numEntry, numDimension);
+    yada.Assert(numDimension == 2); /* must be 2-D */
     numCoordinate = numEntry + 1; /* numbering can start from 1 */
-    coordinates = (coordinate_t*)malloc(numCoordinate * sizeof(coordinate_t));
-    assert(coordinates);
+    coordinates = new coordinate[numCoordinate];
     for (i = 0; i < numEntry; i++) {
         int id;
         double x;
@@ -263,11 +262,11 @@ int mesh_read(String fileNamePrefix) {
         if (inputBuff[0] == '#') {
             continue; /* TODO: handle comments correctly */
         }
-        sscanf(inputBuff, "%li %lf %lf", &id, &x, &y);
+        sscanf(inputBuff, "%li %lf %lf", id, x, y);
         coordinates[id].x = x;
         coordinates[id].y = y;
     }
-    assert(i == numEntry);
+    yada.Assert(i == numEntry);
     fclose(inputFile);
 
     /*
@@ -275,32 +274,32 @@ int mesh_read(String fileNamePrefix) {
      */
     snprintf(fileName, fileNameSize, "%s.poly", fileNamePrefix);
     inputFile = fopen(fileName, "r");
-    assert(inputFile);
+    yada.Assert(inputFile);
     fgets(inputBuff, inputBuffSize, inputFile);
-    sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
-    assert(numEntry == 0); /* .node file used for vertices */
-    assert(numDimension == 2); /* must be edge */
+    sscanf(inputBuff, "%li %li", numEntry, numDimension);
+    yada.Assert(numEntry == 0); /* .node file used for vertices */
+    yada.Assert(numDimension == 2); /* must be edge */
     fgets(inputBuff, inputBuffSize, inputFile);
-    sscanf(inputBuff, "%li", &numEntry);
+    sscanf(inputBuff, "%li", numEntry);
     for (i = 0; i < numEntry; i++) {
         int id;
         int a;
         int b;
-        coordinate_t insertCoordinates[2];
+        coordinate insertCoordinates=new coordinate[2];
         if (!fgets(inputBuff, inputBuffSize, inputFile)) {
             break;
         }
         if (inputBuff[0] == '#') {
             continue; /* TODO: handle comments correctly */
         }
-        sscanf(inputBuff, "%li %li %li", &id, &a, &b);
-        assert(a >= 0 && a < numCoordinate);
-        assert(b >= 0 && b < numCoordinate);
+        sscanf(inputBuff, "%li %li %li", id, a, b);
+        yada.Assert(a >= 0 && a < numCoordinate);
+        yada.Assert(b >= 0 && b < numCoordinate);
         insertCoordinates[0] = coordinates[a];
         insertCoordinates[1] = coordinates[b];
         createElement(meshPtr, insertCoordinates, 2, edgeMapPtr);
     }
-    assert(i == numEntry);
+    yada.Assert(i == numEntry);
     numElement += numEntry;
     fclose(inputFile);
 
@@ -309,32 +308,32 @@ int mesh_read(String fileNamePrefix) {
      */
     snprintf(fileName, fileNameSize, "%s.ele", fileNamePrefix);
     inputFile = fopen(fileName, "r");
-    assert(inputFile);
+    yada.Assert(inputFile);
     fgets(inputBuff, inputBuffSize, inputFile);
-    sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
-    assert(numDimension == 3); /* must be triangle */
+    sscanf(inputBuff, "%li %li", numEntry, numDimension);
+    yada.Assert(numDimension == 3); /* must be triangle */
     for (i = 0; i < numEntry; i++) {
         int id;
         int a;
         int b;
         int c;
-        coordinate_t insertCoordinates[3];
+        coordinate insertCoordinates[]=new coordinate[3];
         if (!fgets(inputBuff, inputBuffSize, inputFile)) {
             break;
         }
         if (inputBuff[0] == '#') {
             continue; /* TODO: handle comments correctly */
         }
-        sscanf(inputBuff, "%li %li %li %li", &id, &a, &b, &c);
-        assert(a >= 0 && a < numCoordinate);
-        assert(b >= 0 && b < numCoordinate);
-        assert(c >= 0 && c < numCoordinate);
+        sscanf(inputBuff, "%li %li %li %li", id, a, b, c);
+        yada.Assert(a >= 0 && a < numCoordinate);
+        yada.Assert(b >= 0 && b < numCoordinate);
+        yada.Assert(c >= 0 && c < numCoordinate);
         insertCoordinates[0] = coordinates[a];
         insertCoordinates[1] = coordinates[b];
         insertCoordinates[2] = coordinates[c];
         createElement(meshPtr, insertCoordinates, 3, edgeMapPtr);
     }
-    assert(i == numEntry);
+    yada.Assert(i == numEntry);
     numElement += numEntry;
     fclose(inputFile);
 
@@ -376,40 +375,40 @@ boolean mesh_check(int expectedNumElement) {
     System.out.println("Checking final mesh:");
     
     Queue_t searchQueuePtr = new Queue_t(-1);
-    assert(searchQueuePtr);
-    MAP_T visitedMapPtr = MAP_ALLOC(NULL, &element_mapCompare);
-    assert(visitedMapPtr);
+    yada.Assert(searchQueuePtr);
+    MAP_T visitedMapPtr = MAP_ALLOC(NULL, element_mapCompare);
+    yada.Assert(visitedMapPtr);
 
     /*
      * Do breadth-first search starting from rootElementPtr
      */
-    assert(rootElementPtr!=null);
+    yada.Assert(rootElementPtr!=null);
     searchQueuePtr.queue_push(rootElementPtr);
     while (!searchQueuePtr.queue_isEmpty()) {
         list_iter_t it;
         List_t neighborListPtr;
 
         element currentElementPtr = (element)queue_pop(searchQueuePtr);
-        if (MAP_CONTAINS(visitedMapPtr, (void*)currentElementPtr)) {
+        if (MAP_CONTAINS(visitedMapPtr, currentElementPtr)) {
             continue;
         }
-        boolean isSuccess = MAP_INSERT(visitedMapPtr, (void*)currentElementPtr, NULL);
-        assert(isSuccess);
+        boolean isSuccess = MAP_INSERT(visitedMapPtr, currentElementPtr, null);
+        yada.Assert(isSuccess);
         if (!currentElementPtr.checkAngles()) {
             numBadTriangle++;
         }
         neighborListPtr = currentElementPtr.element_getNeighborListPtr();
 
-        list_iter_reset(&it, neighborListPtr);
-        while (list_iter_hasNext(&it, neighborListPtr)) {
+        list_iter_reset(it, neighborListPtr);
+        while (list_iter_hasNext(it, neighborListPtr)) {
             element neighborElementPtr =
-                (element)list_iter_next(&it, neighborListPtr);
+                (element)list_iter_next(it, neighborListPtr);
             /*
              * Continue breadth-first search
              */
-            if (!MAP_CONTAINS(visitedMapPtr, (void*)neighborElementPtr)) {
+            if (!MAP_CONTAINS(visitedMapPtr, neighborElementPtr)) {
                 boolean isSuccess = searchQueuePtr.queue_push(neighborElementPtr);
-                assert(isSuccess);
+                yada.Assert(isSuccess);
             }
         } /* for each neighbor */
 
@@ -426,3 +425,4 @@ boolean mesh_check(int expectedNumElement) {
 	      numFalseNeighbor > 0 ||
 	      numElement != expectedNumElement));
 }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/SingleTM/Yada/region.java b/Robust/src/Benchmarks/SingleTM/Yada/region.java
index 4eef55dc..841df3f7 100644
--- a/Robust/src/Benchmarks/SingleTM/Yada/region.java
+++ b/Robust/src/Benchmarks/SingleTM/Yada/region.java
@@ -81,8 +81,8 @@ public class region {
  */
   public region() {
     expandQueuePtr = new Queue_t(-1);
-    beforeListPtr = PLIST_ALLOC(&element_listCompare);
-    borderListPtr = PLIST_ALLOC(&element_listCompareEdge);
+    beforeListPtr = PLIST_ALLOC(element_listCompare);
+    borderListPtr = PLIST_ALLOC(element_listCompareEdge);
     badVectorPtr = new Vector_t(1);
   }
 
@@ -93,7 +93,7 @@ public class region {
    */
   public void TMaddToBadVector(Vector_t badVectorPtr, element badElementPtr) {
     boolean status = badVectorPtr.vector_pushBack(badElementPtr);
-    assert(status);
+    yada.Assert(status);
     badElementPtr.element_setIsReferenced(true);
   }
 
@@ -106,14 +106,14 @@ public class region {
   public int TMretriangulate (element elementPtr,
 			      region regionPtr,
 			      mesh meshPtr,
-			      MAP_T* edgeMapPtr) {
+			      MAP_T edgeMapPtr) {
     Vector_t badVectorPtr = regionPtr.badVectorPtr; /* private */
     list_t beforeListPtr = regionPtr.beforeListPtr; /* private */
     list_t borderListPtr = regionPtr.borderListPtr; /* private */
     list_iter_t it;
     int numDelta = 0;
     
-    assert(edgeMapPtr);
+    yada.Assert(edgeMapPtr);
     
     coordinate centerCoordinate = elementPtr.element_getNewPoint();
     
@@ -121,9 +121,9 @@ public class region {
      * Remove the old triangles
      */
     
-    list_iter_reset(&it, beforeListPtr);
-    while (list_iter_hasNext(&it, beforeListPtr)) {
-      element beforeElementPtr = (element)list_iter_next(&it, beforeListPtr);
+    list_iter_reset(it, beforeListPtr);
+    while (list_iter_hasNext(it, beforeListPtr)) {
+      element beforeElementPtr = (element)list_iter_next(it, beforeListPtr);
       meshPtr.TMmesh_remove(beforeElementPtr);
     }
     
@@ -141,20 +141,20 @@ public class region {
       
       coordinates[1] = (coordinate)(edgePtr.firstPtr);
       element aElementPtr = new element(coordinates, 2);
-      assert(aElementPtr);
+      yada.Assert(aElementPtr);
       meshPtr.TMmesh_insert(aElementPtr, edgeMapPtr);
       
-      coordinates[1] = (coordinate)(edgePtr->secondPtr);
+      coordinates[1] = (coordinate)edgePtr.secondPtr;
       element bElementPtr = new element(coordinates, 2);
-      assert(bElementPtr);
+      yada.Assert(bElementPtr);
       meshPtr.TMmesh_insert(bElementPtr, edgeMapPtr);
       
       boolean status = meshPtr.TMmesh_removeBoundary(elementPtr.element_getEdge(0));
-      assert(status);
+      yada.Assert(status);
       status = mesPtr.TMmesh_insertBoundary(aElementPtr.element_getEdge(0));
-      assert(status);
+      yada.Assert(status);
       status = meshPtr.TMmesh_insertBoundary(bElementPtr.element_getEdge(0));
-      assert(status);
+      yada.Assert(status);
       
       numDelta += 2;
     }
@@ -164,16 +164,16 @@ public class region {
      * point and the two points from the border segment.
      */
 
-    list_iter_reset(&it, borderListPtr);
-    while (list_iter_hasNext(&it, borderListPtr)) {
+    list_iter_reset(it, borderListPtr);
+    while (list_iter_hasNext(it, borderListPtr)) {
       coordinate coordinates[]=new coordinates[3];
-      edge borderEdgePtr = (edge)list_iter_next(&it, borderListPtr);
-      assert(borderEdgePtr);
+      edge borderEdgePtr = (edge)list_iter_next(it, borderListPtr);
+      yada.Assert(borderEdgePtr);
       coordinates[0] = centerCoordinate;
       coordinates[1] = (coordinate)(borderEdgePtr.firstPtr);
       coordinates[2] = (coordinate)(borderEdgePtr.secondPtr);
       element afterElementPtr = new element(coordinates, 3);
-      assert(afterElementPtr);
+      yada.Assert(afterElementPtr!=null);
       meshPtr.TMmesh_insert(afterElementPtr, edgeMapPtr);
       if (afterElementPTr.element_isBad()) {
 	TMaddToBadVector(badVectorPtr, afterElementPtr);
@@ -192,7 +192,7 @@ public class region {
   element TMgrowRegion(element centerElementPtr,
 		       region regionPtr,
 		       mesh meshPtr,
-		       MAP_T* edgeMapPtr) {
+		       MAP_T edgeMapPtr) {
     boolean isBoundary = false;
     
     if (centerElementPtr.element_getNumEdge() == 1) {
@@ -218,9 +218,9 @@ public class region {
       List_t neighborListPtr = currentElementPtr.element_getNeighborListPtr();
       
       list_iter_t it;
-      TMLIST_ITER_RESET(&it, neighborListPtr);
-      while (TMLIST_ITER_HASNEXT(&it, neighborListPtr)) {
-	element neighborElementPtr = (element)TMLIST_ITER_NEXT(&it, neighborListPtr);
+      TMLIST_ITER_RESET(it, neighborListPtr);
+      while (TMLIST_ITER_HASNEXT(it, neighborListPtr)) {
+	element neighborElementPtr = (element)TMLIST_ITER_NEXT(it, neighborListPtr);
 	neighborElementPtr.element_isGarbage(); /* so we can detect conflicts */
 	if (!beforeListPtr.find(neighborElementPtr)) {
 	  if (neighborElementPtr.element_isInCircumCircle(centerCoordinatePtr)) {
@@ -231,7 +231,7 @@ public class region {
 	    } else {
 	      /* Continue breadth-first search */
 	      boolean isSuccess = expandQueuePtr.queue_push(neighborElementPtr);
-	      assert(isSuccess);
+	      yada.Assert(isSuccess);
 	    }
 	  } else {
 	    /* This element borders region; save info for retriangulation */
@@ -266,8 +266,8 @@ public class region {
     elementPtr.element_isGarbage(); /* so we can detect conflicts */
     
     while (true) {
-      edgeMapPtr = PMAP_ALLOC(NULL, &element_mapCompareEdge);
-      assert(edgeMapPtr);
+      edgeMapPtr = PMAP_ALLOC(NULL, element_mapCompareEdge);
+      yada.Assert(edgeMapPtr);
       encroachElementPtr = TMgrowRegion(elementPtr,
 					this,
 					meshPtr,
@@ -324,7 +324,7 @@ public class region {
       if (badElementPtr.element_isGarbage()) {
       } else {
 	boolean status = workHeapPtr.heap_insert(badElementPtr);
-	assert(status);
+	yada.Assert(status);
       }
     }
   }
diff --git a/Robust/src/Benchmarks/SingleTM/Yada/yada.java b/Robust/src/Benchmarks/SingleTM/Yada/yada.java
index f5593bc1..3c356363 100644
--- a/Robust/src/Benchmarks/SingleTM/Yada/yada.java
+++ b/Robust/src/Benchmarks/SingleTM/Yada/yada.java
@@ -75,7 +75,7 @@ public class yada {
     System.out.println("Usage: Yada [options]");
     System.out.println("Options:                              (defaults)");
     System.out.println("    a <FLT>   Min [a]ngle constraint  (20.0)");
-    System.out.println("    i <STR>   [i]nput name prefix     ("")");
+    System.out.println("    i <STR>   [i]nput name prefix     (\"\")");
     System.out.println("    t <UINT>  Number of [t]hreads     (1L)");
     System.exit(1);
   }
@@ -121,14 +121,16 @@ public class yada {
         }
         numBad++;
         boolean status = workHeapPtr.heap_insert(elementPtr);
-        assert(status);
+        yada.Assert(status);
         elementPtr.element_setIsReferenced(true);
     }
     
     return numBad;
   }
-
-
+  
+  public static void Assert(boolean status) {
+    
+  }
 /* =============================================================================
  * process
  * =============================================================================
@@ -141,7 +143,7 @@ public class yada {
     int totalNumAdded = 0;
     int numProcess = 0;
     region regionPtr = new region();
-    assert(regionPtr);
+    yada.Assert(regionPtr);
 
     while (true) {
         element elementPtr;