Some formatting fixes before I go insane

Also delete the French translation from ladmin.

21 files changed, 409 insertions, 409 deletions

diff --git a/src/common/core.cpp b/src/common/core.cpp
index db26e31..9d1d8e7 100644
--- a/src/common/core.cpp
+++ b/src/common/core.cpp
@@ -17,13 +17,13 @@
 // (sigaction() is POSIX; signal() is not.)  Taken from Stevens' _Advanced
 // Programming in the UNIX Environment_.
 //
-typedef void (*sigfunc)(int);
-static sigfunc compat_signal (int signo, sigfunc func)
+typedef void(*sigfunc)(int);
+static sigfunc compat_signal(int signo, sigfunc func)
 {
     struct sigaction sact, oact;
 
     sact.sa_handler = func;
-    sigfillset (&sact.sa_mask);
+    sigfillset(&sact.sa_mask);
     sigdelset(&sact.sa_mask, SIGSEGV);
     sigdelset(&sact.sa_mask, SIGBUS);
     sigdelset(&sact.sa_mask, SIGTRAP);
@@ -31,22 +31,22 @@ static sigfunc compat_signal (int signo, sigfunc func)
     sigdelset(&sact.sa_mask, SIGFPE);
     sact.sa_flags = 0;
 
-    if (sigaction (signo, &sact, &oact) < 0)
+    if (sigaction(signo, &sact, &oact) < 0)
         return SIG_ERR;
 
     return oact.sa_handler;
 }
 
-static void chld_proc (int UNUSED)
+static void chld_proc(int UNUSED)
 {
     wait(NULL);
 }
-static void sig_proc (int UNUSED)
+static void sig_proc(int UNUSED)
 {
     for (int i = 1; i < 31; ++i)
         compat_signal(i, SIG_IGN);
-    term_func ();
-    _exit (0);
+    term_func();
+    _exit(0);
 }
 
 bool runflag = true;
@@ -60,34 +60,34 @@ bool runflag = true;
     Unless you use SA_SIGINFO and *carefully* check the origin,
     that means they must be SIG_DFL.
  */
-int main (int argc, char **argv)
+int main(int argc, char **argv)
 {
     /// Note that getpid() and getppid() may be very close
-    mt_seed (time (NULL) ^ (getpid () << 16) ^ (getppid () << 8));
+    mt_seed(time(NULL) ^ (getpid() << 16) ^ (getppid() << 8));
 
-    do_socket ();
+    do_socket();
 
-    do_init (argc, argv);
+    do_init(argc, argv);
     // set up exit handlers *after* the initialization has happened.
     // This is because term_func is likely to depend on successful init.
 
-    compat_signal (SIGPIPE, SIG_IGN);
-    compat_signal (SIGTERM, sig_proc);
-    compat_signal (SIGINT, sig_proc);
-    compat_signal (SIGCHLD, chld_proc);
+    compat_signal(SIGPIPE, SIG_IGN);
+    compat_signal(SIGTERM, sig_proc);
+    compat_signal(SIGINT, sig_proc);
+    compat_signal(SIGCHLD, chld_proc);
 
     // Signal to create coredumps by system when necessary (crash)
-    compat_signal (SIGSEGV, SIG_DFL);
-    compat_signal (SIGBUS, SIG_DFL);
-    compat_signal (SIGTRAP, SIG_DFL);
-    compat_signal (SIGILL, SIG_DFL);
-    compat_signal (SIGFPE, SIG_DFL);
+    compat_signal(SIGSEGV, SIG_DFL);
+    compat_signal(SIGBUS, SIG_DFL);
+    compat_signal(SIGTRAP, SIG_DFL);
+    compat_signal(SIGILL, SIG_DFL);
+    compat_signal(SIGFPE, SIG_DFL);
 
-    atexit (term_func);
+    atexit(term_func);
 
     while (runflag)
     {
-        do_sendrecv (do_timer (gettick_nocache ()));
-        do_parsepacket ();
+        do_sendrecv(do_timer(gettick_nocache()));
+        do_parsepacket();
     }
 }
diff --git a/src/common/core.hpp b/src/common/core.hpp
index 8a52c55..14dc61d 100644
--- a/src/common/core.hpp
+++ b/src/common/core.hpp
@@ -10,10 +10,10 @@ extern bool runflag;
 
 /// This is an external function defined by each server
 /// This function must register stuff for the parse loop
-extern int  do_init (int, char **);
+extern int do_init(int, char **);
 
 /// Cleanup function called whenever a signal kills us
 /// or when if we manage to exit() gracefully.
-extern void term_func (void);
+extern void term_func(void);
 
 #endif // CORE_HPP
diff --git a/src/common/db.cpp b/src/common/db.cpp
index 21a3597..e04b7d0 100644
--- a/src/common/db.cpp
+++ b/src/common/db.cpp
@@ -8,14 +8,14 @@
 
 #define ROOT_SIZE 4096
 
-static int strdb_cmp (struct dbt *table, const char *a, const char* b)
+static int strdb_cmp(struct dbt *table, const char *a, const char* b)
 {
     if (table->maxlen)
-        return strncmp (a, b, table->maxlen);
-    return strcmp (a, b);
+        return strncmp(a, b, table->maxlen);
+    return strcmp(a, b);
 }
 
-static hash_t strdb_hash (struct dbt *table, const char *a)
+static hash_t strdb_hash(struct dbt *table, const char *a)
 {
     size_t i = table->maxlen;
     if (i == 0)
@@ -29,16 +29,16 @@ static hash_t strdb_hash (struct dbt *table, const char *a)
     return h;
 }
 
-struct dbt *strdb_init (size_t maxlen)
+struct dbt *strdb_init(size_t maxlen)
 {
     struct dbt *table;
-    CREATE (table, struct dbt, 1);
+    CREATE(table, struct dbt, 1);
     table->type = DB_STRING;
     table->maxlen = maxlen;
     return table;
 }
 
-static int numdb_cmp (numdb_key_t a, numdb_key_t b)
+static int numdb_cmp(numdb_key_t a, numdb_key_t b)
 {
     if (a == b)
         return 0;
@@ -47,47 +47,47 @@ static int numdb_cmp (numdb_key_t a, numdb_key_t b)
     return 1;
 }
 
-static hash_t numdb_hash (numdb_key_t a)
+static hash_t numdb_hash(numdb_key_t a)
 {
     return (hash_t) a;
 }
 
-struct dbt *numdb_init (void)
+struct dbt *numdb_init(void)
 {
     struct dbt *table;
-    CREATE (table, struct dbt, 1);
+    CREATE(table, struct dbt, 1);
     table->type = DB_NUMBER;
     return table;
 }
 
-static int table_cmp (struct dbt *table, db_key_t a, db_key_t b)
+static int table_cmp(struct dbt *table, db_key_t a, db_key_t b)
 {
-    switch(table->type)
+    switch (table->type)
     {
-    case DB_NUMBER: return numdb_cmp (a.i, b.i);
-    case DB_STRING: return strdb_cmp (table, a.s, b.s);
+    case DB_NUMBER: return numdb_cmp(a.i, b.i);
+    case DB_STRING: return strdb_cmp(table, a.s, b.s);
     }
     abort();
 }
 
-static hash_t table_hash (struct dbt *table, db_key_t key)
+static hash_t table_hash(struct dbt *table, db_key_t key)
 {
-    switch(table->type)
+    switch (table->type)
     {
-    case DB_NUMBER: return numdb_hash (key.i);
-    case DB_STRING: return strdb_hash (table, key.s);
+    case DB_NUMBER: return numdb_hash(key.i);
+    case DB_STRING: return strdb_hash(table, key.s);
     }
     abort();
 }
 
 /// Search for a node with the given key
-db_val_t db_search (struct dbt *table, db_key_t key)
+db_val_t db_search(struct dbt *table, db_key_t key)
 {
-    struct dbn *p = table->ht[table_hash (table, key) % HASH_SIZE];
+    struct dbn *p = table->ht[table_hash(table, key) % HASH_SIZE];
 
     while (p)
     {
-        int  c = table_cmp (table, key, p->key);
+        int c = table_cmp(table, key, p->key);
         if (c == 0)
             return p->data;
         if (c < 0)
@@ -99,7 +99,7 @@ db_val_t db_search (struct dbt *table, db_key_t key)
 }
 
 // Tree maintainance methods
-static void db_rotate_left (struct dbn *p, struct dbn **root)
+static void db_rotate_left(struct dbn *p, struct dbn **root)
 {
     struct dbn *y = p->right;
     p->right = y->left;
@@ -117,7 +117,7 @@ static void db_rotate_left (struct dbn *p, struct dbn **root)
     p->parent = y;
 }
 
-static void db_rotate_right (struct dbn *p, struct dbn **root)
+static void db_rotate_right(struct dbn *p, struct dbn **root)
 {
     struct dbn *y = p->left;
     p->left = y->right;
@@ -135,7 +135,7 @@ static void db_rotate_right (struct dbn *p, struct dbn **root)
     p->parent = y;
 }
 
-static void db_rebalance (struct dbn *p, struct dbn **root)
+static void db_rebalance(struct dbn *p, struct dbn **root)
 {
     p->color = RED;
     while (p != *root && p->parent->color == RED)
@@ -155,11 +155,11 @@ static void db_rebalance (struct dbn *p, struct dbn **root)
                 if (p == p->parent->right)
                 {
                     p = p->parent;
-                    db_rotate_left (p, root);
+                    db_rotate_left(p, root);
                 }
                 p->parent->color = BLACK;
                 p->parent->parent->color = RED;
-                db_rotate_right (p->parent->parent, root);
+                db_rotate_right(p->parent->parent, root);
             }
         }
         else
@@ -177,11 +177,11 @@ static void db_rebalance (struct dbn *p, struct dbn **root)
                 if (p == p->parent->left)
                 {
                     p = p->parent;
-                    db_rotate_right (p, root);
+                    db_rotate_right(p, root);
                 }
                 p->parent->color = BLACK;
                 p->parent->parent->color = RED;
-                db_rotate_left (p->parent->parent, root);
+                db_rotate_left(p->parent->parent, root);
             }
         }
     }
@@ -189,7 +189,7 @@ static void db_rebalance (struct dbn *p, struct dbn **root)
 }
 
 // param z = node to remove
-static void db_rebalance_erase (struct dbn *z, struct dbn **root)
+static void db_rebalance_erase(struct dbn *z, struct dbn **root)
 {
     struct dbn *y = z;
     struct dbn *x = NULL;
@@ -257,7 +257,7 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root)
                 {
                     w->color = BLACK;
                     x_parent->color = RED;
-                    db_rotate_left (x_parent, root);
+                    db_rotate_left(x_parent, root);
                     w = x_parent->right;
                 }
                 if ((!w->left || w->left->color == BLACK) &&
@@ -274,14 +274,14 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root)
                         if (w->left)
                             w->left->color = BLACK;
                         w->color = RED;
-                        db_rotate_right (w, root);
+                        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);
+                    db_rotate_left(x_parent, root);
                     break;
                 }
             }
@@ -293,7 +293,7 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root)
                 {
                     w->color = BLACK;
                     x_parent->color = RED;
-                    db_rotate_right (x_parent, root);
+                    db_rotate_right(x_parent, root);
                     w = x_parent->left;
                 }
                 if ((!w->right || w->right->color == BLACK) &&
@@ -310,14 +310,14 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root)
                         if (w->right)
                             w->right->color = BLACK;
                         w->color = RED;
-                        db_rotate_left (w, root);
+                        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);
+                    db_rotate_right(x_parent, root);
                     break;
                 }
             }
@@ -326,21 +326,21 @@ static void db_rebalance_erase (struct dbn *z, struct dbn **root)
     }
 }
 
-struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data)
+struct dbn *db_insert(struct dbt *table, db_key_t key, db_val_t data)
 {
-    hash_t hash = table_hash (table, key) % HASH_SIZE;
+    hash_t hash = table_hash(table, key) % HASH_SIZE;
     int c = 0;
     struct dbn *prev = NULL;
     struct dbn *p = table->ht[hash];
     while (p)
     {
-        c = table_cmp (table, key, p->key);
+        c = table_cmp(table, key, p->key);
         if (c == 0)
         {
             // key found in table, replace
             // Tell the user of the table to free the key and value
             if (table->release)
-                table->release (p->key, p->data);
+                table->release(p->key, p->data);
             p->data = data;
             p->key = key;
             return p;
@@ -352,7 +352,7 @@ struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data)
         else
             p = p->right;
     }
-    CREATE (p, struct dbn, 1);
+    CREATE(p, struct dbn, 1);
     p->key = key;
     p->data = data;
     p->color = RED;
@@ -370,18 +370,18 @@ struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data)
     if (prev->color == RED)
     {
         // must rebalance
-        db_rebalance (p, &table->ht[hash]);
+        db_rebalance(p, &table->ht[hash]);
     }
     return p;
 }
 
-db_val_t db_erase (struct dbt *table, db_key_t key)
+db_val_t db_erase(struct dbt *table, db_key_t key)
 {
-    hash_t hash = table_hash (table, key) % HASH_SIZE;
+    hash_t hash = table_hash(table, key) % HASH_SIZE;
     struct dbn *p = table->ht[hash];
     while (p)
     {
-        int c = table_cmp (table, key, p->key);
+        int c = table_cmp(table, key, p->key);
         if (c == 0)
             break;
         if (c < 0)
@@ -392,12 +392,12 @@ db_val_t db_erase (struct dbt *table, db_key_t key)
     if (!p)
         return NULL;
     db_val_t data = p->data;
-    db_rebalance_erase (p, &table->ht[hash]);
-    free (p);
+    db_rebalance_erase(p, &table->ht[hash]);
+    free(p);
     return data;
 }
 #ifdef SMART_WALK_TREE
-static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va_list ap)
+static inline void db_walk_tree(bool dealloc, struct dbn* p, db_func_t func, va_list ap)
 {
     if (!p)
         return;
@@ -415,7 +415,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va
     {
         // apply_func loop
         if (func)
-            func (p->key, p->data, ap);
+            func(p->key, p->data, ap);
         if (p->left)
         {
             // continue descending
@@ -434,7 +434,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va
             if (!p->parent)
             {
                 if (dealloc)
-                    free (p);
+                    free(p);
                 // if we have already done both children, there is no more to do
                 return;
             }
@@ -443,7 +443,7 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va
                 // finished the left tree, now walk the right tree
                 p = p->parent->right;
                 if (dealloc)
-                    free (p->parent->left);
+                    free(p->parent->left);
                 break; //goto apply_func;
             }
             // p->parent->right == p
@@ -451,21 +451,21 @@ static inline void db_walk_tree (bool dealloc, struct dbn* p, db_func_t func, va
             // keep backtracking
             p = p->parent;
             if (dealloc)
-                free (p->right?:p->left);
+                free(p->right?:p->left);
         } //backtrack loop
     } // apply_func loop
 }
 #endif // SMART_WALK_TREE
 
-void db_foreach (struct dbt *table, db_func_t func, ...)
+void db_foreach(struct dbt *table, db_func_t func, ...)
 {
     va_list ap;
-    va_start (ap, func);
+    va_start(ap, func);
 
     for (int i = 0; i < HASH_SIZE; i++)
     {
 #ifdef SMART_WALK_TREE
-        db_walk_tree (false, table->ht[i], func, ap);
+        db_walk_tree(false, table->ht[i], func, ap);
 #else
         struct dbn *p = table->ht[i];
         if (!p)
@@ -474,7 +474,7 @@ void db_foreach (struct dbt *table, db_func_t func, ...)
         int sp = 0;
         while (1)
         {
-            func (p->key, p->data, ap);
+            func(p->key, p->data, ap);
             struct dbn *pn = p->left;
             if (pn)
             {
@@ -496,19 +496,19 @@ void db_foreach (struct dbt *table, db_func_t func, ...)
         } // while true
 #endif // else ! SMART_WALK_TREE
     } // for i
-    va_end (ap);
+    va_end(ap);
 }
 
 // This function is suspiciously similar to the previous
-void db_final (struct dbt *table, db_func_t func, ...)
+void db_final(struct dbt *table, db_func_t func, ...)
 {
     va_list ap;
-    va_start (ap, func);
+    va_start(ap, func);
 
     for (int i = 0; i < HASH_SIZE; i++)
     {
 #ifdef SMART_WALK_TREE
-        db_walk_tree (true, table->ht[i], func, ap);
+        db_walk_tree(true, table->ht[i], func, ap);
 #else
         struct dbn *p = table->ht[i];
         if (!p)
@@ -518,7 +518,7 @@ void db_final (struct dbt *table, db_func_t func, ...)
         while (1)
         {
             if (func)
-                func (p->key, p->data, ap);
+                func(p->key, p->data, ap);
             struct dbn *pn = p->left;
             if (pn)
             {
@@ -536,11 +536,11 @@ void db_final (struct dbt *table, db_func_t func, ...)
                     pn = stack[--sp];
                 }
             } // if pn else if !pn
-            free (p);
+            free(p);
             p = pn;
         } // while true
 #endif // else ! SMART_WALK_TREE
     } // for i
-    free (table);
-    va_end (ap);
+    free(table);
+    va_end(ap);
 }
diff --git a/src/common/db.hpp b/src/common/db.hpp
index 62125d8..313ba3a 100644
--- a/src/common/db.hpp
+++ b/src/common/db.hpp
@@ -28,7 +28,7 @@ typedef union db_key_t
 } db_key_t;
 typedef void* db_val_t;
 typedef uint32_t hash_t;
-typedef void (*db_func_t)(db_key_t, db_val_t, va_list);
+typedef void(*db_func_t)(db_key_t, db_val_t, va_list);
 
 /// DataBase Node
 struct dbn
@@ -51,40 +51,40 @@ struct dbt
     dbt_type type;
     /// Note, before replacement, key/values to be replaced
     // TODO refactor to decrease/eliminate the uses of this?
-    void (*release) (db_key_t, db_val_t) __attribute__((deprecated));
+    void(*release)(db_key_t, db_val_t) __attribute__((deprecated));
     /// Maximum length of a string key - TODO refactor to ensure all strings are NUL-terminated
     size_t maxlen __attribute__((deprecated));
     /// The root trees
     struct dbn *ht[HASH_SIZE];
 };
 
-# define strdb_search(t,k)   db_search((t),(db_key_t)(k))
-# define strdb_insert(t,k,d) db_insert((t),(db_key_t)(k),(db_val_t)(d))
-# define strdb_erase(t,k)    db_erase ((t),(db_key_t)(k))
+# define strdb_search(t,k)   db_search((t), (db_key_t)(k))
+# define strdb_insert(t,k,d) db_insert((t), (db_key_t)(k), (db_val_t)(d))
+# define strdb_erase(t,k)    db_erase((t), (db_key_t)(k))
 # define strdb_foreach       db_foreach
 # define strdb_final         db_final
-# define numdb_search(t,k)   db_search((t),(db_key_t)(k))
-# define numdb_insert(t,k,d) db_insert((t),(db_key_t)(k),(db_val_t)(d))
-# define numdb_erase(t,k)    db_erase ((t),(db_key_t)(k))
+# define numdb_search(t,k)   db_search((t), (db_key_t)(k))
+# define numdb_insert(t,k,d) db_insert((t), (db_key_t)(k), (db_val_t)(d))
+# define numdb_erase(t,k)    db_erase((t), (db_key_t)(k))
 # define numdb_foreach       db_foreach
 # define numdb_final         db_final
 
 /// Create a map from char* to void*, with strings possibly not null-terminated
-struct dbt *strdb_init (size_t maxlen);
+struct dbt *strdb_init(size_t maxlen);
 /// Create a map from int to void*
-struct dbt *numdb_init (void);
+struct dbt *numdb_init(void);
 /// Return the value corresponding to the key, or NULL if not found
-db_val_t db_search (struct dbt *table, db_key_t key);
+db_val_t db_search(struct dbt *table, db_key_t key);
 /// Add or replace table[key] = data
 // if it was already there, call release
-struct dbn *db_insert (struct dbt *table, db_key_t key, db_val_t data);
+struct dbn *db_insert(struct dbt *table, db_key_t key, db_val_t data);
 /// Remove a key from the table, returning the data
-db_val_t db_erase (struct dbt *table, db_key_t key);
+db_val_t db_erase(struct dbt *table, db_key_t key);
 
 /// Execute a function for every element, in unspecified order
-void db_foreach (struct dbt *, db_func_t, ...);
+void db_foreach(struct dbt *, db_func_t, ...);
 // opposite of init? Calls release for every element and frees memory
 // This probably isn't really needed: we don't have to free memory while exiting
-void db_final (struct dbt *, db_func_t, ...) __attribute__((deprecated));
+void db_final(struct dbt *, db_func_t, ...) __attribute__((deprecated));
 
 #endif
diff --git a/src/common/grfio.cpp b/src/common/grfio.cpp
index dd1e707..042de85 100644
--- a/src/common/grfio.cpp
+++ b/src/common/grfio.cpp
@@ -34,7 +34,7 @@ static int16_t filelist_hash[256] = {l,l,l,l,l,l,l,l,l,l,l,l,l,l,l,l};
 #undef l
 
 /// Hash a filename
-static uint8_t filehash (const char *fname)
+static uint8_t filehash(const char *fname)
 {
     // Larger than the return type - upper bits are used in the process
     uint32_t hash = 0;
@@ -48,12 +48,12 @@ static uint8_t filehash (const char *fname)
 
 /// Find the filelist entry for the given filename, or NULL if it is not
 static
-FILELIST *filelist_find (const char *fname)
+FILELIST *filelist_find(const char *fname)
 {
-    int16_t index = filelist_hash[filehash (fname)];
+    int16_t index = filelist_hash[filehash(fname)];
     while (index >= 0)
     {
-        if (strcmp (filelist[index].fn, fname) == 0)
+        if (strcmp(filelist[index].fn, fname) == 0)
             return &filelist[index];
         index = filelist[index].next;
     }
@@ -61,24 +61,24 @@ FILELIST *filelist_find (const char *fname)
 }
 
 /// Copy a temporary entry into the hash map
-static FILELIST *filelist_add (FILELIST * entry)
+static FILELIST *filelist_add(FILELIST * entry)
 {
     if (filelist_entrys >= FILELIST_LIMIT)
     {
-        fprintf (stderr, "filelist limit : filelist_add\n");
-        exit (1);
+        fprintf(stderr, "filelist limit : filelist_add\n");
+        exit(1);
     }
 
     if (filelist_entrys >= filelist_maxentry)
     {
         RECREATE(filelist, FILELIST, filelist_maxentry + FILELIST_ADDS);
-        memset (filelist + filelist_maxentry, '\0',
-                FILELIST_ADDS * sizeof (FILELIST));
+        memset(filelist + filelist_maxentry, '\0',
+                FILELIST_ADDS * sizeof(FILELIST));
         filelist_maxentry += FILELIST_ADDS;
     }
 
     uint16_t new_index = filelist_entrys++;
-    uint8_t hash = filehash (entry->fn);
+    uint8_t hash = filehash(entry->fn);
     entry->next = filelist_hash[hash];
     filelist_hash[hash] = new_index;
 
@@ -87,26 +87,26 @@ static FILELIST *filelist_add (FILELIST * entry)
     return &filelist[new_index];
 }
 
-static FILELIST *filelist_modify (FILELIST * entry)
+static FILELIST *filelist_modify(FILELIST * entry)
 {
-    FILELIST *fentry = filelist_find (entry->fn);
+    FILELIST *fentry = filelist_find(entry->fn);
     if (fentry)
     {
         entry->next = fentry->next;
         *fentry = *entry;
         return fentry;
     }
-    return filelist_add (entry);
+    return filelist_add(entry);
 }
 
 /// Change fname data/*.gat to lfname data/*.wlk
 // TODO even if the file exists, don't keep reopening it every time one loads
 static
-void grfio_resnametable (const char *fname, char *lfname)
+void grfio_resnametable(const char *fname, char *lfname)
 {
     char restable[] = "data/resnametable.txt";
 
-    FILE *fp = fopen_ (restable, "rb");
+    FILE *fp = fopen_(restable, "rb");
     if (fp == NULL)
     {
         fprintf(stderr, "No resnametable, can't look for %s\n", fname);
@@ -118,23 +118,23 @@ void grfio_resnametable (const char *fname, char *lfname)
     }
 
     char line[512];
-    while (fgets (line, sizeof (line), fp))
+    while (fgets(line, sizeof(line), fp))
     {
         char w1[256], w2[256];
         if (
             // line is of the form foo.gat#foo.wlk#
-            (sscanf (line, "%[^#]#%[^#]#", w1, w2) == 2)
+            (sscanf(line, "%[^#]#%[^#]#", w1, w2) == 2)
             // strip data/ from foo.gat before comparing
-            && (!strcmp (w1, fname + 5)))
+            && (!strcmp(w1, fname + 5)))
         {
-            strcpy (lfname, "data/");
-            strcpy (lfname + 5, w2);
-            fclose_ (fp);
+            strcpy(lfname, "data/");
+            strcpy(lfname + 5, w2);
+            fclose_(fp);
             return;
         }
     }
     fprintf(stderr, "Unable to find resource: %s\n", fname);
-    fclose_ (fp);
+    fclose_(fp);
 
     strcpy(lfname, fname);
     char* ext = lfname + strlen(lfname) - 4;
@@ -144,9 +144,9 @@ void grfio_resnametable (const char *fname, char *lfname)
 }
 
 /// Size of resource
-size_t grfio_size (const char *fname)
+size_t grfio_size(const char *fname)
 {
-    FILELIST *entry = filelist_find (fname);
+    FILELIST *entry = filelist_find(fname);
     if (entry)
         return entry->declen;
 
@@ -154,60 +154,60 @@ size_t grfio_size (const char *fname)
     FILELIST lentry;
     struct stat st;
 
-    grfio_resnametable (fname, lfname);
+    grfio_resnametable(fname, lfname);
 
     for (char *p = lfname; *p; p++)
         if (*p == '\\')
             *p = '/';
 
-    if (stat (lfname, &st) == 0)
+    if (stat(lfname, &st) == 0)
     {
-        strncpy (lentry.fn, fname, sizeof (lentry.fn) - 1);
+        strncpy(lentry.fn, fname, sizeof(lentry.fn) - 1);
         lentry.declen = st.st_size;
-        entry = filelist_modify (&lentry);
+        entry = filelist_modify(&lentry);
     }
     else
     {
-        printf ("%s not found\n", fname);
+        printf("%s not found\n", fname);
         return 0;
     }
     return entry->declen;
 }
 
-void *grfio_reads (const char *fname, size_t *size)
+void *grfio_reads(const char *fname, size_t *size)
 {
     char lfname[256];
-    grfio_resnametable (fname, lfname);
+    grfio_resnametable(fname, lfname);
 
     for (char *p = &lfname[0]; *p != 0; p++)
         if (*p == '\\')
             *p = '/';       // * At the time of Unix
 
-    FILE *in = fopen_ (lfname, "rb");
+    FILE *in = fopen_(lfname, "rb");
     if (!in)
     {
-        fprintf (stderr, "%s not found\n", fname);
+        fprintf(stderr, "%s not found\n", fname);
         return NULL;
     }
     FILELIST lentry;
-    FILELIST *entry = filelist_find (fname);
+    FILELIST *entry = filelist_find(fname);
     if (entry)
     {
         lentry.declen = entry->declen;
     }
     else
     {
-        fseek (in, 0, SEEK_END);
-        lentry.declen = ftell (in);
-        fseek (in, 0, SEEK_SET);
-        strncpy (lentry.fn, fname, sizeof (lentry.fn) - 1);
-        entry = filelist_modify (&lentry);
+        fseek(in, 0, SEEK_END);
+        lentry.declen = ftell(in);
+        fseek(in, 0, SEEK_SET);
+        strncpy(lentry.fn, fname, sizeof(lentry.fn) - 1);
+        entry = filelist_modify(&lentry);
     }
     uint8_t *buf2;
-    CREATE (buf2, uint8_t, lentry.declen + 1024);
-    if (fread (buf2, 1, lentry.declen, in) != lentry.declen)
+    CREATE(buf2, uint8_t, lentry.declen + 1024);
+    if (fread(buf2, 1, lentry.declen, in) != lentry.declen)
         exit(1);
-    fclose_ (in);
+    fclose_(in);
     in = NULL;
 
     if (size)
diff --git a/src/common/grfio.hpp b/src/common/grfio.hpp
index 3485904..f418ac3 100644
--- a/src/common/grfio.hpp
+++ b/src/common/grfio.hpp
@@ -6,12 +6,12 @@
 #define GRFIO_HPP
 
 /// Load file into memory
-# define grfio_read(resourcename) grfio_reads (resourcename, NULL)
+# define grfio_read(resourcename) grfio_reads(resourcename, NULL)
 /// Load file into memory and possibly record length
 // For some reason, this allocates an extra 1024 bytes at the end
-void *grfio_reads (const char *resourcename, size_t *size);
+void *grfio_reads(const char *resourcename, size_t *size);
 /// Get size of file
 // This is only called once, and that is to check the existence of a file.
-size_t grfio_size (const char *resourcename) __attribute__((deprecated));
+size_t grfio_size(const char *resourcename) __attribute__((deprecated));
 
 #endif // GRFIO_HPP
diff --git a/src/common/lock.cpp b/src/common/lock.cpp
index 2ba9a0a..13a99c5 100644
--- a/src/common/lock.cpp
+++ b/src/common/lock.cpp
@@ -7,30 +7,30 @@
 /// (Until the file is closed, it keeps the old file)
 
 // Start writing a tmpfile
-FILE *lock_fopen (const char *filename, int *info)
+FILE *lock_fopen(const char *filename, int *info)
 {
     char newfile[512];
     FILE *fp;
-    int  no = getpid ();
+    int no = getpid();
 
     // Get a filename that doesn't already exist
     do
     {
-        sprintf (newfile, "%s_%d.tmp", filename, no++);
+        sprintf(newfile, "%s_%d.tmp", filename, no++);
     }
-    while ((fp = fopen_ (newfile, "r")) && (fclose_ (fp), 1));
+    while ((fp = fopen_(newfile, "r")) && (fclose_(fp), 1));
     *info = --no;
-    return fopen_ (newfile, "w");
+    return fopen_(newfile, "w");
 }
 
 // Delete the old file and rename the new file
-void lock_fclose (FILE * fp, const char *filename, int *info)
+void lock_fclose(FILE * fp, const char *filename, int *info)
 {
     char newfile[512];
     if (fp)
     {
-        fclose_ (fp);
-        sprintf (newfile, "%s_%d.tmp", filename, *info);
-        rename (newfile, filename);
+        fclose_(fp);
+        sprintf(newfile, "%s_%d.tmp", filename, *info);
+        rename(newfile, filename);
     }
 }
diff --git a/src/common/lock.hpp b/src/common/lock.hpp
index 19c1302..d6128d8 100644
--- a/src/common/lock.hpp
+++ b/src/common/lock.hpp
@@ -2,7 +2,7 @@
 #define LOCK_HPP
 /// Locked FILE I/O
 // Changes are made in a separate file until lock_fclose
-FILE *lock_fopen (const char *filename, int *info);
-void lock_fclose (FILE * fp, const char *filename, int *info);
+FILE *lock_fopen(const char *filename, int *info);
+void lock_fclose(FILE * fp, const char *filename, int *info);
 
 #endif // LOCK_HPP
diff --git a/src/common/md5calc.cpp b/src/common/md5calc.cpp
index b0f8e5f..9027bc9 100644
--- a/src/common/md5calc.cpp
+++ b/src/common/md5calc.cpp
@@ -193,7 +193,7 @@ MD5_state MD5_from_string(const char* msg, const size_t msglen)
     }
     // now pad 1-512 bits + the 64-bit length - may be two blocks
     uint8_t buf[0x40] = {};
-    memcpy (buf, msg, rem);
+    memcpy(buf, msg, rem);
     buf[rem] = 0x80; // a single one bit
     if (64 - rem > 8)
     {
diff --git a/src/common/md5calc.hpp b/src/common/md5calc.hpp
index 2dfaecb..2aed0bc 100644
--- a/src/common/md5calc.hpp
+++ b/src/common/md5calc.hpp
@@ -37,13 +37,13 @@ MD5_state MD5_from_FILE(FILE* in);
 
 /// Output in ASCII - with lowercase hex digits, null-terminated
 // these may overlap safely
-static void MD5_String (const char *string, char output[33]) __attribute__((deprecated));
-static inline void MD5_String (const char *string, char output[33]) {
+static void MD5_String(const char *string, char output[33]) __attribute__((deprecated));
+static inline void MD5_String(const char *string, char output[33]) {
     MD5_to_str(MD5_from_cstring(string), output);
 }
 /// Output in binary
-static void MD5_String2binary (const char *string, uint8_t output[16]) __attribute__((deprecated));
-static inline void MD5_String2binary (const char *string, uint8_t output[16]) {
+static void MD5_String2binary(const char *string, uint8_t output[16]) __attribute__((deprecated));
+static inline void MD5_String2binary(const char *string, uint8_t output[16]) {
     MD5_to_bin(MD5_from_cstring(string), output);
 }
 
diff --git a/src/common/mmo.hpp b/src/common/mmo.hpp
index 45f86cf..7441a16 100644
--- a/src/common/mmo.hpp
+++ b/src/common/mmo.hpp
@@ -51,7 +51,7 @@
 
 struct item
 {
-    int  id;
+    int id;
     short nameid;
     short amount;
     unsigned short equip;
@@ -76,23 +76,23 @@ struct skill
 struct global_reg
 {
     char str[32];
-    int  value;
+    int value;
 };
 
 struct mmo_charstatus
 {
-    int  char_id;
-    int  account_id;
-    int  partner_id;
+    int char_id;
+    int account_id;
+    int partner_id;
 
-    int  base_exp, job_exp, zeny;
+    int base_exp, job_exp, zeny;
 
     short pc_class;
     short status_point, skill_point;
-    int  hp, max_hp, sp, max_sp;
+    int hp, max_hp, sp, max_sp;
     short option, karma, manner;
     short hair, hair_color, clothes_color;
-    int  party_id;
+    int party_id;
 
     short weapon, shield;
     short head_top, head_mid, head_bottom;
@@ -108,18 +108,18 @@ struct mmo_charstatus
     struct point last_point, save_point, memo_point[10];
     struct item inventory[MAX_INVENTORY], cart[MAX_CART];
     struct skill skill[MAX_SKILL];
-    int  global_reg_num;
+    int global_reg_num;
     struct global_reg global_reg[GLOBAL_REG_NUM];
-    int  account_reg_num;
+    int account_reg_num;
     struct global_reg account_reg[ACCOUNT_REG_NUM];
-    int  account_reg2_num;
+    int account_reg2_num;
     struct global_reg account_reg2[ACCOUNT_REG2_NUM];
 };
 
 struct storage
 {
-    int  dirty;
-    int  account_id;
+    int dirty;
+    int account_id;
     short storage_status;
     short storage_amount;
     struct item storage_[MAX_STORAGE];
@@ -129,31 +129,31 @@ struct map_session_data;
 
 struct gm_account
 {
-    int  account_id;
-    int  level;
+    int account_id;
+    int level;
 };
 
 struct party_member
 {
-    int  account_id;
+    int account_id;
     char name[24], map[24];
-    int  leader, online, lv;
+    int leader, online, lv;
     struct map_session_data *sd;
 };
 
 struct party
 {
-    int  party_id;
+    int party_id;
     char name[24];
-    int  exp;
-    int  item;
+    int exp;
+    int item;
     struct party_member member[MAX_PARTY];
 };
 
 struct square
 {
-    int  val1[5];
-    int  val2[5];
+    int val1[5];
+    int val2[5];
 };
 
 #endif // MMO_HPP
diff --git a/src/common/mt_rand.cpp b/src/common/mt_rand.cpp
index 676eca1..91ae2e4 100644
--- a/src/common/mt_rand.cpp
+++ b/src/common/mt_rand.cpp
@@ -61,7 +61,7 @@ static uint32_t state[N+1]; // state vector the +1 is needed due to the coding
 static uint32_t *next;      // next random value is computed from here
 static int left = -1;       // can *next++ this many times before reloading
 
-void mt_seed (uint32_t seed)
+void mt_seed(uint32_t seed)
 {
     uint32_t x = seed | 1U;
     uint32_t *s = state;
@@ -71,11 +71,11 @@ void mt_seed (uint32_t seed)
 }
 
 static
-void mt_reload (void)
+void mt_reload(void)
 {
     // if mt_seed has never been called
     if (left < -1)
-        mt_seed (time (NULL));
+        mt_seed(time(NULL));
 
     // conceptually, these are indices into the state that wrap
     uint32_t *p0 = state;
@@ -87,27 +87,27 @@ void mt_reload (void)
 
     // regenerate the lower N-M elements of the state
     for (int j = N-M+1; --j != 0; s0 = s1, s1 = *p2++)
-        *p0++ = *pM++ ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U);
+        *p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
 
     pM = state;
     // regenerate the next M-1 elements of the state
     // note that s1 is set to state[N] at the end, but discarded
     for (int j = M; --j != 0; s0 = s1, s1 = *p2++)
-        *p0++ = *pM++ ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U);
+        *p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
 
     // regenerate the last 1 element of the state
     s1 = state[0];
-    *p0 = *pM ^ (mixBits (s0, s1) >> 1) ^ (loBit (s1) ? K : 0U);
+    *p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
 
     // ready for the normal mt_random algorithm
     left = N;
     next = state;
 }
 
-uint32_t mt_random (void)
+uint32_t mt_random(void)
 {
     if (--left < 0)
-        mt_reload ();
+        mt_reload();
 
     uint32_t y = *next++;
     y ^= (y >> 11);
diff --git a/src/common/mt_rand.hpp b/src/common/mt_rand.hpp
index c7bae4e..ae5986b 100644
--- a/src/common/mt_rand.hpp
+++ b/src/common/mt_rand.hpp
@@ -4,9 +4,9 @@
 # include "sanity.hpp"
 
 /// Initialize the generator (called automatically with time() if you don't)
-void mt_seed (uint32_t seed);
+void mt_seed(uint32_t seed);
 /// Get a random number
-uint32_t mt_random (void);
+uint32_t mt_random(void);
 
 /**
  * ModuloRand and ModuloPlusRand
diff --git a/src/common/nullpo.cpp b/src/common/nullpo.cpp
index 67c839f..ad52009 100644
--- a/src/common/nullpo.cpp
+++ b/src/common/nullpo.cpp
@@ -3,13 +3,13 @@
 #include <string.h>
 #include "nullpo.hpp"
 
-static void nullpo_info_core (const char *file, int line, const char *func);
+static void nullpo_info_core(const char *file, int line, const char *func);
 __attribute__((format(printf, 4, 0)))
-static void nullpo_info_core (const char *file, int line, const char *func,
+static void nullpo_info_core(const char *file, int line, const char *func,
                               const char *fmt, va_list ap);
 
 /// Null check and print format
-bool nullpo_chk_f (const char *file, int line, const char *func,
+bool nullpo_chk_f(const char *file, int line, const char *func,
                    const void *target, const char *fmt, ...)
 {
     va_list ap;
@@ -17,55 +17,55 @@ bool nullpo_chk_f (const char *file, int line, const char *func,
     if (target)
         return 0;
 
-    va_start (ap, fmt);
-    nullpo_info_core (file, line, func, fmt, ap);
-    va_end (ap);
+    va_start(ap, fmt);
+    nullpo_info_core(file, line, func, fmt, ap);
+    va_end(ap);
     return 1;
 }
-bool nullpo_chk (const char *file, int line, const char *func,
+bool nullpo_chk(const char *file, int line, const char *func,
                  const void *target)
 {
     if (target)
         return 0;
 
-    nullpo_info_core (file, line, func);
+    nullpo_info_core(file, line, func);
     return 1;
 }
 
 /// External functions
-void nullpo_info_f (const char *file, int line, const char *func,
+void nullpo_info_f(const char *file, int line, const char *func,
                     const char *fmt, ...)
 {
     va_list ap;
 
-    va_start (ap, fmt);
-    nullpo_info_core (file, line, func, fmt, ap);
-    va_end (ap);
+    va_start(ap, fmt);
+    nullpo_info_core(file, line, func, fmt, ap);
+    va_end(ap);
 }
-void nullpo_info (const char *file, int line, const char *func)
+void nullpo_info(const char *file, int line, const char *func)
 {
-    nullpo_info_core (file, line, func);
+    nullpo_info_core(file, line, func);
 }
 
 /// Actual output function
-static void nullpo_info_core (const char *file, int line, const char *func)
+static void nullpo_info_core(const char *file, int line, const char *func)
 {
     if (!file)
         file = "??";
     if (!func || !*func)
         func = "unknown";
 
-    fprintf (stderr, "%s:%d: in func `%s': NULL pointer\n", file, line, func);
+    fprintf(stderr, "%s:%d: in func `%s': NULL pointer\n", file, line, func);
 }
 
-static void nullpo_info_core (const char *file, int line, const char *func,
+static void nullpo_info_core(const char *file, int line, const char *func,
                               const char *fmt, va_list ap)
 {
     nullpo_info_core(file, line, func);
     if (fmt && *fmt)
     {
-        vfprintf (stderr, fmt, ap);
-        if (fmt[strlen (fmt) - 1] != '\n')
+        vfprintf(stderr, fmt, ap);
+        if (fmt[strlen(fmt) - 1] != '\n')
             fputc('\n', stderr);
     }
 }
diff --git a/src/common/nullpo.hpp b/src/common/nullpo.hpp
index 7aff691..25ab2b9 100644
--- a/src/common/nullpo.hpp
+++ b/src/common/nullpo.hpp
@@ -42,20 +42,20 @@
 # include "sanity.hpp"
 
 /// Used by macros in this header
-bool nullpo_chk (const char *file, int line, const char *func,
+bool nullpo_chk(const char *file, int line, const char *func,
                  const void *target);
 
 /// Used by macros in this header
-bool nullpo_chk_f (const char *file, int line, const char *func,
+bool nullpo_chk_f(const char *file, int line, const char *func,
                    const void *target, const char *fmt, ...)
-    __attribute__ ((format (printf, 5, 6)));
+    __attribute__((format(printf, 5, 6)));
 
 /// Used only by map/battle.c
-void nullpo_info (const char *file, int line, const char *func);
+void nullpo_info(const char *file, int line, const char *func);
 
 /// Not used
-void nullpo_info_f (const char *file, int line, const char *func,
+void nullpo_info_f(const char *file, int line, const char *func,
                     const char *fmt, ...)
-    __attribute__ ((format (printf, 4, 5)));
+    __attribute__((format(printf, 4, 5)));
 
 #endif // NULLPO_HPP
diff --git a/src/common/socket.cpp b/src/common/socket.cpp
index cc6e4b3..fb254dc 100644
--- a/src/common/socket.cpp
+++ b/src/common/socket.cpp
@@ -20,8 +20,8 @@
 #include "utils.hpp"
 
 fd_set readfds;
-int  fd_max;
-int  currentuse;
+int fd_max;
+int currentuse;
 
 const uint32_t RFIFO_SIZE = 65536;
 const uint32_t WFIFO_SIZE = 65536;
@@ -29,23 +29,23 @@ const uint32_t WFIFO_SIZE = 65536;
 struct socket_data *session[FD_SETSIZE];
 
 /// Discard all input
-static void null_parse (int fd);
+static void null_parse(int fd);
 /// Default parser for new connections
-static void (*default_func_parse) (int) = null_parse;
+static void(*default_func_parse)(int) = null_parse;
 
-void set_defaultparse (void (*defaultparse) (int))
+void set_defaultparse(void(*defaultparse)(int))
 {
     default_func_parse = defaultparse;
 }
 
 /// Read from socket to the queue
-static void recv_to_fifo (int fd)
+static void recv_to_fifo(int fd)
 {
     if (session[fd]->eof)
         return;
 
-    ssize_t len = read (fd, session[fd]->rdata + session[fd]->rdata_size,
-                        RFIFOSPACE (fd));
+    ssize_t len = read(fd, session[fd]->rdata + session[fd]->rdata_size,
+                        RFIFOSPACE(fd));
 
     if (len > 0)
     {
@@ -58,19 +58,19 @@ static void recv_to_fifo (int fd)
     }
 }
 
-static void send_from_fifo (int fd)
+static void send_from_fifo(int fd)
 {
     if (session[fd]->eof)
         return;
 
-    ssize_t len = write (fd, session[fd]->wdata, session[fd]->wdata_size);
+    ssize_t len = write(fd, session[fd]->wdata, session[fd]->wdata_size);
 
     if (len > 0)
     {
         session[fd]->wdata_size -= len;
         if (len < (ssize_t)session[fd]->wdata_size)
         {
-            memmove (session[fd]->wdata, session[fd]->wdata + len,
+            memmove(session[fd]->wdata, session[fd]->wdata + len,
                      session[fd]->wdata_size);
         }
         session[fd]->connected = 1;
@@ -81,32 +81,32 @@ static void send_from_fifo (int fd)
     }
 }
 
-static void null_parse (int fd)
+static void null_parse(int fd)
 {
-    printf ("null_parse : %d\n", fd);
-    RFIFOSKIP (fd, RFIFOREST (fd));
+    printf("null_parse : %d\n", fd);
+    RFIFOSKIP(fd, RFIFOREST(fd));
 }
 
 
-static void connect_client (int listen_fd)
+static void connect_client(int listen_fd)
 {
     struct sockaddr_in client_address;
-    socklen_t len = sizeof (client_address);
+    socklen_t len = sizeof(client_address);
 
-    int fd = accept (listen_fd, (struct sockaddr *) &client_address, &len);
+    int fd = accept(listen_fd, (struct sockaddr *) &client_address, &len);
     if (fd == -1)
     {
-        perror ("accept");
+        perror("accept");
         return;
     }
     if (fd_max <= fd)
     {
         fd_max = fd + 1;
     }
-    if (!free_fds ())
+    if (!free_fds())
     {
-        fprintf (stderr, "softlimit reached, disconnecting : %d\n", fd);
-        delete_session (fd);
+        fprintf(stderr, "softlimit reached, disconnecting : %d\n", fd);
+        delete_session(fd);
         return;
     }
 
@@ -114,20 +114,20 @@ static void connect_client (int listen_fd)
     /// Allow to bind() again after the server restarts.
     // Since the socket is still in the TIME_WAIT, there's a possibility
     // that formerly lost packets might be delivered and confuse the server.
-    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
+    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
     /// Send packets as soon as possible
     /// even if the kernel thinks there is too little for it to be worth it!
     // I'm not convinced this is a good idea; although in minimizes the
     // latency for an individual write, it increases traffic in general.
-    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
 
-    FD_SET (fd, &readfds);
+    FD_SET(fd, &readfds);
 
-    fcntl (fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFL, O_NONBLOCK);
 
-    CREATE (session[fd], struct socket_data, 1);
-    CREATE (session[fd]->rdata, uint8_t, RFIFO_SIZE);
-    CREATE (session[fd]->wdata, uint8_t, WFIFO_SIZE);
+    CREATE(session[fd], struct socket_data, 1);
+    CREATE(session[fd]->rdata, uint8_t, RFIFO_SIZE);
+    CREATE(session[fd]->wdata, uint8_t, WFIFO_SIZE);
 
     session[fd]->max_rdata = RFIFO_SIZE;
     session[fd]->max_wdata = WFIFO_SIZE;
@@ -135,72 +135,72 @@ static void connect_client (int listen_fd)
     session[fd]->func_send = send_from_fifo;
     session[fd]->func_parse = default_func_parse;
     session[fd]->client_addr = client_address;
-    session[fd]->created = time (NULL);
+    session[fd]->created = time(NULL);
     session[fd]->connected = 0;
 
     currentuse++;
 }
 
-int make_listen_port (uint16_t port)
+int make_listen_port(uint16_t port)
 {
     struct sockaddr_in server_address;
-    int  fd = socket (AF_INET, SOCK_STREAM, 0);
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
     if (fd == -1)
     {
-        perror ("socket");
+        perror("socket");
         return -1;
     }
     if (fd_max <= fd)
         fd_max = fd + 1;
 
-    fcntl (fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFL, O_NONBLOCK);
 
     const int yes = 1;
     /// Allow to bind() again after the server restarts.
     // Since the socket is still in the TIME_WAIT, there's a possibility
     // that formerly lost packets might be delivered and confuse the server.
-    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
+    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
     /// Send packets as soon as possible
     /// even if the kernel thinks there is too little for it to be worth it!
     // I'm not convinced this is a good idea; although in minimizes the
     // latency for an individual write, it increases traffic in general.
-    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
 
     server_address.sin_family = AF_INET;
-    server_address.sin_addr.s_addr = htonl (INADDR_ANY);
-    server_address.sin_port = htons (port);
+    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
+    server_address.sin_port = htons(port);
 
-    if (bind (fd, (struct sockaddr *) &server_address,
-              sizeof (server_address)) == -1)
+    if (bind(fd, (struct sockaddr *) &server_address,
+              sizeof(server_address)) == -1)
     {
-        perror ("bind");
-        exit (1);
+        perror("bind");
+        exit(1);
     }
-    if (listen (fd, 5) == -1)
+    if (listen(fd, 5) == -1)
     {                           /* error */
-        perror ("listen");
-        exit (1);
+        perror("listen");
+        exit(1);
     }
 
-    FD_SET (fd, &readfds);
+    FD_SET(fd, &readfds);
 
-    CREATE (session[fd], struct socket_data, 1);
+    CREATE(session[fd], struct socket_data, 1);
 
     session[fd]->func_recv = connect_client;
-    session[fd]->created = time (NULL);
+    session[fd]->created = time(NULL);
     session[fd]->connected = 1;
 
     currentuse++;
     return fd;
 }
 
-int make_connection (uint32_t ip, uint16_t port)
+int make_connection(uint32_t ip, uint16_t port)
 {
     struct sockaddr_in server_address;
-    int  fd = socket (AF_INET, SOCK_STREAM, 0);
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
     if (fd == -1)
     {
-        perror ("socket");
+        perror("socket");
         return -1;
     }
     if (fd_max <= fd)
@@ -210,43 +210,43 @@ int make_connection (uint32_t ip, uint16_t port)
     /// Allow to bind() again after the server restarts.
     // Since the socket is still in the TIME_WAIT, there's a possibility
     // that formerly lost packets might be delivered and confuse the server.
-    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
+    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
     /// Send packets as soon as possible
     /// even if the kernel thinks there is too little for it to be worth it!
     // I'm not convinced this is a good idea; although in minimizes the
     // latency for an individual write, it increases traffic in general.
-    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes);
 
     server_address.sin_family = AF_INET;
     server_address.sin_addr.s_addr = ip;
-    server_address.sin_port = htons (port);
+    server_address.sin_port = htons(port);
 
-    fcntl (fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFL, O_NONBLOCK);
 
     /// Errors not caught - we must not block
     /// Let the main select() loop detect when we know the state
-    connect (fd, (struct sockaddr *) &server_address,
-             sizeof (struct sockaddr_in));
+    connect(fd, (struct sockaddr *) &server_address,
+             sizeof(struct sockaddr_in));
 
-    FD_SET (fd, &readfds);
+    FD_SET(fd, &readfds);
 
-    CREATE (session[fd], struct socket_data, 1);
-    CREATE (session[fd]->rdata, uint8_t, RFIFO_SIZE);
-    CREATE (session[fd]->wdata, uint8_t, WFIFO_SIZE);
+    CREATE(session[fd], struct socket_data, 1);
+    CREATE(session[fd]->rdata, uint8_t, RFIFO_SIZE);
+    CREATE(session[fd]->wdata, uint8_t, WFIFO_SIZE);
 
     session[fd]->max_rdata = RFIFO_SIZE;
     session[fd]->max_wdata = WFIFO_SIZE;
     session[fd]->func_recv = recv_to_fifo;
     session[fd]->func_send = send_from_fifo;
     session[fd]->func_parse = default_func_parse;
-    session[fd]->created = time (NULL);
+    session[fd]->created = time(NULL);
     session[fd]->connected = 1;
 
     currentuse++;
     return fd;
 }
 
-void delete_session (int fd)
+void delete_session(int fd)
 {
     if (fd < 0 || fd >= FD_SETSIZE)
         return;
@@ -255,151 +255,151 @@ void delete_session (int fd)
     // but this is cheap and good enough for the typical case
     if (fd == fd_max - 1)
         fd_max--;
-    FD_CLR (fd, &readfds);
+    FD_CLR(fd, &readfds);
     if (session[fd])
     {
-        free (session[fd]->rdata);
-        free (session[fd]->wdata);
-        free (session[fd]->session_data);
-        free (session[fd]);
+        free(session[fd]->rdata);
+        free(session[fd]->wdata);
+        free(session[fd]->session_data);
+        free(session[fd]);
     }
     session[fd] = NULL;
 
     // just close() would try to keep sending buffers
-    shutdown (fd, SHUT_RDWR);
-    close (fd);
+    shutdown(fd, SHUT_RDWR);
+    close(fd);
     currentuse--;
     if (currentuse < 0)
     {
-        fprintf (stderr, "delete_session: current sessions negative!\n");
+        fprintf(stderr, "delete_session: current sessions negative!\n");
         currentuse = 0;
     }
     return;
 }
 
-void realloc_fifo (int fd, size_t rfifo_size, size_t wfifo_size)
+void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size)
 {
     struct socket_data *s = session[fd];
     if (s->max_rdata != rfifo_size && s->rdata_size < rfifo_size)
     {
-        RECREATE (s->rdata, uint8_t, rfifo_size);
+        RECREATE(s->rdata, uint8_t, rfifo_size);
         s->max_rdata = rfifo_size;
     }
     if (s->max_wdata != wfifo_size && s->wdata_size < wfifo_size)
     {
-        RECREATE (s->wdata, uint8_t, wfifo_size);
+        RECREATE(s->wdata, uint8_t, wfifo_size);
         s->max_wdata = wfifo_size;
     }
 }
 
-void WFIFOSET (int fd, size_t len)
+void WFIFOSET(int fd, size_t len)
 {
     struct socket_data *s = session[fd];
     if (s->wdata_size + len + 16384 > s->max_wdata)
     {
-        realloc_fifo (fd, s->max_rdata, s->max_wdata << 1);
-        printf ("socket: %d wdata expanded to %d bytes.\n", fd, s->max_wdata);
+        realloc_fifo(fd, s->max_rdata, s->max_wdata << 1);
+        printf("socket: %d wdata expanded to %d bytes.\n", fd, s->max_wdata);
     }
     if (s->wdata_size + len + 2048 < s->max_wdata)
         s->wdata_size += len;
     else
-        fprintf (stderr, "socket: %d wdata lost !!\n", fd), abort ();
+        fprintf(stderr, "socket: %d wdata lost !!\n", fd), abort();
 }
 
-void do_sendrecv (uint32_t next)
+void do_sendrecv(uint32_t next)
 {
     fd_set rfd = readfds, wfd;
-    FD_ZERO (&wfd);
+    FD_ZERO(&wfd);
     for (int i = 0; i < fd_max; i++)
     {
         if (session[i] && session[i]->wdata_size)
-            FD_SET (i, &wfd);
+            FD_SET(i, &wfd);
     }
     struct timeval timeout;
     timeout.tv_sec = next / 1000;
     timeout.tv_usec = next % 1000 * 1000;
-    if (select (fd_max, &rfd, &wfd, NULL, &timeout) <= 0)
+    if (select(fd_max, &rfd, &wfd, NULL, &timeout) <= 0)
         return;
     for (int i = 0; i < fd_max; i++)
     {
         if (!session[i])
             continue;
-        if (FD_ISSET (i, &wfd))
+        if (FD_ISSET(i, &wfd))
         {
             if (session[i]->func_send)
                 //send_from_fifo(i);
-                session[i]->func_send (i);
+                session[i]->func_send(i);
         }
-        if (FD_ISSET (i, &rfd))
+        if (FD_ISSET(i, &rfd))
         {
             if (session[i]->func_recv)
                 //recv_to_fifo(i);
                 //or connect_client(i);
-                session[i]->func_recv (i);
+                session[i]->func_recv(i);
         }
     }
 }
 
-void do_parsepacket (void)
+void do_parsepacket(void)
 {
     for (int i = 0; i < fd_max; i++)
     {
         if (!session[i])
             continue;
         if (!session[i]->connected
-            && time (NULL) - session[i]->created > CONNECT_TIMEOUT)
+            && time(NULL) - session[i]->created > CONNECT_TIMEOUT)
         {
-            printf ("Session #%d timed out\n", i);
+            printf("Session #%d timed out\n", i);
             session[i]->eof = 1;
         }
         if (!session[i]->rdata_size && !session[i]->eof)
             continue;
         if (session[i]->func_parse)
         {
-            session[i]->func_parse (i);
+            session[i]->func_parse(i);
             /// some func_parse may call delete_session
             if (!session[i])
                 continue;
         }
         /// Reclaim buffer space for what was read
-        RFIFOFLUSH (i);
+        RFIFOFLUSH(i);
     }
 }
 
-void do_socket (void)
+void do_socket(void)
 {
-    FD_ZERO (&readfds);
+    FD_ZERO(&readfds);
     currentuse = 3;
 }
 
-void RFIFOSKIP (int fd, size_t len)
+void RFIFOSKIP(int fd, size_t len)
 {
     struct socket_data *s = session[fd];
     s->rdata_pos += len;
 
     if (s->rdata_size < s->rdata_pos)
     {
-        fprintf (stderr, "too many skip\n");
-        abort ();
+        fprintf(stderr, "too many skip\n");
+        abort();
     }
 }
 
-void fclose_ (FILE * fp)
+void fclose_(FILE * fp)
 {
-    if (fclose (fp))
-        perror ("fclose"), abort ();
+    if (fclose(fp))
+        perror("fclose"), abort();
     currentuse--;
 }
 
-FILE *fopen_ (const char *path, const char *mode)
+FILE *fopen_(const char *path, const char *mode)
 {
-    FILE *f = fopen (path, mode);
+    FILE *f = fopen(path, mode);
     if (f)
         currentuse++;
     return f;
 }
 
-bool free_fds (void)
+bool free_fds(void)
 {
     return currentuse < SOFT_LIMIT;
 }
diff --git a/src/common/socket.hpp b/src/common/socket.hpp
index 00f2df0..b2ef119 100644
--- a/src/common/socket.hpp
+++ b/src/common/socket.hpp
@@ -19,7 +19,7 @@
 # define RFIFOW(fd,pos) (*(uint16_t*)(RFIFOP(fd, pos)))
 # define RFIFOL(fd,pos) (*(uint32_t*)(RFIFOP(fd, pos)))
 /// Done reading
-void RFIFOSKIP (int fd, size_t len);
+void RFIFOSKIP(int fd, size_t len);
 /// Internal - clean up by discarding handled bytes
 // Atm this is also called in char/char.c, but that is unnecessary
 # define RFIFOFLUSH(fd) (memmove(session[fd]->rdata,RFIFOP(fd,0),RFIFOREST(fd)),\
@@ -45,7 +45,7 @@ session[fd]->rdata_pos=0)
 # define WFIFOW(fd,pos) (*(uint16_t*)(WFIFOP(fd,pos)))
 # define WFIFOL(fd,pos) (*(uint32_t*)(WFIFOP(fd,pos)))
 /// Finish writing
-void WFIFOSET (int fd, size_t len);
+void WFIFOSET(int fd, size_t len);
 
 /// Write to an arbitrary buffer
 #define WBUFP(p,pos) (((uint8_t*)(p))+(pos))
@@ -80,13 +80,13 @@ struct socket_data
     /// Only called when select() indicates the socket is ready
     /// If, after that, nothing is read, it sets eof
     // These could probably be hard-coded with a little work
-    void (*func_recv) (int);
-    void (*func_send) (int);
+    void(*func_recv)(int);
+    void(*func_send)(int);
     /// This is the important one
     /// Set to different functions depending on whether the connection
     /// is a player or a server/ladmin
     /// Can be set explicitly or via set_defaultparse
-    void (*func_parse) (int);
+    void(*func_parse)(int);
     /// Server-specific data type
     void *session_data;
 };
@@ -106,30 +106,30 @@ extern int fd_max;
 
 /// open a socket, bind, and listen. Return an fd, or -1 if socket() fails,
 /// but exit if bind() or listen() fails
-int  make_listen_port (uint16_t port);
+int make_listen_port(uint16_t port);
 /// Connect to an address, return a connected socket or -1
 // FIXME - this is IPv4 only!
-int  make_connection (uint32_t ip, uint16_t port);
+int make_connection(uint32_t ip, uint16_t port);
 /// free() the structure and close() the fd
-void delete_session (int);
+void delete_session(int);
 /// Make a the internal queues bigger
-void realloc_fifo (int fd, size_t rfifo_size, size_t wfifo_size);
+void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size);
 /// Update all sockets that can be read/written from the queues
-void do_sendrecv (uint32_t next);
+void do_sendrecv(uint32_t next);
 /// Call the parser function for every socket that has read data
-void do_parsepacket (void);
+void do_parsepacket(void);
 
 /// An init function
-void do_socket (void);
+void do_socket(void);
 
 /// Change the default parser for newly connected clients
 // typically called once per server, but individual clients may identify
 // themselves as servers
-void set_defaultparse (void (*defaultparse) (int));
+void set_defaultparse(void(*defaultparse)(int));
 
 /// Wrappers to track number of free FDs
-void fclose_ (FILE * fp);
-FILE *fopen_ (const char *path, const char *mode);
-bool free_fds (void);
+void fclose_(FILE * fp);
+FILE *fopen_(const char *path, const char *mode);
+bool free_fds(void);
 
 #endif // SOCKET_HPP
diff --git a/src/common/timer.cpp b/src/common/timer.cpp
index 66aaa9b..8a12d19 100644
--- a/src/common/timer.cpp
+++ b/src/common/timer.cpp
@@ -29,30 +29,30 @@ static timer_id *timer_heap = NULL;
 static uint32_t gettick_cache;
 static uint8_t gettick_count = 0;
 
-uint32_t gettick_nocache (void)
+uint32_t gettick_nocache(void)
 {
     struct timeval tval;
     // BUG: This will cause strange behavior if the system clock is changed!
     // it should be reimplemented in terms of clock_gettime(CLOCK_MONOTONIC, )
-    gettimeofday (&tval, NULL);
+    gettimeofday(&tval, NULL);
     gettick_count = 255;
     return gettick_cache = tval.tv_sec * 1000 + tval.tv_usec / 1000;
 }
 
-uint32_t gettick (void)
+uint32_t gettick(void)
 {
     if (gettick_count--)
         return gettick_cache;
-    return gettick_nocache ();
+    return gettick_nocache();
 }
 
-static void push_timer_heap (timer_id index)
+static void push_timer_heap(timer_id index)
 {
     if (timer_heap == NULL || timer_heap[0] + 1 >= timer_heap_max)
     {
         timer_heap_max += 256;
-        RECREATE (timer_heap, timer_id, timer_heap_max);
-        memset (timer_heap + (timer_heap_max - 256), 0, sizeof (timer_id) * 256);
+        RECREATE(timer_heap, timer_id, timer_heap_max);
+        memset(timer_heap + (timer_heap_max - 256), 0, sizeof(timer_id) * 256);
     }
 // timer_heap[0] is the greatest index into the heap, which increases
     timer_heap[0]++;
@@ -71,14 +71,14 @@ static void push_timer_heap (timer_id index)
     timer_heap[h + 1] = index;
 }
 
-static timer_id top_timer_heap (void)
+static timer_id top_timer_heap(void)
 {
     if (!timer_heap || !timer_heap[0])
         return -1;
     return timer_heap[1];
 }
 
-static timer_id pop_timer_heap (void)
+static timer_id pop_timer_heap(void)
 {
     if (!timer_heap || !timer_heap[0])
         return -1;
@@ -99,7 +99,7 @@ static timer_id pop_timer_heap (void)
     uint32_t i = (h - 1) / 2;
     while (h)
     {
-        if (DIFF_TICK (timer_data[timer_heap[i + 1]].tick, timer_data[last].tick) <= 0)
+        if (DIFF_TICK(timer_data[timer_heap[i + 1]].tick, timer_data[last].tick) <= 0)
             break;
         timer_heap[h + 1] = timer_heap[i + 1];
         h = i;
@@ -110,7 +110,7 @@ static timer_id pop_timer_heap (void)
     return ret;
 }
 
-timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t data)
+timer_id add_timer(tick_t tick, timer_func func, custom_id_t id, custom_data_t data)
 {
     timer_id i;
 
@@ -136,14 +136,14 @@ timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t
         if (timer_data_max == 0)
         {
             timer_data_max = 256;
-            CREATE (timer_data, struct TimerData, timer_data_max);
+            CREATE(timer_data, struct TimerData, timer_data_max);
         }
         else
         {
             timer_data_max += 256;
-            RECREATE (timer_data, struct TimerData, timer_data_max);
-            memset (timer_data + (timer_data_max - 256), 0,
-                    sizeof (struct TimerData) * 256);
+            RECREATE(timer_data, struct TimerData, timer_data_max);
+            memset(timer_data + (timer_data_max - 256), 0,
+                    sizeof(struct TimerData) * 256);
         }
     }
     timer_data[i].tick = tick;
@@ -152,32 +152,32 @@ timer_id add_timer (tick_t tick, timer_func func, custom_id_t id, custom_data_t
     timer_data[i].data = data;
     timer_data[i].type = TIMER_ONCE_AUTODEL;
     timer_data[i].interval = 1000;
-    push_timer_heap (i);
+    push_timer_heap(i);
     if (i >= timer_data_num)
         timer_data_num = i + 1;
     return i;
 }
 
-timer_id add_timer_interval (tick_t tick, timer_func func, custom_id_t id,
+timer_id add_timer_interval(tick_t tick, timer_func func, custom_id_t id,
                              custom_data_t data, interval_t interval)
 {
-    timer_id tid = add_timer (tick, func, id, data);
+    timer_id tid = add_timer(tick, func, id, data);
     timer_data[tid].type = TIMER_INTERVAL;
     timer_data[tid].interval = interval;
     return tid;
 }
 
-void delete_timer (timer_id id, timer_func func)
+void delete_timer(timer_id id, timer_func func)
 {
     if (id == 0 || id >= timer_data_num)
     {
-        fprintf (stderr, "delete_timer error : no such timer %d\n", id);
-        abort ();
+        fprintf(stderr, "delete_timer error : no such timer %d\n", id);
+        abort();
     }
     if (timer_data[id].func != func)
     {
-        fprintf (stderr, "Timer mismatch\n");
-        abort ();
+        fprintf(stderr, "Timer mismatch\n");
+        abort();
     }
     // "to let them disappear" - is this just in case?
     timer_data[id].func = NULL;
@@ -185,43 +185,43 @@ void delete_timer (timer_id id, timer_func func)
     timer_data[id].tick -= 60 * 60 * 1000;
 }
 
-tick_t addtick_timer (timer_id tid, interval_t tick)
+tick_t addtick_timer(timer_id tid, interval_t tick)
 {
     return timer_data[tid].tick += tick;
 }
 
-struct TimerData *get_timer (timer_id tid)
+struct TimerData *get_timer(timer_id tid)
 {
     return &timer_data[tid];
 }
 
-interval_t do_timer (tick_t tick)
+interval_t do_timer(tick_t tick)
 {
     timer_id i;
     /// Number of milliseconds until it calls this again
     // this says to wait 1 sec if all timers get popped
     interval_t nextmin = 1000;
 
-    while ((i = top_timer_heap ()) != (timer_id)-1)
+    while ((i = top_timer_heap()) != (timer_id)-1)
     {
         // while the heap is not empty and
-        if (DIFF_TICK (timer_data[i].tick, tick) > 0)
+        if (DIFF_TICK(timer_data[i].tick, tick) > 0)
         {
             /// Return the time until the next timer needs to goes off
-            nextmin = DIFF_TICK (timer_data[i].tick, tick);
+            nextmin = DIFF_TICK(timer_data[i].tick, tick);
             break;
         }
-        pop_timer_heap ();
+        pop_timer_heap();
         if (timer_data[i].func)
         {
-            if (DIFF_TICK (timer_data[i].tick, tick) < -1000)
+            if (DIFF_TICK(timer_data[i].tick, tick) < -1000)
             {
                 // If we are too far past the requested tick, call with the current tick instead to fix reregistering problems
-                timer_data[i].func (i, tick, timer_data[i].id, timer_data[i].data);
+                timer_data[i].func(i, tick, timer_data[i].id, timer_data[i].data);
             }
             else
             {
-                timer_data[i].func (i, timer_data[i].tick, timer_data[i].id, timer_data[i].data);
+                timer_data[i].func(i, timer_data[i].tick, timer_data[i].id, timer_data[i].data);
             }
         }
         switch (timer_data[i].type)
@@ -231,14 +231,14 @@ interval_t do_timer (tick_t tick)
                 if (free_timer_list_pos >= free_timer_list_max)
                 {
                     free_timer_list_max += 256;
-                    RECREATE (free_timer_list, uint32_t, free_timer_list_max);
-                    memset (free_timer_list + (free_timer_list_max - 256),
-                            0, 256 * sizeof (uint32_t));
+                    RECREATE(free_timer_list, uint32_t, free_timer_list_max);
+                    memset(free_timer_list + (free_timer_list_max - 256),
+                            0, 256 * sizeof(uint32_t));
                 }
                 free_timer_list[free_timer_list_pos++] = i;
                 break;
             case TIMER_INTERVAL:
-                if (DIFF_TICK (timer_data[i].tick, tick) < -1000)
+                if (DIFF_TICK(timer_data[i].tick, tick) < -1000)
                 {
                     timer_data[i].tick = tick + timer_data[i].interval;
                 }
@@ -246,7 +246,7 @@ interval_t do_timer (tick_t tick)
                 {
                     timer_data[i].tick += timer_data[i].interval;
                 }
-                push_timer_heap (i);
+                push_timer_heap(i);
                 break;
         }
     }
diff --git a/src/common/timer.hpp b/src/common/timer.hpp
index fdda344..fc4f8cb 100644
--- a/src/common/timer.hpp
+++ b/src/common/timer.hpp
@@ -19,7 +19,7 @@ typedef uint32_t timer_id;
 // BUG: pointers are stored in here
 typedef int32_t custom_id_t;
 typedef int32_t custom_data_t;
-typedef void (*timer_func) (timer_id, tick_t, custom_id_t, custom_data_t);
+typedef void(*timer_func)(timer_id, tick_t, custom_id_t, custom_data_t);
 
 struct TimerData
 {
@@ -41,20 +41,20 @@ struct TimerData
 /// but use of 32-bit integers means it wraps every 49 days.
 // The only external caller of this function is the core.c main loop, but that makes sense
 // in fact, it might make more sense if gettick() ALWAYS returned that cached value
-tick_t gettick_nocache (void);
+tick_t gettick_nocache(void);
 /// This function is called enough that it's worth caching the result for
 /// the next 255 times
-tick_t gettick (void);
+tick_t gettick(void);
 
-timer_id add_timer (tick_t, timer_func, custom_id_t, custom_data_t);
-timer_id add_timer_interval (tick_t, timer_func, custom_id_t, custom_data_t, interval_t);
-void delete_timer (timer_id, timer_func);
+timer_id add_timer(tick_t, timer_func, custom_id_t, custom_data_t);
+timer_id add_timer_interval(tick_t, timer_func, custom_id_t, custom_data_t, interval_t);
+void delete_timer(timer_id, timer_func);
 
-tick_t addtick_timer (timer_id, interval_t);
-struct TimerData *get_timer (timer_id tid);
+tick_t addtick_timer(timer_id, interval_t);
+struct TimerData *get_timer(timer_id tid);
 
 /// Do all timers scheduled before tick, and return the number of milliseconds until the next timer happens
-interval_t do_timer (tick_t tick);
+interval_t do_timer(tick_t tick);
 
 
 
diff --git a/src/common/utils.cpp b/src/common/utils.cpp
index fbdd87e..732f3b1 100644
--- a/src/common/utils.cpp
+++ b/src/common/utils.cpp
@@ -9,10 +9,10 @@
 //-----------------------------------------------------
 // Function to suppress control characters in a string.
 //-----------------------------------------------------
-int remove_control_chars (char *str)
+int remove_control_chars(char *str)
 {
-    int  i;
-    int  change = 0;
+    int i;
+    int change = 0;
 
     for (i = 0; str[i]; i++)
     {
@@ -29,39 +29,39 @@ int remove_control_chars (char *str)
 //---------------------------------------------------
 // E-mail check: return 0 (not correct) or 1 (valid).
 //---------------------------------------------------
-int e_mail_check (const char *email)
+int e_mail_check(const char *email)
 {
     char ch;
     const char *last_arobas;
 
     // athena limits
-    if (strlen (email) < 3 || strlen (email) > 39)
+    if (strlen(email) < 3 || strlen(email) > 39)
         return 0;
 
     // part of RFC limits (official reference of e-mail description)
-    if (strchr (email, '@') == NULL || email[strlen (email) - 1] == '@')
+    if (strchr(email, '@') == NULL || email[strlen(email) - 1] == '@')
         return 0;
 
-    if (email[strlen (email) - 1] == '.')
+    if (email[strlen(email) - 1] == '.')
         return 0;
 
-    last_arobas = strrchr (email, '@');
+    last_arobas = strrchr(email, '@');
 
-    if (strstr (last_arobas, "@.") != NULL ||
-        strstr (last_arobas, "..") != NULL)
+    if (strstr(last_arobas, "@.") != NULL ||
+        strstr(last_arobas, "..") != NULL)
         return 0;
 
     for (ch = 1; ch < 32; ch++)
     {
-        if (strchr (last_arobas, ch) != NULL)
+        if (strchr(last_arobas, ch) != NULL)
         {
             return 0;
             break;
         }
     }
 
-    if (strchr (last_arobas, ' ') != NULL ||
-        strchr (last_arobas, ';') != NULL)
+    if (strchr(last_arobas, ' ') != NULL ||
+        strchr(last_arobas, ';') != NULL)
         return 0;
 
     // all correct
@@ -74,15 +74,15 @@ int e_mail_check (const char *email)
 //-------------------------------------------------
 int config_switch (const char *str)
 {
-    if (strcasecmp (str, "on") == 0 || strcasecmp (str, "yes") == 0
-        || strcasecmp (str, "oui") == 0 || strcasecmp (str, "ja") == 0
-        || strcasecmp (str, "si") == 0)
+    if (strcasecmp(str, "on") == 0 || strcasecmp(str, "yes") == 0
+        || strcasecmp(str, "oui") == 0 || strcasecmp(str, "ja") == 0
+        || strcasecmp(str, "si") == 0)
         return 1;
-    if (strcasecmp (str, "off") == 0 || strcasecmp (str, "no") == 0
-        || strcasecmp (str, "non") == 0 || strcasecmp (str, "nein") == 0)
+    if (strcasecmp(str, "off") == 0 || strcasecmp(str, "no") == 0
+        || strcasecmp(str, "non") == 0 || strcasecmp(str, "nein") == 0)
         return 0;
 
-    return atoi (str);
+    return atoi(str);
 }
 
 const char *ip2str(struct in_addr ip, bool extra_dot)
diff --git a/src/common/utils.hpp b/src/common/utils.hpp
index 1097bf7..fdd9d40 100644
--- a/src/common/utils.hpp
+++ b/src/common/utils.hpp
@@ -11,15 +11,15 @@ I deleted malloc.{h,c} because it was redundant;
 future calls should either use this or depend on the coming segfault.
 */
 # define CREATE(result, type, number) \
-   if (!((result) = (type *) calloc ((number), sizeof(type))))   \
+   if (!((result) = (type *) calloc((number), sizeof(type))))   \
       { perror("SYSERR: malloc failure"); abort(); } else (void)0
 
 # define RECREATE(result,type,number) \
-  if (!((result) = (type *) realloc ((result), sizeof(type) * (number))))\
+  if (!((result) = (type *) realloc((result), sizeof(type) * (number))))\
       { perror("SYSERR: realloc failure"); abort(); } else (void)0
 
-int remove_control_chars (char *str);
-int e_mail_check (const char *email);
+int remove_control_chars(char *str);
+int e_mail_check(const char *email);
 int config_switch (const char *str);
 const char *ip2str(struct in_addr ip, bool extra_dot = false);