Index: uspace/lib/c/generic/adt/hash_table.c
===================================================================
--- uspace/lib/c/generic/adt/hash_table.c	(revision 38d150e6238ab44c861f6486e46454e07caeb0f0)
+++ uspace/lib/c/generic/adt/hash_table.c	(revision 1b20da07baaa3e3c424f62c927274e676e4295cd)
@@ -2,5 +2,5 @@
  * Copyright (c) 2008 Jakub Jermar
  * Copyright (c) 2012 Adam Hraska
- * 
+ *
  * All rights reserved.
  *
@@ -37,11 +37,11 @@
 /*
  * This is an implementation of a generic resizable chained hash table.
- * 
- * The table grows to 2*n+1 buckets each time, starting at n == 89, 
+ *
+ * The table grows to 2*n+1 buckets each time, starting at n == 89,
  * per Thomas Wang's recommendation:
  * http://www.concentric.net/~Ttwang/tech/hashsize.htm
- * 
+ *
  * This policy produces prime table sizes for the first five resizes
- * and generally produces table sizes which are either prime or 
+ * and generally produces table sizes which are either prime or
  * have fairly large (prime/odd) divisors. Having a prime table size
  * mitigates the use of suboptimal hash functions and distributes
@@ -79,5 +79,5 @@
  * @param h        Hash table structure. Will be initialized by this call.
  * @param init_size Initial desired number of hash table buckets. Pass zero
- *                 if you want the default initial size. 
+ *                 if you want the default initial size.
  * @param max_load The table is resized when the average load per bucket
  *                 exceeds this number. Pass zero if you want the default.
@@ -86,5 +86,5 @@
  *                 upon removal. equal() is optional if and only if
  *                 hash_table_insert_unique() will never be invoked.
- *                 All other operations are mandatory. 
+ *                 All other operations are mandatory.
  *
  * @return True on success
@@ -210,6 +210,6 @@
  * @param h    Hash table.
  * @param item Item to be inserted into the hash table.
- * 
- * @return False if such an item had already been inserted. 
+ *
+ * @return False if such an item had already been inserted.
  * @return True if the inserted item was the only item with such a lookup key.
  */
@@ -225,6 +225,6 @@
 	/* Check for duplicates. */
 	list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
-		/* 
-		 * We could filter out items using their hashes first, but 
+		/*
+		 * We could filter out items using their hashes first, but
 		 * calling equal() might very well be just as fast.
 		 */
@@ -255,7 +255,7 @@
 
 	list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
-		/* 
-		 * Is this is the item we are looking for? We could have first 
-		 * checked if the hashes match but op->key_equal() may very well be 
+		/*
+		 * Is this is the item we are looking for? We could have first
+		 * checked if the hashes match but op->key_equal() may very well be
 		 * just as fast as op->hash().
 		 */
@@ -278,7 +278,7 @@
 		assert(cur);
 		ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
-		/* 
-		 * Is this is the item we are looking for? We could have first 
-		 * checked if the hashes match but op->equal() may very well be 
+		/*
+		 * Is this is the item we are looking for? We could have first
+		 * checked if the hashes match but op->equal() may very well be
 		 * just as fast as op->hash().
 		 */
@@ -299,5 +299,5 @@
  *             the hash table.
  * @param keys Number of keys in the 'key' array.
- * 
+ *
  * @return Returns the number of removed items.
  */
@@ -343,12 +343,12 @@
  *
  * @param h   Hash table.
- * @param f   Function to be applied. Return false if no more items 
+ * @param f   Function to be applied. Return false if no more items
  *            should be visited. The functor may only delete the supplied
- *            item. It must not delete the successor of the item passed 
+ *            item. It must not delete the successor of the item passed
  *            in the first argument.
  * @param arg Argument to be passed to the function.
  */
 void hash_table_apply(hash_table_t *h, bool (*f)(ht_link_t *, void *), void *arg)
-{	
+{
 	assert(f);
 	assert(h && h->bucket);
@@ -362,6 +362,6 @@
 		list_foreach_safe(h->bucket[idx], cur, next) {
 			ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
-			/* 
-			 * The next pointer had already been saved. f() may safely 
+			/*
+			 * The next pointer had already been saved. f() may safely
 			 * delete cur (but not next!).
 			 */
@@ -410,6 +410,6 @@
 {
 	if (h->item_cnt <= h->full_item_cnt / 4 && HT_MIN_BUCKETS < h->bucket_cnt) {
-		/* 
-		 * Keep the bucket_cnt odd (possibly also prime). 
+		/*
+		 * Keep the bucket_cnt odd (possibly also prime).
 		 * Shrink from 2n + 1 to n. Integer division discards the +1.
 		 */
@@ -431,5 +431,5 @@
 
 /** Allocates and rehashes items to a new table. Frees the old table. */
-static void resize(hash_table_t *h, size_t new_bucket_cnt) 
+static void resize(hash_table_t *h, size_t new_bucket_cnt)
 {
 	assert(h && h->bucket);
