Fixed brace placement and converted spaces to tabs.

Signed-off-by: Vicent Marti <tanoku@gmail.com>
Signed-off-by: Andreas Ericsson <ae@op5.se>

6 files changed, 441 insertions, 471 deletions

diff --git a/src/commit.c b/src/commit.c
index a39920830..e740db6f3 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -43,381 +43,368 @@ const git_oid *git_commit_id(git_commit *c)
 
 void git_commit__mark_uninteresting(git_commit *commit)
 {
-    if (commit == NULL)
-        return;
+	if (commit == NULL)
+		return;
 
 	git_commit_node *parents = commit->parents.head;
 
-    commit->uninteresting = 1;
+	commit->uninteresting = 1;
 
-	while (parents)
-    {
-        parents->commit->uninteresting = 1;
+	while (parents) {
+		parents->commit->uninteresting = 1;
 		parents = parents->next;
 	}
 }
 
 git_commit *git_commit_parse(git_revpool *pool, const git_oid *id)
 {
-    git_commit *commit = NULL;
+	git_commit *commit = NULL;
 
-    if ((commit = git_commit_lookup(pool, id)) == NULL)
-        return NULL;
+	if ((commit = git_commit_lookup(pool, id)) == NULL)
+		return NULL;
 
-    if (git_commit_parse_existing(commit) < 0)
-        goto error_cleanup;
+	if (git_commit_parse_existing(commit) < 0)
+		goto error_cleanup;
 
-    return commit;
+	return commit;
 
 error_cleanup:
-    free(commit);
-    return NULL;
+	free(commit);
+	return NULL;
 }
 
 int git_commit_parse_existing(git_commit *commit)
 {
-    git_obj commit_obj;
+	git_obj commit_obj;
 
-    if (commit->parsed)
-        return 0;
+	if (commit->parsed)
+		return 0;
 
-    if (git_odb_read(&commit_obj, commit->object.pool->db, &commit->object.id) < 0)
-        return -1;
+	if (git_odb_read(&commit_obj, commit->object.pool->db, &commit->object.id) < 0)
+		return -1;
 
-    if (commit_obj.type != GIT_OBJ_COMMIT)
-        goto error_cleanup;
+	if (commit_obj.type != GIT_OBJ_COMMIT)
+		goto error_cleanup;
 
-    if (git_commit__parse_buffer(commit, commit_obj.data, commit_obj.len) < 0)
-        goto error_cleanup;
+	if (git_commit__parse_buffer(commit, commit_obj.data, commit_obj.len) < 0)
+		goto error_cleanup;
 
-    git_obj_close(&commit_obj);
+	git_obj_close(&commit_obj);
 
-    return 0;
+	return 0;
 
 error_cleanup:
-    git_obj_close(&commit_obj);
-    return -1;
+	git_obj_close(&commit_obj);
+	return -1;
 }
 
 git_commit *git_commit_lookup(git_revpool *pool, const git_oid *id)
 {
-    git_commit *commit = NULL;
+	git_commit *commit = NULL;
 
-    if (pool == NULL)
-        return NULL;
+	if (pool == NULL)
+		return NULL;
 
-    commit = (git_commit *)git_revpool_table_lookup(pool->commits, id);
-    if (commit != NULL)
-        return commit;
+	commit = (git_commit *)git_revpool_table_lookup(pool->commits, id);
+	if (commit != NULL)
+		return commit;
 
-    commit = git__malloc(sizeof(git_commit));
+	commit = git__malloc(sizeof(git_commit));
 
-    if (commit == NULL)
-        return NULL;
+	if (commit == NULL)
+		return NULL;
 
-    memset(commit, 0x0, sizeof(git_commit));
+	memset(commit, 0x0, sizeof(git_commit));
 
-    // Initialize parent object
-    git_oid_cpy(&commit->object.id, id);
-    commit->object.pool = pool;
+	// Initialize parent object
+	git_oid_cpy(&commit->object.id, id);
+	commit->object.pool = pool;
 
-    git_revpool_table_insert(pool->commits, (git_revpool_object *)commit);
+	git_revpool_table_insert(pool->commits, (git_revpool_object *)commit);
 
-    return commit;
+	return commit;
 }
 
 int git_commit__parse_time(time_t *commit_time, char *buffer, const char *buffer_end)
 {
-    if (memcmp(buffer, "author ", 7) != 0)
-        return -1;
+	if (memcmp(buffer, "author ", 7) != 0)
+		return -1;
 
-    buffer = memchr(buffer, '\n', buffer_end - buffer);
-    if (buffer == 0 || ++buffer >= buffer_end)
-        return -1;
+	buffer = memchr(buffer, '\n', buffer_end - buffer);
+	if (buffer == 0 || ++buffer >= buffer_end)
+		return -1;
 
-    if (memcmp(buffer, "committer ", 10) != 0)
-        return -1;
+	if (memcmp(buffer, "committer ", 10) != 0)
+		return -1;
 
-    buffer = memchr(buffer, '>', buffer_end - buffer);
-    if (buffer == 0 || ++buffer >= buffer_end)
-        return -1;
+	buffer = memchr(buffer, '>', buffer_end - buffer);
+	if (buffer == 0 || ++buffer >= buffer_end)
+		return -1;
 
-    *commit_time = strtol(buffer, &buffer, 10);
+	*commit_time = strtol(buffer, &buffer, 10);
 
-    if (*commit_time == 0)
-        return -1;
+	if (*commit_time == 0)
+		return -1;
 
-    buffer = memchr(buffer, '\n', buffer_end - buffer);
-    if (buffer == 0 || ++buffer >= buffer_end)
-        return -1;
+	buffer = memchr(buffer, '\n', buffer_end - buffer);
+	if (buffer == 0 || ++buffer >= buffer_end)
+		return -1;
 
-    return (buffer < buffer_end) ? 0 : -1;
+	return (buffer < buffer_end) ? 0 : -1;
 }
 
 int git_commit__parse_oid(git_oid *oid, char **buffer_out, const char *buffer_end, const char *header)
 {
-    const size_t sha_len = GIT_OID_HEXSZ;
-    const size_t header_len = strlen(header);
+	const size_t sha_len = GIT_OID_HEXSZ;
+	const size_t header_len = strlen(header);
 
-    char *buffer = *buffer_out;
+	char *buffer = *buffer_out;
 
-    if (buffer + (header_len + sha_len + 1) > buffer_end)
-        return -1;
+	if (buffer + (header_len + sha_len + 1) > buffer_end)
+		return -1;
 
-    if (memcmp(buffer, header, header_len) != 0)
-        return -1;
+	if (memcmp(buffer, header, header_len) != 0)
+		return -1;
 
-    if (buffer[header_len + sha_len] != '\n')
-        return -1;
+	if (buffer[header_len + sha_len] != '\n')
+		return -1;
 
-    if (git_oid_mkstr(oid, buffer + header_len) < 0)
-        return -1;
+	if (git_oid_mkstr(oid, buffer + header_len) < 0)
+		return -1;
 
-    *buffer_out = buffer + (header_len + sha_len + 1);
+	*buffer_out = buffer + (header_len + sha_len + 1);
 
-    return 0;
+	return 0;
 }
 
 int git_commit__parse_buffer(git_commit *commit, void *data, size_t len)
 {
-    char *buffer = (char *)data;
-    const char *buffer_end = (char *)data + len;
+	char *buffer = (char *)data;
+	const char *buffer_end = (char *)data + len;
 
-    git_oid oid;
+	git_oid oid;
 
-    if (commit->parsed)
+	if (commit->parsed)
 		return 0;
 
-    if (git_commit__parse_oid(&oid, &buffer, buffer_end, "tree ") < 0)
-        return -1;
+	if (git_commit__parse_oid(&oid, &buffer, buffer_end, "tree ") < 0)
+		return -1;
 
-    /*
-     * TODO: load tree into commit object
-     * TODO: commit grafts!
-     */
+	/*
+	 * TODO: load tree into commit object
+	 * TODO: commit grafts!
+	 */
 
-    while (git_commit__parse_oid(&oid, &buffer, buffer_end, "parent ") == 0) {
-        git_commit *parent;
+	while (git_commit__parse_oid(&oid, &buffer, buffer_end, "parent ") == 0) {
+		git_commit *parent;
 
-        if ((parent = git_commit_lookup(commit->object.pool, &oid)) == NULL)
-            return -1;
+		if ((parent = git_commit_lookup(commit->object.pool, &oid)) == NULL)
+			return -1;
 
-        // Inherit uninteresting flag
-        if (commit->uninteresting)
-            parent->uninteresting = 1;
+		// Inherit uninteresting flag
+		if (commit->uninteresting)
+			parent->uninteresting = 1;
 
-        git_commit_list_push_back(&commit->parents, parent);
-    }
+		git_commit_list_push_back(&commit->parents, parent);
+	}
 
-    if (git_commit__parse_time(&commit->commit_time, buffer, buffer_end) < 0)
-        return -1;
+	if (git_commit__parse_time(&commit->commit_time, buffer, buffer_end) < 0)
+		return -1;
 
-    commit->parsed = 1;
+	commit->parsed = 1;
 
-    return 0;
+	return 0;
 }
 
 void git_commit_list_push_back(git_commit_list *list, git_commit *commit)
 {
-    git_commit_node *node = NULL;
+	git_commit_node *node = NULL;
 
-    node = git__malloc(sizeof(git_commit_list));
+	node = git__malloc(sizeof(git_commit_list));
 
-    if (node == NULL)
-        return;
+	if (node == NULL)
+		return;
 
-    node->commit = commit;
-    node->next = NULL;
-    node->prev = list->tail;
+	node->commit = commit;
+	node->next = NULL;
+	node->prev = list->tail;
 
-    if (list->tail == NULL)
-    {
-        list->head = list->tail = node;
-    }
-    else
-    {
-        list->tail->next = node;
-        list->tail = node;
-    }
+	if (list->tail == NULL) {
+		list->head = list->tail = node;
+	} else {
+		list->tail->next = node;
+		list->tail = node;
+	}
 
-    list->size++;
+	list->size++;
 }
 
 void git_commit_list_push_front(git_commit_list *list, git_commit *commit)
 {
-    git_commit_node *node = NULL;
+	git_commit_node *node = NULL;
 
-    node = git__malloc(sizeof(git_commit_list));
+	node = git__malloc(sizeof(git_commit_list));
 
-    if (node == NULL)
-        return;
+	if (node == NULL)
+		return;
 
-    node->commit = commit;
-    node->next = list->head;
-    node->prev = NULL;
+	node->commit = commit;
+	node->next = list->head;
+	node->prev = NULL;
 
-    if (list->head == NULL)
-    {
-        list->head = list->tail = node;
-    }
-    else
-    {
-        list->head->prev = node;
-        list->head = node;
-    }
+	if (list->head == NULL) {
+		list->head = list->tail = node;
+	} else {
+		list->head->prev = node;
+		list->head = node;
+	}
 
-    list->size++;
+	list->size++;
 }
 
 
 git_commit *git_commit_list_pop_back(git_commit_list *list)
 {
-    git_commit_node *node;
-    git_commit *commit;
+	git_commit_node *node;
+	git_commit *commit;
 
-    if (list->tail == NULL)
-        return NULL;
+	if (list->tail == NULL)
+		return NULL;
 
-    node = list->tail;
-    list->tail = list->tail->prev;
-    if (list->tail == NULL)
-        list->head = NULL;
+	node = list->tail;
+	list->tail = list->tail->prev;
+	if (list->tail == NULL)
+		list->head = NULL;
 
-    commit = node->commit;
-    free(node);
+	commit = node->commit;
+	free(node);
 
-    list->size--;
+	list->size--;
 
-    return commit;
+	return commit;
 }
 
 git_commit *git_commit_list_pop_front(git_commit_list *list)
 {
-    git_commit_node *node;
-    git_commit *commit;
+	git_commit_node *node;
+	git_commit *commit;
 
-    if (list->head == NULL)
-        return NULL;
+	if (list->head == NULL)
+		return NULL;
 
-    node = list->head;
-    list->head = list->head->next;
-    if (list->head == NULL)
-        list->tail = NULL;
+	node = list->head;
+	list->head = list->head->next;
+	if (list->head == NULL)
+		list->tail = NULL;
 
-    commit = node->commit;
-    free(node);
+	commit = node->commit;
+	free(node);
 
-    list->size--;
+	list->size--;
 
-    return commit;
+	return commit;
 }
 
 void git_commit_list_clear(git_commit_list *list, int free_commits)
 {
-    git_commit_node *node, *next_node;
+	git_commit_node *node, *next_node;
 
-    node = list->head;
-    while (node)
-    {
-        if (free_commits)
-            free(node->commit);
+	node = list->head;
+	while (node) {
+		if (free_commits)
+			free(node->commit);
 
-        next_node = node->next;
-        free(node);
-        node = next_node;
-    }
+		next_node = node->next;
+		free(node);
+		node = next_node;
+	}
 
-    list->head = list->tail = NULL;
-    list->size = 0;
+	list->head = list->tail = NULL;
+	list->size = 0;
 }
 
 void git_commit_list_timesort(git_commit_list *list)
 {
-    git_commit_node *p, *q, *e;
-    int in_size, p_size, q_size, merge_count, i;
+	git_commit_node *p, *q, *e;
+	int in_size, p_size, q_size, merge_count, i;
+
+	if (list->head == NULL)
+		return;
 
-    if (list->head == NULL)
-        return;
+	in_size = 1;
 
-    in_size = 1;
+	do {
+		p = list->head;
+		list->tail = NULL;
+		merge_count = 0;
 
-    do
-    {
-        p = list->head;
-        list->tail = NULL;
-        merge_count = 0;
+		while (p != NULL) {
+			merge_count++;
+			q = p;
+			p_size = 0;
+			q_size = in_size;
 
-        while (p != NULL)
-        {
-            merge_count++;
-            q = p;
-            p_size = 0;
-            q_size = in_size;
+			for (i = 0; i < in_size && q; ++i, q = q->next)
+				p_size++;
 
-            for (i = 0; i < in_size && q; ++i, q = q->next)
-                p_size++;
+			while (p_size > 0 || (q_size > 0 && q)) {
 
-            while (p_size > 0 || (q_size > 0 && q))
-            {
-                if (p_size == 0)
-                    e = q, q = q->next, q_size--;
+				if (p_size == 0)
+					e = q, q = q->next, q_size--;
 
-                else if (q_size == 0 || q == NULL ||
-                    p->commit->commit_time >= q->commit->commit_time)
-                    e = p, p = p->next, p_size--;
+				else if (q_size == 0 || q == NULL ||
+						p->commit->commit_time >= q->commit->commit_time)
+					e = p, p = p->next, p_size--;
 
-                else
-                    e = q, q = q->next, q_size--;
+				else
+					e = q, q = q->next, q_size--;
 
-                if (list->tail != NULL)
-                    list->tail->next = e;
-                else
-                    list->head = e;
+				if (list->tail != NULL)
+					list->tail->next = e;
+				else
+					list->head = e;
 
-                e->prev = list->tail;
-                list->tail = e;
-            }
+				e->prev = list->tail;
+				list->tail = e;
+			}
 
-            p = q;
-        }
+			p = q;
+		}
 
-        list->tail->next = NULL;
-        in_size *= 2;
+		list->tail->next = NULL;
+		in_size *= 2;
 
-    } while (merge_count > 1);
+	} while (merge_count > 1);
 }
 
 void git_commit_list_toposort(git_commit_list *list)
 {
-    git_commit *commit;
-    git_commit_list topo;
-    memset(&topo, 0x0, sizeof(git_commit_list));
-
-    while ((commit = git_commit_list_pop_back(list)) != NULL)
-    {
-        git_commit_node *p;
-
-        if (commit->in_degree > 0)
-        {
-            commit->topo_delay = 1;
-            continue;
-        }
-
-        for (p = commit->parents.head; p != NULL; p = p->next)
-        {
-            p->commit->in_degree--;
-
-            if (p->commit->in_degree == 0 && p->commit->topo_delay)
-            {
-                p->commit->topo_delay = 0;
-                git_commit_list_push_back(list, p->commit);
-            }
-        }
-
-        git_commit_list_push_back(&topo, commit);
-    }
-
-    list->head = topo.head;
-    list->tail = topo.tail;
-    list->size = topo.size;
+	git_commit *commit;
+	git_commit_list topo;
+	memset(&topo, 0x0, sizeof(git_commit_list));
+
+	while ((commit = git_commit_list_pop_back(list)) != NULL) {
+		git_commit_node *p;
+
+		if (commit->in_degree > 0) {
+			commit->topo_delay = 1;
+			continue;
+		}
+
+		for (p = commit->parents.head; p != NULL; p = p->next) {
+			p->commit->in_degree--;
+
+			if (p->commit->in_degree == 0 && p->commit->topo_delay) {
+				p->commit->topo_delay = 0;
+				git_commit_list_push_back(list, p->commit);
+			}
+		}
+
+		git_commit_list_push_back(&topo, commit);
+	}
+
+	list->head = topo.head;
+	list->tail = topo.tail;
+	list->size = topo.size;
 }
+
diff --git a/src/commit.h b/src/commit.h
index e8d0c5322..c62b80f26 100644
--- a/src/commit.h
+++ b/src/commit.h
@@ -7,33 +7,33 @@
 #include <time.h>
 
 struct git_commit_node {
-    struct git_commit *commit;
+	struct git_commit *commit;
 
-    struct git_commit_node *next;
-    struct git_commit_node *prev;
+	struct git_commit_node *next;
+	struct git_commit_node *prev;
 };
 
 struct git_commit_list {
-    struct git_commit_node *head;
-    struct git_commit_node *tail;
-    size_t size;
+	struct git_commit_node *head;
+	struct git_commit_node *tail;
+	size_t size;
 };
 
 typedef struct git_commit_list git_commit_list;
 typedef struct git_commit_node git_commit_node;
 
 struct git_commit {
-    git_revpool_object object;
+	git_revpool_object object;
 
-    time_t commit_time;
-    git_commit_list parents;
+	time_t commit_time;
+	git_commit_list parents;
 
-    unsigned short in_degree;
-    unsigned parsed:1,
-             seen:1,
-             uninteresting:1,
-             topo_delay:1,
-             flags:26;
+	unsigned short in_degree;
+	unsigned parsed:1,
+			 seen:1,
+			 uninteresting:1,
+			 topo_delay:1,
+			 flags:26;
 };
 
 int git_commit__parse_oid(git_oid *oid, char **buffer_out, const char *buffer_end, const char *header);
diff --git a/src/revobject.c b/src/revobject.c
index 45fb97389..a0d9ac96c 100644
--- a/src/revobject.c
+++ b/src/revobject.c
@@ -34,10 +34,9 @@ unsigned int git_revpool_table__hash(const git_oid *id)
 	const int r = 24;
 
 	unsigned int h = 0xA8A3D5;
-    int i;
+	int i;
 
-    for (i = 0; i < GIT_OID_RAWSZ / 4; ++i)
-    {
+	for (i = 0; i < GIT_OID_RAWSZ / 4; ++i) {
 		unsigned int k = ((unsigned int *)id->id)[i];
 
 		k *= m;
@@ -45,7 +44,7 @@ unsigned int git_revpool_table__hash(const git_oid *id)
 		k *= m;
 		h *= m;
 		h ^= k;
-    }
+	}
 
 	h ^= h >> 13;
 	h *= m;
@@ -56,169 +55,162 @@ unsigned int git_revpool_table__hash(const git_oid *id)
 
 git_revpool_table *git_revpool_table_create(unsigned int min_size)
 {
-    git_revpool_table *table;
-    int i;
+	git_revpool_table *table;
+	int i;
 
-    table = git__malloc(sizeof(table));
+	table = git__malloc(sizeof(table));
 
-    if (table == NULL)
-        return NULL;
+	if (table == NULL)
+		return NULL;
 
-    // round up size to closest power of 2
-    min_size--;
-    min_size |= min_size >> 1;
-    min_size |= min_size >> 2;
-    min_size |= min_size >> 4;
-    min_size |= min_size >> 8;
-    min_size |= min_size >> 16;
+	// round up size to closest power of 2
+	min_size--;
+	min_size |= min_size >> 1;
+	min_size |= min_size >> 2;
+	min_size |= min_size >> 4;
+	min_size |= min_size >> 8;
+	min_size |= min_size >> 16;
 
-    table->size_mask = min_size;
-    table->count = 0;
-    table->max_count = (min_size + 1) * max_load_factor;
+	table->size_mask = min_size;
+	table->count = 0;
+	table->max_count = (min_size + 1) * max_load_factor;
 
-    table->nodes = git__malloc((min_size + 1) * sizeof(git_revpool_node *));
+	table->nodes = git__malloc((min_size + 1) * sizeof(git_revpool_node *));
 
-    if (table->nodes == NULL)
-    {
-        free(table);
-        return NULL;
-    }
+	if (table->nodes == NULL) {
+		free(table);
+		return NULL;
+	}
 
-    for (i = 0; i <= min_size; ++i)
-        table->nodes[i] = NULL;
+	for (i = 0; i <= min_size; ++i)
+		table->nodes[i] = NULL;
 
-    return table;
+	return table;
 }
 
 int git_revpool_table_insert(git_revpool_table *table, git_revpool_object *object)
 {
-    git_revpool_node *node;
-    unsigned int index, hash;
+	git_revpool_node *node;
+	unsigned int index, hash;
 
-    if (table == NULL)
-        return -1;
+	if (table == NULL)
+		return -1;
 
-    if (table->count + 1 > table->max_count)
-        git_revpool_table_resize(table);
+	if (table->count + 1 > table->max_count)
+		git_revpool_table_resize(table);
 
-    node = git__malloc(sizeof(git_revpool_node));
-    if (node == NULL)
-        return -1;
+	node = git__malloc(sizeof(git_revpool_node));
+	if (node == NULL)
+		return -1;
 
-    hash = git_revpool_table__hash(&object->id);
-    index = (hash & table->size_mask);
+	hash = git_revpool_table__hash(&object->id);
+	index = (hash & table->size_mask);
 
-    node->object = object;
-    node->hash = hash;
-    node->next = table->nodes[index];
+	node->object = object;
+	node->hash = hash;
+	node->next = table->nodes[index];
 
-    table->nodes[index] = node;
-    table->count++;
+	table->nodes[index] = node;
+	table->count++;
 
-    return 0;
+	return 0;
 }
 
 git_revpool_object *git_revpool_table_lookup(git_revpool_table *table, const git_oid *id)
 {
-    git_revpool_node *node;
-    unsigned int index, hash;
+	git_revpool_node *node;
+	unsigned int index, hash;
 
-    if (table == NULL)
-        return NULL;
+	if (table == NULL)
+		return NULL;
 
-    hash = git_revpool_table__hash(id);
-    index = (hash & table->size_mask);
-    node = table->nodes[index];
+	hash = git_revpool_table__hash(id);
+	index = (hash & table->size_mask);
+	node = table->nodes[index];
 
-    while (node != NULL)
-    {
-        if (node->hash == hash && git_oid_cmp(id, &node->object->id) == 0)
-            return node->object;
+	while (node != NULL) {
+		if (node->hash == hash && git_oid_cmp(id, &node->object->id) == 0)
+			return node->object;
 
-        node = node->next;
-    }
+		node = node->next;
+	}
 
-    return NULL;
+	return NULL;
 }
 
 void git_revpool_table_resize(git_revpool_table *table)
 {
-    git_revpool_node **new_nodes;
-    unsigned int new_size, i;
-
-    new_size = (table->size_mask + 1) * 2;
-
-    new_nodes = git__malloc(new_size * sizeof(git_revpool_node *));
-    if (new_nodes == NULL)
-        return;
-
-    memset(new_nodes, 0x0, new_size * sizeof(git_revpool_node *));
-
-    for (i = 0; i <= table->size_mask; ++i)
-    {
-        git_revpool_node *n;
-        unsigned int index;
-
-        while ((n = table->nodes[i]) != NULL)
-        {
-            table->nodes[i] = n->next;
-            index = n->hash & (new_size - 1);
-            n->next = new_nodes[index];
-            new_nodes[index] = n;
-        }
-    }
-
-    free(table->nodes);
-    table->nodes = new_nodes;
-    table->size_mask = (new_size - 1);
-    table->max_count = new_size * max_load_factor;
+	git_revpool_node **new_nodes;
+	unsigned int new_size, i;
+
+	new_size = (table->size_mask + 1) * 2;
+
+	new_nodes = git__malloc(new_size * sizeof(git_revpool_node *));
+	if (new_nodes == NULL)
+		return;
+
+	memset(new_nodes, 0x0, new_size * sizeof(git_revpool_node *));
+
+	for (i = 0; i <= table->size_mask; ++i) {
+		git_revpool_node *n;
+		unsigned int index;
+
+		while ((n = table->nodes[i]) != NULL) {
+			table->nodes[i] = n->next;
+			index = n->hash & (new_size - 1);
+			n->next = new_nodes[index];
+			new_nodes[index] = n;
+		}
+	}
+
+	free(table->nodes);
+	table->nodes = new_nodes;
+	table->size_mask = (new_size - 1);
+	table->max_count = new_size * max_load_factor;
 }
 
 
 void git_revpool_table_free(git_revpool_table *table)
 {
-    int index;
-
-    for (index = 0; index <= table->size_mask; ++index)
-    {
-        git_revpool_node *node, *next_node;
-
-        node = table->nodes[index];
-        while (node != NULL)
-        {
-            next_node = node->next;
-            free(node);
-            node = next_node;
-        }
-    }
-
-    free(table);
+	int index;
+
+	for (index = 0; index <= table->size_mask; ++index) {
+		git_revpool_node *node, *next_node;
+
+		node = table->nodes[index];
+		while (node != NULL) {
+			next_node = node->next;
+			free(node);
+			node = next_node;
+		}
+	}
+
+	free(table);
 }
 
 void git_revpool_tableit_init(git_revpool_table *table, git_revpool_tableit *it)
 {
-    memset(it, 0x0, sizeof(git_revpool_tableit));
+	memset(it, 0x0, sizeof(git_revpool_tableit));
 
-    it->nodes = table->nodes;
-    it->current_node = NULL;
-    it->current_pos = 0;
-    it->size = table->size_mask + 1;
+	it->nodes = table->nodes;
+	it->current_node = NULL;
+	it->current_pos = 0;
+	it->size = table->size_mask + 1;
 }
 
 git_revpool_object *git_revpool_tableit_next(git_revpool_tableit *it)
 {
-    git_revpool_node *next = NULL;
+	git_revpool_node *next = NULL;
 
-    while (it->current_node == NULL)
-    {
-        if (it->current_pos >= it->size)
-            return NULL;
+	while (it->current_node == NULL) {
+		if (it->current_pos >= it->size)
+			return NULL;
 
-        it->current_node = it->nodes[it->current_pos++];
-    }
+		it->current_node = it->nodes[it->current_pos++];
+	}
 
-    next = it->current_node;
-    it->current_node = it->current_node->next;
+	next = it->current_node;
+	it->current_node = it->current_node->next;
 
-    return next->object;
+	return next->object;
 }
diff --git a/src/revobject.h b/src/revobject.h
index 2876a4c21..ccbb507cc 100644
--- a/src/revobject.h
+++ b/src/revobject.h
@@ -4,34 +4,30 @@
 #include "git/common.h"
 #include "git/oid.h"
 
-struct git_revpool_object
-{
-    git_oid id;
-    git_revpool *pool;
+struct git_revpool_object {
+	git_oid id;
+	git_revpool *pool;
 };
 
-struct git_revpool_node
-{
-    struct git_revpool_object *object;
-    unsigned int hash;
-    struct git_revpool_node *next;
+struct git_revpool_node {
+	struct git_revpool_object *object;
+	unsigned int hash;
+	struct git_revpool_node *next;
 };
 
-struct git_revpool_table
-{
-    struct git_revpool_node **nodes;
+struct git_revpool_table {
+	struct git_revpool_node **nodes;
 
-    unsigned int size_mask;
-    unsigned int count;
-    unsigned int max_count;
+	unsigned int size_mask;
+	unsigned int count;
+	unsigned int max_count;
 };
 
-struct git_revpool_tableit
-{
-    struct git_revpool_node **nodes;
-    struct git_revpool_node *current_node;
-    unsigned int current_pos;
-    unsigned int size;
+struct git_revpool_tableit {
+	struct git_revpool_node **nodes;
+	struct git_revpool_node *current_node;
+	unsigned int current_pos;
+	unsigned int size;
 };
 
 
@@ -50,5 +46,4 @@ void git_revpool_table_free(git_revpool_table *table);
 git_revpool_object *git_revpool_tableit_next(git_revpool_tableit *it);
 void git_revpool_tableit_init(git_revpool_table *table, git_revpool_tableit *it);
 
-
 #endif
diff --git a/src/revwalk.c b/src/revwalk.c
index 977c17933..200a9469e 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -35,9 +35,9 @@ git_revpool *gitrp_alloc(git_odb *db)
 	if (!walk)
 		return NULL;
 
-    memset(walk, 0x0, sizeof(git_revpool));
+	memset(walk, 0x0, sizeof(git_revpool));
 
-    walk->commits = git_revpool_table_create(default_table_size);
+	walk->commits = git_revpool_table_create(default_table_size);
 
 	walk->db = db;
 	return walk;
@@ -45,130 +45,126 @@ git_revpool *gitrp_alloc(git_odb *db)
 
 void gitrp_free(git_revpool *walk)
 {
-    git_commit_list_clear(&(walk->iterator), 0);
-    git_commit_list_clear(&(walk->roots), 0);
+	git_commit_list_clear(&(walk->iterator), 0);
+	git_commit_list_clear(&(walk->roots), 0);
 
-    git_revpool_table_free(walk->commits);
+	git_revpool_table_free(walk->commits);
 
 	free(walk);
 }
 
 void gitrp_sorting(git_revpool *pool, unsigned int sort_mode)
 {
-    if (pool->walking)
-        return;
+	if (pool->walking)
+		return;
 
-    pool->sorting = sort_mode;
-    gitrp_reset(pool);
+	pool->sorting = sort_mode;
+	gitrp_reset(pool);
 }
 
 void gitrp_push(git_revpool *pool, git_commit *commit)
 {
-    if (commit == NULL || commit->seen)
-        return;
+	if (commit == NULL || commit->seen)
+		return;
 
-    if (commit->object.pool != pool || pool->walking)
-        return;
+	if (commit->object.pool != pool || pool->walking)
+		return;
 
-    if (!commit->parsed)
-    {
-        if (git_commit_parse_existing(commit) < 0)
-            return;
-    }
+	if (!commit->parsed) {
+		if (git_commit_parse_existing(commit) < 0)
+			return;
+	}
 
-    // Sanity check: make sure that if the commit
-    // has been manually marked as uninteresting,
-    // all the parent commits are too.
-    if (commit->uninteresting)
-        git_commit__mark_uninteresting(commit);
+	// Sanity check: make sure that if the commit
+	// has been manually marked as uninteresting,
+	// all the parent commits are too.
+	if (commit->uninteresting)
+		git_commit__mark_uninteresting(commit);
 
-    git_commit_list_push_back(&pool->roots, commit);
+	git_commit_list_push_back(&pool->roots, commit);
 }
 
 void gitrp_hide(git_revpool *pool, git_commit *commit)
 {
-    if (pool->walking)
-        return;
+	if (pool->walking)
+		return;
 
-    git_commit__mark_uninteresting(commit);
-    gitrp_push(pool, commit);
+	git_commit__mark_uninteresting(commit);
+	gitrp_push(pool, commit);
 }
 
 void gitrp__enroot(git_revpool *pool, git_commit *commit)
 {
-    git_commit_node *parents;
+	git_commit_node *parents;
 
-    if (commit->seen)
-        return;
+	if (commit->seen)
+		return;
 
-    if (commit->parsed == 0)
-        git_commit_parse_existing(commit);
+	if (commit->parsed == 0)
+		git_commit_parse_existing(commit);
 
-    commit->seen = 1;
+	commit->seen = 1;
 
-    for (parents = commit->parents.head; parents != NULL; parents = parents->next)
-    {
-        parents->commit->in_degree++;
-        gitrp__enroot(pool, parents->commit);
-    }
+	for (parents = commit->parents.head; parents != NULL; parents = parents->next) {
+		parents->commit->in_degree++;
+		gitrp__enroot(pool, parents->commit);
+	}
 
-    git_commit_list_push_back(&pool->iterator, commit);
+	git_commit_list_push_back(&pool->iterator, commit);
 }
 
 void gitrp__prepare_walk(git_revpool *pool)
 {
-    git_commit_node *it;
+	git_commit_node *it;
 
-    for (it = pool->roots.head; it != NULL; it = it->next)
-        gitrp__enroot(pool, it->commit);
+	for (it = pool->roots.head; it != NULL; it = it->next)
+		gitrp__enroot(pool, it->commit);
 
-    if (pool->sorting & GIT_RPSORT_TIME)
-        git_commit_list_timesort(&pool->iterator);
+	if (pool->sorting & GIT_RPSORT_TIME)
+		git_commit_list_timesort(&pool->iterator);
 
-    if (pool->sorting & GIT_RPSORT_TOPOLOGICAL)
-        git_commit_list_toposort(&pool->iterator);
+	if (pool->sorting & GIT_RPSORT_TOPOLOGICAL)
+		git_commit_list_toposort(&pool->iterator);
 
-    if (pool->sorting & GIT_RPSORT_REVERSE)
-        pool->next_commit = &git_commit_list_pop_back;
-    else
-        pool->next_commit = &git_commit_list_pop_front;
+	if (pool->sorting & GIT_RPSORT_REVERSE)
+		pool->next_commit = &git_commit_list_pop_back;
+	else
+		pool->next_commit = &git_commit_list_pop_front;
 
-    pool->walking = 1;
+	pool->walking = 1;
 }
 
 git_commit *gitrp_next(git_revpool *pool)
 {
-    git_commit *next;
+	git_commit *next;
 
-    if (!pool->walking)
-        gitrp__prepare_walk(pool);
+	if (!pool->walking)
+		gitrp__prepare_walk(pool);
 
-    while ((next = pool->next_commit(&pool->iterator)) != NULL)
-    {
-        if (!next->uninteresting)
-            return next;
-    }
+	while ((next = pool->next_commit(&pool->iterator)) != NULL) {
+		if (!next->uninteresting)
+			return next;
+	}
 
-    // No commits left to iterate
-    gitrp_reset(pool);
-    return NULL;
+	// No commits left to iterate
+	gitrp_reset(pool);
+	return NULL;
 }
 
 void gitrp_reset(git_revpool *pool)
 {
-    git_commit *commit;
-    git_revpool_tableit it;
+	git_commit *commit;
+	git_revpool_tableit it;
 
-    git_revpool_tableit_init(pool->commits, &it);
+	git_revpool_tableit_init(pool->commits, &it);
 
-    while ((commit = (git_commit *)git_revpool_tableit_next(&it)) != NULL)
-    {
-        commit->seen = 0;
-        commit->topo_delay = 0;
-        commit->in_degree = 0;
-    }
+	while ((commit = (git_commit *)git_revpool_tableit_next(&it)) != NULL) {
+		commit->seen = 0;
+		commit->topo_delay = 0;
+		commit->in_degree = 0;
+	}
 
-    git_commit_list_clear(&pool->iterator, 0);
-    pool->walking = 0;
+	git_commit_list_clear(&pool->iterator, 0);
+	pool->walking = 0;
 }
 
diff --git a/src/revwalk.h b/src/revwalk.h
index da8182721..bff873e98 100644
--- a/src/revwalk.h
+++ b/src/revwalk.h
@@ -7,14 +7,14 @@
 struct git_revpool {
 	git_odb *db;
 
-    git_commit_list iterator;
-    git_commit *(*next_commit)(git_commit_list *);
+	git_commit_list iterator;
+	git_commit *(*next_commit)(git_commit_list *);
 
-    git_commit_list roots;
-    git_revpool_table *commits;
+	git_commit_list roots;
+	git_revpool_table *commits;
 
-    unsigned walking:1;
-    unsigned char sorting;
+	unsigned walking:1;
+	unsigned char sorting;
 };
 
 void gitrp__prepare_walk(git_revpool *pool);