X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flibpspp%2Farray.c;h=db4dbcba01a2af3e2f909465ae8830bb8a1559c8;hb=3f159627d3b80706e58a54be2431c3edbc5333dc;hp=a0639ccadc28de4a5c847d0b4ad4fdbda98a7292;hpb=a1a4228b112a6aca97fef5aaaf9ffa21271a1f72;p=pspp

diff --git a/src/libpspp/array.c b/src/libpspp/array.c
index a0639ccadc..db4dbcba01 100644
--- a/src/libpspp/array.c
+++ b/src/libpspp/array.c
@@ -1,6 +1,5 @@
 /* PSPP - computes sample statistics.
    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
-   Written by Ben Pfaff <blp@gnu.org>.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
@@ -91,7 +90,6 @@
 
 #include <config.h>
 #include "array.h"
-#include <gsl/gsl_rng.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ -99,6 +97,8 @@
 #include <libpspp/assertion.h>
 
 #include "message.h"
+
+#include "minmax.h"
 
 /* Finds an element in ARRAY, which contains COUNT elements of
    SIZE bytes each, using COMPARE for comparisons.  Returns the
@@ -108,7 +108,7 @@
 void *
 find (const void *array, size_t count, size_t size,
       const void *target,
-      algo_compare_func *compare, void *aux) 
+      algo_compare_func *compare, const void *aux) 
 {
   const char *element = array;
 
@@ -130,7 +130,7 @@ find (const void *array, size_t count, size_t size,
 size_t
 count_equal (const void *array, size_t count, size_t size,
              const void *element,
-             algo_compare_func *compare, void *aux)
+             algo_compare_func *compare, const void *aux)
 {
   const char *first = array;
   size_t equal_cnt = 0;
@@ -152,7 +152,7 @@ count_equal (const void *array, size_t count, size_t size,
    PREDICATE. */
 size_t
 count_if (const void *array, size_t count, size_t size,
-          algo_predicate_func *predicate, void *aux) 
+          algo_predicate_func *predicate, const void *aux) 
 {
   const char *first = array;
   size_t true_cnt = 0;
@@ -187,7 +187,7 @@ count_if (const void *array, size_t count, size_t size,
    arrays only.  Arguments same as for sort() above. */
 size_t
 unique (void *array, size_t count, size_t size,
-        algo_compare_func *compare, void *aux) 
+        algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
   char *last = first + size * count;
@@ -217,7 +217,7 @@ unique (void *array, size_t count, size_t size,
 /* Helper function that calls sort(), then unique(). */
 size_t
 sort_unique (void *array, size_t count, size_t size,
-             algo_compare_func *compare, void *aux) 
+             algo_compare_func *compare, const void *aux) 
 {
   sort (array, count, size, compare, aux);
   return unique (array, count, size, compare, aux);
@@ -231,7 +231,7 @@ sort_unique (void *array, size_t count, size_t size,
    stable. */
 size_t 
 partition (void *array, size_t count, size_t size,
-           algo_predicate_func *predicate, void *aux) 
+           algo_predicate_func *predicate, const void *aux) 
 {
   size_t true_cnt = count;
   char *first = array;
@@ -285,7 +285,7 @@ partition (void *array, size_t count, size_t size,
 bool
 is_partitioned (const void *array, size_t count, size_t size,
                 size_t true_cnt,
-                algo_predicate_func *predicate, void *aux) 
+                algo_predicate_func *predicate, const void *aux) 
 {
   const char *first = array;
   size_t idx;
@@ -307,7 +307,7 @@ is_partitioned (const void *array, size_t count, size_t size,
 size_t 
 copy_if (const void *array, size_t count, size_t size,
          void *result,
-         algo_predicate_func *predicate, void *aux) 
+         algo_predicate_func *predicate, const void *aux) 
 {
   const char *input = array;
   const char *last = input + size * count;
@@ -394,11 +394,11 @@ move_element (void *array_, size_t count, size_t size,
 struct pred_aux 
   {
     algo_predicate_func *predicate;
-    void *aux;
+    const void *aux;
   };
 
 static bool
-not (const void *data, void *pred_aux_) 
+not (const void *data, const void *pred_aux_) 
 {
   const struct pred_aux *pred_aux = pred_aux_;
 
@@ -412,7 +412,7 @@ not (const void *data, void *pred_aux_)
 size_t
 remove_equal (void *array, size_t count, size_t size,
               void *element,
-              algo_compare_func *compare, void *aux) 
+              algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
   char *last = first + count * size;
@@ -458,7 +458,7 @@ remove_equal (void *array, size_t count, size_t size,
 size_t 
 remove_copy_if (const void *array, size_t count, size_t size,
                 void *result,
-                algo_predicate_func *predicate, void *aux) 
+                algo_predicate_func *predicate, const void *aux) 
 {
   struct pred_aux pred_aux;
   pred_aux.predicate = predicate;
@@ -474,7 +474,7 @@ remove_copy_if (const void *array, size_t count, size_t size,
 void *
 binary_search (const void *array, size_t count, size_t size,
                void *value,
-               algo_compare_func *compare, void *aux) 
+               algo_compare_func *compare, const void *aux) 
 {
   assert (array != NULL);
   assert (count <= INT_MAX);
@@ -514,7 +514,7 @@ int
 lexicographical_compare_3way (const void *array1, size_t count1,
                               const void *array2, size_t count2,
                               size_t size,
-                              algo_compare_func *compare, void *aux) 
+                              algo_compare_func *compare, const void *aux) 
 {
   const char *first1 = array1;
   const char *first2 = array2;
@@ -700,12 +700,10 @@ sort (void *array, size_t count, size_t size,
      of the array to sort, and END_PTR points at the very last element in
      the array (*not* one beyond it!). */
 
-#define min(x, y) ((x) < (y) ? (x) : (y))
-
   {
     char *const end_ptr = &first[size * (count - 1)];
     char *tmp_ptr = first;
-    char *thresh = min(end_ptr, first + max_thresh);
+    char *thresh = MIN (end_ptr, first + max_thresh);
     register char *run_ptr;
 
     /* Find smallest element in first threshold and place it at the
@@ -779,7 +777,7 @@ size_t set_difference (const void *array1, size_t count1,
                        const void *array2, size_t count2,
                        size_t size,
                        void *result_,
-                       algo_compare_func *compare, void *aux) 
+                       algo_compare_func *compare, const void *aux) 
 {
   const char *first1 = array1;
   const char *last1 = first1 + count1 * size;
@@ -826,7 +824,7 @@ size_t set_difference (const void *array1, size_t count1,
    data. */
 void *
 adjacent_find_equal (const void *array, size_t count, size_t size,
-                     algo_compare_func *compare, void *aux) 
+                     algo_compare_func *compare, const void *aux) 
 {
   const char *first = array;
   const char *last = first + count * size;
@@ -849,7 +847,7 @@ adjacent_find_equal (const void *array, size_t count, size_t size,
    data. */
 void
 push_heap (void *array, size_t count, size_t size,
-           algo_compare_func *compare, void *aux) 
+           algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
   size_t i;
@@ -876,7 +874,7 @@ push_heap (void *array, size_t count, size_t size,
 static void
 heapify (void *array, size_t count, size_t size,
          size_t idx,
-         algo_compare_func *compare, void *aux) 
+         algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
   
@@ -912,7 +910,7 @@ heapify (void *array, size_t count, size_t size,
    AUX as auxiliary data. */
 void
 pop_heap (void *array, size_t count, size_t size,
-          algo_compare_func *compare, void *aux) 
+          algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
 
@@ -928,7 +926,7 @@ pop_heap (void *array, size_t count, size_t size,
    auxiliary data. */
 void
 make_heap (void *array, size_t count, size_t size,
-           algo_compare_func *compare, void *aux) 
+           algo_compare_func *compare, const void *aux) 
 {
   size_t idx;
   
@@ -943,7 +941,7 @@ make_heap (void *array, size_t count, size_t size,
    passing AUX as auxiliary data. */
 void
 sort_heap (void *array, size_t count, size_t size,
-           algo_compare_func *compare, void *aux) 
+           algo_compare_func *compare, const void *aux) 
 {
   char *first = array;
   size_t idx;
@@ -963,7 +961,7 @@ sort_heap (void *array, size_t count, size_t size,
    AUX as auxiliary data. */
 bool
 is_heap (const void *array, size_t count, size_t size,
-         algo_compare_func *compare, void *aux) 
+         algo_compare_func *compare, const void *aux) 
 {
   const char *first = array;
   size_t child;