Reindent everything to K&R style with tabs

Used uncrustify, with the configuration file in ./doc/uncrustify.cfg

Commit author set to "Indent <please@skip.me>" so that it's easier to
skip while doing git blame.

1 files changed, 145 insertions, 133 deletions

diff --git a/set.c b/set.c
index 15b89307..91dd7bd5 100644
--- a/set.c
+++ b/set.c
@@ -1,4 +1,4 @@
-  /********************************************************************\
+/********************************************************************\
   * BitlBee -- An IRC to other IM-networks gateway                     *
   *                                                                    *
   * Copyright 2002-2013 Wilmer van der Gaast and others                *
@@ -29,246 +29,258 @@
 /* Used to use NULL for this, but NULL is actually a "valid" value. */
 char *SET_INVALID = "nee";
 
-set_t *set_add( set_t **head, const char *key, const char *def, set_eval eval, void *data )
+set_t *set_add(set_t **head, const char *key, const char *def, set_eval eval, void *data)
 {
-	set_t *s = set_find( head, key );
-	
+	set_t *s = set_find(head, key);
+
 	/* Possibly the setting already exists. If it doesn't exist yet,
 	   we create it. If it does, we'll just change the default. */
-	if( !s )
-	{
-		if( ( s = *head ) )
-		{
+	if (!s) {
+		if ((s = *head)) {
 			/* Sorted insertion. Special-case insertion at the start. */
-			if( strcmp( key, s->key ) < 0 )
-			{
-				s = g_new0( set_t, 1 );
+			if (strcmp(key, s->key) < 0) {
+				s = g_new0(set_t, 1);
 				s->next = *head;
 				*head = s;
-			}
-			else
-			{
-				while( s->next && strcmp( key, s->next->key ) > 0 )
+			} else {
+				while (s->next && strcmp(key, s->next->key) > 0) {
 					s = s->next;
+				}
 				set_t *last_next = s->next;
-				s->next = g_new0( set_t, 1 );
+				s->next = g_new0(set_t, 1);
 				s = s->next;
 				s->next = last_next;
 			}
+		} else {
+			s = *head = g_new0(set_t, 1);
 		}
-		else
-		{
-			s = *head = g_new0( set_t, 1 );
-		}
-		s->key = g_strdup( key );
+		s->key = g_strdup(key);
 	}
-	
-	if( s->def )
-	{
-		g_free( s->def );
+
+	if (s->def) {
+		g_free(s->def);
 		s->def = NULL;
 	}
-	if( def ) s->def = g_strdup( def );
-	
+	if (def) {
+		s->def = g_strdup(def);
+	}
+
 	s->eval = eval;
 	s->data = data;
-	
+
 	return s;
 }
 
-set_t *set_find( set_t **head, const char *key )
+set_t *set_find(set_t **head, const char *key)
 {
 	set_t *s = *head;
-	
-	while( s )
-	{
-		if( g_strcasecmp( s->key, key ) == 0 ||
-		    ( s->old_key && g_strcasecmp( s->old_key, key ) == 0 ) )
+
+	while (s) {
+		if (g_strcasecmp(s->key, key) == 0 ||
+		    (s->old_key && g_strcasecmp(s->old_key, key) == 0)) {
 			break;
+		}
 		s = s->next;
 	}
-	
+
 	return s;
 }
 
-char *set_getstr( set_t **head, const char *key )
+char *set_getstr(set_t **head, const char *key)
 {
-	set_t *s = set_find( head, key );
-	
-	if( !s || ( !s->value && !s->def ) )
+	set_t *s = set_find(head, key);
+
+	if (!s || (!s->value && !s->def)) {
 		return NULL;
-	
-	return set_value( s );
+	}
+
+	return set_value(s);
 }
 
-int set_getint( set_t **head, const char *key )
+int set_getint(set_t **head, const char *key)
 {
-	char *s = set_getstr( head, key );
+	char *s = set_getstr(head, key);
 	int i = 0;
-	
-	if( !s )
+
+	if (!s) {
 		return 0;
-	
-	if( sscanf( s, "%d", &i ) != 1 )
+	}
+
+	if (sscanf(s, "%d", &i) != 1) {
 		return 0;
-	
+	}
+
 	return i;
 }
 
-int set_getbool( set_t **head, const char *key )
+int set_getbool(set_t **head, const char *key)
 {
-	char *s = set_getstr( head, key );
-	
-	if( !s )
+	char *s = set_getstr(head, key);
+
+	if (!s) {
 		return 0;
-	
-	return bool2int( s );
+	}
+
+	return bool2int(s);
 }
 
-int set_isvisible( set_t *set )
+int set_isvisible(set_t *set)
 {
 	/* the default value is not stored in value, only in def */
-	return !( ( set->flags & SET_HIDDEN ) ||
-	          ( ( set->flags & SET_HIDDEN_DEFAULT ) &&
-	            ( set->value == NULL ) ) );
+	return !((set->flags & SET_HIDDEN) ||
+	         ((set->flags & SET_HIDDEN_DEFAULT) &&
+	          (set->value == NULL)));
 }
 
-int set_setstr( set_t **head, const char *key, char *value )
+int set_setstr(set_t **head, const char *key, char *value)
 {
-	set_t *s = set_find( head, key );
+	set_t *s = set_find(head, key);
 	char *nv = value;
-	
-	if( !s )
+
+	if (!s) {
 		/*
 		Used to do this, but it never really made sense.
 		s = set_add( head, key, NULL, NULL, NULL );
 		*/
 		return 0;
-	
-	if( value == NULL && ( s->flags & SET_NULL_OK ) == 0 )
+	}
+
+	if (value == NULL && (s->flags & SET_NULL_OK) == 0) {
 		return 0;
-	
+	}
+
 	/* Call the evaluator. For invalid values, evaluators should now
 	   return SET_INVALID, but previously this was NULL. Try to handle
 	   that too if NULL is not an allowed value for this setting. */
-	if( s->eval && ( ( nv = s->eval( s, value ) ) == SET_INVALID ||
-	                 ( ( s->flags & SET_NULL_OK ) == 0 && nv == NULL ) ) )
+	if (s->eval && ((nv = s->eval(s, value)) == SET_INVALID ||
+	                ((s->flags & SET_NULL_OK) == 0 && nv == NULL))) {
 		return 0;
-	
-	if( s->value )
-	{
-		g_free( s->value );
+	}
+
+	if (s->value) {
+		g_free(s->value);
 		s->value = NULL;
 	}
-	
+
 	/* If there's a default setting and it's equal to what we're trying to
 	   set, stick with s->value = NULL. Otherwise, remember the setting. */
-	if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
-		s->value = g_strdup( nv );
-	
-	if( nv != value )
-		g_free( nv );
-	
+	if (!s->def || (strcmp(nv, s->def) != 0)) {
+		s->value = g_strdup(nv);
+	}
+
+	if (nv != value) {
+		g_free(nv);
+	}
+
 	return 1;
 }
 
-int set_setint( set_t **head, const char *key, int value )
+int set_setint(set_t **head, const char *key, int value)
 {
-	char *s = g_strdup_printf( "%d", value );
-	int retval = set_setstr( head, key, s );
-	g_free( s );
+	char *s = g_strdup_printf("%d", value);
+	int retval = set_setstr(head, key, s);
+
+	g_free(s);
 	return retval;
 }
 
-void set_del( set_t **head, const char *key )
+void set_del(set_t **head, const char *key)
 {
 	set_t *s = *head, *t = NULL;
-	
-	while( s )
-	{
-		if( g_strcasecmp( s->key, key ) == 0 )
+
+	while (s) {
+		if (g_strcasecmp(s->key, key) == 0) {
 			break;
-		s = (t=s)->next;
+		}
+		s = (t = s)->next;
 	}
-	if( s )
-	{
-		if( t )
+	if (s) {
+		if (t) {
 			t->next = s->next;
-		else
+		} else {
 			*head = s->next;
-		
-		g_free( s->key );
-		g_free( s->old_key );
-		g_free( s->value );
-		g_free( s->def );
-		g_free( s );
+		}
+
+		g_free(s->key);
+		g_free(s->old_key);
+		g_free(s->value);
+		g_free(s->def);
+		g_free(s);
 	}
 }
 
-int set_reset( set_t **head, const char *key )
+int set_reset(set_t **head, const char *key)
 {
 	set_t *s;
-	
-	s = set_find( head, key );
-	if( s )
-		return set_setstr( head, key, s->def );
-	
+
+	s = set_find(head, key);
+	if (s) {
+		return set_setstr(head, key, s->def);
+	}
+
 	return 0;
 }
 
-char *set_eval_int( set_t *set, char *value )
+char *set_eval_int(set_t *set, char *value)
 {
 	char *s = value;
-	
+
 	/* Allow a minus at the first position. */
-	if( *s == '-' )
-		s ++;
-	
-	for( ; *s; s ++ )
-		if( !g_ascii_isdigit( *s ) )
+	if (*s == '-') {
+		s++;
+	}
+
+	for (; *s; s++) {
+		if (!g_ascii_isdigit(*s)) {
 			return SET_INVALID;
-	
+		}
+	}
+
 	return value;
 }
 
-char *set_eval_bool( set_t *set, char *value )
+char *set_eval_bool(set_t *set, char *value)
 {
-	return is_bool( value ) ? value : SET_INVALID;
+	return is_bool(value) ? value : SET_INVALID;
 }
 
-char *set_eval_list( set_t *set, char *value )
+char *set_eval_list(set_t *set, char *value)
 {
 	GSList *options = set->eval_data, *opt;
-	
-	for( opt = options; opt; opt = opt->next )
-		if( strcmp( value, opt->data ) == 0 )
+
+	for (opt = options; opt; opt = opt->next) {
+		if (strcmp(value, opt->data) == 0) {
 			return value;
-	
+		}
+	}
+
 	/* TODO: It'd be nice to show the user a list of allowed values,
 	         but we don't have enough context here to do that. May
 	         want to fix that. */
-	
+
 	return NULL;
 }
 
-char *set_eval_to_char( set_t *set, char *value )
+char *set_eval_to_char(set_t *set, char *value)
 {
-	char *s = g_new( char, 3 );
-	
-	if( *value == ' ' )
-		strcpy( s, " " );
-	else
-		sprintf( s, "%c ", *value );
-	
+	char *s = g_new(char, 3);
+
+	if (*value == ' ') {
+		strcpy(s, " ");
+	} else {
+		sprintf(s, "%c ", *value);
+	}
+
 	return s;
 }
 
-char *set_eval_oauth( set_t *set, char *value )
+char *set_eval_oauth(set_t *set, char *value)
 {
 	account_t *acc = set->data;
-	
-	if( bool2int( value ) && strcmp( acc->pass, PASSWORD_PENDING ) == 0 )
+
+	if (bool2int(value) && strcmp(acc->pass, PASSWORD_PENDING) == 0) {
 		*acc->pass = '\0';
-	
-	return set_eval_bool( set, value );
+	}
+
+	return set_eval_bool(set, value);
 }