Skip to content

G
git2
Commit 9b3577ed by Vicent Marti Committed by Andreas Ericsson
Options

Fixed brace placement and converted spaces to tabs. 

Signed-off-by: Vicent Marti <tanoku@gmail.com>
Signed-off-by: Andreas Ericsson <ae@op5.se>
parent 0cf02ff9
Showing with 219 additions and 236 deletions
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);
......
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;
}
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
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;
}
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);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment