From d7d04e024cae2eeb4515afa548a565a4a075f1c2 Mon Sep 17 00:00:00 2001
From: Gareth Rees <gdr@ravenbrook.com>
Date: Wed, 9 Apr 2014 14:37:39 +0100
Subject: [PATCH] Size class structures (mps_sac_class_s) are public, so should
 have names starting with "mps_" (these were removed incorrectly in change
 179383).

Copied from Perforce
 Change: 185389
 ServerID: perforce.ravenbrook.com
---
 mps/code/mps.h                    |  6 +++---
 mps/code/sac.c                    | 28 ++++++++++++++--------------
 mps/manual/source/topic/cache.rst |  6 +++---
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/mps/code/mps.h b/mps/code/mps.h
index b948a5f8d7d..58cbb2ebf88 100644
--- a/mps/code/mps.h
+++ b/mps/code/mps.h
@@ -325,9 +325,9 @@ typedef struct _mps_sac_s {
 
 /* .sacc: Keep in sync with <code/sac.h>. */
 typedef struct mps_sac_class_s {
-  size_t _block_size;
-  size_t _cached_count;
-  unsigned _frequency;
+  size_t mps_block_size;
+  size_t mps_cached_count;
+  unsigned mps_frequency;
 } mps_sac_class_s;
 
 #define mps_sac_classes_s mps_sac_class_s
diff --git a/mps/code/sac.c b/mps/code/sac.c
index 435988cf867..3854a40b0d5 100644
--- a/mps/code/sac.c
+++ b/mps/code/sac.c
@@ -113,10 +113,10 @@ Res SACCreate(SAC *sacReturn, Pool pool, Count classesCount,
   /* to be large enough, but that gets complicated, if you have to */
   /* merge classes because of the adjustment. */
   for (i = 0; i < classesCount; ++i) {
-    AVER(classes[i]._block_size > 0);
-    AVER(SizeIsAligned(classes[i]._block_size, PoolAlignment(pool)));
-    AVER(prevSize < classes[i]._block_size);
-    prevSize = classes[i]._block_size;
+    AVER(classes[i].mps_block_size > 0);
+    AVER(SizeIsAligned(classes[i].mps_block_size, PoolAlignment(pool)));
+    AVER(prevSize < classes[i].mps_block_size);
+    prevSize = classes[i].mps_block_size;
     /* no restrictions on count */
     /* no restrictions on frequency */
   }
@@ -124,7 +124,7 @@ Res SACCreate(SAC *sacReturn, Pool pool, Count classesCount,
   /* Calculate frequency scale */
   for (i = 0; i < classesCount; ++i) {
     unsigned oldFreq = totalFreq;
-    totalFreq += classes[i]._frequency;
+    totalFreq += classes[i].mps_frequency;
     AVER(oldFreq <= totalFreq); /* check for overflow */
     UNUSED(oldFreq); /* <code/mpm.c#check.unused> */
   }
@@ -132,10 +132,10 @@ Res SACCreate(SAC *sacReturn, Pool pool, Count classesCount,
   /* Find middle one */
   totalFreq /= 2;
   for (i = 0; i < classesCount; ++i) {
-    if (totalFreq < classes[i]._frequency) break;
-    totalFreq -= classes[i]._frequency;
+    if (totalFreq < classes[i].mps_frequency) break;
+    totalFreq -= classes[i].mps_frequency;
   }
-  if (totalFreq <= classes[i]._frequency / 2)
+  if (totalFreq <= classes[i].mps_frequency / 2)
     middleIndex = i;
   else
     middleIndex = i + 1; /* there must exist another class at i+1 */
@@ -151,9 +151,9 @@ Res SACCreate(SAC *sacReturn, Pool pool, Count classesCount,
   /* It's important this matches SACFind. */
   esac = ExternalSACOfSAC(sac);
   for (j = middleIndex + 1, i = 0; j < classesCount; ++j, i += 2) {
-    esac->_freelists[i]._size = classes[j]._block_size;
+    esac->_freelists[i]._size = classes[j].mps_block_size;
     esac->_freelists[i]._count = 0;
-    esac->_freelists[i]._count_max = classes[j]._cached_count;
+    esac->_freelists[i]._count_max = classes[j].mps_cached_count;
     esac->_freelists[i]._blocks = NULL;
   }
   esac->_freelists[i]._size = SizeMAX;
@@ -161,19 +161,19 @@ Res SACCreate(SAC *sacReturn, Pool pool, Count classesCount,
   esac->_freelists[i]._count_max = 0;
   esac->_freelists[i]._blocks = NULL;
   for (j = middleIndex, i = 1; j > 0; --j, i += 2) {
-    esac->_freelists[i]._size = classes[j-1]._block_size;
+    esac->_freelists[i]._size = classes[j-1].mps_block_size;
     esac->_freelists[i]._count = 0;
-    esac->_freelists[i]._count_max = classes[j]._cached_count;
+    esac->_freelists[i]._count_max = classes[j].mps_cached_count;
     esac->_freelists[i]._blocks = NULL;
   }
   esac->_freelists[i]._size = 0;
   esac->_freelists[i]._count = 0;
-  esac->_freelists[i]._count_max = classes[j]._cached_count;
+  esac->_freelists[i]._count_max = classes[j].mps_cached_count;
   esac->_freelists[i]._blocks = NULL;
 
   /* finish init */
   esac->_trapped = FALSE;
-  esac->_middle = classes[middleIndex]._block_size;
+  esac->_middle = classes[middleIndex].mps_block_size;
   sac->pool = pool;
   sac->classesCount = classesCount;
   sac->middleIndex = middleIndex;
diff --git a/mps/manual/source/topic/cache.rst b/mps/manual/source/topic/cache.rst
index fc523161a21..589e5e86db0 100644
--- a/mps/manual/source/topic/cache.rst
+++ b/mps/manual/source/topic/cache.rst
@@ -170,9 +170,9 @@ Cache interface
 
     The size classes are described by an array of element type
     :c:type:`mps_sac_class_s`. This array is used to initialize the
-    segregated allocation cache, and is not needed
-    after:c:func:`mps_sac_create` returns. The following constraints
-    apply to the array:
+    segregated allocation cache, and is not needed after
+    :c:func:`mps_sac_create` returns. The following constraints apply
+    to the array:
 
     * You must specify at least one size class.