cleanup:global:Reformat with astyle and remove trailing spaces

Mirrors 8a76acb and 41a1264

Signed-off-by: mvglasow <michael -at- vonglasow.com>

1 files changed, 655 insertions, 689 deletions

diff --git a/navit/util.c b/navit/util.c
index 2bb2887ea..c374edd46 100644
--- a/navit/util.c
+++ b/navit/util.c
@@ -39,33 +39,30 @@ typedef int ssize_t ;
 #include "config.h"
 
 void
-strtoupper(char *dest, const char *src)
-{
-	while (*src)
-		*dest++=toupper(*src++);
-	*dest='\0';
+strtoupper(char *dest, const char *src) {
+    while (*src)
+        *dest++=toupper(*src++);
+    *dest='\0';
 }
 
 void
-strtolower(char *dest, const char *src)
-{
-	while (*src)
-		*dest++=tolower(*src++);
-	*dest='\0';
+strtolower(char *dest, const char *src) {
+    while (*src)
+        *dest++=tolower(*src++);
+    *dest='\0';
 }
 
 int
-navit_utf8_strcasecmp(const char *s1, const char *s2)
-{
-        char *s1_folded,*s2_folded;
-	int cmpres;
-	s1_folded=g_utf8_casefold(s1,-1);
-	s2_folded=g_utf8_casefold(s2,-1);
-	cmpres=strcmp(s1_folded,s2_folded);
-	dbg(lvl_debug,"Compared %s with %s, got %d",s1_folded,s2_folded,cmpres);
-	g_free(s1_folded);
-	g_free(s2_folded);
-	return cmpres;
+navit_utf8_strcasecmp(const char *s1, const char *s2) {
+    char *s1_folded,*s2_folded;
+    int cmpres;
+    s1_folded=g_utf8_casefold(s1,-1);
+    s2_folded=g_utf8_casefold(s2,-1);
+    cmpres=strcmp(s1_folded,s2_folded);
+    dbg(lvl_debug,"Compared %s with %s, got %d",s1_folded,s2_folded,cmpres);
+    g_free(s1_folded);
+    g_free(s2_folded);
+    return cmpres;
 }
 
 /**
@@ -78,23 +75,23 @@ navit_utf8_strcasecmp(const char *s1, const char *s2)
  * @param s The string to trim
  */
 void strtrim(char *s) {
-	char *tmp = g_strdup(s);
-	char *in = tmp;
-	while (strlen(in) && (in[0] <= 0x20))
-		in++;
-	while (strlen(in) && (in[strlen(in) - 1] <= 0x20))
-		in[strlen(in) - 1] = 0;
-	strcpy(s, in);
-	g_free(tmp);
+    char *tmp = g_strdup(s);
+    char *in = tmp;
+    while (strlen(in) && (in[0] <= 0x20))
+        in++;
+    while (strlen(in) && (in[strlen(in) - 1] <= 0x20))
+        in[strlen(in) - 1] = 0;
+    strcpy(s, in);
+    g_free(tmp);
 }
 
 /**
  * @brief Parser states for `parse_for_systematic_comparison()`.
  */
 enum parse_state {
-	parse_state_whitespace,
-	parse_state_numeric,
-	parse_state_alpha,
+    parse_state_whitespace,
+    parse_state_numeric,
+    parse_state_alpha,
 };
 
 /**
@@ -112,85 +109,85 @@ enum parse_state {
  * followed by a double null character.
  */
 static char * parse_for_systematic_comparison(const char *s) {
-	char *ret = g_malloc0(strlen(s) * 2 + 1);
-	const char *in = s;
-	char *out = ret;
-	char *part;
-	enum parse_state state = parse_state_whitespace;
-	int i = 0;
-	char c;
-
-	dbg(lvl_debug, "enter\n");
-
-	while (i < strlen(in)) {
-		c = in[i];
-		if ((c <= 0x20) || (c == ',') || (c == '-') || (c == '.') || (c == '/')) {
-			/* whitespace */
-			if (state == parse_state_numeric) {
-				part = g_malloc0(i + 1);
-				strncpy(part, in, i);
-				sprintf(part, "%d", atoi(part));
-				strcpy(out, part);
-				out += strlen(part) + 1;
-				dbg(lvl_debug, "part='%s'\n", part);
-				g_free(part);
-				in += i;
-				i = 1;
-				state = parse_state_whitespace;
-			} else
-				i++;
-		} else if ((c >= '0') && (c <= '9')) {
-			/* numeric */
-			if (state == parse_state_alpha) {
-				part = g_malloc0(i + 1);
-				strncpy(part, in, i);
-				strtrim(part);
-				strcpy(out, part);
-				out += strlen(part) + 1;
-				dbg(lvl_debug, "part='%s'\n", part);
-				g_free(part);
-				in += i;
-				i = 1;
-			} else
-				i++;
-			state = parse_state_numeric;
-		} else {
-			/* alpha */
-			if (state == parse_state_numeric) {
-				part = g_malloc0(i + 1);
-				strncpy(part, in, i);
-				sprintf(part, "%d", atoi(part));
-				strcpy(out, part);
-				out += strlen(part) + 1;
-				dbg(lvl_debug, "part='%s'\n", part);
-				g_free(part);
-				in += i;
-				i = 1;
-			} else
-				i++;
-			state = parse_state_alpha;
-		}
-	}
-
-	if (strlen(in) > 0) {
-		if (state == parse_state_numeric) {
-			part = g_malloc0(strlen(in) + 1);
-			strcpy(part, in);
-			sprintf(part, "%d", atoi(part));
-			strcpy(out, part);
-			dbg(lvl_debug, "part='%s'\n", part);
-			g_free(part);
-		} else if (state == parse_state_alpha) {
-			part = g_malloc0(strlen(in) + 1);
-			strcpy(part, in);
-			strtrim(part);
-			strcpy(out, part);
-			dbg(lvl_debug, "part='%s'\n", part);
-			g_free(part);
-		}
-	}
-
-	return ret;
+    char *ret = g_malloc0(strlen(s) * 2 + 1);
+    const char *in = s;
+    char *out = ret;
+    char *part;
+    enum parse_state state = parse_state_whitespace;
+    int i = 0;
+    char c;
+
+    dbg(lvl_debug, "enter\n");
+
+    while (i < strlen(in)) {
+        c = in[i];
+        if ((c <= 0x20) || (c == ',') || (c == '-') || (c == '.') || (c == '/')) {
+            /* whitespace */
+            if (state == parse_state_numeric) {
+                part = g_malloc0(i + 1);
+                strncpy(part, in, i);
+                sprintf(part, "%d", atoi(part));
+                strcpy(out, part);
+                out += strlen(part) + 1;
+                dbg(lvl_debug, "part='%s'\n", part);
+                g_free(part);
+                in += i;
+                i = 1;
+                state = parse_state_whitespace;
+            } else
+                i++;
+        } else if ((c >= '0') && (c <= '9')) {
+            /* numeric */
+            if (state == parse_state_alpha) {
+                part = g_malloc0(i + 1);
+                strncpy(part, in, i);
+                strtrim(part);
+                strcpy(out, part);
+                out += strlen(part) + 1;
+                dbg(lvl_debug, "part='%s'\n", part);
+                g_free(part);
+                in += i;
+                i = 1;
+            } else
+                i++;
+            state = parse_state_numeric;
+        } else {
+            /* alpha */
+            if (state == parse_state_numeric) {
+                part = g_malloc0(i + 1);
+                strncpy(part, in, i);
+                sprintf(part, "%d", atoi(part));
+                strcpy(out, part);
+                out += strlen(part) + 1;
+                dbg(lvl_debug, "part='%s'\n", part);
+                g_free(part);
+                in += i;
+                i = 1;
+            } else
+                i++;
+            state = parse_state_alpha;
+        }
+    }
+
+    if (strlen(in) > 0) {
+        if (state == parse_state_numeric) {
+            part = g_malloc0(strlen(in) + 1);
+            strcpy(part, in);
+            sprintf(part, "%d", atoi(part));
+            strcpy(out, part);
+            dbg(lvl_debug, "part='%s'\n", part);
+            g_free(part);
+        } else if (state == parse_state_alpha) {
+            part = g_malloc0(strlen(in) + 1);
+            strcpy(part, in);
+            strtrim(part);
+            strcpy(out, part);
+            dbg(lvl_debug, "part='%s'\n", part);
+            g_free(part);
+        }
+    }
+
+    return ret;
 }
 
 /**
@@ -216,106 +213,100 @@ static char * parse_for_systematic_comparison(const char *s) {
  */
 /* TODO break up strings at semicolons and parse each separately, return 0 if any two match */
 int compare_name_systematic(const char *s1, const char *s2) {
-	int ret = 0;
-	char *l, *r, *l0, *r0;
-
-	if (!s1 || !s1[0]) {
-		if (!s2 || !s2[0])
-			return 0;
-		else
-			return 1;
-	} else if (!s2 || !s2[0])
-		return -1;
-
-	l0 = parse_for_systematic_comparison(s1);
-	r0 = parse_for_systematic_comparison(s2);
-
-	l = l0;
-	r = r0;
-
-	while (!ret && l[0] && r[0]) {
-		if (atoi(l) || (l[0] == '0')) {
-			if (atoi(r) || (r[0] == '0'))
-				ret = atoi(l) - atoi(r);
-			else
-				ret = -1;
-		} else {
-			if (atoi(r) || (r[0] == '0'))
-				ret = 1;
-			else
-				ret = strcasecmp(l, r);
-		}
-
-		l += strlen(l) + 1;
-		r += strlen(r) + 1;
-	}
-
-	if (!ret)
-		ret = l[0] - r[0];
-
-	dbg(lvl_debug, "'%s' %s '%s'\n", s1, ret?"does NOT match":"matches", s2);
-
-	g_free(l0);
-	g_free(r0);
-
-	return ret;
+    int ret = 0;
+    char *l, *r, *l0, *r0;
+
+    if (!s1 || !s1[0]) {
+        if (!s2 || !s2[0])
+            return 0;
+        else
+            return 1;
+    } else if (!s2 || !s2[0])
+        return -1;
+
+    l0 = parse_for_systematic_comparison(s1);
+    r0 = parse_for_systematic_comparison(s2);
+
+    l = l0;
+    r = r0;
+
+    while (!ret && l[0] && r[0]) {
+        if (atoi(l) || (l[0] == '0')) {
+            if (atoi(r) || (r[0] == '0'))
+                ret = atoi(l) - atoi(r);
+            else
+                ret = -1;
+        } else {
+            if (atoi(r) || (r[0] == '0'))
+                ret = 1;
+            else
+                ret = strcasecmp(l, r);
+        }
+
+        l += strlen(l) + 1;
+        r += strlen(r) + 1;
+    }
+
+    if (!ret)
+        ret = l[0] - r[0];
+
+    dbg(lvl_debug, "'%s' %s '%s'\n", s1, ret?"does NOT match":"matches", s2);
+
+    g_free(l0);
+    g_free(r0);
+
+    return ret;
 }
 
 static void
-hash_callback(gpointer key, gpointer value, gpointer user_data)
-{
-	GList **l=user_data;
-	*l=g_list_prepend(*l, value);
+hash_callback(gpointer key, gpointer value, gpointer user_data) {
+    GList **l=user_data;
+    *l=g_list_prepend(*l, value);
 }
 
 GList *
-g_hash_to_list(GHashTable *h)
-{
-	GList *ret=NULL;
-	g_hash_table_foreach(h, hash_callback, &ret);
+g_hash_to_list(GHashTable *h) {
+    GList *ret=NULL;
+    g_hash_table_foreach(h, hash_callback, &ret);
 
-	return ret;
+    return ret;
 }
 
 static void
-hash_callback_key(gpointer key, gpointer value, gpointer user_data)
-{
-	GList **l=user_data;
-	*l=g_list_prepend(*l, key);
+hash_callback_key(gpointer key, gpointer value, gpointer user_data) {
+    GList **l=user_data;
+    *l=g_list_prepend(*l, key);
 }
 
 GList *
-g_hash_to_list_keys(GHashTable *h)
-{
-	GList *ret=NULL;
-	g_hash_table_foreach(h, hash_callback_key, &ret);
+g_hash_to_list_keys(GHashTable *h) {
+    GList *ret=NULL;
+    g_hash_table_foreach(h, hash_callback_key, &ret);
 
-	return ret;
+    return ret;
 }
 
 gchar *
-g_strconcat_printf(gchar *buffer, gchar *fmt, ...)
-{
-	gchar *str,*ret;
-	va_list ap;
-
-	va_start(ap, fmt);
-        str=g_strdup_vprintf(fmt, ap);
-        va_end(ap);
-	if (! buffer)
-		return str;
-	ret=g_strconcat(buffer, str, NULL);
-	g_free(buffer);
-	g_free(str);
-	return ret;
+g_strconcat_printf(gchar *buffer, gchar *fmt, ...) {
+    gchar *str,*ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    str=g_strdup_vprintf(fmt, ap);
+    va_end(ap);
+    if (! buffer)
+        return str;
+    ret=g_strconcat(buffer, str, NULL);
+    g_free(buffer);
+    g_free(str);
+    return ret;
 }
 
 #ifndef HAVE_GLIB
 int g_utf8_strlen_force_link(gchar *buffer, int max);
 int
-g_utf8_strlen_force_link(gchar *buffer, int max)
-{
-	return g_utf8_strlen(buffer, max);
+g_utf8_strlen_force_link(gchar *buffer, int max) {
+    return g_utf8_strlen(buffer, max);
 }
 #endif
 
@@ -325,33 +316,30 @@ g_utf8_strlen_force_link(gchar *buffer, int max)
 #endif
 
 #if defined(_WIN32) || defined(__CEGCC__) || defined (__APPLE__) || defined(HAVE_API_ANDROID)
-char *stristr(const char *String, const char *Pattern)
-{
-      char *pptr, *sptr, *start;
-
-      for (start = (char *)String; *start != (int)NULL; start++)
-      {
-            /* find start of pattern in string */
-            for ( ; ((*start!=(int)NULL) && (toupper(*start) != toupper(*Pattern))); start++)
-                  ;
-            if ((int)NULL == *start)
-                  return NULL;
-
-            pptr = (char *)Pattern;
-            sptr = (char *)start;
-
-            while (toupper(*sptr) == toupper(*pptr))
-            {
-                  sptr++;
-                  pptr++;
-
-                  /* if end of pattern then pattern was found */
-
-                  if ((int)NULL == *pptr)
-                        return (start);
-            }
-      }
-      return NULL;
+char *stristr(const char *String, const char *Pattern) {
+    char *pptr, *sptr, *start;
+
+    for (start = (char *)String; *start != (int)NULL; start++) {
+        /* find start of pattern in string */
+        for ( ; ((*start!=(int)NULL) && (toupper(*start) != toupper(*Pattern))); start++)
+            ;
+        if ((int)NULL == *start)
+            return NULL;
+
+        pptr = (char *)Pattern;
+        sptr = (char *)start;
+
+        while (toupper(*sptr) == toupper(*pptr)) {
+            sptr++;
+            pptr++;
+
+            /* if end of pattern then pattern was found */
+
+            if ((int)NULL == *pptr)
+                return (start);
+        }
+    }
+    return NULL;
 }
 
 #ifndef SIZE_MAX
@@ -378,111 +366,99 @@ char *stristr(const char *String, const char *Pattern)
 #ifndef HAVE_GETDELIM
 /**
  * @brief Reads the part of a file up to a delimiter to a string.
- * <p> 
+ * <p>
  * Read up to (and including) a DELIMITER from FP into *LINEPTR (and NUL-terminate it).
  *
  * @param lineptr Pointer to a pointer returned from malloc (or NULL), pointing to a buffer. It is
  * realloc'ed as necessary and will receive the data read.
- * @param n Size of the buffer.  
+ * @param n Size of the buffer.
  *
  * @return Number of characters read (not including the null terminator), or -1 on error or EOF.
 */
 ssize_t
-getdelim (char **lineptr, size_t *n, int delimiter, FILE *fp)
-{
-  int result;
-  size_t cur_len = 0;
+getdelim (char **lineptr, size_t *n, int delimiter, FILE *fp) {
+    int result;
+    size_t cur_len = 0;
 
-  if (lineptr == NULL || n == NULL || fp == NULL)
-    {
-      return -1;
+    if (lineptr == NULL || n == NULL || fp == NULL) {
+        return -1;
     }
 
-  flockfile (fp);
+    flockfile (fp);
 
-  if (*lineptr == NULL || *n == 0)
-    {
-      *n = 120;
-      *lineptr = (char *) realloc (*lineptr, *n);
-      if (*lineptr == NULL)
-	{
-	  result = -1;
-	  goto unlock_return;
-	}
+    if (*lineptr == NULL || *n == 0) {
+        *n = 120;
+        *lineptr = (char *) realloc (*lineptr, *n);
+        if (*lineptr == NULL) {
+            result = -1;
+            goto unlock_return;
+        }
     }
 
-  for (;;)
-    {
-      int i;
-
-      i = getc (fp);
-      if (i == EOF)
-	{
-	  result = -1;
-	  break;
-	}
-
-      /* Make enough space for len+1 (for final NUL) bytes.  */
-      if (cur_len + 1 >= *n)
-	{
-	  size_t needed_max=SIZE_MAX;
-	  size_t needed = 2 * *n + 1;   /* Be generous. */
-	  char *new_lineptr;
-	  if (needed_max < needed)
-	    needed = needed_max;
-	  if (cur_len + 1 >= needed)
-	    {
-	      result = -1;
-	      goto unlock_return;
-	    }
-
-	  new_lineptr = (char *) realloc (*lineptr, needed);
-	  if (new_lineptr == NULL)
-	    {
-	      result = -1;
-	      goto unlock_return;
-	    }
-
-	  *lineptr = new_lineptr;
-	  *n = needed;
-	}
-
-      (*lineptr)[cur_len] = i;
-      cur_len++;
-
-      if (i == delimiter)
-	break;
+    for (;;) {
+        int i;
+
+        i = getc (fp);
+        if (i == EOF) {
+            result = -1;
+            break;
+        }
+
+        /* Make enough space for len+1 (for final NUL) bytes.  */
+        if (cur_len + 1 >= *n) {
+            size_t needed_max=SIZE_MAX;
+            size_t needed = 2 * *n + 1;   /* Be generous. */
+            char *new_lineptr;
+            if (needed_max < needed)
+                needed = needed_max;
+            if (cur_len + 1 >= needed) {
+                result = -1;
+                goto unlock_return;
+            }
+
+            new_lineptr = (char *) realloc (*lineptr, needed);
+            if (new_lineptr == NULL) {
+                result = -1;
+                goto unlock_return;
+            }
+
+            *lineptr = new_lineptr;
+            *n = needed;
+        }
+
+        (*lineptr)[cur_len] = i;
+        cur_len++;
+
+        if (i == delimiter)
+            break;
     }
-  (*lineptr)[cur_len] = '\0';
-  result = cur_len ? cur_len : result;
+    (*lineptr)[cur_len] = '\0';
+    result = cur_len ? cur_len : result;
 
- unlock_return:
-  funlockfile (fp); /* doesn't set errno */
+unlock_return:
+    funlockfile (fp); /* doesn't set errno */
 
-  return result;
+    return result;
 }
 #endif
 
 #ifndef HAVE_GETLINE
 ssize_t
-getline (char **lineptr, size_t *n, FILE *stream)
-{
-  return getdelim (lineptr, n, '\n', stream);
+getline (char **lineptr, size_t *n, FILE *stream) {
+    return getdelim (lineptr, n, '\n', stream);
 }
 #endif
 
 #if defined(_UNICODE)
-wchar_t* newSysString(const char *toconvert)
-{
-	int newstrlen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toconvert, -1, 0, 0);
-	wchar_t *newstring = g_new(wchar_t,newstrlen);
-	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toconvert, -1, newstring, newstrlen) ;
-	return newstring;
+wchar_t* newSysString(const char *toconvert) {
+    int newstrlen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toconvert, -1, 0, 0);
+    wchar_t *newstring = g_new(wchar_t,newstrlen);
+    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toconvert, -1, newstring, newstrlen) ;
+    return newstring;
 }
 #else
-char * newSysString(const char *toconvert)
-{
-	return g_strdup(toconvert);
+char * newSysString(const char *toconvert) {
+    return g_strdup(toconvert);
 }
 #endif
 #endif
@@ -492,14 +468,13 @@ char * newSysString(const char *toconvert)
  * Impements a simple incomplete version of gettimeofday. Only usefull for messuring
  * time spans, not the real time of day.
  */
-int gettimeofday(struct timeval *time, void *local)
-{
-  int milliseconds = GetTickCount();
+int gettimeofday(struct timeval *time, void *local) {
+    int milliseconds = GetTickCount();
 
-  time->tv_sec = milliseconds/1000;
-  time->tv_usec = (milliseconds - (time->tv_sec * 1000)) * 1000;
+    time->tv_sec = milliseconds/1000;
+    time->tv_usec = (milliseconds - (time->tv_sec * 1000)) * 1000;
 
-  return 0;
+    return 0;
 }
 #endif
 /**
@@ -510,31 +485,30 @@ int gettimeofday(struct timeval *time, void *local)
  * @return The number of seconds elapsed since January 1, 1970, 00:00:00 UTC.
  */
 unsigned int
-iso8601_to_secs(char *iso8601)
-{
-	int a,b,d,val[6],i=0;
-	char *start=iso8601,*pos=iso8601;
-	while (*pos && i < 6) {
-		if (*pos < '0' || *pos > '9') {
-			val[i++]=atoi(start);
-			pos++;
-			start=pos;
-		} 
-		if(*pos)
-			pos++;
-	}
-	
-	a=val[0]/100;
-	b=2-a+a/4;
-
-	if (val[1] < 2) {
-		val[0]--;
-		val[1]+=12;
-	}
-
-	d=1461*(val[0]+4716)/4+306001*(val[1]+1)/10000+val[2]+b-2442112;
-
-	return ((d*24+val[3])*60+val[4])*60+val[5];
+iso8601_to_secs(char *iso8601) {
+    int a,b,d,val[6],i=0;
+    char *start=iso8601,*pos=iso8601;
+    while (*pos && i < 6) {
+        if (*pos < '0' || *pos > '9') {
+            val[i++]=atoi(start);
+            pos++;
+            start=pos;
+        }
+        if(*pos)
+            pos++;
+    }
+
+    a=val[0]/100;
+    b=2-a+a/4;
+
+    if (val[1] < 2) {
+        val[0]--;
+        val[1]+=12;
+    }
+
+    d=1461*(val[0]+4716)/4+306001*(val[1]+1)/10000+val[2]+b-2442112;
+
+    return ((d*24+val[3])*60+val[4])*60+val[5];
 }
 
 /**
@@ -558,89 +532,89 @@ iso8601_to_secs(char *iso8601)
  *
  */
 time_t mkgmtime(struct tm * pt) {
-	time_t ret;
+    time_t ret;
 
-	/* Input, GMT and local time */
-	struct tm * pti, * pgt, * plt;
+    /* Input, GMT and local time */
+    struct tm * pti, * pgt, * plt;
 
-	pti = g_memdup(pt, sizeof(struct tm));
+    pti = g_memdup(pt, sizeof(struct tm));
 
-	ret = mktime(pti);
+    ret = mktime(pti);
 
-	pgt = g_memdup(gmtime(&ret), sizeof(struct tm));
-	plt = g_memdup(localtime(&ret), sizeof(struct tm));
+    pgt = g_memdup(gmtime(&ret), sizeof(struct tm));
+    plt = g_memdup(localtime(&ret), sizeof(struct tm));
 
-	pti->tm_year -= pgt->tm_year - plt->tm_year;
-	pti->tm_mon -= pgt->tm_mon - plt->tm_mon;
-	pti->tm_mday -= pgt->tm_mday - plt->tm_mday;
-	pti->tm_hour -= pgt->tm_hour - plt->tm_hour;
-	pti->tm_min -= pgt->tm_min - plt->tm_min;
-	pti->tm_sec -= pgt->tm_sec - plt->tm_sec;
+    pti->tm_year -= pgt->tm_year - plt->tm_year;
+    pti->tm_mon -= pgt->tm_mon - plt->tm_mon;
+    pti->tm_mday -= pgt->tm_mday - plt->tm_mday;
+    pti->tm_hour -= pgt->tm_hour - plt->tm_hour;
+    pti->tm_min -= pgt->tm_min - plt->tm_min;
+    pti->tm_sec -= pgt->tm_sec - plt->tm_sec;
 
-	ret = mktime(pti);
+    ret = mktime(pti);
 
-	dbg(lvl_debug, "time %ld (%02d-%02d-%02d %02d:%02d:%02d)\n", ret, pti->tm_year, pti->tm_mon, pti->tm_mday,
-			pti->tm_hour, pti->tm_min, pti->tm_sec);
+    dbg(lvl_debug, "time %ld (%02d-%02d-%02d %02d:%02d:%02d)\n", ret, pti->tm_year, pti->tm_mon, pti->tm_mday,
+        pti->tm_hour, pti->tm_min, pti->tm_sec);
 
-	g_free(pti);
-	g_free(pgt);
-	g_free(plt);
+    g_free(pti);
+    g_free(pgt);
+    g_free(plt);
 
-	return ret;
+    return ret;
 }
 
 /**
  * @brief Converts an ISO 8601-style time string into `time_t`.
  */
 time_t iso8601_to_time(char * iso8601) {
-	/* Date/time fields (YYYY-MM-DD-hh-mm-ss) */
-	int val[8];
-
-	int i = 0;
-
-	/* Start of next integer portion and current position */
-	char *start = iso8601, *pos = iso8601;
-
-	/* Time struct */
-	struct tm tm;
-
-	memset(&tm, 0, sizeof(struct tm));
-
-	while (*pos && i < 6) {
-		if (*pos < '0' || *pos > '9') {
-			val[i++] = atoi(start);
-			pos++;
-			start = pos;
-		}
-		if (*pos)
-			pos++;
-	}
-	val[6] = 0;
-	val[7] = 0;
-	if (*pos && i == 6) {
-		if (pos[1] && pos[2] && (!pos[3] || pos[3] == ':')) {
-			val[6] = atoi(pos);
-			if (pos[3] == ':') {
-				pos += 3;
-				val[7] = (val[6] < 0) ? -atoi(pos) : atoi(pos);
-			}
-		} else if (pos[1] && pos[2] && pos[3] && pos[4]) {
-			val[6] = atoi(pos) / 100;
-			val[7] = atoi(pos) % 100;
-		}
-	}
-
-	tm.tm_year = val[0] - 1900;
-	tm.tm_mon = val[1] - 1;
-	tm.tm_mday = val[2];
-	tm.tm_hour = val[3];
-	tm.tm_min = val[4] - val[6];
-	tm.tm_sec = val[5] - val[7];
-
-	dbg(lvl_debug, "time %s (%02d-%02d-%02d %02d:%02d:%02d)\n", iso8601, tm.tm_year, tm.tm_mon, tm.tm_mday,
-			tm.tm_hour, tm.tm_min, tm.tm_sec);
-
-	return mkgmtime(&tm);
+    /* Date/time fields (YYYY-MM-DD-hh-mm-ss) */
+    int val[8];
+
+    int i = 0;
+
+    /* Start of next integer portion and current position */
+    char *start = iso8601, *pos = iso8601;
+
+    /* Time struct */
+    struct tm tm;
+
+    memset(&tm, 0, sizeof(struct tm));
+
+    while (*pos && i < 6) {
+        if (*pos < '0' || *pos > '9') {
+            val[i++] = atoi(start);
+            pos++;
+            start = pos;
+        }
+        if (*pos)
+            pos++;
+    }
+    val[6] = 0;
+    val[7] = 0;
+    if (*pos && i == 6) {
+        if (pos[1] && pos[2] && (!pos[3] || pos[3] == ':')) {
+            val[6] = atoi(pos);
+            if (pos[3] == ':') {
+                pos += 3;
+                val[7] = (val[6] < 0) ? -atoi(pos) : atoi(pos);
+            }
+        } else if (pos[1] && pos[2] && pos[3] && pos[4]) {
+            val[6] = atoi(pos) / 100;
+            val[7] = atoi(pos) % 100;
+        }
+    }
+
+    tm.tm_year = val[0] - 1900;
+    tm.tm_mon = val[1] - 1;
+    tm.tm_mday = val[2];
+    tm.tm_hour = val[3];
+    tm.tm_min = val[4] - val[6];
+    tm.tm_sec = val[5] - val[7];
+
+    dbg(lvl_debug, "time %s (%02d-%02d-%02d %02d:%02d:%02d)\n", iso8601, tm.tm_year, tm.tm_mon, tm.tm_mday,
+        tm.tm_hour, tm.tm_min, tm.tm_sec);
+
+    return mkgmtime(&tm);
 }
 
 /**
@@ -653,16 +627,16 @@ time_t iso8601_to_time(char * iso8601) {
  * @return Time in ISO8601 format
  */
 char * time_to_iso8601(time_t time) {
-	char *timep=NULL;
-	char buffer[32];
-	struct tm *tm;
-
-	tm = gmtime(&time);
-	if (tm) {
-		strftime(buffer, sizeof(buffer), "%Y-%m-%dT%TZ", tm);
-		timep=g_strdup(buffer);
-	}
-	return timep;
+    char *timep=NULL;
+    char buffer[32];
+    struct tm *tm;
+
+    tm = gmtime(&time);
+    if (tm) {
+        strftime(buffer, sizeof(buffer), "%Y-%m-%dT%TZ", tm);
+        timep=g_strdup(buffer);
+    }
+    return timep;
 }
 
 /**
@@ -671,28 +645,27 @@ char * time_to_iso8601(time_t time) {
  * @return Time in ISO 8601 format
  */
 char *
-current_to_iso8601(void)
-{
+current_to_iso8601(void) {
 #ifdef HAVE_API_WIN32_BASE
-	char *timep=NULL;
-	SYSTEMTIME ST;
-	GetSystemTime(&ST);
-	timep=g_strdup_printf("%d-%02d-%02dT%02d:%02d:%02dZ",ST.wYear,ST.wMonth,ST.wDay,ST.wHour,ST.wMinute,ST.wSecond);
-	return timep;
+    char *timep=NULL;
+    SYSTEMTIME ST;
+    GetSystemTime(&ST);
+    timep=g_strdup_printf("%d-%02d-%02dT%02d:%02d:%02dZ",ST.wYear,ST.wMonth,ST.wDay,ST.wHour,ST.wMinute,ST.wSecond);
+    return timep;
 #else
-	time_t tnow;
-	tnow = time(0);
-	return time_to_iso8601(tnow);
+    time_t tnow;
+    tnow = time(0);
+    return time_to_iso8601(tnow);
 #endif
 }
 
 
 struct spawn_process_info {
 #ifdef HAVE_API_WIN32_BASE
-	PROCESS_INFORMATION pr;
+    PROCESS_INFORMATION pr;
 #else
-	pid_t pid; // = -1 if non-blocking spawn isn't supported
-	int status; // exit status if non-blocking spawn isn't supported
+    pid_t pid; // = -1 if non-blocking spawn isn't supported
+    int status; // exit status if non-blocking spawn isn't supported
 #endif
 };
 
@@ -704,94 +677,92 @@ struct spawn_process_info {
  * @returns escaped string
  */
 char *
-shell_escape(char *arg) 
-{
-	char *r;
-	int arglen=strlen(arg);
-	int i,j,rlen;
+shell_escape(char *arg) {
+    char *r;
+    int arglen=strlen(arg);
+    int i,j,rlen;
 #ifdef HAVE_API_WIN32_BASE
-	{
-		int bscount=0;
-		rlen=arglen+3;
-		r=g_new(char,rlen);
-		r[0]='"';
-		for(i=0,j=1;i<arglen;i++) {
-			if(arg[i]=='\\') {
-				bscount++;
-				if(i==(arglen-1)) {
-					// Most special case - last char is 
-					// backslash. We can't escape it inside
-					// quoted string due to Win unescaping 
-					// rules so quote should be closed 
-					// before backslashes and these
-					// backslashes shouldn't be doubled
-					rlen+=bscount;
-					r=g_realloc(r,rlen);
-					r[j++]='"';
-					memset(r+j,'\\',bscount);
-					j+=bscount;
-				}
-			} else {
-				//Any preceeding backslashes will be doubled.
-				bscount*=2;
-				// Double quote needs to be preceeded by 
-				// at least one backslash
-				if(arg[i]=='"')
-					bscount++;
-				if(bscount>0) {
-					rlen+=bscount;
-					r=g_realloc(r,rlen);
-					memset(r+j,'\\',bscount);
-					j+=bscount;
-					bscount=0;
-				}
-				r[j++]=arg[i];
-				if(i==(arglen-1)) {
-					r[j++]='"';
-				}
-			}
-		}
-		r[j++]=0;
-	}
+    {
+        int bscount=0;
+        rlen=arglen+3;
+        r=g_new(char,rlen);
+        r[0]='"';
+        for(i=0,j=1; i<arglen; i++) {
+            if(arg[i]=='\\') {
+                bscount++;
+                if(i==(arglen-1)) {
+                    // Most special case - last char is
+                    // backslash. We can't escape it inside
+                    // quoted string due to Win unescaping
+                    // rules so quote should be closed
+                    // before backslashes and these
+                    // backslashes shouldn't be doubled
+                    rlen+=bscount;
+                    r=g_realloc(r,rlen);
+                    r[j++]='"';
+                    memset(r+j,'\\',bscount);
+                    j+=bscount;
+                }
+            } else {
+                //Any preceeding backslashes will be doubled.
+                bscount*=2;
+                // Double quote needs to be preceeded by
+                // at least one backslash
+                if(arg[i]=='"')
+                    bscount++;
+                if(bscount>0) {
+                    rlen+=bscount;
+                    r=g_realloc(r,rlen);
+                    memset(r+j,'\\',bscount);
+                    j+=bscount;
+                    bscount=0;
+                }
+                r[j++]=arg[i];
+                if(i==(arglen-1)) {
+                    r[j++]='"';
+                }
+            }
+        }
+        r[j++]=0;
+    }
 #else
-	{
-		// Will use hard quoting for the whole string
-		// and replace each singular quote found with a '\'' sequence.
-		rlen=arglen+3;
-		r=g_new(char,rlen);
-		r[0]='\'';
-		for(i=0,j=1;i<arglen;i++) {
-			if(arg[i]=='\'') {
-				rlen+=3;
-				r=g_realloc(r,rlen);
-				g_strlcpy(r+j,"'\\''",rlen-j);
-			} else {
-				r[j++]=arg[i];
-			}
-		}
-		r[j++]='\'';
-		r[j++]=0;
-	}
+    {
+        // Will use hard quoting for the whole string
+        // and replace each singular quote found with a '\'' sequence.
+        rlen=arglen+3;
+        r=g_new(char,rlen);
+        r[0]='\'';
+        for(i=0,j=1; i<arglen; i++) {
+            if(arg[i]=='\'') {
+                rlen+=3;
+                r=g_realloc(r,rlen);
+                g_strlcpy(r+j,"'\\''",rlen-j);
+            } else {
+                r[j++]=arg[i];
+            }
+        }
+        r[j++]='\'';
+        r[j++]=0;
+    }
 #endif
-	return r;
+    return r;
 }
 
 #ifndef _POSIX_C_SOURCE
 static char*
-spawn_process_compose_cmdline(char **argv)
-{
-	int i,j;
-	char *cmdline=shell_escape(argv[0]);
-	for(i=1,j=strlen(cmdline);argv[i];i++) {
-		char *arg=shell_escape(argv[i]);
-		int arglen=strlen(arg);
-		cmdline[j]=' ';
-		cmdline=g_realloc(cmdline,j+1+arglen+1);
-		memcpy(cmdline+j+1,arg,arglen+1);
-		g_free(arg);
-		j=j+1+arglen;
-	}
-	return cmdline;
+spawn_process_compose_cmdline(char **argv) {
+    int i,j;
+    char *cmdline=shell_escape(argv[0]);
+    for(i=1,j=strlen(cmdline); argv[i]; i++) {
+        char *arg=shell_escape(argv[i]);
+        int arglen=strlen(arg);
+        cmdline[j]=' ';
+        cmdline=g_realloc(cmdline,j+1+arglen+1);
+        memcpy(cmdline+j+1,arg,arglen+1);
+        g_free(arg);
+        j=j+1+arglen;
+    }
+    return cmdline;
 }
 #endif
 
@@ -816,82 +787,81 @@ GList *spawn_process_children=NULL;
  * @returns 0 - success, >0 - return code, -1 - error
  */
 struct spawn_process_info*
-spawn_process(char **argv)
-{
-	struct spawn_process_info*r=g_new(struct spawn_process_info,1);
+spawn_process(char **argv) {
+    struct spawn_process_info*r=g_new(struct spawn_process_info,1);
 #ifdef _POSIX_C_SOURCE
-	{
-		pid_t pid;
-		
-		sigset_t set, old;
-		dbg(lvl_debug,"spawning process for '%s'", argv[0]);
-		sigemptyset(&set);
-		sigaddset(&set,SIGCHLD);
-		spawn_process_sigmask(SIG_BLOCK,&set,&old);
-		pid=fork();
-		if(pid==0) {
-			execvp(argv[0], argv);
-			/*Shouldn't reach here*/
-			exit(1);
-		} else if(pid>0) {
-			r->status=-1;
-			r->pid=pid;
-			spawn_process_children=g_list_prepend(spawn_process_children,r);
-		} else {
-			dbg(lvl_error,"fork() returned error.");
-			g_free(r);
-			r=NULL;
-		}
-		spawn_process_sigmask(SIG_SETMASK,&old,NULL);
-		return r;
-	}
+    {
+        pid_t pid;
+
+        sigset_t set, old;
+        dbg(lvl_debug,"spawning process for '%s'", argv[0]);
+        sigemptyset(&set);
+        sigaddset(&set,SIGCHLD);
+        spawn_process_sigmask(SIG_BLOCK,&set,&old);
+        pid=fork();
+        if(pid==0) {
+            execvp(argv[0], argv);
+            /*Shouldn't reach here*/
+            exit(1);
+        } else if(pid>0) {
+            r->status=-1;
+            r->pid=pid;
+            spawn_process_children=g_list_prepend(spawn_process_children,r);
+        } else {
+            dbg(lvl_error,"fork() returned error.");
+            g_free(r);
+            r=NULL;
+        }
+        spawn_process_sigmask(SIG_SETMASK,&old,NULL);
+        return r;
+    }
 #else
 #ifdef HAVE_API_WIN32_BASE
-	{
-		char *cmdline;
-		DWORD dwRet;
-
-		// For [desktop] Windows it's adviceable not to use
-		// first CreateProcess parameter because PATH is not used
-		// if it is defined.
-		//
-		// On WinCE 6.0 I was unable to launch anything
-		// without first CreateProcess parameter, also it seems that
-		// no WinCE program has support for quoted strings in arguments.
-		// So...
+    {
+        char *cmdline;
+        DWORD dwRet;
+
+        // For [desktop] Windows it's adviceable not to use
+        // first CreateProcess parameter because PATH is not used
+        // if it is defined.
+        //
+        // On WinCE 6.0 I was unable to launch anything
+        // without first CreateProcess parameter, also it seems that
+        // no WinCE program has support for quoted strings in arguments.
+        // So...
 #ifdef HAVE_API_WIN32_CE
-		LPWSTR cmd,args;
-		cmdline=g_strjoinv(" ",argv+1);
-		args=newSysString(cmdline);
-		cmd = newSysString(argv[0]);
-		dwRet=CreateProcess(cmd, args, NULL, NULL, 0, 0, NULL, NULL, NULL, &(r->pr));
-		dbg(lvl_debug, "CreateProcess(%s,%s), PID=%i",argv[0],cmdline,r->pr.dwProcessId);
-		g_free(cmd);
+        LPWSTR cmd,args;
+        cmdline=g_strjoinv(" ",argv+1);
+        args=newSysString(cmdline);
+        cmd = newSysString(argv[0]);
+        dwRet=CreateProcess(cmd, args, NULL, NULL, 0, 0, NULL, NULL, NULL, &(r->pr));
+        dbg(lvl_debug, "CreateProcess(%s,%s), PID=%i",argv[0],cmdline,r->pr.dwProcessId);
+        g_free(cmd);
 #else
-		TCHAR* args;
-		STARTUPINFO startupInfo;
-		memset(&startupInfo, 0, sizeof(startupInfo));
-		startupInfo.cb = sizeof(startupInfo);
-		cmdline=spawn_process_compose_cmdline(argv);
-		args=newSysString(cmdline);
-		dwRet=CreateProcess(NULL, args, NULL, NULL, 0, 0, NULL, NULL, &startupInfo, &(r->pr));
-		dbg(lvl_debug, "CreateProcess(%s), PID=%i",cmdline,r->pr.dwProcessId);
+        TCHAR* args;
+        STARTUPINFO startupInfo;
+        memset(&startupInfo, 0, sizeof(startupInfo));
+        startupInfo.cb = sizeof(startupInfo);
+        cmdline=spawn_process_compose_cmdline(argv);
+        args=newSysString(cmdline);
+        dwRet=CreateProcess(NULL, args, NULL, NULL, 0, 0, NULL, NULL, &startupInfo, &(r->pr));
+        dbg(lvl_debug, "CreateProcess(%s), PID=%i",cmdline,r->pr.dwProcessId);
 #endif
-		g_free(cmdline);
-		g_free(args);
-		return r;
-	}
+        g_free(cmdline);
+        g_free(args);
+        return r;
+    }
 #else
-	{
-		char *cmdline=spawn_process_compose_cmdline(argv);
-		int status;
-		dbg(lvl_error,"Unblocked spawn_process isn't availiable on this platform.");
-		status=system(cmdline);
-		g_free(cmdline);
-		r->status=status;
-		r->pid=0;
-		return r;
-	}
+    {
+        char *cmdline=spawn_process_compose_cmdline(argv);
+        int status;
+        dbg(lvl_error,"Unblocked spawn_process isn't availiable on this platform.");
+        status=system(cmdline);
+        g_free(cmdline);
+        r->status=status;
+        r->pid=0;
+        return r;
+    }
 #endif
 #endif
 }
@@ -901,127 +871,124 @@ spawn_process(char **argv)
  *
  * @param in *pi pointer to spawn_process_info structure
  * @param in block =0 do not block =1 block until child terminated
- * @returns -1 - still running, >=0 program exited, 
+ * @returns -1 - still running, >=0 program exited,
  *     =255 trminated abnormally or wasn't run at all.
- * 
+ *
  */
-int spawn_process_check_status(struct spawn_process_info *pi, int block)
-{
-	if(pi==NULL) {
-		dbg(lvl_error,"Trying to get process status of NULL, assuming process is terminated.");
-		return 255;
-	}
+int spawn_process_check_status(struct spawn_process_info *pi, int block) {
+    if(pi==NULL) {
+        dbg(lvl_error,"Trying to get process status of NULL, assuming process is terminated.");
+        return 255;
+    }
 #ifdef HAVE_API_WIN32_BASE
-	{int failcount=0;
-		while(1){
-			DWORD dw;
-			if(GetExitCodeProcess(pi->pr.hProcess,&dw)) {
-				if(dw!=STILL_ACTIVE) {
-					return dw;
-					break;
-				}
-			} else {
-				dbg(lvl_error,"GetExitCodeProcess failed. Assuming the process is terminated.");
-				return 255;
-			}
-			if(!block)
-				return -1;
-		
-			dw=WaitForSingleObject(pi->pr.hProcess,INFINITE);
-			if(dw==WAIT_FAILED && failcount++==1) {
-				dbg(lvl_error,"WaitForSingleObject failed twice. Assuming the process is terminated.");
-				return 0;
-				break;
-			}
-		}
-	}
+    {
+        int failcount=0;
+        while(1) {
+            DWORD dw;
+            if(GetExitCodeProcess(pi->pr.hProcess,&dw)) {
+                if(dw!=STILL_ACTIVE) {
+                    return dw;
+                    break;
+                }
+            } else {
+                dbg(lvl_error,"GetExitCodeProcess failed. Assuming the process is terminated.");
+                return 255;
+            }
+            if(!block)
+                return -1;
+
+            dw=WaitForSingleObject(pi->pr.hProcess,INFINITE);
+            if(dw==WAIT_FAILED && failcount++==1) {
+                dbg(lvl_error,"WaitForSingleObject failed twice. Assuming the process is terminated.");
+                return 0;
+                break;
+            }
+        }
+    }
 #else
 #ifdef _POSIX_C_SOURCE
-	if(pi->status!=-1) {
-		return pi->status;
-	}
-	while(1) {
-		int status;
-		pid_t w=waitpid(pi->pid,&status,block?0:WNOHANG);
-		if(w>0) {
-			if(WIFEXITED(status))
-				pi->status=WEXITSTATUS(status);
-				return pi->status;
-			if(WIFSTOPPED(status)) {
-				dbg(lvl_debug,"child is stopped by %i signal",WSTOPSIG(status));
-			} else if (WIFSIGNALED(status)) {
-				dbg(lvl_debug,"child terminated by signal %i",WEXITSTATUS(status));
-				pi->status=255;
-				return 255;
-			}
-			if(!block)
-				return -1;
-		} else if(w==0) {
-			if(!block)
-				return -1;
-		} else {
-			if(pi->status!=-1) // Signal handler has changed pi->status while in this function
-				return pi->status;
-			dbg(lvl_error,"waitpid() indicated error, reporting process termination.");
-			return 255;
-		}
-	}
+    if(pi->status!=-1) {
+        return pi->status;
+    }
+    while(1) {
+        int status;
+        pid_t w=waitpid(pi->pid,&status,block?0:WNOHANG);
+        if(w>0) {
+            if(WIFEXITED(status))
+                pi->status=WEXITSTATUS(status);
+            return pi->status;
+            if(WIFSTOPPED(status)) {
+                dbg(lvl_debug,"child is stopped by %i signal",WSTOPSIG(status));
+            } else if (WIFSIGNALED(status)) {
+                dbg(lvl_debug,"child terminated by signal %i",WEXITSTATUS(status));
+                pi->status=255;
+                return 255;
+            }
+            if(!block)
+                return -1;
+        } else if(w==0) {
+            if(!block)
+                return -1;
+        } else {
+            if(pi->status!=-1) // Signal handler has changed pi->status while in this function
+                return pi->status;
+            dbg(lvl_error,"waitpid() indicated error, reporting process termination.");
+            return 255;
+        }
+    }
 #else
-	dbg(lvl_error, "Non-blocking spawn_process isn't availiable for this platform, repoting process exit status.");
-	return pi->status;
+    dbg(lvl_error, "Non-blocking spawn_process isn't availiable for this platform, repoting process exit status.");
+    return pi->status;
 #endif
 #endif
 }
 
-void spawn_process_info_free(struct spawn_process_info *pi)
-{
-	if(pi==NULL)
-		return;
+void spawn_process_info_free(struct spawn_process_info *pi) {
+    if(pi==NULL)
+        return;
 #ifdef HAVE_API_WIN32_BASE
-	CloseHandle(pi->pr.hProcess);
-	CloseHandle(pi->pr.hThread);
+    CloseHandle(pi->pr.hProcess);
+    CloseHandle(pi->pr.hThread);
 #endif
 #ifdef _POSIX_C_SOURCE
-	{
-		sigset_t set, old;
-		sigemptyset(&set);
-		sigaddset(&set,SIGCHLD);
-		spawn_process_sigmask(SIG_BLOCK,&set,&old);
-		spawn_process_children=g_list_remove(spawn_process_children,pi);
-		spawn_process_sigmask(SIG_SETMASK,&old,NULL);
-	}
+    {
+        sigset_t set, old;
+        sigemptyset(&set);
+        sigaddset(&set,SIGCHLD);
+        spawn_process_sigmask(SIG_BLOCK,&set,&old);
+        spawn_process_children=g_list_remove(spawn_process_children,pi);
+        spawn_process_sigmask(SIG_SETMASK,&old,NULL);
+    }
 #endif
-	g_free(pi);
+    g_free(pi);
 }
 
 #ifdef _POSIX_C_SOURCE
-static void spawn_process_sigchld(int sig)
-{
-	int status;
-	pid_t pid;
-	while ((pid=waitpid(-1, &status, WNOHANG)) > 0) {
-		GList *el=g_list_first(spawn_process_children);
-		while(el) {
-			struct spawn_process_info *p=el->data;
-			if(p->pid==pid) {
-				p->status=status;
-			}
-			el=g_list_next(el);
-		}
-	}
+static void spawn_process_sigchld(int sig) {
+    int status;
+    pid_t pid;
+    while ((pid=waitpid(-1, &status, WNOHANG)) > 0) {
+        GList *el=g_list_first(spawn_process_children);
+        while(el) {
+            struct spawn_process_info *p=el->data;
+            if(p->pid==pid) {
+                p->status=status;
+            }
+            el=g_list_next(el);
+        }
+    }
 }
 #endif
 
-void spawn_process_init()
-{
+void spawn_process_init() {
 #ifdef _POSIX_C_SOURCE
-	struct sigaction act;
-	act.sa_handler=spawn_process_sigchld;
-	act.sa_flags=0;
-	sigemptyset(&act.sa_mask);
-	sigaction(SIGCHLD, &act, NULL);
+    struct sigaction act;
+    act.sa_handler=spawn_process_sigchld;
+    act.sa_flags=0;
+    sigemptyset(&act.sa_mask);
+    sigaction(SIGCHLD, &act, NULL);
 #endif
-	return;
+    return;
 }
 
 /**
@@ -1041,29 +1008,28 @@ void spawn_process_init()
  * @param mode The conversion mode, see description
  */
 void
-get_compass_direction(char *buffer, int angle, int mode)
-{
-	angle=angle%360;
-	switch (mode) {
-	case 0:
-		sprintf(buffer,"%d",angle);
-		break;
-	case 1:
-		if (angle < 69 || angle > 291)
-			*buffer++='N';
-		if (angle > 111 && angle < 249)
-			*buffer++='S';
-		if (angle > 22 && angle < 158)
-			*buffer++='E';
-		if (angle > 202 && angle < 338)
-			*buffer++='W';
-		*buffer++='\0';
-		break;
-	case 2:
-		angle=(angle+15)/30;
-		if (! angle)
-			angle=12;
-		sprintf(buffer,"%d H", angle);
-		break;
-	}
+get_compass_direction(char *buffer, int angle, int mode) {
+    angle=angle%360;
+    switch (mode) {
+    case 0:
+        sprintf(buffer,"%d",angle);
+        break;
+    case 1:
+        if (angle < 69 || angle > 291)
+            *buffer++='N';
+        if (angle > 111 && angle < 249)
+            *buffer++='S';
+        if (angle > 22 && angle < 158)
+            *buffer++='E';
+        if (angle > 202 && angle < 338)
+            *buffer++='W';
+        *buffer++='\0';
+        break;
+    case 2:
+        angle=(angle+15)/30;
+        if (! angle)
+            angle=12;
+        sprintf(buffer,"%d H", angle);
+        break;
+    }
 }