Rename the enumeration cbsfinddelete to finddelete in anticipation of it being shared between cbs and new freelist module.

Since ABQDisposition enumeration only has two values, it's better to use Bool.

Copied from Perforce
 Change: 182347
 ServerID: perforce.ravenbrook.com

10 files changed, 71 insertions, 89 deletions

diff --git a/mps/code/abq.c b/mps/code/abq.c
index aa796057acc..f9317c49728 100644
--- a/mps/code/abq.c
+++ b/mps/code/abq.c
@@ -241,17 +241,6 @@ Count ABQDepth(ABQ abq)
 }
 
 
-/* ABQDispositionCheck -- check method for an ABQDisposition value */
-static Bool ABQDispositionCheck(ABQDisposition disposition)
-{
-  CHECKL(disposition == ABQDispositionKEEP
-         || disposition == ABQDispositionDELETE);
-  UNUSED(disposition); /* <code/mpm.c#check.unused> */
-
-  return TRUE;
-}
-
-
 /* ABQIterate -- call 'iterate' for each element in an ABQ */
 void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP, Size closureS)
 {
@@ -266,11 +255,12 @@ void ABQIterate(ABQ abq, ABQIterateMethod iterate, void *closureP, Size closureS
  
   while (index != in) {
     void *element = ABQElement(abq, index);
-    ABQDisposition disposition = ABQDispositionNONE;
+    Bool delete = FALSE;
     Bool cont;
-    cont = (*iterate)(&disposition, element, closureP, closureS);
-    AVERT(ABQDisposition, disposition);
-    if (disposition == ABQDispositionKEEP) {
+    cont = (*iterate)(&delete, element, closureP, closureS);
+    AVERT(Bool, cont);
+    AVERT(Bool, delete);
+    if (!delete) {
       if (copy != index)
         mps_lib_memcpy(ABQElement(abq, copy), element, abq->elementSize);
       copy = ABQNextIndex(abq, copy);
diff --git a/mps/code/abq.h b/mps/code/abq.h
index 08462c9192f..7a7cc2a65d9 100644
--- a/mps/code/abq.h
+++ b/mps/code/abq.h
@@ -24,8 +24,7 @@
 
 typedef struct ABQStruct *ABQ;
 typedef Res (*ABQDescribeElement)(void *element, mps_lib_FILE *stream);
-typedef unsigned ABQDisposition;
-typedef Bool (*ABQIterateMethod)(ABQDisposition *dispositionReturn, void *element, void *closureP, Size closureS);
+typedef Bool (*ABQIterateMethod)(Bool *deleteReturn, void *element, void *closureP, Size closureS);
 
 extern Res ABQInit(Arena arena, ABQ abq, void *owner, Count elements, Size elementSize);
 extern Bool ABQCheck(ABQ abq);
@@ -59,18 +58,6 @@ typedef struct ABQStruct
   Sig sig;
 } ABQStruct;
 
-enum {
-  ABQIterationCONTINUE = 1, /* continue iterating */
-  ABQIterationSTOP,         /* stop iterating */
-  ABQIterationNONE          /* no iteration (error) */
-};
-
-enum {
-  ABQDispositionKEEP = 1, /* keep item in queue */
-  ABQDispositionDELETE,   /* delete element from queue */
-  ABQDispositionNONE      /* no disposition (error) */
-};
-
 #endif /* abq_h */
 
 
diff --git a/mps/code/abqtest.c b/mps/code/abqtest.c
index 4588af97954..32987836dae 100644
--- a/mps/code/abqtest.c
+++ b/mps/code/abqtest.c
@@ -95,17 +95,17 @@ typedef struct TestClosureStruct {
   Res res;
 } TestClosureStruct;
 
-static Bool TestDeleteCallback(ABQDisposition *dispositionReturn,
-                               void *element, void *closureP, Size closureS)
+static Bool TestDeleteCallback(Bool *deleteReturn, void *element,
+                               void *closureP, Size closureS)
 {
   TestBlock *a = (TestBlock *)element;
   TestClosure cl = (TestClosure)closureP;
   UNUSED(closureS);
   if (*a == cl->b) {
-    *dispositionReturn = ABQDispositionDELETE;
+    *deleteReturn = TRUE;
     cl->res = ResOK;
   } else {
-    *dispositionReturn = ABQDispositionKEEP;
+    *deleteReturn = FALSE;
   }
   return TRUE;
 }
diff --git a/mps/code/cbs.c b/mps/code/cbs.c
index 658af95c022..45a708f2ba7 100644
--- a/mps/code/cbs.c
+++ b/mps/code/cbs.c
@@ -690,13 +690,14 @@ void CBSIterate(CBS cbs, CBSIterateMethod iterate,
 }
 
 
-/* CBSFindDeleteCheck -- check method for a CBSFindDelete value */
+/* FindDeleteCheck -- check method for a FindDelete value */
 
-static Bool CBSFindDeleteCheck(CBSFindDelete findDelete)
+Bool FindDeleteCheck(FindDelete findDelete)
 {
-  CHECKL(findDelete == CBSFindDeleteNONE || findDelete == CBSFindDeleteLOW
-         || findDelete == CBSFindDeleteHIGH
-         || findDelete == CBSFindDeleteENTIRE);
+  CHECKL(findDelete == FindDeleteNONE
+         || findDelete == FindDeleteLOW
+         || findDelete == FindDeleteHIGH
+         || findDelete == FindDeleteENTIRE);
   UNUSED(findDelete); /* <code/mpm.c#check.unused> */
 
   return TRUE;
@@ -708,7 +709,7 @@ static Bool CBSFindDeleteCheck(CBSFindDelete findDelete)
 static void cbsFindDeleteRange(Addr *baseReturn, Addr *limitReturn,
                                Addr *oldBaseReturn, Addr *oldLimitReturn,
                                CBS cbs, Addr base, Addr limit, Size size,
-                               CBSFindDelete findDelete)
+                               FindDelete findDelete)
 {
   Bool callDelete = TRUE;
 
@@ -718,23 +719,23 @@ static void cbsFindDeleteRange(Addr *baseReturn, Addr *limitReturn,
   AVER(base < limit);
   AVER(size > 0);
   AVER(AddrOffset(base, limit) >= size);
-  AVERT(CBSFindDelete, findDelete);
+  AVERT(FindDelete, findDelete);
 
   switch(findDelete) {
 
-  case CBSFindDeleteNONE:
+  case FindDeleteNONE:
     callDelete = FALSE;
     break;
 
-  case CBSFindDeleteLOW:
+  case FindDeleteLOW:
     limit = AddrAdd(base, size);
     break;
 
-  case CBSFindDeleteHIGH:
+  case FindDeleteHIGH:
     base = AddrSub(limit, size);
     break;
 
-  case CBSFindDeleteENTIRE:
+  case FindDeleteENTIRE:
     /* do nothing */
     break;
 
@@ -762,7 +763,7 @@ static void cbsFindDeleteRange(Addr *baseReturn, Addr *limitReturn,
 
 Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
                   Addr *oldBaseReturn, Addr *oldLimitReturn,
-                  CBS cbs, Size size, CBSFindDelete findDelete)
+                  CBS cbs, Size size, FindDelete findDelete)
 {
   Bool found;
   SplayNode node;
@@ -775,7 +776,7 @@ Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
   AVER(size > 0);
   AVER(SizeIsAligned(size, cbs->alignment));
   AVER(cbs->fastFind);
-  AVERT(CBSFindDelete, findDelete);
+  AVERT(FindDelete, findDelete);
 
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   found = SplayFindFirst(&node, splayTreeOfCBS(cbs), &cbsTestNode,
@@ -801,7 +802,7 @@ Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
 
 Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
                  Addr *oldBaseReturn, Addr *oldLimitReturn,
-                 CBS cbs, Size size, CBSFindDelete findDelete)
+                 CBS cbs, Size size, FindDelete findDelete)
 {
   Bool found;
   SplayNode node;
@@ -814,7 +815,7 @@ Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
   AVER(size > 0);
   AVER(SizeIsAligned(size, cbs->alignment));
   AVER(cbs->fastFind);
-  AVERT(CBSFindDelete, findDelete);
+  AVERT(FindDelete, findDelete);
 
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   found = SplayFindLast(&node, splayTreeOfCBS(cbs), &cbsTestNode,
@@ -840,7 +841,7 @@ Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
 
 Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
                     Addr *oldBaseReturn, Addr *oldLimitReturn,
-                    CBS cbs, CBSFindDelete findDelete)
+                    CBS cbs, FindDelete findDelete)
 {
   Bool found = FALSE;
   SplayNode root;
@@ -852,7 +853,7 @@ Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
   AVER(baseReturn != NULL);
   AVER(limitReturn != NULL);
   AVER(cbs->fastFind);
-  AVERT(CBSFindDelete, findDelete);
+  AVERT(FindDelete, findDelete);
 
   notEmpty = SplayRoot(&root, splayTreeOfCBS(cbs));
   if (notEmpty) {
diff --git a/mps/code/cbs.h b/mps/code/cbs.h
index 4ac99ad8254..544df0a0586 100644
--- a/mps/code/cbs.h
+++ b/mps/code/cbs.h
@@ -49,23 +49,15 @@ extern void CBSIterate(CBS cbs, CBSIterateMethod iterate,
 
 extern Res CBSDescribe(CBS cbs, mps_lib_FILE *stream);
 
-typedef unsigned CBSFindDelete;
-enum {
-  CBSFindDeleteNONE = 1,/* don't delete after finding */
-  CBSFindDeleteLOW,     /* delete precise size from low end */
-  CBSFindDeleteHIGH,    /* delete precise size from high end */
-  CBSFindDeleteENTIRE   /* delete entire range */
-};
-
 extern Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
                          Addr *oldBaseReturn, Addr *oldLimitReturn,
-                         CBS cbs, Size size, CBSFindDelete findDelete);
+                         CBS cbs, Size size, FindDelete findDelete);
 extern Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
                         Addr *oldBaseReturn, Addr *oldLimitReturn,
-                        CBS cbs, Size size, CBSFindDelete findDelete);
+                        CBS cbs, Size size, FindDelete findDelete);
 extern Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
                            Addr *oldBaseReturn, Addr *oldLimitReturn,
-                           CBS cbs, CBSFindDelete findDelete);
+                           CBS cbs, FindDelete findDelete);
 
 
 #endif /* cbs_h */
diff --git a/mps/code/cbstest.c b/mps/code/cbstest.c
index 9a3191530dc..3588d488204 100644
--- a/mps/code/cbstest.c
+++ b/mps/code/cbstest.c
@@ -317,7 +317,7 @@ static void deallocate(CBS cbs, Addr block, BT allocTable,
 
 
 static void find(CBS cbs, void *block, BT alloc, Size size, Bool high,
-                 CBSFindDelete findDelete)
+                 FindDelete findDelete)
 {
   Bool expected, found;
   Index expectedBase, expectedLimit;
@@ -336,23 +336,23 @@ static void find(CBS cbs, void *block, BT alloc, Size size, Bool high,
     remainderLimit = origLimit = addrOfIndex(block, expectedLimit);
 
     switch(findDelete) {
-    case CBSFindDeleteNONE: {
+    case FindDeleteNONE: {
       /* do nothing */
     } break;
-    case CBSFindDeleteENTIRE: {
+    case FindDeleteENTIRE: {
       remainderBase = remainderLimit;
     } break;
-    case CBSFindDeleteLOW: {
+    case FindDeleteLOW: {
       expectedLimit = expectedBase + size;
       remainderBase = addrOfIndex(block, expectedLimit);
     } break;
-    case CBSFindDeleteHIGH: {
+    case FindDeleteHIGH: {
       expectedBase = expectedLimit - size;
       remainderLimit = addrOfIndex(block, expectedBase);
     } break;
     }
 
-    if (findDelete != CBSFindDeleteNONE) {
+    if (findDelete != FindDeleteNONE) {
       newSize = AddrOffset(remainderBase, remainderLimit);
     }
 
@@ -371,7 +371,7 @@ static void find(CBS cbs, void *block, BT alloc, Size size, Bool high,
     Insist(expectedBase == indexOfAddr(block, foundBase));
     Insist(expectedLimit == indexOfAddr(block, foundLimit));
 
-    if (findDelete != CBSFindDeleteNONE) {
+    if (findDelete != FindDeleteNONE) {
       Insist(oldBase == origBase);
       Insist(oldLimit == origLimit);
       BTSetRange(alloc, expectedBase, expectedLimit);
@@ -397,7 +397,7 @@ extern int main(int argc, char *argv[])
   BT allocTable;
   Size size;
   Bool high;
-  CBSFindDelete findDelete = CBSFindDeleteNONE;
+  FindDelete findDelete = FindDeleteNONE;
 
   randomize(argc, argv);
 
@@ -445,10 +445,10 @@ extern int main(int argc, char *argv[])
       switch(cbsRnd(6)) {
       case 0:
       case 1:
-      case 2: findDelete = CBSFindDeleteNONE; break;
-      case 3: findDelete = CBSFindDeleteLOW; break;
-      case 4: findDelete = CBSFindDeleteHIGH; break;
-      case 5: findDelete = CBSFindDeleteENTIRE; break;
+      case 2: findDelete = FindDeleteNONE; break;
+      case 3: findDelete = FindDeleteLOW; break;
+      case 4: findDelete = FindDeleteHIGH; break;
+      case 5: findDelete = FindDeleteENTIRE; break;
       }
       find(cbs, dummyBlock, allocTable, size, high, findDelete);
     } break;
diff --git a/mps/code/mpm.h b/mps/code/mpm.h
index 4292f9fa671..1f7ffa15f9b 100644
--- a/mps/code/mpm.h
+++ b/mps/code/mpm.h
@@ -799,6 +799,11 @@ extern AllocPattern AllocPatternRamp(void);
 extern AllocPattern AllocPatternRampCollectAll(void);
 
 
+/* FindDelete -- see <code/cbs.c> and <code/freelist.c> */
+
+extern Bool FindDeleteCheck(FindDelete findDelete);
+
+
 /* Format Interface -- see <code/format.c> */
 
 extern Bool FormatCheck(Format format);
diff --git a/mps/code/mpmtypes.h b/mps/code/mpmtypes.h
index e9797863bb8..49265c35a72 100644
--- a/mps/code/mpmtypes.h
+++ b/mps/code/mpmtypes.h
@@ -109,6 +109,7 @@ typedef struct AllocPatternStruct *AllocPattern;
 typedef struct AllocFrameStruct *AllocFrame; /* <design/alloc-frame/> */
 typedef struct ReservoirStruct *Reservoir;   /* <design/reservoir/> */
 typedef struct StackContextStruct *StackContext;
+typedef unsigned FindDelete;    /* <design/cbs/> */
 
 
 /* Arena*Method -- see <code/mpmst.h#ArenaClassStruct> */
@@ -424,6 +425,17 @@ enum {
 };
 
 
+/* FindDelete operations -- see <design/cbs/> */
+
+enum {
+  FindDeleteNONE = 1, /* don't delete after finding */
+  FindDeleteLOW,      /* delete precise size from low end */
+  FindDeleteHIGH,     /* delete precise size from high end */
+  FindDeleteENTIRE,   /* delete entire range */
+  FindDeleteLIMIT     /* not a FindDelete operation; the limit of the enum. */
+};
+
+
 /* Types for WriteF formats */
 /* These should be used with calls to WriteF. */
 /* These must be unpromotable types. */
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index ac0e4e87b50..e2642f23c43 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -588,16 +588,16 @@ done:
 
 
 /* MVTDeleteOverlapping -- ABQIterate callback used by MVTInsert and
- * MVTDelete. It receives a Range in its closureP argument, and
- * returns the DELETE disposition for ranges in the ABQ that overlap
- * with it, and the KEEP disposition for ranges that do not.
+ * MVTDelete. It receives a Range in its closureP argument, and sets
+ * *deleteReturn to TRUE for ranges in the ABQ that overlap with it,
+ * and FALSE for ranges that do not.
  */
-static Bool MVTDeleteOverlapping(ABQDisposition *dispositionReturn,
-                                 void *element, void *closureP, Size closureS)
+static Bool MVTDeleteOverlapping(Bool *deleteReturn, void *element,
+                                 void *closureP, Size closureS)
 {
   Range oldRange, newRange;
 
-  AVER(dispositionReturn != NULL);
+  AVER(deleteReturn != NULL);
   AVER(element != NULL);
   AVER(closureP != NULL);
   UNUSED(closureS);
@@ -605,12 +605,7 @@ static Bool MVTDeleteOverlapping(ABQDisposition *dispositionReturn,
   oldRange = element;
   newRange = closureP;
 
-  if (RangesOverlap(oldRange, newRange)) {
-    *dispositionReturn = ABQDispositionDELETE;
-  } else {
-    *dispositionReturn = ABQDispositionKEEP;
-  }
-
+  *deleteReturn = RangesOverlap(oldRange, newRange);
   return TRUE;
 }
 
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index 95e09d90b26..e5335377175 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -247,7 +247,7 @@ static Bool MVFFFindFirstFree(Addr *baseReturn, Addr *limitReturn,
                               MVFF mvff, Size size)
 {
   Bool foundBlock;
-  CBSFindDelete findDelete;
+  FindDelete findDelete;
   Addr oldBase, oldLimit;
 
   AVER(baseReturn != NULL);
@@ -256,7 +256,7 @@ static Bool MVFFFindFirstFree(Addr *baseReturn, Addr *limitReturn,
   AVER(size > 0);
   AVER(SizeIsAligned(size, PoolAlignment(MVFF2Pool(mvff))));
 
-  findDelete = mvff->slotHigh ? CBSFindDeleteHIGH : CBSFindDeleteLOW;
+  findDelete = mvff->slotHigh ? FindDeleteHIGH : FindDeleteLOW;
 
   foundBlock =
     (mvff->firstFit ? CBSFindFirst : CBSFindLast)
@@ -370,7 +370,7 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
 
   /* Hoping the largest is big enough, delete it and return if small. */
   foundBlock = CBSFindLargest(&base, &limit, &oldBase, &oldLimit,
-                              CBSOfMVFF(mvff), CBSFindDeleteENTIRE);
+                              CBSOfMVFF(mvff), FindDeleteENTIRE);
   if (foundBlock && AddrOffset(base, limit) < size) {
     Addr newBase, newLimit;
     foundBlock = FALSE;
@@ -388,7 +388,7 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
     if (res != ResOK)
       return res;
     foundBlock = CBSFindLargest(&base, &limit, &oldBase, &oldLimit,
-                                CBSOfMVFF(mvff), CBSFindDeleteENTIRE);
+                                CBSOfMVFF(mvff), FindDeleteENTIRE);
     AVER(foundBlock); /* We will find the new segment. */
   }