X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flibpspp%2Farray.h;h=c80fb24c5bb5f717a82d7e9a45e0e31685c5d35d;hb=e7d0a9f16192ceeff9243f0ede8e399ee1ef0d44;hp=a06a7ca1545d6790da05d57245fd3affa39fa762;hpb=a1a4228b112a6aca97fef5aaaf9ffa21271a1f72;p=pspp-builds.git

diff --git a/src/libpspp/array.h b/src/libpspp/array.h
index a06a7ca1..c80fb24c 100644
--- a/src/libpspp/array.h
+++ b/src/libpspp/array.h
@@ -10,11 +10,11 @@
 typedef int algo_compare_func (const void *a, const void *b, const void *aux);
 
 /* Tests a predicate on DATA, given auxiliary data AUX */
-typedef bool algo_predicate_func (const void *data, void *aux);
+typedef bool algo_predicate_func (const void *data, const void *aux);
 
 /* Returns a random number in the range 0 through MAX exclusive,
    given auxiliary data AUX. */
-typedef unsigned algo_random_func (unsigned max, void *aux);
+typedef unsigned algo_random_func (unsigned max, const void *aux);
 
 /* A generally suitable random function. */
 algo_random_func algo_default_random;
@@ -26,7 +26,7 @@ algo_random_func algo_default_random;
    data. */
 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);
 
 /* Counts and return the number of elements in ARRAY, which
    contains COUNT elements of SIZE bytes each, which are equal to
@@ -34,14 +34,14 @@ void *find (const void *array, size_t count, size_t size,
    data to COMPARE. */
 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);
 
 /* Counts and return the number of elements in ARRAY, which
    contains COUNT elements of SIZE bytes each, for which
    PREDICATE returns true.  AUX is passed as auxiliary data to
    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);
 
 /* Sorts ARRAY, which contains COUNT elements of SIZE bytes each,
    using COMPARE for comparisons.  AUX is passed to each
@@ -59,11 +59,11 @@ bool is_sorted (const void *array, size_t count, size_t size,
    and returns the new number of elements in the array.  Sorted
    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);
 
 /* 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);
 
 /* Reorders ARRAY, which contains COUNT elements of SIZE bytes
    each, so that the elements for which PREDICATE returns true
@@ -71,7 +71,7 @@ size_t sort_unique (void *array, size_t count, size_t size,
    as auxiliary data to PREDICATE.  Returns the number of
    elements for which PREDICATE returns true.  Not 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);
 
 /* Checks whether ARRAY, which contains COUNT elements of SIZE
    bytes each, is partitioned such that PREDICATE returns true
@@ -79,14 +79,14 @@ size_t 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,
-                    algo_predicate_func *predicate, void *aux);
+                    algo_predicate_func *predicate, const void *aux);
 
 /* Randomly reorders ARRAY, which contains COUNT elements of SIZE
    bytes each.  Uses RANDOM as a source of random data, passing
    AUX as the auxiliary data.  RANDOM may be null to use a
    default random source. */
 void random_shuffle (void *array, size_t count, size_t size,
-                     algo_random_func *random, void *aux);
+                     algo_random_func *random, const void *aux);
 
 /* Copies the COUNT elements of SIZE bytes each from ARRAY to
    RESULT, except that elements for which PREDICATE is false are
@@ -94,7 +94,7 @@ void random_shuffle (void *array, size_t count, size_t size,
    passed to PREDICATE as auxiliary data.  */
 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);
 
 /* Removes N elements starting at IDX from ARRAY, which consists
    of COUNT elements of SIZE bytes each, by shifting the elements
@@ -121,7 +121,7 @@ void move_element (void *array, size_t count, size_t size,
    data. */
 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);
 
 /* Copies the COUNT elements of SIZE bytes each from ARRAY to
    RESULT, except that elements for which PREDICATE is true are
@@ -129,7 +129,7 @@ size_t remove_equal (void *array, size_t count, size_t size,
    passed to PREDICATE as auxiliary data.  */
 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);
 
 /* Searches ARRAY, which contains COUNT elements of SIZE bytes
    each, for VALUE, using a binary search.  ARRAY must ordered
@@ -137,7 +137,7 @@ size_t remove_copy_if (const void *array, size_t count, size_t size,
    data. */
 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);
 
 /* Lexicographically compares ARRAY1, which contains COUNT1
    elements of SIZE bytes each, to ARRAY2, which contains COUNT2
@@ -147,7 +147,7 @@ void *binary_search (const void *array, size_t count, size_t size,
 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);
 
 /* Computes the generalized set difference, ARRAY1 minus ARRAY2,
    into RESULT, and returns the number of elements written to
@@ -161,7 +161,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);
 
 /* Finds the first pair of adjacent equal elements in ARRAY,
    which has COUNT elements of SIZE bytes.  Returns the first
@@ -169,7 +169,7 @@ size_t set_difference (const void *array1, size_t count1,
    its successor element are compared.  AUX is passed to COMPARE
    as auxiliary 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);
 
 /* ARRAY contains COUNT elements of SIZE bytes each.  Initially
    the first COUNT - 1 elements of these form a heap, followed by
@@ -178,7 +178,7 @@ void *adjacent_find_equal (const void *array, size_t count, size_t size,
    Uses COMPARE to compare elements, passing AUX as auxiliary
    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);
 
 /* ARRAY contains COUNT elements of SIZE bytes each.  Initially
    all COUNT elements form a heap.  This function moves the
@@ -187,27 +187,27 @@ void push_heap (void *array, size_t count, size_t size,
    beginning of ARRAY.  Uses COMPARE to compare elements, passing
    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);
 
 /* Turns ARRAY, which contains COUNT elements of SIZE bytes, into
    a heap.  Uses COMPARE to compare elements, passing AUX as
    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);
 
 /* ARRAY contains COUNT elements of SIZE bytes each.  Initially
    all COUNT elements form a heap.  This function turns the heap
    into a fully sorted array.  Uses COMPARE to compare elements,
    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);
 
 /* ARRAY contains COUNT elements of SIZE bytes each.  This
    function tests whether ARRAY is a heap and returns true if so, 
    false otherwise.  Uses COMPARE to compare elements, passing 
    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);
 
 
 #endif /* algorithm.h */