Replace more uses of 'cnt' by 'n'.

[pspp] / tests / libpspp / range-map-test.c

diff --git a/tests/libpspp/range-map-test.c b/tests/libpspp/range-map-test.c
index 5377f2bda2e3f3a931ca8110a23d0db2718c5d3e..5ac611f77aac84194134dad6826f22f6f26eb442 100644 (file)
--- a/tests/libpspp/range-map-test.c
+++ b/tests/libpspp/range-map-test.c
@@ -73,18 +73,18 @@ swap (int *a, int *b)
   *b = t;
 }
 
   *b = t;
 }
 

-/* Reverses the order of the CNT integers starting at VALUES. */
+/* Reverses the order of the N integers starting at VALUES. */

 static void
 static void

-reverse (int *values, size_t cnt)
+reverse (int *values, size_t n)

 {
   size_t i = 0;
 {
   size_t i = 0;

-  size_t j = cnt;
+  size_t j = n;

 
   while (j > i)
     swap (&values[i++], &values[--j]);
 }
 
 
   while (j > i)
     swap (&values[i++], &values[--j]);
 }
 

-/* Arranges the CNT blocks in VALUES into the lexicographically
+/* Arranges the N blocks in VALUES into the lexicographically

    next greater permutation.  Returns true if successful.
    If VALUES is already the lexicographically greatest
    permutation of its blocks (i.e. ordered from greatest to
    next greater permutation.  Returns true if successful.
    If VALUES is already the lexicographically greatest
    permutation of its blocks (i.e. ordered from greatest to


@@ -92,26 +92,26 @@ reverse (int *values, size_t cnt)
    permutation (i.e. ordered from smallest to largest) and
    returns false. */
 static bool
    permutation (i.e. ordered from smallest to largest) and
    returns false. */
 static bool

-next_permutation (int *values, size_t cnt)
+next_permutation (int *values, size_t n)

 {
 {

-  if (cnt > 0)
+  if (n > 0)

     {
     {

-      size_t i = cnt - 1;
+      size_t i = n - 1;

       while (i != 0)
         {
           i--;
           if (values[i] < values[i + 1])
             {
               size_t j;
       while (i != 0)
         {
           i--;
           if (values[i] < values[i + 1])
             {
               size_t j;

-              for (j = cnt - 1; values[i] >= values[j]; j--)
+              for (j = n - 1; values[i] >= values[j]; j--)

                 continue;
               swap (values + i, values + j);
                 continue;
               swap (values + i, values + j);

-              reverse (values + (i + 1), cnt - (i + 1));
+              reverse (values + (i + 1), n - (i + 1));

               return true;
             }
         }
 
               return true;
             }
         }
 

-      reverse (values, cnt);
+      reverse (values, n);

     }
 
   return false;
     }
 
   return false;


@@ -244,7 +244,7 @@ compare_expected_element (const void *a_, const void *b_)
   return a->start < b->start ? -1 : a->start > b->start;
 }
 
   return a->start < b->start ? -1 : a->start > b->start;
 }
 

-/* Checks that RM contains the ELEM_CNT elements described by
+/* Checks that RM contains the ELEM_N elements described by

    ELEMENTS[]. */
 static void
 check_range_map (struct range_map *rm,
    ELEMENTS[]. */
 static void
 check_range_map (struct range_map *rm,


@@ -306,9 +306,9 @@ static void
 test_insert (void)
 {
   const int max_range = 7;
 test_insert (void)
 {
   const int max_range = 7;

-  int cnt;
+  int n;

 
 

-  for (cnt = 1; cnt <= max_range; cnt++)
+  for (n = 1; n <= max_range; n++)

     {
       unsigned int n_compositions;
       struct expected_element *expected;
     {
       unsigned int n_compositions;
       struct expected_element *expected;


@@ -317,14 +317,14 @@ test_insert (void)
       int *order;
       struct element *elements;
 
       int *order;
       struct element *elements;
 

-      expected = xnmalloc (cnt, sizeof *expected);
-      widths = xnmalloc (cnt, sizeof *widths);
-      order = xnmalloc (cnt, sizeof *order);
-      elements = xnmalloc (cnt, sizeof *elements);
+      expected = xnmalloc (n, sizeof *expected);
+      widths = xnmalloc (n, sizeof *widths);
+      order = xnmalloc (n, sizeof *order);
+      elements = xnmalloc (n, sizeof *elements);

 
       n_elems = 0;
       n_compositions = 0;
 
       n_elems = 0;
       n_compositions = 0;

-      while (next_composition (cnt, &n_elems, widths))
+      while (next_composition (n, &n_elems, widths))

         {
           int i, j;
           unsigned int n_permutations;
         {
           int i, j;
           unsigned int n_permutations;


@@ -370,7 +370,7 @@ test_insert (void)
 
           n_compositions++;
         }
 
           n_compositions++;
         }

-      check (n_compositions == 1 << (cnt - 1));
+      check (n_compositions == 1 << (n - 1));

 
       free (expected);
       free (widths);
 
       free (expected);
       free (widths);


@@ -385,9 +385,9 @@ static void
 test_delete (int gap)
 {
   const int max_range = 7;
 test_delete (int gap)
 {
   const int max_range = 7;

-  int cnt;
+  int n;

 
 

-  for (cnt = 1; cnt <= max_range; cnt++)
+  for (n = 1; n <= max_range; n++)

     {
       unsigned int n_compositions;
       struct expected_element *expected;
     {
       unsigned int n_compositions;
       struct expected_element *expected;


@@ -396,14 +396,14 @@ test_delete (int gap)
       int *order;
       struct element *elements;
 
       int *order;
       struct element *elements;
 

-      expected = xnmalloc (cnt, sizeof *expected);
-      widths = xnmalloc (cnt, sizeof *widths);
-      order = xnmalloc (cnt, sizeof *order);
-      elements = xnmalloc (cnt, sizeof *elements);
+      expected = xnmalloc (n, sizeof *expected);
+      widths = xnmalloc (n, sizeof *widths);
+      order = xnmalloc (n, sizeof *order);
+      elements = xnmalloc (n, sizeof *elements);

 
       n_elems = 0;
       n_compositions = 0;
 
       n_elems = 0;
       n_compositions = 0;

-      while (next_composition (cnt, &n_elems, widths))
+      while (next_composition (n, &n_elems, widths))

         {
           int i, j;
           unsigned int n_permutations;
         {
           int i, j;
           unsigned int n_permutations;


@@ -458,7 +458,7 @@ test_delete (int gap)
 
           n_compositions++;
         }
 
           n_compositions++;
         }

-      check (n_compositions == 1 << (cnt - 1));
+      check (n_compositions == 1 << (n - 1));

 
       free (expected);
       free (widths);
 
       free (expected);
       free (widths);