Applied AStyle code formating as discussed on tid:74602.

Removed /SAFESEH option from MSVC11 projects.

git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@16968 54d463be-8e91-2dee-dedb-b68131a5f0ec

1 files changed, 1634 insertions, 1612 deletions

diff --git a/src/common/db.c b/src/common/db.c
index 204c6d2ea..c5db21a02 100644
--- a/src/common/db.c
+++ b/src/common/db.c
@@ -88,7 +88,7 @@
 \*****************************************************************************/
 
 /**
- * If defined statistics about database nodes, database creating/destruction 
+ * If defined statistics about database nodes, database creating/destruction
  * and function usage are keept and displayed when finalizing the database
  * system.
  * WARNING: This adds overhead to every database operation (not shure how much).
@@ -112,8 +112,8 @@
  * @see struct dbn
  */
 typedef enum node_color {
-	RED,
-	BLACK
+    RED,
+    BLACK
 } node_color;
 
 /**
@@ -129,16 +129,16 @@ typedef enum node_color {
  * @see DBMap_impl#ht
  */
 typedef struct dbn {
-	// Tree structure
-	struct dbn *parent;
-	struct dbn *left;
-	struct dbn *right;
-	// Node data
-	DBKey key;
-	DBData data;
-	// Other
-	node_color color;
-	unsigned deleted : 1;
+    // Tree structure
+    struct dbn *parent;
+    struct dbn *left;
+    struct dbn *right;
+    // Node data
+    DBKey key;
+    DBData data;
+    // Other
+    node_color color;
+    unsigned deleted : 1;
 } *DBNode;
 
 /**
@@ -149,8 +149,8 @@ typedef struct dbn {
  * @see DBMap_impl#free_list
  */
 struct db_free {
-	DBNode node;
-	DBNode *root;
+    DBNode node;
+    DBNode *root;
 };
 
 /**
@@ -176,28 +176,28 @@ struct db_free {
  * @see #db_alloc(const char*,int,DBType,DBOptions,unsigned short)
  */
 typedef struct DBMap_impl {
-	// Database interface
-	struct DBMap vtable;
-	// File and line of allocation
-	const char *alloc_file;
-	int alloc_line;
-	// Lock system
-	struct db_free *free_list;
-	unsigned int free_count;
-	unsigned int free_max;
-	unsigned int free_lock;
-	// Other
-	ERS nodes;
-	DBComparator cmp;
-	DBHasher hash;
-	DBReleaser release;
-	DBNode ht[HASH_SIZE];
-	DBNode cache;
-	DBType type;
-	DBOptions options;
-	uint32 item_count;
-	unsigned short maxlen;
-	unsigned global_lock : 1;
+    // Database interface
+    struct DBMap vtable;
+    // File and line of allocation
+    const char *alloc_file;
+    int alloc_line;
+    // Lock system
+    struct db_free *free_list;
+    unsigned int free_count;
+    unsigned int free_max;
+    unsigned int free_lock;
+    // Other
+    ERS nodes;
+    DBComparator cmp;
+    DBHasher hash;
+    DBReleaser release;
+    DBNode ht[HASH_SIZE];
+    DBNode cache;
+    DBType type;
+    DBOptions options;
+    uint32 item_count;
+    unsigned short maxlen;
+    unsigned global_lock : 1;
 } DBMap_impl;
 
 /**
@@ -212,11 +212,11 @@ typedef struct DBMap_impl {
  * @see #DBNode
  */
 typedef struct DBIterator_impl {
-	// Iterator interface
-	struct DBIterator vtable;
-	DBMap_impl* db;
-	int ht_index;
-	DBNode node;
+    // Iterator interface
+    struct DBIterator vtable;
+    DBMap_impl *db;
+    int ht_index;
+    DBNode node;
 } DBIterator_impl;
 
 #if defined(DB_ENABLE_STATS)
@@ -227,92 +227,92 @@ typedef struct DBIterator_impl {
  * @see #stats
  */
 static struct db_stats {
-	// Node alloc/free
-	uint32 db_node_alloc;
-	uint32 db_node_free;
-	// Database creating/destruction counters
-	uint32 db_int_alloc;
-	uint32 db_uint_alloc;
-	uint32 db_string_alloc;
-	uint32 db_istring_alloc;
-	uint32 db_int_destroy;
-	uint32 db_uint_destroy;
-	uint32 db_string_destroy;
-	uint32 db_istring_destroy;
-	// Function usage counters
-	uint32 db_rotate_left;
-	uint32 db_rotate_right;
-	uint32 db_rebalance;
-	uint32 db_rebalance_erase;
-	uint32 db_is_key_null;
-	uint32 db_dup_key;
-	uint32 db_dup_key_free;
-	uint32 db_free_add;
-	uint32 db_free_remove;
-	uint32 db_free_lock;
-	uint32 db_free_unlock;
-	uint32 db_int_cmp;
-	uint32 db_uint_cmp;
-	uint32 db_string_cmp;
-	uint32 db_istring_cmp;
-	uint32 db_int_hash;
-	uint32 db_uint_hash;
-	uint32 db_string_hash;
-	uint32 db_istring_hash;
-	uint32 db_release_nothing;
-	uint32 db_release_key;
-	uint32 db_release_data;
-	uint32 db_release_both;
-	uint32 dbit_first;
-	uint32 dbit_last;
-	uint32 dbit_next;
-	uint32 dbit_prev;
-	uint32 dbit_exists;
-	uint32 dbit_remove;
-	uint32 dbit_destroy;
-	uint32 db_iterator;
-	uint32 db_exists;
-	uint32 db_get;
-	uint32 db_getall;
-	uint32 db_vgetall;
-	uint32 db_ensure;
-	uint32 db_vensure;
-	uint32 db_put;
-	uint32 db_remove;
-	uint32 db_foreach;
-	uint32 db_vforeach;
-	uint32 db_clear;
-	uint32 db_vclear;
-	uint32 db_destroy;
-	uint32 db_vdestroy;
-	uint32 db_size;
-	uint32 db_type;
-	uint32 db_options;
-	uint32 db_fix_options;
-	uint32 db_default_cmp;
-	uint32 db_default_hash;
-	uint32 db_default_release;
-	uint32 db_custom_release;
-	uint32 db_alloc;
-	uint32 db_i2key;
-	uint32 db_ui2key;
-	uint32 db_str2key;
-	uint32 db_i2data;
-	uint32 db_ui2data;
-	uint32 db_ptr2data;
-	uint32 db_data2i;
-	uint32 db_data2ui;
-	uint32 db_data2ptr;
-	uint32 db_init;
-	uint32 db_final;
+    // Node alloc/free
+    uint32 db_node_alloc;
+    uint32 db_node_free;
+    // Database creating/destruction counters
+    uint32 db_int_alloc;
+    uint32 db_uint_alloc;
+    uint32 db_string_alloc;
+    uint32 db_istring_alloc;
+    uint32 db_int_destroy;
+    uint32 db_uint_destroy;
+    uint32 db_string_destroy;
+    uint32 db_istring_destroy;
+    // Function usage counters
+    uint32 db_rotate_left;
+    uint32 db_rotate_right;
+    uint32 db_rebalance;
+    uint32 db_rebalance_erase;
+    uint32 db_is_key_null;
+    uint32 db_dup_key;
+    uint32 db_dup_key_free;
+    uint32 db_free_add;
+    uint32 db_free_remove;
+    uint32 db_free_lock;
+    uint32 db_free_unlock;
+    uint32 db_int_cmp;
+    uint32 db_uint_cmp;
+    uint32 db_string_cmp;
+    uint32 db_istring_cmp;
+    uint32 db_int_hash;
+    uint32 db_uint_hash;
+    uint32 db_string_hash;
+    uint32 db_istring_hash;
+    uint32 db_release_nothing;
+    uint32 db_release_key;
+    uint32 db_release_data;
+    uint32 db_release_both;
+    uint32 dbit_first;
+    uint32 dbit_last;
+    uint32 dbit_next;
+    uint32 dbit_prev;
+    uint32 dbit_exists;
+    uint32 dbit_remove;
+    uint32 dbit_destroy;
+    uint32 db_iterator;
+    uint32 db_exists;
+    uint32 db_get;
+    uint32 db_getall;
+    uint32 db_vgetall;
+    uint32 db_ensure;
+    uint32 db_vensure;
+    uint32 db_put;
+    uint32 db_remove;
+    uint32 db_foreach;
+    uint32 db_vforeach;
+    uint32 db_clear;
+    uint32 db_vclear;
+    uint32 db_destroy;
+    uint32 db_vdestroy;
+    uint32 db_size;
+    uint32 db_type;
+    uint32 db_options;
+    uint32 db_fix_options;
+    uint32 db_default_cmp;
+    uint32 db_default_hash;
+    uint32 db_default_release;
+    uint32 db_custom_release;
+    uint32 db_alloc;
+    uint32 db_i2key;
+    uint32 db_ui2key;
+    uint32 db_str2key;
+    uint32 db_i2data;
+    uint32 db_ui2data;
+    uint32 db_ptr2data;
+    uint32 db_data2i;
+    uint32 db_data2ui;
+    uint32 db_data2ptr;
+    uint32 db_init;
+    uint32 db_final;
 } stats = {
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0
 };
 #define DB_COUNTSTAT(token) if (stats. ## token != UINT32_MAX) ++stats. ## token
 #else /* !defined(DB_ENABLE_STATS) */
@@ -346,25 +346,25 @@ static struct db_stats {
  */
 static void db_rotate_left(DBNode node, DBNode *root)
 {
-	DBNode y = node->right;
+    DBNode y = node->right;
 
-	DB_COUNTSTAT(db_rotate_left);
-	// put the left of y at the right of node
-	node->right = y->left;
-	if (y->left)
-		y->left->parent = node;
-	y->parent = node->parent;
-	// link y and node's parent
-	if (node == *root) {
-		*root = y; // node was root
-	} else if (node == node->parent->left) {
-		node->parent->left = y; // node was at the left
-	} else {
-		node->parent->right = y; // node was at the right
-	}
-	// put node at the left of y
-	y->left = node;
-	node->parent = y;
+    DB_COUNTSTAT(db_rotate_left);
+    // put the left of y at the right of node
+    node->right = y->left;
+    if (y->left)
+        y->left->parent = node;
+    y->parent = node->parent;
+    // link y and node's parent
+    if (node == *root) {
+        *root = y; // node was root
+    } else if (node == node->parent->left) {
+        node->parent->left = y; // node was at the left
+    } else {
+        node->parent->right = y; // node was at the right
+    }
+    // put node at the left of y
+    y->left = node;
+    node->parent = y;
 }
 
 /**
@@ -377,25 +377,25 @@ static void db_rotate_left(DBNode node, DBNode *root)
  */
 static void db_rotate_right(DBNode node, DBNode *root)
 {
-	DBNode y = node->left;
+    DBNode y = node->left;
 
-	DB_COUNTSTAT(db_rotate_right);
-	// put the right of y at the left of node
-	node->left = y->right;
-	if (y->right != 0)
-		y->right->parent = node;
-	y->parent = node->parent;
-	// link y and node's parent
-	if (node == *root) {
-		*root = y; // node was root
-	} else if (node == node->parent->right) {
-		node->parent->right = y; // node was at the right
-	} else {
-		node->parent->left = y; // node was at the left
-	}
-	// put node at the right of y
-	y->right = node;
-	node->parent = y;
+    DB_COUNTSTAT(db_rotate_right);
+    // put the right of y at the left of node
+    node->left = y->right;
+    if (y->right != 0)
+        y->right->parent = node;
+    y->parent = node->parent;
+    // link y and node's parent
+    if (node == *root) {
+        *root = y; // node was root
+    } else if (node == node->parent->right) {
+        node->parent->right = y; // node was at the right
+    } else {
+        node->parent->left = y; // node was at the left
+    }
+    // put node at the right of y
+    y->right = node;
+    node->parent = y;
 }
 
 /**
@@ -410,55 +410,55 @@ static void db_rotate_right(DBNode node, DBNode *root)
  */
 static void db_rebalance(DBNode node, DBNode *root)
 {
-	DBNode y;
-
-	DB_COUNTSTAT(db_rebalance);
-	// Restore the RED-BLACK properties
-	node->color = RED;
-	while (node != *root && node->parent->color == RED) {
-		if (node->parent == node->parent->parent->left) {
-			// If node's parent is a left, y is node's right 'uncle'
-			y = node->parent->parent->right;
-			if (y && y->color == RED) { // case 1
-				// change the colors and move up the tree
-				node->parent->color = BLACK;
-				y->color = BLACK;
-				node->parent->parent->color = RED;
-				node = node->parent->parent;
-			} else {
-				if (node == node->parent->right) { // case 2
-					// move up and rotate
-					node = node->parent;
-					db_rotate_left(node, root);
-				}
-				// case 3
-				node->parent->color = BLACK;
-				node->parent->parent->color = RED;
-				db_rotate_right(node->parent->parent, root);
-			}
-		} else {
-			// If node's parent is a right, y is node's left 'uncle'
-			y = node->parent->parent->left;
-			if (y && y->color == RED) { // case 1
-				// change the colors and move up the tree
-				node->parent->color = BLACK;
-				y->color = BLACK;
-				node->parent->parent->color = RED;
-				node = node->parent->parent;
-			} else {
-				if (node == node->parent->left) { // case 2
-					// move up and rotate
-					node = node->parent;
-					db_rotate_right(node, root);
-				}
-				// case 3
-				node->parent->color = BLACK;
-				node->parent->parent->color = RED;
-				db_rotate_left(node->parent->parent, root);
-			}
-		}
-	}
-	(*root)->color = BLACK; // the root can and should always be black
+    DBNode y;
+
+    DB_COUNTSTAT(db_rebalance);
+    // Restore the RED-BLACK properties
+    node->color = RED;
+    while (node != *root && node->parent->color == RED) {
+        if (node->parent == node->parent->parent->left) {
+            // If node's parent is a left, y is node's right 'uncle'
+            y = node->parent->parent->right;
+            if (y && y->color == RED) { // case 1
+                // change the colors and move up the tree
+                node->parent->color = BLACK;
+                y->color = BLACK;
+                node->parent->parent->color = RED;
+                node = node->parent->parent;
+            } else {
+                if (node == node->parent->right) { // case 2
+                    // move up and rotate
+                    node = node->parent;
+                    db_rotate_left(node, root);
+                }
+                // case 3
+                node->parent->color = BLACK;
+                node->parent->parent->color = RED;
+                db_rotate_right(node->parent->parent, root);
+            }
+        } else {
+            // If node's parent is a right, y is node's left 'uncle'
+            y = node->parent->parent->left;
+            if (y && y->color == RED) { // case 1
+                // change the colors and move up the tree
+                node->parent->color = BLACK;
+                y->color = BLACK;
+                node->parent->parent->color = RED;
+                node = node->parent->parent;
+            } else {
+                if (node == node->parent->left) { // case 2
+                    // move up and rotate
+                    node = node->parent;
+                    db_rotate_right(node, root);
+                }
+                // case 3
+                node->parent->color = BLACK;
+                node->parent->parent->color = RED;
+                db_rotate_left(node->parent->parent, root);
+            }
+        }
+    }
+    (*root)->color = BLACK; // the root can and should always be black
 }
 
 /**
@@ -472,133 +472,133 @@ static void db_rebalance(DBNode node, DBNode *root)
  */
 static void db_rebalance_erase(DBNode node, DBNode *root)
 {
-	DBNode y = node;
-	DBNode x = NULL;
-	DBNode x_parent = NULL;
-	DBNode w;
-
-	DB_COUNTSTAT(db_rebalance_erase);
-	// Select where to change the tree
-	if (y->left == NULL) { // no left
-		x = y->right;
-	} else if (y->right == NULL) { // no right
-		x = y->left;
-	} else { // both exist, go to the leftmost node of the right sub-tree
-		y = y->right;
-		while (y->left != NULL)
-			y = y->left;
-		x = y->right;
-	}
-
-	// Remove the node from the tree
-	if (y != node) { // both childs existed
-		// put the left of 'node' in the left of 'y'
-		node->left->parent = y;
-		y->left = node->left;
-
-		// 'y' is not the direct child of 'node'
-		if (y != node->right) {
-			// put 'x' in the old position of 'y'
-			x_parent = y->parent;
-			if (x) x->parent = y->parent;
-			y->parent->left = x;
-			// put the right of 'node' in 'y' 
-			y->right = node->right;
-			node->right->parent = y;
-		// 'y' is a direct child of 'node'
-		} else {
-			x_parent = y;
-		}
-
-		// link 'y' and the parent of 'node'
-		if (*root == node) {
-			*root = y; // 'node' was the root
-		} else if (node->parent->left == node) {
-			node->parent->left = y; // 'node' was at the left
-		} else {
-			node->parent->right = y; // 'node' was at the right
-		}
-		y->parent = node->parent;
-		// switch colors
-		{
-			node_color tmp = y->color;
-			y->color = node->color;
-			node->color = tmp;
-		}
-		y = node;
-	} else { // one child did not exist
-		// put x in node's position
-		x_parent = y->parent;
-		if (x) x->parent = y->parent;
-		// link x and node's parent
-		if (*root == node) {
-			*root = x; // node was the root
-		} else if (node->parent->left == node) {
-			node->parent->left = x; // node was at the left
-		} else {
-			node->parent->right = x;  // node was at the right
-		}
-	}
-
-	// Restore the RED-BLACK properties
-	if (y->color != RED) {
-		while (x != *root && (x == NULL || x->color == BLACK)) {
-			if (x == x_parent->left) {
-				w = x_parent->right;
-				if (w->color == RED) {
-					w->color = BLACK;
-					x_parent->color = RED;
-					db_rotate_left(x_parent, root);
-					w = x_parent->right;
-				}
-				if ((w->left == NULL || w->left->color == BLACK) &&
-					(w->right == NULL || w->right->color == BLACK)) {
-					w->color = RED;
-					x = x_parent;
-					x_parent = x_parent->parent;
-				} else {
-					if (w->right == NULL ||	w->right->color == BLACK) {
-						if (w->left) w->left->color = BLACK;
-						w->color = RED;
-						db_rotate_right(w, root);
-						w = x_parent->right;
-					}
-					w->color = x_parent->color;
-					x_parent->color = BLACK;
-					if (w->right) w->right->color = BLACK;
-					db_rotate_left(x_parent, root);
-					break;
-				}
-			} else {
-				w = x_parent->left;
-				if (w->color == RED) {
-					w->color = BLACK;
-					x_parent->color = RED;
-					db_rotate_right(x_parent, root);
-					w = x_parent->left;
-				}
-				if ((w->right == NULL || w->right->color == BLACK) &&
-					(w->left == NULL || w->left->color == BLACK)) {
-					w->color = RED;
-					x = x_parent;
-					x_parent = x_parent->parent;
-				} else {
-					if (w->left == NULL || w->left->color == BLACK) {
-						if (w->right) w->right->color = BLACK;
-						w->color = RED;
-						db_rotate_left(w, root);
-						w = x_parent->left;
-					}
-					w->color = x_parent->color;
-					x_parent->color = BLACK;
-					if (w->left) w->left->color = BLACK;
-					db_rotate_right(x_parent, root);
-					break;
-				}
-			}
-		}
-		if (x) x->color = BLACK;
-	}
+    DBNode y = node;
+    DBNode x = NULL;
+    DBNode x_parent = NULL;
+    DBNode w;
+
+    DB_COUNTSTAT(db_rebalance_erase);
+    // Select where to change the tree
+    if (y->left == NULL) { // no left
+        x = y->right;
+    } else if (y->right == NULL) { // no right
+        x = y->left;
+    } else { // both exist, go to the leftmost node of the right sub-tree
+        y = y->right;
+        while (y->left != NULL)
+            y = y->left;
+        x = y->right;
+    }
+
+    // Remove the node from the tree
+    if (y != node) { // both childs existed
+        // put the left of 'node' in the left of 'y'
+        node->left->parent = y;
+        y->left = node->left;
+
+        // 'y' is not the direct child of 'node'
+        if (y != node->right) {
+            // put 'x' in the old position of 'y'
+            x_parent = y->parent;
+            if (x) x->parent = y->parent;
+            y->parent->left = x;
+            // put the right of 'node' in 'y'
+            y->right = node->right;
+            node->right->parent = y;
+            // 'y' is a direct child of 'node'
+        } else {
+            x_parent = y;
+        }
+
+        // link 'y' and the parent of 'node'
+        if (*root == node) {
+            *root = y; // 'node' was the root
+        } else if (node->parent->left == node) {
+            node->parent->left = y; // 'node' was at the left
+        } else {
+            node->parent->right = y; // 'node' was at the right
+        }
+        y->parent = node->parent;
+        // switch colors
+        {
+            node_color tmp = y->color;
+            y->color = node->color;
+            node->color = tmp;
+        }
+        y = node;
+    } else { // one child did not exist
+        // put x in node's position
+        x_parent = y->parent;
+        if (x) x->parent = y->parent;
+        // link x and node's parent
+        if (*root == node) {
+            *root = x; // node was the root
+        } else if (node->parent->left == node) {
+            node->parent->left = x; // node was at the left
+        } else {
+            node->parent->right = x;  // node was at the right
+        }
+    }
+
+    // Restore the RED-BLACK properties
+    if (y->color != RED) {
+        while (x != *root && (x == NULL || x->color == BLACK)) {
+            if (x == x_parent->left) {
+                w = x_parent->right;
+                if (w->color == RED) {
+                    w->color = BLACK;
+                    x_parent->color = RED;
+                    db_rotate_left(x_parent, root);
+                    w = x_parent->right;
+                }
+                if ((w->left == NULL || w->left->color == BLACK) &&
+                    (w->right == NULL || w->right->color == BLACK)) {
+                    w->color = RED;
+                    x = x_parent;
+                    x_parent = x_parent->parent;
+                } else {
+                    if (w->right == NULL || w->right->color == BLACK) {
+                        if (w->left) w->left->color = BLACK;
+                        w->color = RED;
+                        db_rotate_right(w, root);
+                        w = x_parent->right;
+                    }
+                    w->color = x_parent->color;
+                    x_parent->color = BLACK;
+                    if (w->right) w->right->color = BLACK;
+                    db_rotate_left(x_parent, root);
+                    break;
+                }
+            } else {
+                w = x_parent->left;
+                if (w->color == RED) {
+                    w->color = BLACK;
+                    x_parent->color = RED;
+                    db_rotate_right(x_parent, root);
+                    w = x_parent->left;
+                }
+                if ((w->right == NULL || w->right->color == BLACK) &&
+                    (w->left == NULL || w->left->color == BLACK)) {
+                    w->color = RED;
+                    x = x_parent;
+                    x_parent = x_parent->parent;
+                } else {
+                    if (w->left == NULL || w->left->color == BLACK) {
+                        if (w->right) w->right->color = BLACK;
+                        w->color = RED;
+                        db_rotate_left(w, root);
+                        w = x_parent->left;
+                    }
+                    w->color = x_parent->color;
+                    x_parent->color = BLACK;
+                    if (w->left) w->left->color = BLACK;
+                    db_rotate_right(x_parent, root);
+                    break;
+                }
+            }
+        }
+        if (x) x->color = BLACK;
+    }
 }
 
 /**
@@ -613,15 +613,15 @@ static void db_rebalance_erase(DBNode node, DBNode *root)
  */
 static int db_is_key_null(DBType type, DBKey key)
 {
-	DB_COUNTSTAT(db_is_key_null);
-	switch (type) {
-		case DB_STRING:
-		case DB_ISTRING:
-			return (key.str == NULL);
+    DB_COUNTSTAT(db_is_key_null);
+    switch (type) {
+        case DB_STRING:
+        case DB_ISTRING:
+            return (key.str == NULL);
 
-		default: // Not a pointer
-			return 0;
-	}
+        default: // Not a pointer
+            return 0;
+    }
 }
 
 /**
@@ -635,25 +635,25 @@ static int db_is_key_null(DBType type, DBKey key)
  * @see #db_obj_put(DBMap*,DBKey,void *)
  * @see #db_dup_key_free(DBMap_impl*,DBKey)
  */
-static DBKey db_dup_key(DBMap_impl* db, DBKey key)
+static DBKey db_dup_key(DBMap_impl *db, DBKey key)
 {
-	char *str;
-	size_t len;
+    char *str;
+    size_t len;
 
-	DB_COUNTSTAT(db_dup_key);
-	switch (db->type) {
-		case DB_STRING:
-		case DB_ISTRING:
-			len = strnlen(key.str, db->maxlen);
-			str = (char*)aMalloc(len + 1);
-			memcpy(str, key.str, len);
-			str[len] = '\0';
-			key.str = str;
-			return key;
+    DB_COUNTSTAT(db_dup_key);
+    switch (db->type) {
+        case DB_STRING:
+        case DB_ISTRING:
+            len = strnlen(key.str, db->maxlen);
+            str = (char *)aMalloc(len + 1);
+            memcpy(str, key.str, len);
+            str[len] = '\0';
+            key.str = str;
+            return key;
 
-		default:
-			return key;
-	}
+        default:
+            return key;
+    }
 }
 
 /**
@@ -663,18 +663,18 @@ static DBKey db_dup_key(DBMap_impl* db, DBKey key)
  * @private
  * @see #db_dup_key(DBMap_impl*,DBKey)
  */
-static void db_dup_key_free(DBMap_impl* db, DBKey key)
+static void db_dup_key_free(DBMap_impl *db, DBKey key)
 {
-	DB_COUNTSTAT(db_dup_key_free);
-	switch (db->type) {
-		case DB_STRING:
-		case DB_ISTRING:
-			aFree((char*)key.str);
-			return;
+    DB_COUNTSTAT(db_dup_key_free);
+    switch (db->type) {
+        case DB_STRING:
+        case DB_ISTRING:
+            aFree((char *)key.str);
+            return;
 
-		default:
-			return;
-	}
+        default:
+            return;
+    }
 }
 
 /**
@@ -692,40 +692,40 @@ static void db_dup_key_free(DBMap_impl* db, DBKey key)
  * @see #db_obj_remove(DBMap*,DBKey)
  * @see #db_free_remove(DBMap_impl*,DBNode)
  */
-static void db_free_add(DBMap_impl* db, DBNode node, DBNode *root)
-{
-	DBKey old_key;
-
-	DB_COUNTSTAT(db_free_add);
-	if (db->free_lock == (unsigned int)~0) {
-		ShowFatalError("db_free_add: free_lock overflow\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-		exit(EXIT_FAILURE);
-	}
-	if (!(db->options&DB_OPT_DUP_KEY)) { // Make sure we have a key until the node is freed
-		old_key = node->key;
-		node->key = db_dup_key(db, node->key);
-		db->release(old_key, node->data, DB_RELEASE_KEY);
-	}
-	if (db->free_count == db->free_max) { // No more space, expand free_list
-		db->free_max = (db->free_max<<2) +3; // = db->free_max*4 +3
-		if (db->free_max <= db->free_count) {
-			if (db->free_count == (unsigned int)~0) {
-				ShowFatalError("db_free_add: free_count overflow\n"
-						"Database allocated at %s:%d\n",
-						db->alloc_file, db->alloc_line);
-				exit(EXIT_FAILURE);
-			}
-			db->free_max = (unsigned int)~0;
-		}
-		RECREATE(db->free_list, struct db_free, db->free_max);
-	}
-	node->deleted = 1;
-	db->free_list[db->free_count].node = node;
-	db->free_list[db->free_count].root = root;
-	db->free_count++;
-	db->item_count--;
+static void db_free_add(DBMap_impl *db, DBNode node, DBNode *root)
+{
+    DBKey old_key;
+
+    DB_COUNTSTAT(db_free_add);
+    if (db->free_lock == (unsigned int)~0) {
+        ShowFatalError("db_free_add: free_lock overflow\n"
+                       "Database allocated at %s:%d\n",
+                       db->alloc_file, db->alloc_line);
+        exit(EXIT_FAILURE);
+    }
+    if (!(db->options&DB_OPT_DUP_KEY)) { // Make sure we have a key until the node is freed
+        old_key = node->key;
+        node->key = db_dup_key(db, node->key);
+        db->release(old_key, node->data, DB_RELEASE_KEY);
+    }
+    if (db->free_count == db->free_max) { // No more space, expand free_list
+        db->free_max = (db->free_max<<2) +3; // = db->free_max*4 +3
+        if (db->free_max <= db->free_count) {
+            if (db->free_count == (unsigned int)~0) {
+                ShowFatalError("db_free_add: free_count overflow\n"
+                               "Database allocated at %s:%d\n",
+                               db->alloc_file, db->alloc_line);
+                exit(EXIT_FAILURE);
+            }
+            db->free_max = (unsigned int)~0;
+        }
+        RECREATE(db->free_list, struct db_free, db->free_max);
+    }
+    node->deleted = 1;
+    db->free_list[db->free_count].node = node;
+    db->free_list[db->free_count].root = root;
+    db->free_count++;
+    db->item_count--;
 }
 
 /**
@@ -741,26 +741,26 @@ static void db_free_add(DBMap_impl* db, DBNode node, DBNode *root)
  * @see #db_obj_put(DBMap*,DBKey,DBData)
  * @see #db_free_add(DBMap_impl*,DBNode*,DBNode)
  */
-static void db_free_remove(DBMap_impl* db, DBNode node)
+static void db_free_remove(DBMap_impl *db, DBNode node)
 {
-	unsigned int i;
+    unsigned int i;
 
-	DB_COUNTSTAT(db_free_remove);
-	for (i = 0; i < db->free_count; i++) {
-		if (db->free_list[i].node == node) {
-			if (i < db->free_count -1) // copy the last item to where the removed one was
-				memcpy(&db->free_list[i], &db->free_list[db->free_count -1], sizeof(struct db_free));
-			db_dup_key_free(db, node->key);
-			break;
-		}
-	}
-	node->deleted = 0;
-	if (i == db->free_count) {
-		ShowWarning("db_free_remove: node was not found - database allocated at %s:%d\n", db->alloc_file, db->alloc_line);
-	} else {
-		db->free_count--;
-	}
-	db->item_count++;
+    DB_COUNTSTAT(db_free_remove);
+    for (i = 0; i < db->free_count; i++) {
+        if (db->free_list[i].node == node) {
+            if (i < db->free_count -1) // copy the last item to where the removed one was
+                memcpy(&db->free_list[i], &db->free_list[db->free_count -1], sizeof(struct db_free));
+            db_dup_key_free(db, node->key);
+            break;
+        }
+    }
+    node->deleted = 0;
+    if (i == db->free_count) {
+        ShowWarning("db_free_remove: node was not found - database allocated at %s:%d\n", db->alloc_file, db->alloc_line);
+    } else {
+        db->free_count--;
+    }
+    db->item_count++;
 }
 
 /**
@@ -770,16 +770,16 @@ static void db_free_remove(DBMap_impl* db, DBNode node)
  * @see DBMap_impl#free_lock
  * @see #db_unlock(DBMap_impl*)
  */
-static void db_free_lock(DBMap_impl* db)
+static void db_free_lock(DBMap_impl *db)
 {
-	DB_COUNTSTAT(db_free_lock);
-	if (db->free_lock == (unsigned int)~0) {
-		ShowFatalError("db_free_lock: free_lock overflow\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-		exit(EXIT_FAILURE);
-	}
-	db->free_lock++;
+    DB_COUNTSTAT(db_free_lock);
+    if (db->free_lock == (unsigned int)~0) {
+        ShowFatalError("db_free_lock: free_lock overflow\n"
+                       "Database allocated at %s:%d\n",
+                       db->alloc_file, db->alloc_line);
+        exit(EXIT_FAILURE);
+    }
+    db->free_lock++;
 }
 
 /**
@@ -793,28 +793,28 @@ static void db_free_lock(DBMap_impl* db)
  * @see #db_free_dbn(DBNode)
  * @see #db_lock(DBMap_impl*)
  */
-static void db_free_unlock(DBMap_impl* db)
+static void db_free_unlock(DBMap_impl *db)
 {
-	unsigned int i;
+    unsigned int i;
 
-	DB_COUNTSTAT(db_free_unlock);
-	if (db->free_lock == 0) {
-		ShowWarning("db_free_unlock: free_lock was already 0\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-	} else {
-		db->free_lock--;
-	}
-	if (db->free_lock)
-		return; // Not last lock
+    DB_COUNTSTAT(db_free_unlock);
+    if (db->free_lock == 0) {
+        ShowWarning("db_free_unlock: free_lock was already 0\n"
+                    "Database allocated at %s:%d\n",
+                    db->alloc_file, db->alloc_line);
+    } else {
+        db->free_lock--;
+    }
+    if (db->free_lock)
+        return; // Not last lock
 
-	for (i = 0; i < db->free_count ; i++) {
-		db_rebalance_erase(db->free_list[i].node, db->free_list[i].root);
-		db_dup_key_free(db, db->free_list[i].node->key);
-		DB_COUNTSTAT(db_node_free);
-		ers_free(db->nodes, db->free_list[i].node);
-	}
-	db->free_count = 0;
+    for (i = 0; i < db->free_count ; i++) {
+        db_rebalance_erase(db->free_list[i].node, db->free_list[i].root);
+        db_dup_key_free(db, db->free_list[i].node->key);
+        DB_COUNTSTAT(db_node_free);
+        ers_free(db->nodes, db->free_list[i].node);
+    }
+    db->free_count = 0;
 }
 
 /*****************************************************************************\
@@ -850,11 +850,11 @@ static void db_free_unlock(DBMap_impl* db)
  */
 static int db_int_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
 {
-	(void)maxlen;//not used
-	DB_COUNTSTAT(db_int_cmp);
-	if (key1.i < key2.i) return -1;
-	if (key1.i > key2.i) return 1;
-	return 0;
+    (void)maxlen;//not used
+    DB_COUNTSTAT(db_int_cmp);
+    if (key1.i < key2.i) return -1;
+    if (key1.i > key2.i) return 1;
+    return 0;
 }
 
 /**
@@ -872,11 +872,11 @@ static int db_int_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
  */
 static int db_uint_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
 {
-	(void)maxlen;//not used
-	DB_COUNTSTAT(db_uint_cmp);
-	if (key1.ui < key2.ui) return -1;
-	if (key1.ui > key2.ui) return 1;
-	return 0;
+    (void)maxlen;//not used
+    DB_COUNTSTAT(db_uint_cmp);
+    if (key1.ui < key2.ui) return -1;
+    if (key1.ui > key2.ui) return 1;
+    return 0;
 }
 
 /**
@@ -893,8 +893,8 @@ static int db_uint_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
  */
 static int db_string_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
 {
-	DB_COUNTSTAT(db_string_cmp);
-	return strncmp((const char *)key1.str, (const char *)key2.str, maxlen);
+    DB_COUNTSTAT(db_string_cmp);
+    return strncmp((const char *)key1.str, (const char *)key2.str, maxlen);
 }
 
 /**
@@ -911,8 +911,8 @@ static int db_string_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
  */
 static int db_istring_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
 {
-	DB_COUNTSTAT(db_istring_cmp);
-	return strncasecmp((const char *)key1.str, (const char *)key2.str, maxlen);
+    DB_COUNTSTAT(db_istring_cmp);
+    return strncasecmp((const char *)key1.str, (const char *)key2.str, maxlen);
 }
 
 /**
@@ -928,9 +928,9 @@ static int db_istring_cmp(DBKey key1, DBKey key2, unsigned short maxlen)
  */
 static unsigned int db_int_hash(DBKey key, unsigned short maxlen)
 {
-	(void)maxlen;//not used
-	DB_COUNTSTAT(db_int_hash);
-	return (unsigned int)key.i;
+    (void)maxlen;//not used
+    DB_COUNTSTAT(db_int_hash);
+    return (unsigned int)key.i;
 }
 
 /**
@@ -946,9 +946,9 @@ static unsigned int db_int_hash(DBKey key, unsigned short maxlen)
  */
 static unsigned int db_uint_hash(DBKey key, unsigned short maxlen)
 {
-	(void)maxlen;//not used
-	DB_COUNTSTAT(db_uint_hash);
-	return key.ui;
+    (void)maxlen;//not used
+    DB_COUNTSTAT(db_uint_hash);
+    return key.ui;
 }
 
 /**
@@ -962,20 +962,20 @@ static unsigned int db_uint_hash(DBKey key, unsigned short maxlen)
  */
 static unsigned int db_string_hash(DBKey key, unsigned short maxlen)
 {
-	const char *k = key.str;
-	unsigned int hash = 0;
-	unsigned short i;
+    const char *k = key.str;
+    unsigned int hash = 0;
+    unsigned short i;
 
-	DB_COUNTSTAT(db_string_hash);
+    DB_COUNTSTAT(db_string_hash);
 
-	for (i = 0; *k; ++i) {
-		hash = (hash*33 + ((unsigned char)*k))^(hash>>24);
-		k++;
-		if (i == maxlen)
-			break;
-	}
+    for (i = 0; *k; ++i) {
+        hash = (hash*33 + ((unsigned char)*k))^(hash>>24);
+        k++;
+        if (i == maxlen)
+            break;
+    }
 
-	return hash;
+    return hash;
 }
 
 /**
@@ -988,20 +988,20 @@ static unsigned int db_string_hash(DBKey key, unsigned short maxlen)
  */
 static unsigned int db_istring_hash(DBKey key, unsigned short maxlen)
 {
-	const char *k = key.str;
-	unsigned int hash = 0;
-	unsigned short i;
+    const char *k = key.str;
+    unsigned int hash = 0;
+    unsigned short i;
 
-	DB_COUNTSTAT(db_istring_hash);
+    DB_COUNTSTAT(db_istring_hash);
 
-	for (i = 0; *k; i++) {
-		hash = (hash*33 + ((unsigned char)TOLOWER(*k)))^(hash>>24);
-		k++;
-		if (i == maxlen)
-			break;
-	}
+    for (i = 0; *k; i++) {
+        hash = (hash*33 + ((unsigned char)TOLOWER(*k)))^(hash>>24);
+        k++;
+        if (i == maxlen)
+            break;
+    }
 
-	return hash;
+    return hash;
 }
 
 /**
@@ -1015,8 +1015,10 @@ static unsigned int db_istring_hash(DBKey key, unsigned short maxlen)
  */
 static void db_release_nothing(DBKey key, DBData data, DBRelease which)
 {
-	(void)key;(void)data;(void)which;//not used
-	DB_COUNTSTAT(db_release_nothing);
+    (void)key;
+    (void)data;
+    (void)which;//not used
+    DB_COUNTSTAT(db_release_nothing);
 }
 
 /**
@@ -1030,9 +1032,9 @@ static void db_release_nothing(DBKey key, DBData data, DBRelease which)
  */
 static void db_release_key(DBKey key, DBData data, DBRelease which)
 {
-	(void)data;//not used
-	DB_COUNTSTAT(db_release_key);
-	if (which&DB_RELEASE_KEY) aFree((char*)key.str); // needs to be a pointer
+    (void)data;//not used
+    DB_COUNTSTAT(db_release_key);
+    if (which&DB_RELEASE_KEY) aFree((char *)key.str); // needs to be a pointer
 }
 
 /**
@@ -1048,9 +1050,9 @@ static void db_release_key(DBKey key, DBData data, DBRelease which)
  */
 static void db_release_data(DBKey key, DBData data, DBRelease which)
 {
-	(void)key;//not used
-	DB_COUNTSTAT(db_release_data);
-	if (which&DB_RELEASE_DATA && data.type == DB_DATA_PTR) aFree(data.u.ptr);
+    (void)key;//not used
+    DB_COUNTSTAT(db_release_data);
+    if (which&DB_RELEASE_DATA && data.type == DB_DATA_PTR) aFree(data.u.ptr);
 }
 
 /**
@@ -1067,9 +1069,9 @@ static void db_release_data(DBKey key, DBData data, DBRelease which)
  */
 static void db_release_both(DBKey key, DBData data, DBRelease which)
 {
-	DB_COUNTSTAT(db_release_both);
-	if (which&DB_RELEASE_KEY) aFree((char*)key.str); // needs to be a pointer
-	if (which&DB_RELEASE_DATA && data.type == DB_DATA_PTR) aFree(data.u.ptr);
+    DB_COUNTSTAT(db_release_both);
+    if (which&DB_RELEASE_KEY) aFree((char *)key.str); // needs to be a pointer
+    if (which&DB_RELEASE_DATA && data.type == DB_DATA_PTR) aFree(data.u.ptr);
 }
 
 /*****************************************************************************\
@@ -1115,16 +1117,16 @@ static void db_release_both(DBKey key, DBData data, DBRelease which)
  * @protected
  * @see DBIterator#first
  */
-DBData* dbit_obj_first(DBIterator* self, DBKey* out_key)
+DBData *dbit_obj_first(DBIterator *self, DBKey *out_key)
 {
-	DBIterator_impl* it = (DBIterator_impl*)self;
-	
-	DB_COUNTSTAT(dbit_first);
-	// position before the first entry
-	it->ht_index = -1;
-	it->node = NULL;
-	// get next entry
-	return self->next(self, out_key);
+    DBIterator_impl *it = (DBIterator_impl *)self;
+
+    DB_COUNTSTAT(dbit_first);
+    // position before the first entry
+    it->ht_index = -1;
+    it->node = NULL;
+    // get next entry
+    return self->next(self, out_key);
 }
 
 /**
@@ -1137,16 +1139,16 @@ DBData* dbit_obj_first(DBIterator* self, DBKey* out_key)
  * @protected
  * @see DBIterator#last
  */
-DBData* dbit_obj_last(DBIterator* self, DBKey* out_key)
+DBData *dbit_obj_last(DBIterator *self, DBKey *out_key)
 {
-	DBIterator_impl* it = (DBIterator_impl*)self;
-	
-	DB_COUNTSTAT(dbit_last);
-	// position after the last entry
-	it->ht_index = HASH_SIZE;
-	it->node = NULL;
-	// get previous entry
-	return self->prev(self, out_key);
+    DBIterator_impl *it = (DBIterator_impl *)self;
+
+    DB_COUNTSTAT(dbit_last);
+    // position after the last entry
+    it->ht_index = HASH_SIZE;
+    it->node = NULL;
+    // get previous entry
+    return self->prev(self, out_key);
 }
 
 /**
@@ -1159,70 +1161,67 @@ DBData* dbit_obj_last(DBIterator* self, DBKey* out_key)
  * @protected
  * @see DBIterator#next
  */
-DBData* dbit_obj_next(DBIterator* self, DBKey* out_key)
-{
-	DBIterator_impl* it = (DBIterator_impl*)self;
-	DBNode node;
-	DBNode parent;
-	struct dbn fake;
-
-	DB_COUNTSTAT(dbit_next);
-	if( it->ht_index < 0 )
-	{// get first node
-		it->ht_index = 0;
-		it->node = NULL;
-	}
-	node = it->node;
-	memset(&fake, 0, sizeof(fake));
-	for( ; it->ht_index < HASH_SIZE; ++(it->ht_index) )
-	{
-		// Iterate in the order: left tree, current node, right tree
-		if( node == NULL )
-		{// prepare initial node of this hash
-			node = it->db->ht[it->ht_index];
-			if( node == NULL )
-				continue;// next hash
-			fake.right = node;
-			node = &fake;
-		}
-
-		while( node )
-		{// next node
-			if( node->right )
-			{// continue in the right subtree
-				node = node->right;
-				while( node->left )
-					node = node->left;// get leftmost node
-			}
-			else
-			{// continue to the next parent (recursive)
-				parent = node->parent;
-				while( parent )
-				{
-					if( parent->right != node )
-						break;
-					node = parent;
-					parent = node->parent;
-				}
-				if( parent == NULL )
-				{// next hash
-					node = NULL;
-					break;
-				}
-				node = parent;
-			}
-
-			if( !node->deleted )
-			{// found next entry
-				it->node = node;
-				if( out_key )
-					memcpy(out_key, &node->key, sizeof(DBKey));
-				return &node->data;
-			}
-		}
-	}
-	it->node = NULL;
-	return NULL;// not found
+DBData *dbit_obj_next(DBIterator *self, DBKey *out_key)
+{
+    DBIterator_impl *it = (DBIterator_impl *)self;
+    DBNode node;
+    DBNode parent;
+    struct dbn fake;
+
+    DB_COUNTSTAT(dbit_next);
+    if (it->ht_index < 0) {
+        // get first node
+        it->ht_index = 0;
+        it->node = NULL;
+    }
+    node = it->node;
+    memset(&fake, 0, sizeof(fake));
+    for (; it->ht_index < HASH_SIZE; ++(it->ht_index)) {
+        // Iterate in the order: left tree, current node, right tree
+        if (node == NULL) {
+            // prepare initial node of this hash
+            node = it->db->ht[it->ht_index];
+            if (node == NULL)
+                continue;// next hash
+            fake.right = node;
+            node = &fake;
+        }
+
+        while (node) {
+            // next node
+            if (node->right) {
+                // continue in the right subtree
+                node = node->right;
+                while (node->left)
+                    node = node->left;// get leftmost node
+            } else {
+                // continue to the next parent (recursive)
+                parent = node->parent;
+                while (parent) {
+                    if (parent->right != node)
+                        break;
+                    node = parent;
+                    parent = node->parent;
+                }
+                if (parent == NULL) {
+                    // next hash
+                    node = NULL;
+                    break;
+                }
+                node = parent;
+            }
+
+            if (!node->deleted) {
+                // found next entry
+                it->node = node;
+                if (out_key)
+                    memcpy(out_key, &node->key, sizeof(DBKey));
+                return &node->data;
+            }
+        }
+    }
+    it->node = NULL;
+    return NULL;// not found
 }
 
 /**
@@ -1235,93 +1234,90 @@ DBData* dbit_obj_next(DBIterator* self, DBKey* out_key)
  * @protected
  * @see DBIterator#prev
  */
-DBData* dbit_obj_prev(DBIterator* self, DBKey* out_key)
-{
-	DBIterator_impl* it = (DBIterator_impl*)self;
-	DBNode node;
-	DBNode parent;
-	struct dbn fake;
-
-	DB_COUNTSTAT(dbit_prev);
-	if( it->ht_index >= HASH_SIZE )
-	{// get last node
-		it->ht_index = HASH_SIZE-1;
-		it->node = NULL;
-	}
-	node = it->node;
-	memset(&fake, 0, sizeof(fake));
-	for( ; it->ht_index >= 0; --(it->ht_index) )
-	{
-		// Iterate in the order: right tree, current node, left tree
-		if( node == NULL )
-		{// prepare initial node of this hash
-			node = it->db->ht[it->ht_index];
-			if( node == NULL )
-				continue;// next hash
-			fake.left = node;
-			node = &fake;
-		}
-
-		
-		while( node )
-		{// next node
-			if( node->left )
-			{// continue in the left subtree
-				node = node->left;
-				while( node->right )
-					node = node->right;// get rightmost node
-			}
-			else
-			{// continue to the next parent (recursive)
-				parent = node->parent;
-				while( parent )
-				{
-					if( parent->left != node )
-						break;
-					node = parent;
-					parent = node->parent;
-				}
-				if( parent == NULL )
-				{// next hash
-					node = NULL;
-					break;
-				}
-				node = parent;
-			}
-
-			if( !node->deleted )
-			{// found previous entry
-				it->node = node;
-				if( out_key )
-					memcpy(out_key, &node->key, sizeof(DBKey));
-				return &node->data;
-			}
-		}
-	}
-	it->node = NULL;
-	return NULL;// not found
+DBData *dbit_obj_prev(DBIterator *self, DBKey *out_key)
+{
+    DBIterator_impl *it = (DBIterator_impl *)self;
+    DBNode node;
+    DBNode parent;
+    struct dbn fake;
+
+    DB_COUNTSTAT(dbit_prev);
+    if (it->ht_index >= HASH_SIZE) {
+        // get last node
+        it->ht_index = HASH_SIZE-1;
+        it->node = NULL;
+    }
+    node = it->node;
+    memset(&fake, 0, sizeof(fake));
+    for (; it->ht_index >= 0; --(it->ht_index)) {
+        // Iterate in the order: right tree, current node, left tree
+        if (node == NULL) {
+            // prepare initial node of this hash
+            node = it->db->ht[it->ht_index];
+            if (node == NULL)
+                continue;// next hash
+            fake.left = node;
+            node = &fake;
+        }
+
+
+        while (node) {
+            // next node
+            if (node->left) {
+                // continue in the left subtree
+                node = node->left;
+                while (node->right)
+                    node = node->right;// get rightmost node
+            } else {
+                // continue to the next parent (recursive)
+                parent = node->parent;
+                while (parent) {
+                    if (parent->left != node)
+                        break;
+                    node = parent;
+                    parent = node->parent;
+                }
+                if (parent == NULL) {
+                    // next hash
+                    node = NULL;
+                    break;
+                }
+                node = parent;
+            }
+
+            if (!node->deleted) {
+                // found previous entry
+                it->node = node;
+                if (out_key)
+                    memcpy(out_key, &node->key, sizeof(DBKey));
+                return &node->data;
+            }
+        }
+    }
+    it->node = NULL;
+    return NULL;// not found
 }
 
 /**
  * Returns true if the fetched entry exists.
- * The databases entries might have NULL data, so use this to to test if 
+ * The databases entries might have NULL data, so use this to to test if
  * the iterator is done.
  * @param self Iterator
  * @return true if the entry exists
  * @protected
  * @see DBIterator#exists
  */
-bool dbit_obj_exists(DBIterator* self)
+bool dbit_obj_exists(DBIterator *self)
 {
-	DBIterator_impl* it = (DBIterator_impl*)self;
+    DBIterator_impl *it = (DBIterator_impl *)self;
 
-	DB_COUNTSTAT(dbit_exists);
-	return (it->node && !it->node->deleted);
+    DB_COUNTSTAT(dbit_exists);
+    return (it->node && !it->node->deleted);
 }
 
 /**
  * Removes the current entry from the database.
- * NOTE: {@link DBIterator#exists} will return false until another entry 
+ * NOTE: {@link DBIterator#exists} will return false until another entry
  *       is fetched
  * Puts data of the removed entry in out_data, if out_data is not NULL.
  * @param self Iterator
@@ -1331,26 +1327,25 @@ bool dbit_obj_exists(DBIterator* self)
  * @see DBMap#remove
  * @see DBIterator#remove
  */
-int dbit_obj_remove(DBIterator* self, DBData *out_data)
+int dbit_obj_remove(DBIterator *self, DBData *out_data)
 {
-	DBIterator_impl* it = (DBIterator_impl*)self;
-	DBNode node;
-	int retval = 0;
+    DBIterator_impl *it = (DBIterator_impl *)self;
+    DBNode node;
+    int retval = 0;
 
-	DB_COUNTSTAT(dbit_remove);
-	node = it->node;
-	if( node && !node->deleted )
-	{
-		DBMap_impl* db = it->db;
-		if( db->cache == node )
-			db->cache = NULL;
-		if( out_data )
-			memcpy(out_data, &node->data, sizeof(DBData));
-		retval = 1;
-		db->release(node->key, node->data, DB_RELEASE_DATA);
-		db_free_add(db, node, &db->ht[it->ht_index]);
-	}
-	return retval;
+    DB_COUNTSTAT(dbit_remove);
+    node = it->node;
+    if (node && !node->deleted) {
+        DBMap_impl *db = it->db;
+        if (db->cache == node)
+            db->cache = NULL;
+        if (out_data)
+            memcpy(out_data, &node->data, sizeof(DBData));
+        retval = 1;
+        db->release(node->key, node->data, DB_RELEASE_DATA);
+        db_free_add(db, node, &db->ht[it->ht_index]);
+    }
+    return retval;
 }
 
 /**
@@ -1358,48 +1353,48 @@ int dbit_obj_remove(DBIterator* self, DBData *out_data)
  * @param self Iterator
  * @protected
  */
-void dbit_obj_destroy(DBIterator* self)
+void dbit_obj_destroy(DBIterator *self)
 {
-	DBIterator_impl* it = (DBIterator_impl*)self;
+    DBIterator_impl *it = (DBIterator_impl *)self;
 
-	DB_COUNTSTAT(dbit_destroy);
-	// unlock the database
-	db_free_unlock(it->db);
-	// free iterator
-	aFree(self);
+    DB_COUNTSTAT(dbit_destroy);
+    // unlock the database
+    db_free_unlock(it->db);
+    // free iterator
+    aFree(self);
 }
 
 /**
  * Returns a new iterator for this database.
  * The iterator keeps the database locked until it is destroyed.
- * The database will keep functioning normally but will only free internal 
+ * The database will keep functioning normally but will only free internal
  * memory when unlocked, so destroy the iterator as soon as possible.
  * @param self Database
  * @return New iterator
  * @protected
  */
-static DBIterator* db_obj_iterator(DBMap* self)
+static DBIterator *db_obj_iterator(DBMap *self)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBIterator_impl* it;
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBIterator_impl *it;
 
-	DB_COUNTSTAT(db_iterator);
-	CREATE(it, struct DBIterator_impl, 1);
-	/* Interface of the iterator **/
-	it->vtable.first   = dbit_obj_first;
-	it->vtable.last    = dbit_obj_last;
-	it->vtable.next    = dbit_obj_next;
-	it->vtable.prev    = dbit_obj_prev;
-	it->vtable.exists  = dbit_obj_exists;
-	it->vtable.remove  = dbit_obj_remove;
-	it->vtable.destroy = dbit_obj_destroy;
-	/* Initial state (before the first entry) */
-	it->db = db;
-	it->ht_index = -1;
-	it->node = NULL;
-	/* Lock the database */
-	db_free_lock(db);
-	return &it->vtable;
+    DB_COUNTSTAT(db_iterator);
+    CREATE(it, struct DBIterator_impl, 1);
+    /* Interface of the iterator **/
+    it->vtable.first   = dbit_obj_first;
+    it->vtable.last    = dbit_obj_last;
+    it->vtable.next    = dbit_obj_next;
+    it->vtable.prev    = dbit_obj_prev;
+    it->vtable.exists  = dbit_obj_exists;
+    it->vtable.remove  = dbit_obj_remove;
+    it->vtable.destroy = dbit_obj_destroy;
+    /* Initial state (before the first entry) */
+    it->db = db;
+    it->ht_index = -1;
+    it->node = NULL;
+    /* Lock the database */
+    db_free_lock(db);
+    return &it->vtable;
 }
 
 /**
@@ -1410,47 +1405,47 @@ static DBIterator* db_obj_iterator(DBMap* self)
  * @protected
  * @see DBMap#exists
  */
-static bool db_obj_exists(DBMap* self, DBKey key)
+static bool db_obj_exists(DBMap *self, DBKey key)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBNode node;
-	int c;
-	bool found = false;
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBNode node;
+    int c;
+    bool found = false;
 
-	DB_COUNTSTAT(db_exists);
-	if (db == NULL) return false; // nullpo candidate
-	if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
-		return false; // nullpo candidate
-	}
+    DB_COUNTSTAT(db_exists);
+    if (db == NULL) return false; // nullpo candidate
+    if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
+        return false; // nullpo candidate
+    }
 
-	if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0) {
+    if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0) {
 #if defined(DEBUG)
-		if (db->cache->deleted) {
-			ShowDebug("db_exists: Cache contains a deleted node. Please report this!!!\n");
-			return false;
-		}
+        if (db->cache->deleted) {
+            ShowDebug("db_exists: Cache contains a deleted node. Please report this!!!\n");
+            return false;
+        }
 #endif
-		return true; // cache hit
-	}
-
-	db_free_lock(db);
-	node = db->ht[db->hash(key, db->maxlen)%HASH_SIZE];
-	while (node) {
-		c = db->cmp(key, node->key, db->maxlen);
-		if (c == 0) {
-			if (!(node->deleted)) {
-				db->cache = node;
-				found = true;
-			}
-			break;
-		}
-		if (c < 0)
-			node = node->left;
-		else
-			node = node->right;
-	}
-	db_free_unlock(db);
-	return found;
+        return true; // cache hit
+    }
+
+    db_free_lock(db);
+    node = db->ht[db->hash(key, db->maxlen)%HASH_SIZE];
+    while (node) {
+        c = db->cmp(key, node->key, db->maxlen);
+        if (c == 0) {
+            if (!(node->deleted)) {
+                db->cache = node;
+                found = true;
+            }
+            break;
+        }
+        if (c < 0)
+            node = node->left;
+        else
+            node = node->right;
+    }
+    db_free_unlock(db);
+    return found;
 }
 
 /**
@@ -1461,48 +1456,48 @@ static bool db_obj_exists(DBMap* self, DBKey key)
  * @protected
  * @see DBMap#get
  */
-static DBData* db_obj_get(DBMap* self, DBKey key)
+static DBData *db_obj_get(DBMap *self, DBKey key)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBNode node;
-	int c;
-	DBData *data = NULL;
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBNode node;
+    int c;
+    DBData *data = NULL;
 
-	DB_COUNTSTAT(db_get);
-	if (db == NULL) return NULL; // nullpo candidate
-	if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
-		ShowError("db_get: Attempted to retrieve non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return NULL; // nullpo candidate
-	}
+    DB_COUNTSTAT(db_get);
+    if (db == NULL) return NULL; // nullpo candidate
+    if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
+        ShowError("db_get: Attempted to retrieve non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return NULL; // nullpo candidate
+    }
 
-	if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0) {
+    if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0) {
 #if defined(DEBUG)
-		if (db->cache->deleted) {
-			ShowDebug("db_get: Cache contains a deleted node. Please report this!!!\n");
-			return NULL;
-		}
+        if (db->cache->deleted) {
+            ShowDebug("db_get: Cache contains a deleted node. Please report this!!!\n");
+            return NULL;
+        }
 #endif
-		return &db->cache->data; // cache hit
-	}
-
-	db_free_lock(db);
-	node = db->ht[db->hash(key, db->maxlen)%HASH_SIZE];
-	while (node) {
-		c = db->cmp(key, node->key, db->maxlen);
-		if (c == 0) {
-			if (!(node->deleted)) {
-				data = &node->data;
-				db->cache = node;
-			}
-			break;
-		}
-		if (c < 0)
-			node = node->left;
-		else
-			node = node->right;
-	}
-	db_free_unlock(db);
-	return data;
+        return &db->cache->data; // cache hit
+    }
+
+    db_free_lock(db);
+    node = db->ht[db->hash(key, db->maxlen)%HASH_SIZE];
+    while (node) {
+        c = db->cmp(key, node->key, db->maxlen);
+        if (c == 0) {
+            if (!(node->deleted)) {
+                data = &node->data;
+                db->cache = node;
+            }
+            break;
+        }
+        if (c < 0)
+            node = node->left;
+        else
+            node = node->right;
+    }
+    db_free_unlock(db);
+    return data;
 }
 
 /**
@@ -1510,7 +1505,7 @@ static DBData* db_obj_get(DBMap* self, DBKey key)
  * It puts a maximum of <code>max</code> entries into <code>buf</code>.
  * If <code>buf</code> is NULL, it only counts the matches.
  * Returns the number of entries that matched.
- * NOTE: if the value returned is greater than <code>max</code>, only the 
+ * NOTE: if the value returned is greater than <code>max</code>, only the
  * first <code>max</code> entries found are put into the buffer.
  * @param self Interface of the database
  * @param buf Buffer to put the data of the matched entries
@@ -1521,58 +1516,58 @@ static DBData* db_obj_get(DBMap* self, DBKey key)
  * @protected
  * @see DBMap#vgetall
  */
-static unsigned int db_obj_vgetall(DBMap* self, DBData **buf, unsigned int max, DBMatcher match, va_list args)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	unsigned int i;
-	DBNode node;
-	DBNode parent;
-	unsigned int ret = 0;
-
-	DB_COUNTSTAT(db_vgetall);
-	if (db == NULL) return 0; // nullpo candidate
-	if (match == NULL) return 0; // nullpo candidate
-
-	db_free_lock(db);
-	for (i = 0; i < HASH_SIZE; i++) {
-		// Match in the order: current node, left tree, right tree
-		node = db->ht[i];
-		while (node) {
-
-			if (!(node->deleted)) {
-				va_list argscopy;
-				va_copy(argscopy, args);
-				if (match(node->key, node->data, argscopy) == 0) {
-					if (buf && ret < max)
-						buf[ret] = &node->data;
-					ret++;
-				}
-				va_end(argscopy);
-			}
-			
-			if (node->left) {
-				node = node->left;
-				continue;
-			}
-			
-			if (node->right) {
-				node = node->right;
-				continue;
-			}
-			
-			while (node) {
-				parent = node->parent;
-				if (parent && parent->right && parent->left == node) {
-					node = parent->right;
-					break;
-				}
-				node = parent;
-			}
-
-		}
-	}
-	db_free_unlock(db);
-	return ret;
+static unsigned int db_obj_vgetall(DBMap *self, DBData **buf, unsigned int max, DBMatcher match, va_list args)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    unsigned int i;
+    DBNode node;
+    DBNode parent;
+    unsigned int ret = 0;
+
+    DB_COUNTSTAT(db_vgetall);
+    if (db == NULL) return 0; // nullpo candidate
+    if (match == NULL) return 0; // nullpo candidate
+
+    db_free_lock(db);
+    for (i = 0; i < HASH_SIZE; i++) {
+        // Match in the order: current node, left tree, right tree
+        node = db->ht[i];
+        while (node) {
+
+            if (!(node->deleted)) {
+                va_list argscopy;
+                va_copy(argscopy, args);
+                if (match(node->key, node->data, argscopy) == 0) {
+                    if (buf && ret < max)
+                        buf[ret] = &node->data;
+                    ret++;
+                }
+                va_end(argscopy);
+            }
+
+            if (node->left) {
+                node = node->left;
+                continue;
+            }
+
+            if (node->right) {
+                node = node->right;
+                continue;
+            }
+
+            while (node) {
+                parent = node->parent;
+                if (parent && parent->right && parent->left == node) {
+                    node = parent->right;
+                    break;
+                }
+                node = parent;
+            }
+
+        }
+    }
+    db_free_unlock(db);
+    return ret;
 }
 
 /**
@@ -1581,7 +1576,7 @@ static unsigned int db_obj_vgetall(DBMap* self, DBData **buf, unsigned int max,
  * It puts a maximum of <code>max</code> entries into <code>buf</code>.
  * If <code>buf</code> is NULL, it only counts the matches.
  * Returns the number of entries that matched.
- * NOTE: if the value returned is greater than <code>max</code>, only the 
+ * NOTE: if the value returned is greater than <code>max</code>, only the
  * first <code>max</code> entries found are put into the buffer.
  * @param self Interface of the database
  * @param buf Buffer to put the data of the matched entries
@@ -1593,23 +1588,23 @@ static unsigned int db_obj_vgetall(DBMap* self, DBData **buf, unsigned int max,
  * @see DBMap#vgetall
  * @see DBMap#getall
  */
-static unsigned int db_obj_getall(DBMap* self, DBData **buf, unsigned int max, DBMatcher match, ...)
+static unsigned int db_obj_getall(DBMap *self, DBData **buf, unsigned int max, DBMatcher match, ...)
 {
-	va_list args;
-	unsigned int ret;
+    va_list args;
+    unsigned int ret;
 
-	DB_COUNTSTAT(db_getall);
-	if (self == NULL) return 0; // nullpo candidate
+    DB_COUNTSTAT(db_getall);
+    if (self == NULL) return 0; // nullpo candidate
 
-	va_start(args, match);
-	ret = self->vgetall(self, buf, max, match, args);
-	va_end(args);
-	return ret;
+    va_start(args, match);
+    ret = self->vgetall(self, buf, max, match, args);
+    va_end(args);
+    return ret;
 }
 
 /**
  * Get the data of the entry identified by the key.
- * If the entry does not exist, an entry is added with the data returned by 
+ * If the entry does not exist, an entry is added with the data returned by
  * <code>create</code>.
  * @param self Interface of the database
  * @param key Key that identifies the entry
@@ -1619,96 +1614,96 @@ static unsigned int db_obj_getall(DBMap* self, DBData **buf, unsigned int max, D
  * @protected
  * @see DBMap#vensure
  */
-static DBData* db_obj_vensure(DBMap* self, DBKey key, DBCreateData create, va_list args)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBNode node;
-	DBNode parent = NULL;
-	unsigned int hash;
-	int c = 0;
-	DBData *data = NULL;
-
-	DB_COUNTSTAT(db_vensure);
-	if (db == NULL) return NULL; // nullpo candidate
-	if (create == NULL) {
-		ShowError("db_ensure: Create function is NULL for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return NULL; // nullpo candidate
-	}
-	if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
-		ShowError("db_ensure: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return NULL; // nullpo candidate
-	}
-
-	if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0)
-		return &db->cache->data; // cache hit
-
-	db_free_lock(db);
-	hash = db->hash(key, db->maxlen)%HASH_SIZE;
-	node = db->ht[hash];
-	while (node) {
-		c = db->cmp(key, node->key, db->maxlen);
-		if (c == 0) {
-			break;
-		}
-		parent = node;
-		if (c < 0)
-			node = node->left;
-		else
-			node = node->right;
-	}
-	// Create node if necessary
-	if (node == NULL) {
-		va_list argscopy;
-		if (db->item_count == UINT32_MAX) {
-			ShowError("db_vensure: item_count overflow, aborting item insertion.\n"
-					"Database allocated at %s:%d",
-					db->alloc_file, db->alloc_line);
-				return NULL;
-		}
-		DB_COUNTSTAT(db_node_alloc);
-		node = ers_alloc(db->nodes, struct dbn);
-		node->left = NULL;
-		node->right = NULL;
-		node->deleted = 0;
-		db->item_count++;
-		if (c == 0) { // hash entry is empty
-			node->color = BLACK;
-			node->parent = NULL;
-			db->ht[hash] = node;
-		} else {
-			node->color = RED;
-			if (c < 0) { // put at the left
-				parent->left = node;
-				node->parent = parent;
-			} else { // put at the right
-				parent->right = node;
-				node->parent = parent;
-			}
-			if (parent->color == RED) // two consecutive RED nodes, must rebalance
-				db_rebalance(node, &db->ht[hash]);
-		}
-		// put key and data in the node
-		if (db->options&DB_OPT_DUP_KEY) {
-			node->key = db_dup_key(db, key);
-			if (db->options&DB_OPT_RELEASE_KEY)
-				db->release(key, *data, DB_RELEASE_KEY);
-		} else {
-			node->key = key;
-		}
-		va_copy(argscopy, args);
-		node->data = create(key, argscopy);
-		va_end(argscopy);
-	}
-	data = &node->data;
-	db->cache = node;
-	db_free_unlock(db);
-	return data;
+static DBData *db_obj_vensure(DBMap *self, DBKey key, DBCreateData create, va_list args)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBNode node;
+    DBNode parent = NULL;
+    unsigned int hash;
+    int c = 0;
+    DBData *data = NULL;
+
+    DB_COUNTSTAT(db_vensure);
+    if (db == NULL) return NULL; // nullpo candidate
+    if (create == NULL) {
+        ShowError("db_ensure: Create function is NULL for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return NULL; // nullpo candidate
+    }
+    if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
+        ShowError("db_ensure: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return NULL; // nullpo candidate
+    }
+
+    if (db->cache && db->cmp(key, db->cache->key, db->maxlen) == 0)
+        return &db->cache->data; // cache hit
+
+    db_free_lock(db);
+    hash = db->hash(key, db->maxlen)%HASH_SIZE;
+    node = db->ht[hash];
+    while (node) {
+        c = db->cmp(key, node->key, db->maxlen);
+        if (c == 0) {
+            break;
+        }
+        parent = node;
+        if (c < 0)
+            node = node->left;
+        else
+            node = node->right;
+    }
+    // Create node if necessary
+    if (node == NULL) {
+        va_list argscopy;
+        if (db->item_count == UINT32_MAX) {
+            ShowError("db_vensure: item_count overflow, aborting item insertion.\n"
+                      "Database allocated at %s:%d",
+                      db->alloc_file, db->alloc_line);
+            return NULL;
+        }
+        DB_COUNTSTAT(db_node_alloc);
+        node = ers_alloc(db->nodes, struct dbn);
+        node->left = NULL;
+        node->right = NULL;
+        node->deleted = 0;
+        db->item_count++;
+        if (c == 0) { // hash entry is empty
+            node->color = BLACK;
+            node->parent = NULL;
+            db->ht[hash] = node;
+        } else {
+            node->color = RED;
+            if (c < 0) { // put at the left
+                parent->left = node;
+                node->parent = parent;
+            } else { // put at the right
+                parent->right = node;
+                node->parent = parent;
+            }
+            if (parent->color == RED) // two consecutive RED nodes, must rebalance
+                db_rebalance(node, &db->ht[hash]);
+        }
+        // put key and data in the node
+        if (db->options&DB_OPT_DUP_KEY) {
+            node->key = db_dup_key(db, key);
+            if (db->options&DB_OPT_RELEASE_KEY)
+                db->release(key, *data, DB_RELEASE_KEY);
+        } else {
+            node->key = key;
+        }
+        va_copy(argscopy, args);
+        node->data = create(key, argscopy);
+        va_end(argscopy);
+    }
+    data = &node->data;
+    db->cache = node;
+    db_free_unlock(db);
+    return data;
 }
 
 /**
  * Just calls {@link DBMap#vensure}.
  * Get the data of the entry identified by the key.
- * If the entry does not exist, an entry is added with the data returned by 
+ * If the entry does not exist, an entry is added with the data returned by
  * <code>create</code>.
  * @param self Interface of the database
  * @param key Key that identifies the entry
@@ -1719,18 +1714,18 @@ static DBData* db_obj_vensure(DBMap* self, DBKey key, DBCreateData create, va_li
  * @see DBMap#vensure
  * @see DBMap#ensure
  */
-static DBData* db_obj_ensure(DBMap* self, DBKey key, DBCreateData create, ...)
+static DBData *db_obj_ensure(DBMap *self, DBKey key, DBCreateData create, ...)
 {
-	va_list args;
-	DBData *ret = NULL;
+    va_list args;
+    DBData *ret = NULL;
 
-	DB_COUNTSTAT(db_ensure);
-	if (self == NULL) return NULL; // nullpo candidate
+    DB_COUNTSTAT(db_ensure);
+    if (self == NULL) return NULL; // nullpo candidate
 
-	va_start(args, create);
-	ret = self->vensure(self, key, create, args);
-	va_end(args);
-	return ret;
+    va_start(args, create);
+    ret = self->vensure(self, key, create, args);
+    va_end(args);
+    return ret;
 }
 
 /**
@@ -1746,97 +1741,97 @@ static DBData* db_obj_ensure(DBMap* self, DBKey key, DBCreateData create, ...)
  * @see #db_malloc_dbn(void)
  * @see DBMap#put
  */
-static int db_obj_put(DBMap* self, DBKey key, DBData data, DBData *out_data)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBNode node;
-	DBNode parent = NULL;
-	int c = 0, retval = 0;
-	unsigned int hash;
-
-	DB_COUNTSTAT(db_put);
-	if (db == NULL) return 0; // nullpo candidate
-	if (db->global_lock) {
-		ShowError("db_put: Database is being destroyed, aborting entry insertion.\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-	if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
-		ShowError("db_put: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-	if (!(db->options&DB_OPT_ALLOW_NULL_DATA) && (data.type == DB_DATA_PTR && data.u.ptr == NULL)) {
-		ShowError("db_put: Attempted to use non-allowed NULL data for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-
-	if (db->item_count == UINT32_MAX) {
-		ShowError("db_put: item_count overflow, aborting item insertion.\n"
-				"Database allocated at %s:%d",
-				db->alloc_file, db->alloc_line);
-		return 0;
-	}
-	// search for an equal node
-	db_free_lock(db);
-	hash = db->hash(key, db->maxlen)%HASH_SIZE;
-	for (node = db->ht[hash]; node; ) {
-		c = db->cmp(key, node->key, db->maxlen);
-		if (c == 0) { // equal entry, replace
-			if (node->deleted) {
-				db_free_remove(db, node);
-			} else {
-				db->release(node->key, node->data, DB_RELEASE_BOTH);
-				if (out_data)
-					memcpy(out_data, &node->data, sizeof(*out_data));
-				retval = 1;
-			}
-			break;
-		}
-		parent = node;
-		if (c < 0) {
-			node = node->left;
-		} else {
-			node = node->right;
-		}
-	}
-	// allocate a new node if necessary
-	if (node == NULL) {
-		DB_COUNTSTAT(db_node_alloc);
-		node = ers_alloc(db->nodes, struct dbn);
-		node->left = NULL;
-		node->right = NULL;
-		node->deleted = 0;
-		db->item_count++;
-		if (c == 0) { // hash entry is empty
-			node->color = BLACK;
-			node->parent = NULL;
-			db->ht[hash] = node;
-		} else {
-			node->color = RED;
-			if (c < 0) { // put at the left
-				parent->left = node;
-				node->parent = parent;
-			} else { // put at the right
-				parent->right = node;
-				node->parent = parent;
-			}
-			if (parent->color == RED) // two consecutive RED nodes, must rebalance
-				db_rebalance(node, &db->ht[hash]);
-		}
-	}
-	// put key and data in the node
-	if (db->options&DB_OPT_DUP_KEY) {
-		node->key = db_dup_key(db, key);
-		if (db->options&DB_OPT_RELEASE_KEY)
-			db->release(key, data, DB_RELEASE_KEY);
-	} else {
-		node->key = key;
-	}
-	node->data = data;
-	db->cache = node;
-	db_free_unlock(db);
-	return retval;
+static int db_obj_put(DBMap *self, DBKey key, DBData data, DBData *out_data)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBNode node;
+    DBNode parent = NULL;
+    int c = 0, retval = 0;
+    unsigned int hash;
+
+    DB_COUNTSTAT(db_put);
+    if (db == NULL) return 0; // nullpo candidate
+    if (db->global_lock) {
+        ShowError("db_put: Database is being destroyed, aborting entry insertion.\n"
+                  "Database allocated at %s:%d\n",
+                  db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+    if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key)) {
+        ShowError("db_put: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+    if (!(db->options&DB_OPT_ALLOW_NULL_DATA) && (data.type == DB_DATA_PTR && data.u.ptr == NULL)) {
+        ShowError("db_put: Attempted to use non-allowed NULL data for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+
+    if (db->item_count == UINT32_MAX) {
+        ShowError("db_put: item_count overflow, aborting item insertion.\n"
+                  "Database allocated at %s:%d",
+                  db->alloc_file, db->alloc_line);
+        return 0;
+    }
+    // search for an equal node
+    db_free_lock(db);
+    hash = db->hash(key, db->maxlen)%HASH_SIZE;
+    for (node = db->ht[hash]; node;) {
+        c = db->cmp(key, node->key, db->maxlen);
+        if (c == 0) { // equal entry, replace
+            if (node->deleted) {
+                db_free_remove(db, node);
+            } else {
+                db->release(node->key, node->data, DB_RELEASE_BOTH);
+                if (out_data)
+                    memcpy(out_data, &node->data, sizeof(*out_data));
+                retval = 1;
+            }
+            break;
+        }
+        parent = node;
+        if (c < 0) {
+            node = node->left;
+        } else {
+            node = node->right;
+        }
+    }
+    // allocate a new node if necessary
+    if (node == NULL) {
+        DB_COUNTSTAT(db_node_alloc);
+        node = ers_alloc(db->nodes, struct dbn);
+        node->left = NULL;
+        node->right = NULL;
+        node->deleted = 0;
+        db->item_count++;
+        if (c == 0) { // hash entry is empty
+            node->color = BLACK;
+            node->parent = NULL;
+            db->ht[hash] = node;
+        } else {
+            node->color = RED;
+            if (c < 0) { // put at the left
+                parent->left = node;
+                node->parent = parent;
+            } else { // put at the right
+                parent->right = node;
+                node->parent = parent;
+            }
+            if (parent->color == RED) // two consecutive RED nodes, must rebalance
+                db_rebalance(node, &db->ht[hash]);
+        }
+    }
+    // put key and data in the node
+    if (db->options&DB_OPT_DUP_KEY) {
+        node->key = db_dup_key(db, key);
+        if (db->options&DB_OPT_RELEASE_KEY)
+            db->release(key, data, DB_RELEASE_KEY);
+    } else {
+        node->key = key;
+    }
+    node->data = data;
+    db->cache = node;
+    db_free_unlock(db);
+    return retval;
 }
 
 /**
@@ -1851,49 +1846,49 @@ static int db_obj_put(DBMap* self, DBKey key, DBData data, DBData *out_data)
  * @see #db_free_add(DBMap_impl*,DBNode,DBNode *)
  * @see DBMap#remove
  */
-static int db_obj_remove(DBMap* self, DBKey key, DBData *out_data)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBNode node;
-	unsigned int hash;
-	int c = 0, retval = 0;
-
-	DB_COUNTSTAT(db_remove);
-	if (db == NULL) return 0; // nullpo candidate
-	if (db->global_lock) {
-		ShowError("db_remove: Database is being destroyed. Aborting entry deletion.\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-	if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key))	{
-		ShowError("db_remove: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-
-	db_free_lock(db);
-	hash = db->hash(key, db->maxlen)%HASH_SIZE;
-	for(node = db->ht[hash]; node; ){
-		c = db->cmp(key, node->key, db->maxlen);
-		if (c == 0) {
-			if (!(node->deleted)) {
-				if (db->cache == node)
-					db->cache = NULL;
-				if (out_data)
-					memcpy(out_data, &node->data, sizeof(*out_data));
-				retval = 1;
-				db->release(node->key, node->data, DB_RELEASE_DATA);
-				db_free_add(db, node, &db->ht[hash]);
-			}
-			break;
-		}
-		if (c < 0)
-			node = node->left;
-		else
-			node = node->right;
-	}
-	db_free_unlock(db);
-	return retval;
+static int db_obj_remove(DBMap *self, DBKey key, DBData *out_data)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBNode node;
+    unsigned int hash;
+    int c = 0, retval = 0;
+
+    DB_COUNTSTAT(db_remove);
+    if (db == NULL) return 0; // nullpo candidate
+    if (db->global_lock) {
+        ShowError("db_remove: Database is being destroyed. Aborting entry deletion.\n"
+                  "Database allocated at %s:%d\n",
+                  db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+    if (!(db->options&DB_OPT_ALLOW_NULL_KEY) && db_is_key_null(db->type, key))  {
+        ShowError("db_remove: Attempted to use non-allowed NULL key for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+
+    db_free_lock(db);
+    hash = db->hash(key, db->maxlen)%HASH_SIZE;
+    for (node = db->ht[hash]; node;) {
+        c = db->cmp(key, node->key, db->maxlen);
+        if (c == 0) {
+            if (!(node->deleted)) {
+                if (db->cache == node)
+                    db->cache = NULL;
+                if (out_data)
+                    memcpy(out_data, &node->data, sizeof(*out_data));
+                retval = 1;
+                db->release(node->key, node->data, DB_RELEASE_DATA);
+                db_free_add(db, node, &db->ht[hash]);
+            }
+            break;
+        }
+        if (c < 0)
+            node = node->left;
+        else
+            node = node->right;
+    }
+    db_free_unlock(db);
+    return retval;
 }
 
 /**
@@ -1906,52 +1901,52 @@ static int db_obj_remove(DBMap* self, DBKey key, DBData *out_data)
  * @protected
  * @see DBMap#vforeach
  */
-static int db_obj_vforeach(DBMap* self, DBApply func, va_list args)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	unsigned int i;
-	int sum = 0;
-	DBNode node;
-	DBNode parent;
-
-	DB_COUNTSTAT(db_vforeach);
-	if (db == NULL) return 0; // nullpo candidate
-	if (func == NULL) {
-		ShowError("db_foreach: Passed function is NULL for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
-		return 0; // nullpo candidate
-	}
-
-	db_free_lock(db);
-	for (i = 0; i < HASH_SIZE; i++) {
-		// Apply func in the order: current node, left node, right node
-		node = db->ht[i];
-		while (node) {
-			if (!(node->deleted)) {
-				va_list argscopy;
-				va_copy(argscopy, args);
-				sum += func(node->key, &node->data, argscopy);
-				va_end(argscopy);
-			}
-			if (node->left) {
-				node = node->left;
-				continue;
-			}
-			if (node->right) {
-				node = node->right;
-				continue;
-			}
-			while (node) {
-				parent = node->parent;
-				if (parent && parent->right && parent->left == node) {
-					node = parent->right;
-					break;
-				}
-				node = parent;
-			}
-		}
-	}
-	db_free_unlock(db);
-	return sum;
+static int db_obj_vforeach(DBMap *self, DBApply func, va_list args)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    unsigned int i;
+    int sum = 0;
+    DBNode node;
+    DBNode parent;
+
+    DB_COUNTSTAT(db_vforeach);
+    if (db == NULL) return 0; // nullpo candidate
+    if (func == NULL) {
+        ShowError("db_foreach: Passed function is NULL for db allocated at %s:%d\n",db->alloc_file, db->alloc_line);
+        return 0; // nullpo candidate
+    }
+
+    db_free_lock(db);
+    for (i = 0; i < HASH_SIZE; i++) {
+        // Apply func in the order: current node, left node, right node
+        node = db->ht[i];
+        while (node) {
+            if (!(node->deleted)) {
+                va_list argscopy;
+                va_copy(argscopy, args);
+                sum += func(node->key, &node->data, argscopy);
+                va_end(argscopy);
+            }
+            if (node->left) {
+                node = node->left;
+                continue;
+            }
+            if (node->right) {
+                node = node->right;
+                continue;
+            }
+            while (node) {
+                parent = node->parent;
+                if (parent && parent->right && parent->left == node) {
+                    node = parent->right;
+                    break;
+                }
+                node = parent;
+            }
+        }
+    }
+    db_free_unlock(db);
+    return sum;
 }
 
 /**
@@ -1966,18 +1961,18 @@ static int db_obj_vforeach(DBMap* self, DBApply func, va_list args)
  * @see DBMap#vforeach
  * @see DBMap#foreach
  */
-static int db_obj_foreach(DBMap* self, DBApply func, ...)
+static int db_obj_foreach(DBMap *self, DBApply func, ...)
 {
-	va_list args;
-	int ret;
+    va_list args;
+    int ret;
 
-	DB_COUNTSTAT(db_foreach);
-	if (self == NULL) return 0; // nullpo candidate
+    DB_COUNTSTAT(db_foreach);
+    if (self == NULL) return 0; // nullpo candidate
 
-	va_start(args, func);
-	ret = self->vforeach(self, func, args);
-	va_end(args);
-	return ret;
+    va_start(args, func);
+    ret = self->vforeach(self, func, args);
+    va_end(args);
+    return ret;
 }
 
 /**
@@ -1992,62 +1987,61 @@ static int db_obj_foreach(DBMap* self, DBApply func, ...)
  * @protected
  * @see DBMap#vclear
  */
-static int db_obj_vclear(DBMap* self, DBApply func, va_list args)
-{
-	DBMap_impl* db = (DBMap_impl*)self;
-	int sum = 0;
-	unsigned int i;
-	DBNode node;
-	DBNode parent;
-
-	DB_COUNTSTAT(db_vclear);
-	if (db == NULL) return 0; // nullpo candidate
-
-	db_free_lock(db);
-	db->cache = NULL;
-	for (i = 0; i < HASH_SIZE; i++) {
-		// Apply the func and delete in the order: left tree, right tree, current node
-		node = db->ht[i];
-		db->ht[i] = NULL;
-		while (node) {
-			parent = node->parent;
-			if (node->left) {
-				node = node->left;
-				continue;
-			}
-			if (node->right) {
-				node = node->right;
-				continue;
-			}
-			if (node->deleted) {
-				db_dup_key_free(db, node->key);
-			} else {
-				if (func)
-				{
-					va_list argscopy;
-					va_copy(argscopy, args);
-					sum += func(node->key, &node->data, argscopy);
-					va_end(argscopy);
-				}
-				db->release(node->key, node->data, DB_RELEASE_BOTH);
-				node->deleted = 1;
-			}
-			DB_COUNTSTAT(db_node_free);
-			if (parent) {
-				if (parent->left == node)
-					parent->left = NULL;
-				else
-					parent->right = NULL;
-			}
-			ers_free(db->nodes, node);
-			node = parent;
-		}
-		db->ht[i] = NULL;
-	}
-	db->free_count = 0;
-	db->item_count = 0;
-	db_free_unlock(db);
-	return sum;
+static int db_obj_vclear(DBMap *self, DBApply func, va_list args)
+{
+    DBMap_impl *db = (DBMap_impl *)self;
+    int sum = 0;
+    unsigned int i;
+    DBNode node;
+    DBNode parent;
+
+    DB_COUNTSTAT(db_vclear);
+    if (db == NULL) return 0; // nullpo candidate
+
+    db_free_lock(db);
+    db->cache = NULL;
+    for (i = 0; i < HASH_SIZE; i++) {
+        // Apply the func and delete in the order: left tree, right tree, current node
+        node = db->ht[i];
+        db->ht[i] = NULL;
+        while (node) {
+            parent = node->parent;
+            if (node->left) {
+                node = node->left;
+                continue;
+            }
+            if (node->right) {
+                node = node->right;
+                continue;
+            }
+            if (node->deleted) {
+                db_dup_key_free(db, node->key);
+            } else {
+                if (func) {
+                    va_list argscopy;
+                    va_copy(argscopy, args);
+                    sum += func(node->key, &node->data, argscopy);
+                    va_end(argscopy);
+                }
+                db->release(node->key, node->data, DB_RELEASE_BOTH);
+                node->deleted = 1;
+            }
+            DB_COUNTSTAT(db_node_free);
+            if (parent) {
+                if (parent->left == node)
+                    parent->left = NULL;
+                else
+                    parent->right = NULL;
+            }
+            ers_free(db->nodes, node);
+            node = parent;
+        }
+        db->ht[i] = NULL;
+    }
+    db->free_count = 0;
+    db->item_count = 0;
+    db_free_unlock(db);
+    return sum;
 }
 
 /**
@@ -2056,7 +2050,7 @@ static int db_obj_vclear(DBMap* self, DBApply func, va_list args)
  * Before deleting an entry, func is applied to it.
  * Releases the key and the data.
  * Returns the sum of values returned by func, if it exists.
- * NOTE: This locks the database globally. Any attempt to insert or remove 
+ * NOTE: This locks the database globally. Any attempt to insert or remove
  * a database entry will give an error and be aborted (except for clearing).
  * @param self Interface of the database
  * @param func Function to be applied to every entry before deleting
@@ -2066,25 +2060,25 @@ static int db_obj_vclear(DBMap* self, DBApply func, va_list args)
  * @see DBMap#vclear
  * @see DBMap#clear
  */
-static int db_obj_clear(DBMap* self, DBApply func, ...)
+static int db_obj_clear(DBMap *self, DBApply func, ...)
 {
-	va_list args;
-	int ret;
+    va_list args;
+    int ret;
 
-	DB_COUNTSTAT(db_clear);
-	if (self == NULL) return 0; // nullpo candidate
+    DB_COUNTSTAT(db_clear);
+    if (self == NULL) return 0; // nullpo candidate
 
-	va_start(args, func);
-	ret = self->vclear(self, func, args);
-	va_end(args);
-	return ret;
+    va_start(args, func);
+    ret = self->vclear(self, func, args);
+    va_end(args);
+    return ret;
 }
 
 /**
  * Finalize the database, feeing all the memory it uses.
  * Before deleting an entry, func is applied to it.
  * Returns the sum of values returned by func, if it exists.
- * NOTE: This locks the database globally. Any attempt to insert or remove 
+ * NOTE: This locks the database globally. Any attempt to insert or remove
  * a database entry will give an error and be aborted (except for clearing).
  * @param self Interface of the database
  * @param func Function to be applied to every entry before deleting
@@ -2093,42 +2087,50 @@ static int db_obj_clear(DBMap* self, DBApply func, ...)
  * @protected
  * @see DBMap#vdestroy
  */
-static int db_obj_vdestroy(DBMap* self, DBApply func, va_list args)
+static int db_obj_vdestroy(DBMap *self, DBApply func, va_list args)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	int sum;
+    DBMap_impl *db = (DBMap_impl *)self;
+    int sum;
 
-	DB_COUNTSTAT(db_vdestroy);
-	if (db == NULL) return 0; // nullpo candidate
-	if (db->global_lock) {
-		ShowError("db_vdestroy: Database is already locked for destruction. Aborting second database destruction.\n"
-				"Database allocated at %s:%d\n",
-				db->alloc_file, db->alloc_line);
-		return 0;
-	}
-	if (db->free_lock)
-		ShowWarning("db_vdestroy: Database is still in use, %u lock(s) left. Continuing database destruction.\n"
-				"Database allocated at %s:%d\n",
-				db->free_lock, db->alloc_file, db->alloc_line);
+    DB_COUNTSTAT(db_vdestroy);
+    if (db == NULL) return 0; // nullpo candidate
+    if (db->global_lock) {
+        ShowError("db_vdestroy: Database is already locked for destruction. Aborting second database destruction.\n"
+                  "Database allocated at %s:%d\n",
+                  db->alloc_file, db->alloc_line);
+        return 0;
+    }
+    if (db->free_lock)
+        ShowWarning("db_vdestroy: Database is still in use, %u lock(s) left. Continuing database destruction.\n"
+                    "Database allocated at %s:%d\n",
+                    db->free_lock, db->alloc_file, db->alloc_line);
 
 #ifdef DB_ENABLE_STATS
-	switch (db->type) {
-		case DB_INT: DB_COUNTSTAT(db_int_destroy); break;
-		case DB_UINT: DB_COUNTSTAT(db_uint_destroy); break;
-		case DB_STRING: DB_COUNTSTAT(db_string_destroy); break;
-		case DB_ISTRING: DB_COUNTSTAT(db_istring_destroy); break;
-	}
+    switch (db->type) {
+        case DB_INT:
+            DB_COUNTSTAT(db_int_destroy);
+            break;
+        case DB_UINT:
+            DB_COUNTSTAT(db_uint_destroy);
+            break;
+        case DB_STRING:
+            DB_COUNTSTAT(db_string_destroy);
+            break;
+        case DB_ISTRING:
+            DB_COUNTSTAT(db_istring_destroy);
+            break;
+    }
 #endif /* DB_ENABLE_STATS */
-	db_free_lock(db);
-	db->global_lock = 1;
-	sum = self->vclear(self, func, args);
-	aFree(db->free_list);
-	db->free_list = NULL;
-	db->free_max = 0;
-	ers_destroy(db->nodes);
-	db_free_unlock(db);
-	aFree(db);
-	return sum;
+    db_free_lock(db);
+    db->global_lock = 1;
+    sum = self->vclear(self, func, args);
+    aFree(db->free_list);
+    db->free_list = NULL;
+    db->free_max = 0;
+    ers_destroy(db->nodes);
+    db_free_unlock(db);
+    aFree(db);
+    return sum;
 }
 
 /**
@@ -2137,7 +2139,7 @@ static int db_obj_vdestroy(DBMap* self, DBApply func, va_list args)
  * Before deleting an entry, func is applied to it.
  * Releases the key and the data.
  * Returns the sum of values returned by func, if it exists.
- * NOTE: This locks the database globally. Any attempt to insert or remove 
+ * NOTE: This locks the database globally. Any attempt to insert or remove
  * a database entry will give an error and be aborted.
  * @param self Database
  * @param func Function to be applied to every entry before deleting
@@ -2147,18 +2149,18 @@ static int db_obj_vdestroy(DBMap* self, DBApply func, va_list args)
  * @see DBMap#vdestroy
  * @see DBMap#destroy
  */
-static int db_obj_destroy(DBMap* self, DBApply func, ...)
+static int db_obj_destroy(DBMap *self, DBApply func, ...)
 {
-	va_list args;
-	int ret;
+    va_list args;
+    int ret;
 
-	DB_COUNTSTAT(db_destroy);
-	if (self == NULL) return 0; // nullpo candidate
+    DB_COUNTSTAT(db_destroy);
+    if (self == NULL) return 0; // nullpo candidate
 
-	va_start(args, func);
-	ret = self->vdestroy(self, func, args);
-	va_end(args);
-	return ret;
+    va_start(args, func);
+    ret = self->vdestroy(self, func, args);
+    va_end(args);
+    return ret;
 }
 
 /**
@@ -2169,19 +2171,19 @@ static int db_obj_destroy(DBMap* self, DBApply func, ...)
  * @see DBMap_impl#item_count
  * @see DBMap#size
  */
-static unsigned int db_obj_size(DBMap* self)
+static unsigned int db_obj_size(DBMap *self)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	unsigned int item_count;
+    DBMap_impl *db = (DBMap_impl *)self;
+    unsigned int item_count;
 
-	DB_COUNTSTAT(db_size);
-	if (db == NULL) return 0; // nullpo candidate
+    DB_COUNTSTAT(db_size);
+    if (db == NULL) return 0; // nullpo candidate
 
-	db_free_lock(db);
-	item_count = db->item_count;
-	db_free_unlock(db);
+    db_free_lock(db);
+    item_count = db->item_count;
+    db_free_unlock(db);
 
-	return item_count;
+    return item_count;
 }
 
 /**
@@ -2192,19 +2194,19 @@ static unsigned int db_obj_size(DBMap* self)
  * @see DBMap_impl#type
  * @see DBMap#type
  */
-static DBType db_obj_type(DBMap* self)
+static DBType db_obj_type(DBMap *self)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBType type;
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBType type;
 
-	DB_COUNTSTAT(db_type);
-	if (db == NULL) return (DBType)-1; // nullpo candidate - TODO what should this return?
+    DB_COUNTSTAT(db_type);
+    if (db == NULL) return (DBType)-1; // nullpo candidate - TODO what should this return?
 
-	db_free_lock(db);
-	type = db->type;
-	db_free_unlock(db);
+    db_free_lock(db);
+    type = db->type;
+    db_free_unlock(db);
 
-	return type;
+    return type;
 }
 
 /**
@@ -2215,19 +2217,19 @@ static DBType db_obj_type(DBMap* self)
  * @see DBMap_impl#options
  * @see DBMap#options
  */
-static DBOptions db_obj_options(DBMap* self)
+static DBOptions db_obj_options(DBMap *self)
 {
-	DBMap_impl* db = (DBMap_impl*)self;
-	DBOptions options;
+    DBMap_impl *db = (DBMap_impl *)self;
+    DBOptions options;
 
-	DB_COUNTSTAT(db_options);
-	if (db == NULL) return DB_OPT_BASE; // nullpo candidate - TODO what should this return?
+    DB_COUNTSTAT(db_options);
+    if (db == NULL) return DB_OPT_BASE; // nullpo candidate - TODO what should this return?
 
-	db_free_lock(db);
-	options = db->options;
-	db_free_unlock(db);
+    db_free_lock(db);
+    options = db->options;
+    db_free_unlock(db);
 
-	return options;
+    return options;
 }
 
 /*****************************************************************************\
@@ -2264,18 +2266,18 @@ static DBOptions db_obj_options(DBMap* self)
  */
 DBOptions db_fix_options(DBType type, DBOptions options)
 {
-	DB_COUNTSTAT(db_fix_options);
-	switch (type) {
-		case DB_INT:
-		case DB_UINT: // Numeric database, do nothing with the keys
-			return (DBOptions)(options&~(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY));
+    DB_COUNTSTAT(db_fix_options);
+    switch (type) {
+        case DB_INT:
+        case DB_UINT: // Numeric database, do nothing with the keys
+            return (DBOptions)(options&~(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY));
 
-		default:
-			ShowError("db_fix_options: Unknown database type %u with options %x\n", type, options);
-		case DB_STRING:
-		case DB_ISTRING: // String databases, no fix required
-			return options;
-	}
+        default:
+            ShowError("db_fix_options: Unknown database type %u with options %x\n", type, options);
+        case DB_STRING:
+        case DB_ISTRING: // String databases, no fix required
+            return options;
+    }
 }
 
 /**
@@ -2290,16 +2292,20 @@ DBOptions db_fix_options(DBType type, DBOptions options)
  */
 DBComparator db_default_cmp(DBType type)
 {
-	DB_COUNTSTAT(db_default_cmp);
-	switch (type) {
-		case DB_INT:     return &db_int_cmp;
-		case DB_UINT:    return &db_uint_cmp;
-		case DB_STRING:  return &db_string_cmp;
-		case DB_ISTRING: return &db_istring_cmp;
-		default:
-			ShowError("db_default_cmp: Unknown database type %u\n", type);
-			return NULL;
-	}
+    DB_COUNTSTAT(db_default_cmp);
+    switch (type) {
+        case DB_INT:
+            return &db_int_cmp;
+        case DB_UINT:
+            return &db_uint_cmp;
+        case DB_STRING:
+            return &db_string_cmp;
+        case DB_ISTRING:
+            return &db_istring_cmp;
+        default:
+            ShowError("db_default_cmp: Unknown database type %u\n", type);
+            return NULL;
+    }
 }
 
 /**
@@ -2314,20 +2320,24 @@ DBComparator db_default_cmp(DBType type)
  */
 DBHasher db_default_hash(DBType type)
 {
-	DB_COUNTSTAT(db_default_hash);
-	switch (type) {
-		case DB_INT:     return &db_int_hash;
-		case DB_UINT:    return &db_uint_hash;
-		case DB_STRING:  return &db_string_hash;
-		case DB_ISTRING: return &db_istring_hash;
-		default:
-			ShowError("db_default_hash: Unknown database type %u\n", type);
-			return NULL;
-	}
+    DB_COUNTSTAT(db_default_hash);
+    switch (type) {
+        case DB_INT:
+            return &db_int_hash;
+        case DB_UINT:
+            return &db_uint_hash;
+        case DB_STRING:
+            return &db_string_hash;
+        case DB_ISTRING:
+            return &db_istring_hash;
+        default:
+            ShowError("db_default_hash: Unknown database type %u\n", type);
+            return NULL;
+    }
 }
 
 /**
- * Returns the default releaser for the specified type of database with the 
+ * Returns the default releaser for the specified type of database with the
  * specified options.
  * NOTE: the options are fixed with {@link #db_fix_options(DBType,DBOptions)}
  * before choosing the releaser.
@@ -2343,16 +2353,16 @@ DBHasher db_default_hash(DBType type)
  */
 DBReleaser db_default_release(DBType type, DBOptions options)
 {
-	DB_COUNTSTAT(db_default_release);
-	options = db_fix_options(type, options);
-	if (options&DB_OPT_RELEASE_DATA) { // Release data, what about the key?
-		if (options&(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY))
-			return &db_release_both; // Release both key and data
-		return &db_release_data; // Only release data
-	}
-	if (options&(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY))
-		return &db_release_key; // Only release key
-	return &db_release_nothing; // Release nothing
+    DB_COUNTSTAT(db_default_release);
+    options = db_fix_options(type, options);
+    if (options&DB_OPT_RELEASE_DATA) { // Release data, what about the key?
+        if (options&(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY))
+            return &db_release_both; // Release both key and data
+        return &db_release_data; // Only release data
+    }
+    if (options&(DB_OPT_DUP_KEY|DB_OPT_RELEASE_KEY))
+        return &db_release_key; // Only release key
+    return &db_release_nothing; // Release nothing
 }
 
 /**
@@ -2368,16 +2378,20 @@ DBReleaser db_default_release(DBType type, DBOptions options)
  */
 DBReleaser db_custom_release(DBRelease which)
 {
-	DB_COUNTSTAT(db_custom_release);
-	switch (which) {
-		case DB_RELEASE_NOTHING: return &db_release_nothing;
-		case DB_RELEASE_KEY:     return &db_release_key;
-		case DB_RELEASE_DATA:    return &db_release_data;
-		case DB_RELEASE_BOTH:    return &db_release_both;
-		default:
-			ShowError("db_custom_release: Unknown release options %u\n", which);
-			return NULL;
-	}
+    DB_COUNTSTAT(db_custom_release);
+    switch (which) {
+        case DB_RELEASE_NOTHING:
+            return &db_release_nothing;
+        case DB_RELEASE_KEY:
+            return &db_release_key;
+        case DB_RELEASE_DATA:
+            return &db_release_data;
+        case DB_RELEASE_BOTH:
+            return &db_release_both;
+        default:
+            ShowError("db_custom_release: Unknown release options %u\n", which);
+            return NULL;
+    }
 }
 
 /**
@@ -2388,75 +2402,83 @@ DBReleaser db_custom_release(DBRelease which)
  * @param line Line of the file where the database is being allocated
  * @param type Type of database
  * @param options Options of the database
- * @param maxlen Maximum length of the string to be used as key in string 
+ * @param maxlen Maximum length of the string to be used as key in string
  *          databases. If 0, the maximum number of maxlen is used (64K).
  * @return The interface of the database
  * @public
  * @see #DBMap_impl
  * @see #db_fix_options(DBType,DBOptions)
  */
-DBMap* db_alloc(const char *file, int line, DBType type, DBOptions options, unsigned short maxlen)
+DBMap *db_alloc(const char *file, int line, DBType type, DBOptions options, unsigned short maxlen)
 {
-	DBMap_impl* db;
-	unsigned int i;
+    DBMap_impl *db;
+    unsigned int i;
 
 #ifdef DB_ENABLE_STATS
-	DB_COUNTSTAT(db_alloc);
-	switch (type) {
-		case DB_INT: DB_COUNTSTAT(db_int_alloc); break;
-		case DB_UINT: DB_COUNTSTAT(db_uint_alloc); break;
-		case DB_STRING: DB_COUNTSTAT(db_string_alloc); break;
-		case DB_ISTRING: DB_COUNTSTAT(db_istring_alloc); break;
-	}
+    DB_COUNTSTAT(db_alloc);
+    switch (type) {
+        case DB_INT:
+            DB_COUNTSTAT(db_int_alloc);
+            break;
+        case DB_UINT:
+            DB_COUNTSTAT(db_uint_alloc);
+            break;
+        case DB_STRING:
+            DB_COUNTSTAT(db_string_alloc);
+            break;
+        case DB_ISTRING:
+            DB_COUNTSTAT(db_istring_alloc);
+            break;
+    }
 #endif /* DB_ENABLE_STATS */
-	CREATE(db, struct DBMap_impl, 1);
-
-	options = db_fix_options(type, options);
-	/* Interface of the database */
-	db->vtable.iterator = db_obj_iterator;
-	db->vtable.exists   = db_obj_exists;
-	db->vtable.get      = db_obj_get;
-	db->vtable.getall   = db_obj_getall;
-	db->vtable.vgetall  = db_obj_vgetall;
-	db->vtable.ensure   = db_obj_ensure;
-	db->vtable.vensure  = db_obj_vensure;
-	db->vtable.put      = db_obj_put;
-	db->vtable.remove   = db_obj_remove;
-	db->vtable.foreach  = db_obj_foreach;
-	db->vtable.vforeach = db_obj_vforeach;
-	db->vtable.clear    = db_obj_clear;
-	db->vtable.vclear   = db_obj_vclear;
-	db->vtable.destroy  = db_obj_destroy;
-	db->vtable.vdestroy = db_obj_vdestroy;
-	db->vtable.size     = db_obj_size;
-	db->vtable.type     = db_obj_type;
-	db->vtable.options  = db_obj_options;
-	/* File and line of allocation */
-	db->alloc_file = file;
-	db->alloc_line = line;
-	/* Lock system */
-	db->free_list = NULL;
-	db->free_count = 0;
-	db->free_max = 0;
-	db->free_lock = 0;
-	/* Other */
-	db->nodes = ers_new(sizeof(struct dbn),"db.c::db_alloc",ERS_OPT_NONE);
-	db->cmp = db_default_cmp(type);
-	db->hash = db_default_hash(type);
-	db->release = db_default_release(type, options);
-	for (i = 0; i < HASH_SIZE; i++)
-		db->ht[i] = NULL;
-	db->cache = NULL;
-	db->type = type;
-	db->options = options;
-	db->item_count = 0;
-	db->maxlen = maxlen;
-	db->global_lock = 0;
-
-	if( db->maxlen == 0 && (type == DB_STRING || type == DB_ISTRING) )
-		db->maxlen = UINT16_MAX;
-
-	return &db->vtable;
+    CREATE(db, struct DBMap_impl, 1);
+
+    options = db_fix_options(type, options);
+    /* Interface of the database */
+    db->vtable.iterator = db_obj_iterator;
+    db->vtable.exists   = db_obj_exists;
+    db->vtable.get      = db_obj_get;
+    db->vtable.getall   = db_obj_getall;
+    db->vtable.vgetall  = db_obj_vgetall;
+    db->vtable.ensure   = db_obj_ensure;
+    db->vtable.vensure  = db_obj_vensure;
+    db->vtable.put      = db_obj_put;
+    db->vtable.remove   = db_obj_remove;
+    db->vtable.foreach  = db_obj_foreach;
+    db->vtable.vforeach = db_obj_vforeach;
+    db->vtable.clear    = db_obj_clear;
+    db->vtable.vclear   = db_obj_vclear;
+    db->vtable.destroy  = db_obj_destroy;
+    db->vtable.vdestroy = db_obj_vdestroy;
+    db->vtable.size     = db_obj_size;
+    db->vtable.type     = db_obj_type;
+    db->vtable.options  = db_obj_options;
+    /* File and line of allocation */
+    db->alloc_file = file;
+    db->alloc_line = line;
+    /* Lock system */
+    db->free_list = NULL;
+    db->free_count = 0;
+    db->free_max = 0;
+    db->free_lock = 0;
+    /* Other */
+    db->nodes = ers_new(sizeof(struct dbn),"db.c::db_alloc",ERS_OPT_NONE);
+    db->cmp = db_default_cmp(type);
+    db->hash = db_default_hash(type);
+    db->release = db_default_release(type, options);
+    for (i = 0; i < HASH_SIZE; i++)
+        db->ht[i] = NULL;
+    db->cache = NULL;
+    db->type = type;
+    db->options = options;
+    db->item_count = 0;
+    db->maxlen = maxlen;
+    db->global_lock = 0;
+
+    if (db->maxlen == 0 && (type == DB_STRING || type == DB_ISTRING))
+        db->maxlen = UINT16_MAX;
+
+    return &db->vtable;
 }
 
 /**
@@ -2467,11 +2489,11 @@ DBMap* db_alloc(const char *file, int line, DBType type, DBOptions options, unsi
  */
 DBKey db_i2key(int key)
 {
-	DBKey ret;
+    DBKey ret;
 
-	DB_COUNTSTAT(db_i2key);
-	ret.i = key;
-	return ret;
+    DB_COUNTSTAT(db_i2key);
+    ret.i = key;
+    return ret;
 }
 
 /**
@@ -2482,11 +2504,11 @@ DBKey db_i2key(int key)
  */
 DBKey db_ui2key(unsigned int key)
 {
-	DBKey ret;
+    DBKey ret;
 
-	DB_COUNTSTAT(db_ui2key);
-	ret.ui = key;
-	return ret;
+    DB_COUNTSTAT(db_ui2key);
+    ret.ui = key;
+    return ret;
 }
 
 /**
@@ -2497,11 +2519,11 @@ DBKey db_ui2key(unsigned int key)
  */
 DBKey db_str2key(const char *key)
 {
-	DBKey ret;
+    DBKey ret;
 
-	DB_COUNTSTAT(db_str2key);
-	ret.str = key;
-	return ret;
+    DB_COUNTSTAT(db_str2key);
+    ret.str = key;
+    return ret;
 }
 
 /**
@@ -2512,12 +2534,12 @@ DBKey db_str2key(const char *key)
  */
 DBData db_i2data(int data)
 {
-	DBData ret;
+    DBData ret;
 
-	DB_COUNTSTAT(db_i2data);
-	ret.type = DB_DATA_INT;
-	ret.u.i = data;
-	return ret;
+    DB_COUNTSTAT(db_i2data);
+    ret.type = DB_DATA_INT;
+    ret.u.i = data;
+    return ret;
 }
 
 /**
@@ -2528,12 +2550,12 @@ DBData db_i2data(int data)
  */
 DBData db_ui2data(unsigned int data)
 {
-	DBData ret;
+    DBData ret;
 
-	DB_COUNTSTAT(db_ui2data);
-	ret.type = DB_DATA_UINT;
-	ret.u.ui = data;
-	return ret;
+    DB_COUNTSTAT(db_ui2data);
+    ret.type = DB_DATA_UINT;
+    ret.u.ui = data;
+    return ret;
 }
 
 /**
@@ -2544,12 +2566,12 @@ DBData db_ui2data(unsigned int data)
  */
 DBData db_ptr2data(void *data)
 {
-	DBData ret;
+    DBData ret;
 
-	DB_COUNTSTAT(db_ptr2data);
-	ret.type = DB_DATA_PTR;
-	ret.u.ptr = data;
-	return ret;
+    DB_COUNTSTAT(db_ptr2data);
+    ret.type = DB_DATA_PTR;
+    ret.u.ptr = data;
+    return ret;
 }
 
 /**
@@ -2561,10 +2583,10 @@ DBData db_ptr2data(void *data)
  */
 int db_data2i(DBData *data)
 {
-	DB_COUNTSTAT(db_data2i);
-	if (data && DB_DATA_INT == data->type)
-		return data->u.i;
-	return 0;
+    DB_COUNTSTAT(db_data2i);
+    if (data && DB_DATA_INT == data->type)
+        return data->u.i;
+    return 0;
 }
 
 /**
@@ -2576,10 +2598,10 @@ int db_data2i(DBData *data)
  */
 unsigned int db_data2ui(DBData *data)
 {
-	DB_COUNTSTAT(db_data2ui);
-	if (data && DB_DATA_UINT == data->type)
-		return data->u.ui;
-	return 0;
+    DB_COUNTSTAT(db_data2ui);
+    if (data && DB_DATA_UINT == data->type)
+        return data->u.ui;
+    return 0;
 }
 
 /**
@@ -2589,12 +2611,12 @@ unsigned int db_data2ui(DBData *data)
  * @return Void* value of the data.
  * @public
  */
-void* db_data2ptr(DBData *data)
+void *db_data2ptr(DBData *data)
 {
-	DB_COUNTSTAT(db_data2ptr);
-	if (data && DB_DATA_PTR == data->type)
-		return data->u.ptr;
-	return NULL;
+    DB_COUNTSTAT(db_data2ptr);
+    if (data && DB_DATA_PTR == data->type)
+        return data->u.ptr;
+    return NULL;
 }
 
 /**
@@ -2604,7 +2626,7 @@ void* db_data2ptr(DBData *data)
  */
 void db_init(void)
 {
-	DB_COUNTSTAT(db_init);
+    DB_COUNTSTAT(db_init);
 }
 
 /**
@@ -2615,208 +2637,208 @@ void db_init(void)
 void db_final(void)
 {
 #ifdef DB_ENABLE_STATS
-	DB_COUNTSTAT(db_final);
-	ShowInfo(CL_WHITE"Database nodes"CL_RESET":\n"
-			"allocated %u, freed %u\n",
-			stats.db_node_alloc, stats.db_node_free);
-	ShowInfo(CL_WHITE"Database types"CL_RESET":\n"
-			"DB_INT     : allocated %10u, destroyed %10u\n"
-			"DB_UINT    : allocated %10u, destroyed %10u\n"
-			"DB_STRING  : allocated %10u, destroyed %10u\n"
-			"DB_ISTRING : allocated %10u, destroyed %10u\n",
-			stats.db_int_alloc,     stats.db_int_destroy,
-			stats.db_uint_alloc,    stats.db_uint_destroy,
-			stats.db_string_alloc,  stats.db_string_destroy,
-			stats.db_istring_alloc, stats.db_istring_destroy);
-	ShowInfo(CL_WHITE"Database function counters"CL_RESET":\n"
-			"db_rotate_left     %10u, db_rotate_right    %10u,\n"
-			"db_rebalance       %10u, db_rebalance_erase %10u,\n"
-			"db_is_key_null     %10u,\n"
-			"db_dup_key         %10u, db_dup_key_free    %10u,\n"
-			"db_free_add        %10u, db_free_remove     %10u,\n"
-			"db_free_lock       %10u, db_free_unlock     %10u,\n"
-			"db_int_cmp         %10u, db_uint_cmp        %10u,\n"
-			"db_string_cmp      %10u, db_istring_cmp     %10u,\n"
-			"db_int_hash        %10u, db_uint_hash       %10u,\n"
-			"db_string_hash     %10u, db_istring_hash    %10u,\n"
-			"db_release_nothing %10u, db_release_key     %10u,\n"
-			"db_release_data    %10u, db_release_both    %10u,\n"
-			"dbit_first         %10u, dbit_last          %10u,\n"
-			"dbit_next          %10u, dbit_prev          %10u,\n"
-			"dbit_exists        %10u, dbit_remove        %10u,\n"
-			"dbit_destroy       %10u, db_iterator        %10u,\n"
-			"db_exits           %10u, db_get             %10u,\n"
-			"db_getall          %10u, db_vgetall         %10u,\n"
-			"db_ensure          %10u, db_vensure         %10u,\n"
-			"db_put             %10u, db_remove          %10u,\n"
-			"db_foreach         %10u, db_vforeach        %10u,\n"
-			"db_clear           %10u, db_vclear          %10u,\n"
-			"db_destroy         %10u, db_vdestroy        %10u,\n"
-			"db_size            %10u, db_type            %10u,\n"
-			"db_options         %10u, db_fix_options     %10u,\n"
-			"db_default_cmp     %10u, db_default_hash    %10u,\n"
-			"db_default_release %10u, db_custom_release  %10u,\n"
-			"db_alloc           %10u, db_i2key           %10u,\n"
-			"db_ui2key          %10u, db_str2key         %10u,\n"
-			"db_i2data          %10u, db_ui2data         %10u,\n"
-			"db_ptr2data        %10u, db_data2i          %10u,\n"
-			"db_data2ui         %10u, db_data2ptr        %10u,\n"
-			"db_init            %10u, db_final           %10u\n",
-			stats.db_rotate_left,     stats.db_rotate_right,
-			stats.db_rebalance,       stats.db_rebalance_erase,
-			stats.db_is_key_null,
-			stats.db_dup_key,         stats.db_dup_key_free,
-			stats.db_free_add,        stats.db_free_remove,
-			stats.db_free_lock,       stats.db_free_unlock,
-			stats.db_int_cmp,         stats.db_uint_cmp,
-			stats.db_string_cmp,      stats.db_istring_cmp,
-			stats.db_int_hash,        stats.db_uint_hash,
-			stats.db_string_hash,     stats.db_istring_hash,
-			stats.db_release_nothing, stats.db_release_key,
-			stats.db_release_data,    stats.db_release_both,
-			stats.dbit_first,         stats.dbit_last,
-			stats.dbit_next,          stats.dbit_prev,
-			stats.dbit_exists,        stats.dbit_remove,
-			stats.dbit_destroy,       stats.db_iterator,
-			stats.db_exists,          stats.db_get,
-			stats.db_getall,          stats.db_vgetall,
-			stats.db_ensure,          stats.db_vensure,
-			stats.db_put,             stats.db_remove,
-			stats.db_foreach,         stats.db_vforeach,
-			stats.db_clear,           stats.db_vclear,
-			stats.db_destroy,         stats.db_vdestroy,
-			stats.db_size,            stats.db_type,
-			stats.db_options,         stats.db_fix_options,
-			stats.db_default_cmp,     stats.db_default_hash,
-			stats.db_default_release, stats.db_custom_release,
-			stats.db_alloc,           stats.db_i2key,
-			stats.db_ui2key,          stats.db_str2key,
-			stats.db_i2data,          stats.db_ui2data,
-			stats.db_ptr2data,        stats.db_data2i,
-			stats.db_data2ui,         stats.db_data2ptr,
-			stats.db_init,            stats.db_final);
+    DB_COUNTSTAT(db_final);
+    ShowInfo(CL_WHITE"Database nodes"CL_RESET":\n"
+             "allocated %u, freed %u\n",
+             stats.db_node_alloc, stats.db_node_free);
+    ShowInfo(CL_WHITE"Database types"CL_RESET":\n"
+             "DB_INT     : allocated %10u, destroyed %10u\n"
+             "DB_UINT    : allocated %10u, destroyed %10u\n"
+             "DB_STRING  : allocated %10u, destroyed %10u\n"
+             "DB_ISTRING : allocated %10u, destroyed %10u\n",
+             stats.db_int_alloc,     stats.db_int_destroy,
+             stats.db_uint_alloc,    stats.db_uint_destroy,
+             stats.db_string_alloc,  stats.db_string_destroy,
+             stats.db_istring_alloc, stats.db_istring_destroy);
+    ShowInfo(CL_WHITE"Database function counters"CL_RESET":\n"
+             "db_rotate_left     %10u, db_rotate_right    %10u,\n"
+             "db_rebalance       %10u, db_rebalance_erase %10u,\n"
+             "db_is_key_null     %10u,\n"
+             "db_dup_key         %10u, db_dup_key_free    %10u,\n"
+             "db_free_add        %10u, db_free_remove     %10u,\n"
+             "db_free_lock       %10u, db_free_unlock     %10u,\n"
+             "db_int_cmp         %10u, db_uint_cmp        %10u,\n"
+             "db_string_cmp      %10u, db_istring_cmp     %10u,\n"
+             "db_int_hash        %10u, db_uint_hash       %10u,\n"
+             "db_string_hash     %10u, db_istring_hash    %10u,\n"
+             "db_release_nothing %10u, db_release_key     %10u,\n"
+             "db_release_data    %10u, db_release_both    %10u,\n"
+             "dbit_first         %10u, dbit_last          %10u,\n"
+             "dbit_next          %10u, dbit_prev          %10u,\n"
+             "dbit_exists        %10u, dbit_remove        %10u,\n"
+             "dbit_destroy       %10u, db_iterator        %10u,\n"
+             "db_exits           %10u, db_get             %10u,\n"
+             "db_getall          %10u, db_vgetall         %10u,\n"
+             "db_ensure          %10u, db_vensure         %10u,\n"
+             "db_put             %10u, db_remove          %10u,\n"
+             "db_foreach         %10u, db_vforeach        %10u,\n"
+             "db_clear           %10u, db_vclear          %10u,\n"
+             "db_destroy         %10u, db_vdestroy        %10u,\n"
+             "db_size            %10u, db_type            %10u,\n"
+             "db_options         %10u, db_fix_options     %10u,\n"
+             "db_default_cmp     %10u, db_default_hash    %10u,\n"
+             "db_default_release %10u, db_custom_release  %10u,\n"
+             "db_alloc           %10u, db_i2key           %10u,\n"
+             "db_ui2key          %10u, db_str2key         %10u,\n"
+             "db_i2data          %10u, db_ui2data         %10u,\n"
+             "db_ptr2data        %10u, db_data2i          %10u,\n"
+             "db_data2ui         %10u, db_data2ptr        %10u,\n"
+             "db_init            %10u, db_final           %10u\n",
+             stats.db_rotate_left,     stats.db_rotate_right,
+             stats.db_rebalance,       stats.db_rebalance_erase,
+             stats.db_is_key_null,
+             stats.db_dup_key,         stats.db_dup_key_free,
+             stats.db_free_add,        stats.db_free_remove,
+             stats.db_free_lock,       stats.db_free_unlock,
+             stats.db_int_cmp,         stats.db_uint_cmp,
+             stats.db_string_cmp,      stats.db_istring_cmp,
+             stats.db_int_hash,        stats.db_uint_hash,
+             stats.db_string_hash,     stats.db_istring_hash,
+             stats.db_release_nothing, stats.db_release_key,
+             stats.db_release_data,    stats.db_release_both,
+             stats.dbit_first,         stats.dbit_last,
+             stats.dbit_next,          stats.dbit_prev,
+             stats.dbit_exists,        stats.dbit_remove,
+             stats.dbit_destroy,       stats.db_iterator,
+             stats.db_exists,          stats.db_get,
+             stats.db_getall,          stats.db_vgetall,
+             stats.db_ensure,          stats.db_vensure,
+             stats.db_put,             stats.db_remove,
+             stats.db_foreach,         stats.db_vforeach,
+             stats.db_clear,           stats.db_vclear,
+             stats.db_destroy,         stats.db_vdestroy,
+             stats.db_size,            stats.db_type,
+             stats.db_options,         stats.db_fix_options,
+             stats.db_default_cmp,     stats.db_default_hash,
+             stats.db_default_release, stats.db_custom_release,
+             stats.db_alloc,           stats.db_i2key,
+             stats.db_ui2key,          stats.db_str2key,
+             stats.db_i2data,          stats.db_ui2data,
+             stats.db_ptr2data,        stats.db_data2i,
+             stats.db_data2ui,         stats.db_data2ptr,
+             stats.db_init,            stats.db_final);
 #endif /* DB_ENABLE_STATS */
 }
 
 // Link DB System - jAthena
-void linkdb_insert( struct linkdb_node** head, void *key, void* data)
-{
-	struct linkdb_node *node;
-	if( head == NULL ) return ;
-	node = (struct linkdb_node*)aMalloc( sizeof(struct linkdb_node) );
-	if( *head == NULL ) {
-		// first node
-		*head      = node;
-		node->prev = NULL;
-		node->next = NULL;
-	} else {
-		// link nodes
-		node->next    = *head;
-		node->prev    = (*head)->prev;
-		(*head)->prev = node;
-		(*head)       = node;
-	}
-	node->key  = key;
-	node->data = data;
-}
-
-void linkdb_foreach( struct linkdb_node** head, LinkDBFunc func, ...  )
-{
-	struct linkdb_node *node;
-	if( head == NULL ) return;
-	node = *head;
-	while ( node ) {
-		va_list args;
-		va_start(args, func);
-		func( node->key, node->data, args );
-		va_end(args);
-		node = node->next;
-	}
-}
-
-void* linkdb_search( struct linkdb_node** head, void *key)
-{
-	int n = 0;
-	struct linkdb_node *node;
-	if( head == NULL ) return NULL;
-	node = *head;
-	while( node ) {
-		if( node->key == key ) {
-			if( node->prev && n > 5 ) {
-				//Moving the head in order to improve processing efficiency
-				if(node->prev) node->prev->next = node->next;
-				if(node->next) node->next->prev = node->prev;
-				node->next = *head;
-				node->prev = (*head)->prev;
-				(*head)->prev = node;
-				(*head)       = node;
-			}
-			return node->data;
-		}
-		node = node->next;
-		n++;
-	}
-	return NULL;
-}
-
-void* linkdb_erase( struct linkdb_node** head, void *key)
-{
-	struct linkdb_node *node;
-	if( head == NULL ) return NULL;
-	node = *head;
-	while( node ) {
-		if( node->key == key ) {
-			void *data = node->data;
-			if( node->prev == NULL )
-				*head = node->next;
-			else
-				node->prev->next = node->next;
-			if( node->next )
-				node->next->prev = node->prev;
-			aFree( node );
-			return data;
-		}
-		node = node->next;
-	}
-	return NULL;
-}
-
-void linkdb_replace( struct linkdb_node** head, void *key, void *data )
-{
-	int n = 0;
-	struct linkdb_node *node;
-	if( head == NULL ) return ;
-	node = *head;
-	while( node ) {
-		if( node->key == key ) {
-			if( node->prev && n > 5 ) {
-				//Moving the head in order to improve processing efficiency
-				if(node->prev) node->prev->next = node->next;
-				if(node->next) node->next->prev = node->prev;
-				node->next = *head;
-				node->prev = (*head)->prev;
-				(*head)->prev = node;
-				(*head)       = node;
-			}
-			node->data = data;
-			return ;
-		}
-		node = node->next;
-		n++;
-	}
-	//Insert because it can not find
-	linkdb_insert( head, key, data );
-}
-
-void linkdb_final( struct linkdb_node** head )
-{
-	struct linkdb_node *node, *node2;
-	if( head == NULL ) return ;
-	node = *head;
-	while( node ) {
-		node2 = node->next;
-		aFree( node );
-		node = node2;
-	}
-	*head = NULL;
+void linkdb_insert(struct linkdb_node **head, void *key, void *data)
+{
+    struct linkdb_node *node;
+    if (head == NULL) return ;
+    node = (struct linkdb_node *)aMalloc(sizeof(struct linkdb_node));
+    if (*head == NULL) {
+        // first node
+        *head      = node;
+        node->prev = NULL;
+        node->next = NULL;
+    } else {
+        // link nodes
+        node->next    = *head;
+        node->prev    = (*head)->prev;
+        (*head)->prev = node;
+        (*head)       = node;
+    }
+    node->key  = key;
+    node->data = data;
+}
+
+void linkdb_foreach(struct linkdb_node **head, LinkDBFunc func, ...)
+{
+    struct linkdb_node *node;
+    if (head == NULL) return;
+    node = *head;
+    while (node) {
+        va_list args;
+        va_start(args, func);
+        func(node->key, node->data, args);
+        va_end(args);
+        node = node->next;
+    }
+}
+
+void *linkdb_search(struct linkdb_node **head, void *key)
+{
+    int n = 0;
+    struct linkdb_node *node;
+    if (head == NULL) return NULL;
+    node = *head;
+    while (node) {
+        if (node->key == key) {
+            if (node->prev && n > 5) {
+                //Moving the head in order to improve processing efficiency
+                if (node->prev) node->prev->next = node->next;
+                if (node->next) node->next->prev = node->prev;
+                node->next = *head;
+                node->prev = (*head)->prev;
+                (*head)->prev = node;
+                (*head)       = node;
+            }
+            return node->data;
+        }
+        node = node->next;
+        n++;
+    }
+    return NULL;
+}
+
+void *linkdb_erase(struct linkdb_node **head, void *key)
+{
+    struct linkdb_node *node;
+    if (head == NULL) return NULL;
+    node = *head;
+    while (node) {
+        if (node->key == key) {
+            void *data = node->data;
+            if (node->prev == NULL)
+                *head = node->next;
+            else
+                node->prev->next = node->next;
+            if (node->next)
+                node->next->prev = node->prev;
+            aFree(node);
+            return data;
+        }
+        node = node->next;
+    }
+    return NULL;
+}
+
+void linkdb_replace(struct linkdb_node **head, void *key, void *data)
+{
+    int n = 0;
+    struct linkdb_node *node;
+    if (head == NULL) return ;
+    node = *head;
+    while (node) {
+        if (node->key == key) {
+            if (node->prev && n > 5) {
+                //Moving the head in order to improve processing efficiency
+                if (node->prev) node->prev->next = node->next;
+                if (node->next) node->next->prev = node->prev;
+                node->next = *head;
+                node->prev = (*head)->prev;
+                (*head)->prev = node;
+                (*head)       = node;
+            }
+            node->data = data;
+            return ;
+        }
+        node = node->next;
+        n++;
+    }
+    //Insert because it can not find
+    linkdb_insert(head, key, data);
+}
+
+void linkdb_final(struct linkdb_node **head)
+{
+    struct linkdb_node *node, *node2;
+    if (head == NULL) return ;
+    node = *head;
+    while (node) {
+        node2 = node->next;
+        aFree(node);
+        node = node2;
+    }
+    *head = NULL;
 }