X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flibpspp%2Farray.c;h=9ae278027bca0ff21432ed718106ec64ba75285d;hb=88377f51d06cade55ad3eed7fa8dd36d748da4db;hp=f37270c81da9796320de8507cb097a80ceca6869;hpb=825c7a4a81fe81f804fe95e128fa9f740ca4be2d;p=pspp

diff --git a/src/libpspp/array.c b/src/libpspp/array.c
index f37270c81d..9ae278027b 100644
--- a/src/libpspp/array.c
+++ b/src/libpspp/array.c
@@ -89,6 +89,7 @@
 
 #include <limits.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include "libpspp/assertion.h"
 
@@ -128,17 +129,17 @@ count_equal (const void *array, size_t count, size_t size,
              algo_compare_func *compare, const void *aux)
 {
   const char *first = array;
-  size_t equal_cnt = 0;
+  size_t n_equals = 0;
 
   while (count-- > 0)
     {
       if (compare (element, first, aux) == 0)
-        equal_cnt++;
+        n_equals++;
 
       first += size;
     }
 
-  return equal_cnt;
+  return n_equals;
 }
 
 /* Counts and return the number of elements in ARRAY, which
@@ -150,17 +151,17 @@ count_if (const void *array, size_t count, size_t size,
           algo_predicate_func *predicate, const void *aux)
 {
   const char *first = array;
-  size_t true_cnt = 0;
+  size_t n_trues = 0;
 
   while (count-- > 0)
     {
       if (predicate (first, aux) != 0)
-        true_cnt++;
+        n_trues++;
 
       first += size;
     }
 
-  return true_cnt;
+  return n_trues;
 }
 
 /* Byte-wise swap objects A and B, each SIZE bytes. */
@@ -228,9 +229,9 @@ size_t
 partition (void *array, size_t count, size_t size,
            algo_predicate_func *predicate, const void *aux)
 {
-  size_t true_cnt = count;
+  size_t n_trues = count;
   char *first = array;
-  char *last = first + true_cnt * size;
+  char *last = first + n_trues * size;
 
   for (;;)
     {
@@ -245,7 +246,7 @@ partition (void *array, size_t count, size_t size,
 
           first += size;
         }
-      true_cnt--;
+      n_trues--;
 
       /* Move LAST backward to point to last element that passes
          PREDICATE. */
@@ -258,7 +259,7 @@ partition (void *array, size_t count, size_t size,
           else if (predicate (last, aux))
             break;
           else
-            true_cnt--;
+            n_trues--;
         }
 
       /* By swapping FIRST and LAST we extend the starting and
@@ -269,8 +270,8 @@ partition (void *array, size_t count, size_t size,
     }
 
  done:
-  assert (is_partitioned (array, count, size, true_cnt, predicate, aux));
-  return true_cnt;
+  assert (is_partitioned (array, count, size, n_trues, predicate, aux));
+  return n_trues;
 }
 
 /* Checks whether ARRAY, which contains COUNT elements of SIZE
@@ -279,17 +280,17 @@ partition (void *array, size_t count, size_t size,
    elements.  AUX is passed as auxiliary data to PREDICATE. */
 bool
 is_partitioned (const void *array, size_t count, size_t size,
-                size_t true_cnt,
+                size_t n_trues,
                 algo_predicate_func *predicate, const void *aux)
 {
   const char *first = array;
   size_t idx;
 
-  assert (true_cnt <= count);
-  for (idx = 0; idx < true_cnt; idx++)
+  assert (n_trues <= count);
+  for (idx = 0; idx < n_trues; idx++)
     if (predicate (first + idx * size, aux) == 0)
       return false;
-  for (idx = true_cnt; idx < count; idx++)
+  for (idx = n_trues; idx < count; idx++)
     if (predicate (first + idx * size, aux) != 0)
       return false;
   return true;
@@ -307,7 +308,7 @@ copy_if (const void *array, size_t count, size_t size,
   const char *input = array;
   const char *last = input + size * count;
   char *output = result;
-  size_t nonzero_cnt = 0;
+  size_t n_nonzeros = 0;
 
   while (input < last)
     {
@@ -315,16 +316,16 @@ copy_if (const void *array, size_t count, size_t size,
         {
           memcpy (output, input, size);
           output += size;
-          nonzero_cnt++;
+          n_nonzeros++;
         }
 
       input += size;
     }
 
-  assert (nonzero_cnt == count_if (array, count, size, predicate, aux));
-  assert (nonzero_cnt == count_if (result, nonzero_cnt, size, predicate, aux));
+  assert (n_nonzeros == count_if (array, count, size, predicate, aux));
+  assert (n_nonzeros == count_if (result, n_nonzeros, size, predicate, aux));
 
-  return nonzero_cnt;
+  return n_nonzeros;
 }
 
 /* Removes N elements starting at IDX from ARRAY, which consists
@@ -1027,3 +1028,18 @@ is_heap (const void *array, size_t count, size_t size,
   return true;
 }
 
+/* Reverses the order of ARRAY, which contains COUNT elements of SIZE bytes
+   each. */
+void
+reverse_array (void *array_, size_t count, size_t size)
+{
+  uint8_t *array = array_;
+  uint8_t *first = array;
+  uint8_t *last = array + (count - 1) * size;
+  for (size_t i = 0; i < count / 2; i++)
+    {
+      swap (first, last, size);
+      first += size;
+      last -= size;
+    }
+}