libprelude/master: Whitespace police

commit 0226b50f6ea31f8b81144d4c792d944d51ba5ccc
Author: Yoann Vandoorselaere <[email protected]>
Date:   Mon Jan 18 19:19:57 2010 +0100

    Whitespace police


========================================

 src/prelude-hash.c |  154 ++++++++++++++++++++++++++--------------------------
 1 files changed, 77 insertions(+), 77 deletions(-)

========================================

diff --git a/src/prelude-hash.c b/src/prelude-hash.c
index cf523bc..b8bea70 100644
--- a/src/prelude-hash.c
+++ b/src/prelude-hash.c
@@ -6,7 +6,7 @@
 * This file is part of the Prelude library.
 *
 * This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by 
+* it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
@@ -32,23 +32,23 @@
 #include "prelude-hash.h"
 
 
-#define	HASH_DEFAULT_SIZE	128
+#define HASH_DEFAULT_SIZE       128
 
 
 
 typedef struct hash_elem {
-	prelude_list_t list;
-	void *key;
-	void *value;
+        prelude_list_t list;
+        void *key;
+        void *value;
 } hash_elem_t;
 
 
 struct prelude_hash {
-	size_t lists_size;
-	prelude_list_t *lists;
+        size_t lists_size;
+        prelude_list_t *lists;
 
         unsigned int (*hash_func)(const void *key);
-	int (*key_cmp_func)(const void *key1, const void *key2);
+        int (*key_cmp_func)(const void *key1, const void *key2);
         void (*key_destroy_func)(void *key);
         void (*value_destroy_func)(void *value);
 };
@@ -66,9 +66,9 @@ static unsigned int default_hash_func(const void *key)
         if ( hv )
                 for ( ptr += 1; *ptr; ptr++ )
                         hv = (hv << 5) - hv + *ptr;
-       
+
         return hv;
-        
+
 }
 
 
@@ -148,106 +148,106 @@ int prelude_hash_new2(prelude_hash_t **nhash, size_t size,
 
         hash->lists_size = size;
 
-	hash->lists = malloc(hash->lists_size * sizeof(*hash->lists));
-	if ( ! hash->lists ) {
-		free(hash);
-		return prelude_error_from_errno(errno);
-	}
+        hash->lists = malloc(hash->lists_size * sizeof(*hash->lists));
+        if ( ! hash->lists ) {
+                free(hash);
+                return prelude_error_from_errno(errno);
+        }
 
-	hash->hash_func = hash_func ? hash_func : default_hash_func;
-	hash->key_cmp_func = key_cmp_func ? key_cmp_func : default_key_cmp_func;
-	hash->key_destroy_func = key_destroy_func;
-	hash->value_destroy_func = value_destroy_func;
+        hash->hash_func = hash_func ? hash_func : default_hash_func;
+        hash->key_cmp_func = key_cmp_func ? key_cmp_func : default_key_cmp_func;
+        hash->key_destroy_func = key_destroy_func;
+        hash->value_destroy_func = value_destroy_func;
 
-	for ( i = 0; i < hash->lists_size; i++ )
-		prelude_list_init(hash->lists + i);
+        for ( i = 0; i < hash->lists_size; i++ )
+                prelude_list_init(hash->lists + i);
 
-	return 0;
+        return 0;
 }
 
 
 
 void prelude_hash_destroy(prelude_hash_t *hash)
 {
-	prelude_list_t *list;
-	prelude_list_t *ptr;
-	prelude_list_t *tmp;
-	hash_elem_t *hash_elem;
-	int cnt;
-
-	for ( cnt = 0; cnt < hash->lists_size; cnt++ ) {
-		list = hash->lists + cnt;
-
-		prelude_list_for_each_safe(list, ptr, tmp) {
-			hash_elem = prelude_list_entry(ptr, hash_elem_t, list);
-                        
-			hash_elem_key_destroy(hash, hash_elem);
-			hash_elem_value_destroy(hash, hash_elem);
-			prelude_list_del(&hash_elem->list);
-			free(hash_elem);
-		}
-	}
+        size_t cnt;
+        prelude_list_t *list;
+        prelude_list_t *ptr;
+        prelude_list_t *tmp;
+        hash_elem_t *hash_elem;
+
+        for ( cnt = 0; cnt < hash->lists_size; cnt++ ) {
+                list = hash->lists + cnt;
+
+                prelude_list_for_each_safe(list, ptr, tmp) {
+                        hash_elem = prelude_list_entry(ptr, hash_elem_t, list);
+
+                        hash_elem_key_destroy(hash, hash_elem);
+                        hash_elem_value_destroy(hash, hash_elem);
+                        prelude_list_del(&hash_elem->list);
+                        free(hash_elem);
+                }
+        }
 
         free(hash->lists);
-	free(hash);
+        free(hash);
 }
 
 
 
 int prelude_hash_set(prelude_hash_t *hash, void *key, void *value)
 {
-	hash_elem_t *hash_elem;
-	prelude_list_t *list;
-
-	hash_elem = hash_elem_get(hash, key);
-        
-	if ( hash_elem ) {
-		hash_elem_key_destroy(hash, hash_elem);
-		hash_elem_value_destroy(hash, hash_elem);
-		hash_elem->key = key;
-		hash_elem->value = value;
-		return 0;
-	}
-
-	hash_elem = calloc(1, sizeof(*hash_elem));
-	if ( ! hash_elem )
-		return prelude_error_from_errno(errno);
-
-	hash_elem->key = key;
-	hash_elem->value = value;
-
-	list = hash->lists + hash_value_calc(hash, key);
-	prelude_list_add(list, &hash_elem->list);
-
-	return 1;
+        hash_elem_t *hash_elem;
+        prelude_list_t *list;
+
+        hash_elem = hash_elem_get(hash, key);
+
+        if ( hash_elem ) {
+                hash_elem_key_destroy(hash, hash_elem);
+                hash_elem_value_destroy(hash, hash_elem);
+                hash_elem->key = key;
+                hash_elem->value = value;
+                return 0;
+        }
+
+        hash_elem = calloc(1, sizeof(*hash_elem));
+        if ( ! hash_elem )
+                return prelude_error_from_errno(errno);
+
+        hash_elem->key = key;
+        hash_elem->value = value;
+
+        list = hash->lists + hash_value_calc(hash, key);
+        prelude_list_add(list, &hash_elem->list);
+
+        return 1;
 }
 
 
 
 void *prelude_hash_get(prelude_hash_t *hash, const void *key)
 {
-	hash_elem_t *hash_elem;
+        hash_elem_t *hash_elem;
 
-	return (hash_elem = hash_elem_get(hash, key)) ? hash_elem->value : NULL;
+        return (hash_elem = hash_elem_get(hash, key)) ? hash_elem->value : NULL;
 }
 
 
 
 int prelude_hash_elem_destroy(prelude_hash_t *hash, const void *key)
 {
-	hash_elem_t *hash_elem;
+        hash_elem_t *hash_elem;
 
-	hash_elem = hash_elem_get(hash, key);
+        hash_elem = hash_elem_get(hash, key);
 
-	if ( ! hash_elem )
-		return -1;
+        if ( ! hash_elem )
+                return -1;
 
-	hash_elem_key_destroy(hash, hash_elem);
-	hash_elem_value_destroy(hash, hash_elem);
-	prelude_list_del(&hash_elem->list);
-	free(hash_elem);
+        hash_elem_key_destroy(hash, hash_elem);
+        hash_elem_value_destroy(hash, hash_elem);
+        prelude_list_del(&hash_elem->list);
+        free(hash_elem);
 
-	return 0;
+        return 0;
 }
 
 
@@ -257,7 +257,7 @@ void prelude_hash_iterate(prelude_hash_t *hash, void (*cb)(void *data))
         unsigned int i;
         prelude_list_t *tmp;
         hash_elem_t *hash_elem;
-        
+
         for ( i = 0; i < hash->lists_size; i++ ) {
                 prelude_list_for_each(&hash->lists[i], tmp) {
                         hash_elem = prelude_list_entry(tmp, hash_elem_t, list);
_______________________________________________
Prelude-cvslog site list
[email protected]
http://lists.prelude-ids.org/mailman/listinfo/prelude-cvslog