Use spaces for indentation, not tabs.

[gnulib.git] / lib / gl_array_oset.c

diff --git a/lib/gl_array_oset.c b/lib/gl_array_oset.c
index 83c563b..959de3f 100644 (file)
--- a/lib/gl_array_oset.c
+++ b/lib/gl_array_oset.c
@@ -42,8 +42,8 @@ struct gl_oset_impl
 
 static gl_oset_t
 gl_array_create_empty (gl_oset_implementation_t implementation,
-                      gl_setelement_compar_fn compar_fn,
-                      gl_setelement_dispose_fn dispose_fn)
+                       gl_setelement_compar_fn compar_fn,
+                       gl_setelement_dispose_fn dispose_fn)
 {
   struct gl_oset_impl *set = XMALLOC (struct gl_oset_impl);
 
@@ -75,25 +75,25 @@ gl_array_indexof (gl_oset_t set, const void *elt)
       size_t high = count;
 
       /* At each loop iteration, low < high; for indices < low the values
-        are smaller than ELT; for indices >= high the values are greater
-        than ELT.  So, if the element occurs in the list, it is at
-        low <= position < high.  */
+         are smaller than ELT; for indices >= high the values are greater
+         than ELT.  So, if the element occurs in the list, it is at
+         low <= position < high.  */
       do
-       {
-         size_t mid = low + (high - low) / 2; /* low <= mid < high */
-         int cmp = (compar != NULL
-                    ? compar (set->elements[mid], elt)
-                    : (set->elements[mid] > elt ? 1 :
-                       set->elements[mid] < elt ? -1 : 0));
-
-         if (cmp < 0)
-           low = mid + 1;
-         else if (cmp > 0)
-           high = mid;
-         else /* cmp == 0 */
-           /* We have an element equal to ELT at index MID.  */
-           return mid;
-       }
+        {
+          size_t mid = low + (high - low) / 2; /* low <= mid < high */
+          int cmp = (compar != NULL
+                     ? compar (set->elements[mid], elt)
+                     : (set->elements[mid] > elt ? 1 :
+                        set->elements[mid] < elt ? -1 : 0));
+
+          if (cmp < 0)
+            low = mid + 1;
+          else if (cmp > 0)
+            high = mid;
+          else /* cmp == 0 */
+            /* We have an element equal to ELT at index MID.  */
+            return mid;
+        }
       while (low < high);
     }
   return (size_t)(-1);
@@ -107,9 +107,9 @@ gl_array_search (gl_oset_t set, const void *elt)
 
 static bool
 gl_array_search_atleast (gl_oset_t set,
-                        gl_setelement_threshold_fn threshold_fn,
-                        const void *threshold,
-                        const void **eltp)
+                         gl_setelement_threshold_fn threshold_fn,
+                         const void *threshold,
+                         const void **eltp)
 {
   size_t count = set->count;
 
@@ -119,37 +119,37 @@ gl_array_search_atleast (gl_oset_t set,
       size_t high = count;
 
       /* At each loop iteration, low < high; for indices < low the values are
-        smaller than THRESHOLD; for indices >= high the values are nonexistent.
-        So, if an element >= THRESHOLD occurs in the list, it is at
-        low <= position < high.  */
+         smaller than THRESHOLD; for indices >= high the values are nonexistent.
+         So, if an element >= THRESHOLD occurs in the list, it is at
+         low <= position < high.  */
       do
-       {
-         size_t mid = low + (high - low) / 2; /* low <= mid < high */
-
-         if (! threshold_fn (set->elements[mid], threshold))
-           low = mid + 1;
-         else
-           {
-             /* We have an element >= THRESHOLD at index MID.  But we need the
-                minimal such index.  */
-             high = mid;
-             /* At each loop iteration, low <= high and
-                  compar (list->elements[high], value) >= 0,
-                and we know that the first occurrence of the element is at
-                low <= position <= high.  */
-             while (low < high)
-               {
-                 size_t mid2 = low + (high - low) / 2; /* low <= mid2 < high */
-
-                 if (! threshold_fn (set->elements[mid2], threshold))
-                   low = mid2 + 1;
-                 else
-                   high = mid2;
-               }
-             *eltp = set->elements[low];
-             return true;
-           }
-       }
+        {
+          size_t mid = low + (high - low) / 2; /* low <= mid < high */
+
+          if (! threshold_fn (set->elements[mid], threshold))
+            low = mid + 1;
+          else
+            {
+              /* We have an element >= THRESHOLD at index MID.  But we need the
+                 minimal such index.  */
+              high = mid;
+              /* At each loop iteration, low <= high and
+                   compar (list->elements[high], value) >= 0,
+                 and we know that the first occurrence of the element is at
+                 low <= position <= high.  */
+              while (low < high)
+                {
+                  size_t mid2 = low + (high - low) / 2; /* low <= mid2 < high */
+
+                  if (! threshold_fn (set->elements[mid2], threshold))
+                    low = mid2 + 1;
+                  else
+                    high = mid2;
+                }
+              *eltp = set->elements[low];
+              return true;
+            }
+        }
       while (low < high);
     }
   return false;
@@ -224,24 +224,24 @@ gl_array_add (gl_oset_t set, const void *elt)
       size_t high = count;
 
       /* At each loop iteration, low < high; for indices < low the values
-        are smaller than ELT; for indices >= high the values are greater
-        than ELT.  So, if the element occurs in the list, it is at
-        low <= position < high.  */
+         are smaller than ELT; for indices >= high the values are greater
+         than ELT.  So, if the element occurs in the list, it is at
+         low <= position < high.  */
       do
-       {
-         size_t mid = low + (high - low) / 2; /* low <= mid < high */
-         int cmp = (compar != NULL
-                    ? compar (set->elements[mid], elt)
-                    : (set->elements[mid] > elt ? 1 :
-                       set->elements[mid] < elt ? -1 : 0));
-
-         if (cmp < 0)
-           low = mid + 1;
-         else if (cmp > 0)
-           high = mid;
-         else /* cmp == 0 */
-           return false;
-       }
+        {
+          size_t mid = low + (high - low) / 2; /* low <= mid < high */
+          int cmp = (compar != NULL
+                     ? compar (set->elements[mid], elt)
+                     : (set->elements[mid] > elt ? 1 :
+                        set->elements[mid] < elt ? -1 : 0));
+
+          if (cmp < 0)
+            low = mid + 1;
+          else if (cmp > 0)
+            high = mid;
+          else /* cmp == 0 */
+            return false;
+        }
       while (low < high);
     }
   gl_array_add_at (set, low, elt);
@@ -267,19 +267,19 @@ gl_array_free (gl_oset_t set)
   if (set->elements != NULL)
     {
       if (set->base.dispose_fn != NULL)
-       {
-         size_t count = set->count;
-
-         if (count > 0)
-           {
-             gl_setelement_dispose_fn dispose = set->base.dispose_fn;
-             const void **elements = set->elements;
-
-             do
-               dispose (*elements++);
-             while (--count > 0);
-           }
-       }
+        {
+          size_t count = set->count;
+
+          if (count > 0)
+            {
+              gl_setelement_dispose_fn dispose = set->base.dispose_fn;
+              const void **elements = set->elements;
+
+              do
+                dispose (*elements++);
+              while (--count > 0);
+            }
+        }
       free (set->elements);
     }
   free (set);
@@ -312,8 +312,8 @@ gl_array_iterator_next (gl_oset_iterator_t *iterator, const void **eltp)
   if (iterator->count != set->count)
     {
       if (iterator->count != set->count + 1)
-       /* Concurrent modifications were done on the set.  */
-       abort ();
+        /* Concurrent modifications were done on the set.  */
+        abort ();
       /* The last returned element was removed.  */
       iterator->count--;
       iterator->p = (const void **) iterator->p - 1;