X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flibpspp%2Farray.c;h=376bd681dbfa586807c160908cd74b2adb4dd325;hb=eeedca3fcd959f73ba2c2fd4cbab5bd03ceb4f8d;hp=f82bce913012bb3f7e30cb816713428021e4faa6;hpb=52c400a0ac67e4a43c5cae5a0d40e1452326240c;p=pspp

diff --git a/src/libpspp/array.c b/src/libpspp/array.c
index f82bce9130..376bd681db 100644
--- a/src/libpspp/array.c
+++ b/src/libpspp/array.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2010 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2010, 2011 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -80,7 +80,7 @@
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library.  If not, see 
+   License along with the GNU C Library.  If not, see
    <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
@@ -89,11 +89,12 @@
 
 #include <limits.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
-#include <libpspp/assertion.h>
+#include "libpspp/assertion.h"
 
-#include "xalloc.h"
-#include "minmax.h"
+#include "gl/xalloc.h"
+#include "gl/minmax.h"
 
 /* Finds an element in ARRAY, which contains COUNT elements of
    SIZE bytes each, using COMPARE for comparisons.  Returns the
@@ -163,19 +164,19 @@ count_if (const void *array, size_t count, size_t size,
   return true_cnt;
 }
 
-/* Byte-wise swap two items of size SIZE. */
-#define SWAP(a, b, size)                        \
-  do                                            \
-    {                                           \
-      register size_t __size = (size);          \
-      register char *__a = (a), *__b = (b);     \
-      do                                        \
-	{                                       \
-	  char __tmp = *__a;                    \
-	  *__a++ = *__b;                        \
-	  *__b++ = __tmp;                       \
-	} while (--__size > 0);                 \
-    } while (0)
+/* Byte-wise swap objects A and B, each SIZE bytes. */
+static void
+swap (void *a_, void *b_, size_t size)
+{
+  uint8_t *a = a_;
+  uint8_t *b = b_;
+  while (size-- > 0)
+    {
+      uint8_t tmp = *a;
+      *a++ = *b;
+      *b++ = tmp;
+    }
+}
 
 /* Makes the elements in ARRAY unique, by moving up duplicates,
    and returns the new number of elements in the array.  Sorted
@@ -264,7 +265,7 @@ partition (void *array, size_t count, size_t size,
       /* By swapping FIRST and LAST we extend the starting and
          ending sequences that pass and fail, respectively,
          PREDICATE. */
-      SWAP (first, last, size);
+      swap (first, last, size);
       first += size;
     }
 
@@ -670,13 +671,13 @@ sort (void *array, size_t count, size_t size,
 	  char *mid = lo + size * ((hi - lo) / size >> 1);
 
 	  if (compare (mid, lo, aux) < 0)
-	    SWAP (mid, lo, size);
+	    swap (mid, lo, size);
 	  if (compare (hi, mid, aux) < 0)
-	    SWAP (mid, hi, size);
+	    swap (mid, hi, size);
 	  else
 	    goto jump_over;
 	  if (compare (mid, lo, aux) < 0)
-	    SWAP (mid, lo, size);
+	    swap (mid, lo, size);
 	jump_over:;
 
 	  left_ptr  = lo + size;
@@ -695,7 +696,7 @@ sort (void *array, size_t count, size_t size,
 
 	      if (left_ptr < right_ptr)
 		{
-		  SWAP (left_ptr, right_ptr, size);
+		  swap (left_ptr, right_ptr, size);
 		  if (mid == left_ptr)
 		    mid = right_ptr;
 		  else if (mid == right_ptr)
@@ -765,7 +766,7 @@ sort (void *array, size_t count, size_t size,
         tmp_ptr = run_ptr;
 
     if (tmp_ptr != first)
-      SWAP (tmp_ptr, first, size);
+      swap (tmp_ptr, first, size);
 
     /* Insertion sort, running from left-hand-side up to right-hand-side.  */
 
@@ -909,7 +910,7 @@ push_heap (void *array, size_t count, size_t size,
       char *parent = first + (i / 2 - 1) * size;
       char *element = first + (i - 1) * size;
       if (compare (parent, element, aux) < 0)
-        SWAP (parent, element, size);
+        swap (parent, element, size);
       else
         break;
     }
@@ -947,7 +948,7 @@ heapify (void *array, size_t count, size_t size,
       if (largest == idx)
         break;
 
-      SWAP (first + size * (idx - 1), first + size * (largest - 1), size);
+      swap (first + size * (idx - 1), first + size * (largest - 1), size);
       idx = largest;
     }
 }
@@ -965,7 +966,7 @@ pop_heap (void *array, size_t count, size_t size,
   char *first = array;
 
   expensive_assert (is_heap (array, count, size, compare, aux));
-  SWAP (first, first + (count - 1) * size, size);
+  swap (first, first + (count - 1) * size, size);
   heapify (first, count - 1, size, 1, compare, aux);
   expensive_assert (count < 1 || is_heap (array, count - 1,
                                           size, compare, aux));
@@ -999,7 +1000,7 @@ sort_heap (void *array, size_t count, size_t size,
   expensive_assert (is_heap (array, count, size, compare, aux));
   for (idx = count; idx >= 2; idx--)
     {
-      SWAP (first, first + (idx - 1) * size, size);
+      swap (first, first + (idx - 1) * size, size);
       heapify (array, idx - 1, size, 1, compare, aux);
     }
   expensive_assert (is_sorted (array, count, size, compare, aux));
@@ -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;
+    }
+}