#include "cache.h"

#include "config.h"

#include "dir.h"

#include "git-compat-util.h"

#include "lockfile.h"

#include "pack.h"

#include "packfile.h"

#include "commit.h"

#include "object.h"

#include "refs.h"

#include "revision.h"

#include "sha1-lookup.h"

#include "commit-graph.h"

#include "object-store.h"

#include "alloc.h"

#include "hashmap.h"

#include "replace-object.h"

#include "progress.h"

#include "bloom.h"

#include "commit-slab.h"

#include "shallow.h"

void git_test_write_commit_graph_or_die(void)

{

int flags = 0;

if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0))

return;

if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

if (write_commit_graph_reachable(the_repository->objects->odb,

flags, NULL))

die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH");

}

#define GRAPH_SIGNATURE 0x43475048 /* "CGPH" */

#define GRAPH_CHUNKID_OIDFANOUT 0x4f494446 /* "OIDF" */

#define GRAPH_CHUNKID_OIDLOOKUP 0x4f49444c /* "OIDL" */

#define GRAPH_CHUNKID_DATA 0x43444154 /* "CDAT" */

#define GRAPH_CHUNKID_EXTRAEDGES 0x45444745 /* "EDGE" */

#define GRAPH_CHUNKID_BLOOMINDEXES 0x42494458 /* "BIDX" */

#define GRAPH_CHUNKID_BLOOMDATA 0x42444154 /* "BDAT" */

#define GRAPH_CHUNKID_BASE 0x42415345 /* "BASE" */

#define MAX_NUM_CHUNKS 7

#define GRAPH_DATA_WIDTH (the_hash_algo->rawsz + 16)

#define GRAPH_VERSION_1 0x1

#define GRAPH_VERSION GRAPH_VERSION_1

#define GRAPH_EXTRA_EDGES_NEEDED 0x80000000

#define GRAPH_EDGE_LAST_MASK 0x7fffffff

#define GRAPH_PARENT_NONE 0x70000000

#define GRAPH_LAST_EDGE 0x80000000

#define GRAPH_HEADER_SIZE 8

#define GRAPH_FANOUT_SIZE (4 * 256)

#define GRAPH_CHUNKLOOKUP_WIDTH 12

#define GRAPH_MIN_SIZE (GRAPH_HEADER_SIZE + 4 * GRAPH_CHUNKLOOKUP_WIDTH \

+ GRAPH_FANOUT_SIZE + the_hash_algo->rawsz)

#define REACHABLE (1u<<15)

define_commit_slab(commit_pos, int);

static struct commit_pos commit_pos = COMMIT_SLAB_INIT(1, commit_pos);

static void set_commit_pos(struct repository *r, const struct object_id *oid)

{

static int32_t max_pos;

struct commit *commit = lookup_commit(r, oid);

if (!commit)

return; /* should never happen, but be lenient */

*commit_pos_at(&commit_pos, commit) = max_pos++;

}

static int commit_pos_cmp(const void *va, const void *vb)

{

const struct commit *a = *(const struct commit **)va;

const struct commit *b = *(const struct commit **)vb;

return commit_pos_at(&commit_pos, a) -

commit_pos_at(&commit_pos, b);

}

static int commit_gen_cmp(const void *va, const void *vb)

{

const struct commit *a = *(const struct commit **)va;

const struct commit *b = *(const struct commit **)vb;

/* lower generation commits first */

if (a->generation < b->generation)

return -1;

else if (a->generation > b->generation)

return 1;

/* use date as a heuristic when generations are equal */

if (a->date < b->date)

return -1;

else if (a->date > b->date)

return 1;

return 0;

}

char *get_commit_graph_filename(struct object_directory *obj_dir)

{

return xstrfmt("%s/info/commit-graph", obj_dir->path);

}

static char *get_split_graph_filename(struct object_directory *odb,

const char *oid_hex)

{

return xstrfmt("%s/info/commit-graphs/graph-%s.graph", odb->path,

oid_hex);

}

static char *get_chain_filename(struct object_directory *odb)

{

return xstrfmt("%s/info/commit-graphs/commit-graph-chain", odb->path);

}

static uint8_t oid_version(void)

{

return 1;

}

static struct commit_graph *alloc_commit_graph(void)

{

struct commit_graph *g = xcalloc(1, sizeof(*g));

return g;

}

extern int read_replace_refs;

static int commit_graph_compatible(struct repository *r)

{

if (!r->gitdir)

return 0;

if (read_replace_refs) {

prepare_replace_object(r);

if (hashmap_get_size(&r->objects->replace_map->map))

return 0;

}

prepare_commit_graft(r);

if (r->parsed_objects && r->parsed_objects->grafts_nr)

return 0;

if (is_repository_shallow(r))

return 0;

return 1;

}

int open_commit_graph(const char *graph_file, int *fd, struct stat *st)

{

*fd = git_open(graph_file);

if (*fd < 0)

return 0;

if (fstat(*fd, st)) {

close(*fd);

return 0;

}

return 1;

}

struct commit_graph *load_commit_graph_one_fd_st(int fd, struct stat *st,

struct object_directory *odb)

{

void *graph_map;

size_t graph_size;

struct commit_graph *ret;

graph_size = xsize_t(st->st_size);

if (graph_size < GRAPH_MIN_SIZE) {

close(fd);

error(_("commit-graph file is too small"));

return NULL;

}

graph_map = xmmap(NULL, graph_size, PROT_READ, MAP_PRIVATE, fd, 0);

close(fd);

ret = parse_commit_graph(graph_map, graph_size);

if (ret)

ret->odb = odb;

else

munmap(graph_map, graph_size);

return ret;

}

static int verify_commit_graph_lite(struct commit_graph *g)

{

/*

if (!g->chunk_oid_fanout) {

error("commit-graph is missing the OID Fanout chunk");

return 1;

}

if (!g->chunk_oid_lookup) {

error("commit-graph is missing the OID Lookup chunk");

return 1;

}

if (!g->chunk_commit_data) {

error("commit-graph is missing the Commit Data chunk");

return 1;

}

return 0;

}

struct commit_graph *parse_commit_graph(void *graph_map, size_t graph_size)

{

const unsigned char *data, *chunk_lookup;

uint32_t i;

struct commit_graph *graph;

uint64_t last_chunk_offset;

uint32_t last_chunk_id;

uint32_t graph_signature;

unsigned char graph_version, hash_version;

if (!graph_map)

return NULL;

if (graph_size < GRAPH_MIN_SIZE)

return NULL;

data = (const unsigned char *)graph_map;

graph_signature = get_be32(data);

if (graph_signature != GRAPH_SIGNATURE) {

error(_("commit-graph signature %X does not match signature %X"),

graph_signature, GRAPH_SIGNATURE);

return NULL;

}

graph_version = *(unsigned char*)(data + 4);

if (graph_version != GRAPH_VERSION) {

error(_("commit-graph version %X does not match version %X"),

graph_version, GRAPH_VERSION);

return NULL;

}

hash_version = *(unsigned char*)(data + 5);

if (hash_version != oid_version()) {

error(_("commit-graph hash version %X does not match version %X"),

hash_version, oid_version());

return NULL;

}

graph = alloc_commit_graph();

graph->hash_len = the_hash_algo->rawsz;

graph->num_chunks = *(unsigned char*)(data + 6);

graph->data = graph_map;

graph->data_len = graph_size;

last_chunk_id = 0;

last_chunk_offset = 8;

chunk_lookup = data + 8;

for (i = 0; i < graph->num_chunks; i++) {

uint32_t chunk_id;

uint64_t chunk_offset;

int chunk_repeated = 0;

if (data + graph_size - chunk_lookup <

GRAPH_CHUNKLOOKUP_WIDTH) {

error(_("commit-graph chunk lookup table entry missing; file may be incomplete"));

goto free_and_return;

}

chunk_id = get_be32(chunk_lookup + 0);

chunk_offset = get_be64(chunk_lookup + 4);

chunk_lookup += GRAPH_CHUNKLOOKUP_WIDTH;

if (chunk_offset > graph_size - the_hash_algo->rawsz) {

error(_("commit-graph improper chunk offset %08x%08x"), (uint32_t)(chunk_offset >> 32),

(uint32_t)chunk_offset);

goto free_and_return;

}

switch (chunk_id) {

case GRAPH_CHUNKID_OIDFANOUT:

if (graph->chunk_oid_fanout)

chunk_repeated = 1;

else

graph->chunk_oid_fanout = (uint32_t*)(data + chunk_offset);

break;

case GRAPH_CHUNKID_OIDLOOKUP:

if (graph->chunk_oid_lookup)

chunk_repeated = 1;

else

graph->chunk_oid_lookup = data + chunk_offset;

break;

case GRAPH_CHUNKID_DATA:

if (graph->chunk_commit_data)

chunk_repeated = 1;

else

graph->chunk_commit_data = data + chunk_offset;

break;

case GRAPH_CHUNKID_EXTRAEDGES:

if (graph->chunk_extra_edges)

chunk_repeated = 1;

else

graph->chunk_extra_edges = data + chunk_offset;

break;

case GRAPH_CHUNKID_BASE:

if (graph->chunk_base_graphs)

chunk_repeated = 1;

else

graph->chunk_base_graphs = data + chunk_offset;

break;

case GRAPH_CHUNKID_BLOOMINDEXES:

if (graph->chunk_bloom_indexes)

chunk_repeated = 1;

else

graph->chunk_bloom_indexes = data + chunk_offset;

break;

case GRAPH_CHUNKID_BLOOMDATA:

if (graph->chunk_bloom_data)

chunk_repeated = 1;

else {

uint32_t hash_version;

graph->chunk_bloom_data = data + chunk_offset;

hash_version = get_be32(data + chunk_offset);

if (hash_version != 1)

break;

graph->bloom_filter_settings = xmalloc(sizeof(struct bloom_filter_settings));

graph->bloom_filter_settings->hash_version = hash_version;

graph->bloom_filter_settings->num_hashes = get_be32(data + chunk_offset + 4);

graph->bloom_filter_settings->bits_per_entry = get_be32(data + chunk_offset + 8);

}

break;

}

if (chunk_repeated) {

error(_("commit-graph chunk id %08x appears multiple times"), chunk_id);

goto free_and_return;

}

if (last_chunk_id == GRAPH_CHUNKID_OIDLOOKUP)

{

graph->num_commits = (chunk_offset - last_chunk_offset)

/ graph->hash_len;

}

last_chunk_id = chunk_id;

last_chunk_offset = chunk_offset;

}

if (graph->chunk_bloom_indexes && graph->chunk_bloom_data) {

init_bloom_filters();

} else {

/* We need both the bloom chunks to exist together. Else ignore the data */

graph->chunk_bloom_indexes = NULL;

graph->chunk_bloom_data = NULL;

FREE_AND_NULL(graph->bloom_filter_settings);

}

hashcpy(graph->oid.hash, graph->data + graph->data_len - graph->hash_len);

if (verify_commit_graph_lite(graph))

goto free_and_return;

return graph;

free_and_return:

free(graph->bloom_filter_settings);

free(graph);

return NULL;

}

static struct commit_graph *load_commit_graph_one(const char *graph_file,

struct object_directory *odb)

{

struct stat st;

int fd;

struct commit_graph *g;

int open_ok = open_commit_graph(graph_file, &fd, &st);

if (!open_ok)

return NULL;

g = load_commit_graph_one_fd_st(fd, &st, odb);

if (g)

g->filename = xstrdup(graph_file);

return g;

}

static struct commit_graph *load_commit_graph_v1(struct repository *r,

struct object_directory *odb)

{

char *graph_name = get_commit_graph_filename(odb);

struct commit_graph *g = load_commit_graph_one(graph_name, odb);

free(graph_name);

return g;

}

static int add_graph_to_chain(struct commit_graph *g,

struct commit_graph *chain,

struct object_id *oids,

int n)

{

struct commit_graph *cur_g = chain;

if (n && !g->chunk_base_graphs) {

warning(_("commit-graph has no base graphs chunk"));

return 0;

}

while (n) {

n--;

if (!cur_g ||

!oideq(&oids[n], &cur_g->oid) ||

!hasheq(oids[n].hash, g->chunk_base_graphs + g->hash_len * n)) {

warning(_("commit-graph chain does not match"));

return 0;

}

cur_g = cur_g->base_graph;

}

g->base_graph = chain;

if (chain)

g->num_commits_in_base = chain->num_commits + chain->num_commits_in_base;

return 1;

}

static struct commit_graph *load_commit_graph_chain(struct repository *r,

struct object_directory *odb)

{

struct commit_graph *graph_chain = NULL;

struct strbuf line = STRBUF_INIT;

struct stat st;

struct object_id *oids;

int i = 0, valid = 1, count;

char *chain_name = get_chain_filename(odb);

FILE *fp;

int stat_res;

fp = fopen(chain_name, "r");

stat_res = stat(chain_name, &st);

free(chain_name);

if (!fp ||

stat_res ||

st.st_size <= the_hash_algo->hexsz)

return NULL;

count = st.st_size / (the_hash_algo->hexsz + 1);

oids = xcalloc(count, sizeof(struct object_id));

prepare_alt_odb(r);

for (i = 0; i < count; i++) {

struct object_directory *odb;

if (strbuf_getline_lf(&line, fp) == EOF)

break;

if (get_oid_hex(line.buf, &oids[i])) {

warning(_("invalid commit-graph chain: line '%s' not a hash"),

line.buf);

valid = 0;

break;

}

valid = 0;

for (odb = r->objects->odb; odb; odb = odb->next) {

char *graph_name = get_split_graph_filename(odb, line.buf);

struct commit_graph *g = load_commit_graph_one(graph_name, odb);

free(graph_name);

if (g) {

if (add_graph_to_chain(g, graph_chain, oids, i)) {

graph_chain = g;

valid = 1;

}

break;

}

}

if (!valid) {

warning(_("unable to find all commit-graph files"));

break;

}

}

free(oids);

fclose(fp);

strbuf_release(&line);

return graph_chain;

}

struct commit_graph *read_commit_graph_one(struct repository *r,

struct object_directory *odb)

{

struct commit_graph *g = load_commit_graph_v1(r, odb);

if (!g)

g = load_commit_graph_chain(r, odb);

return g;

}

static void prepare_commit_graph_one(struct repository *r,

struct object_directory *odb)

{

if (r->objects->commit_graph)

return;

r->objects->commit_graph = read_commit_graph_one(r, odb);

}

static int prepare_commit_graph(struct repository *r)

{

struct object_directory *odb;

/*

if (r->commit_graph_disabled)

return 0;

if (r->objects->commit_graph_attempted)

return !!r->objects->commit_graph;

r->objects->commit_graph_attempted = 1;

if (git_env_bool(GIT_TEST_COMMIT_GRAPH_DIE_ON_LOAD, 0))

die("dying as requested by the '%s' variable on commit-graph load!",

GIT_TEST_COMMIT_GRAPH_DIE_ON_LOAD);

prepare_repo_settings(r);

if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0) &&

r->settings.core_commit_graph != 1)

/*

return 0;

if (!commit_graph_compatible(r))

return 0;

prepare_alt_odb(r);

for (odb = r->objects->odb;

!r->objects->commit_graph && odb;

odb = odb->next)

prepare_commit_graph_one(r, odb);

return !!r->objects->commit_graph;

}

int generation_numbers_enabled(struct repository *r)

{

uint32_t first_generation;

struct commit_graph *g;

if (!prepare_commit_graph(r))

return 0;

g = r->objects->commit_graph;

if (!g->num_commits)

return 0;

first_generation = get_be32(g->chunk_commit_data +

g->hash_len + 8) >> 2;

return !!first_generation;

}

static void close_commit_graph_one(struct commit_graph *g)

{

if (!g)

return;

close_commit_graph_one(g->base_graph);

free_commit_graph(g);

}

void close_commit_graph(struct raw_object_store *o)

{

close_commit_graph_one(o->commit_graph);

o->commit_graph = NULL;

}

static int bsearch_graph(struct commit_graph *g, struct object_id *oid, uint32_t *pos)

{

return bsearch_hash(oid->hash, g->chunk_oid_fanout,

g->chunk_oid_lookup, g->hash_len, pos);

}

static void load_oid_from_graph(struct commit_graph *g,

uint32_t pos,

struct object_id *oid)

{

uint32_t lex_index;

while (g && pos < g->num_commits_in_base)

g = g->base_graph;

if (!g)

BUG("NULL commit-graph");

if (pos >= g->num_commits + g->num_commits_in_base)

die(_("invalid commit position. commit-graph is likely corrupt"));

lex_index = pos - g->num_commits_in_base;

hashcpy(oid->hash, g->chunk_oid_lookup + g->hash_len * lex_index);

}

static struct commit_list **insert_parent_or_die(struct repository *r,

struct commit_graph *g,

uint32_t pos,

struct commit_list **pptr)

{

struct commit *c;

struct object_id oid;

if (pos >= g->num_commits + g->num_commits_in_base)

die("invalid parent position %"PRIu32, pos);

load_oid_from_graph(g, pos, &oid);

c = lookup_commit(r, &oid);

if (!c)

die(_("could not find commit %s"), oid_to_hex(&oid));

c->graph_pos = pos;

return &commit_list_insert(c, pptr)->next;

}

static void fill_commit_graph_info(struct commit *item, struct commit_graph *g, uint32_t pos)

{

const unsigned char *commit_data;

uint32_t lex_index;

while (pos < g->num_commits_in_base)

g = g->base_graph;

lex_index = pos - g->num_commits_in_base;

commit_data = g->chunk_commit_data + GRAPH_DATA_WIDTH * lex_index;

item->graph_pos = pos;

item->generation = get_be32(commit_data + g->hash_len + 8) >> 2;

}

static inline void set_commit_tree(struct commit *c, struct tree *t)

{

c->maybe_tree = t;

}

static int fill_commit_in_graph(struct repository *r,

struct commit *item,

struct commit_graph *g, uint32_t pos)

{

uint32_t edge_value;

uint32_t *parent_data_ptr;

uint64_t date_low, date_high;

struct commit_list **pptr;

const unsigned char *commit_data;

uint32_t lex_index;

while (pos < g->num_commits_in_base)

g = g->base_graph;

if (pos >= g->num_commits + g->num_commits_in_base)

die(_("invalid commit position. commit-graph is likely corrupt"));

/*

item->graph_pos = pos;

lex_index = pos - g->num_commits_in_base;

commit_data = g->chunk_commit_data + (g->hash_len + 16) * lex_index;

item->object.parsed = 1;

set_commit_tree(item, NULL);

date_high = get_be32(commit_data + g->hash_len + 8) & 0x3;

date_low = get_be32(commit_data + g->hash_len + 12);

item->date = (timestamp_t)((date_high << 32) | date_low);

item->generation = get_be32(commit_data + g->hash_len + 8) >> 2;

pptr = &item->parents;

edge_value = get_be32(commit_data + g->hash_len);

if (edge_value == GRAPH_PARENT_NONE)

return 1;

pptr = insert_parent_or_die(r, g, edge_value, pptr);

edge_value = get_be32(commit_data + g->hash_len + 4);

if (edge_value == GRAPH_PARENT_NONE)

return 1;

if (!(edge_value & GRAPH_EXTRA_EDGES_NEEDED)) {

pptr = insert_parent_or_die(r, g, edge_value, pptr);

return 1;

}

parent_data_ptr = (uint32_t*)(g->chunk_extra_edges +

4 * (uint64_t)(edge_value & GRAPH_EDGE_LAST_MASK));

do {

edge_value = get_be32(parent_data_ptr);

pptr = insert_parent_or_die(r, g,

edge_value & GRAPH_EDGE_LAST_MASK,

pptr);

parent_data_ptr++;

} while (!(edge_value & GRAPH_LAST_EDGE));

return 1;

}

static int find_commit_in_graph(struct commit *item, struct commit_graph *g, uint32_t *pos)

{

if (item->graph_pos != COMMIT_NOT_FROM_GRAPH) {

*pos = item->graph_pos;

return 1;

} else {

struct commit_graph *cur_g = g;

uint32_t lex_index;

while (cur_g && !bsearch_graph(cur_g, &(item->object.oid), &lex_index))

cur_g = cur_g->base_graph;

if (cur_g) {

*pos = lex_index + cur_g->num_commits_in_base;

return 1;

}

return 0;

}

}

static int parse_commit_in_graph_one(struct repository *r,

struct commit_graph *g,

struct commit *item)

{

uint32_t pos;

if (item->object.parsed)

return 1;

if (find_commit_in_graph(item, g, &pos))

return fill_commit_in_graph(r, item, g, pos);

return 0;

}

int parse_commit_in_graph(struct repository *r, struct commit *item)

{

if (!prepare_commit_graph(r))

return 0;

return parse_commit_in_graph_one(r, r->objects->commit_graph, item);

}

void load_commit_graph_info(struct repository *r, struct commit *item)

{

uint32_t pos;

if (!prepare_commit_graph(r))

return;

if (find_commit_in_graph(item, r->objects->commit_graph, &pos))

fill_commit_graph_info(item, r->objects->commit_graph, pos);

}

static struct tree *load_tree_for_commit(struct repository *r,

struct commit_graph *g,

struct commit *c)

{

struct object_id oid;

const unsigned char *commit_data;

while (c->graph_pos < g->num_commits_in_base)

g = g->base_graph;

commit_data = g->chunk_commit_data +

GRAPH_DATA_WIDTH * (c->graph_pos - g->num_commits_in_base);

hashcpy(oid.hash, commit_data);

set_commit_tree(c, lookup_tree(r, &oid));

return c->maybe_tree;

}

static struct tree *get_commit_tree_in_graph_one(struct repository *r,

struct commit_graph *g,

const struct commit *c)

{

if (c->maybe_tree)

return c->maybe_tree;

if (c->graph_pos == COMMIT_NOT_FROM_GRAPH)

BUG("get_commit_tree_in_graph_one called from non-commit-graph commit");

return load_tree_for_commit(r, g, (struct commit *)c);

}

struct tree *get_commit_tree_in_graph(struct repository *r, const struct commit *c)

{

return get_commit_tree_in_graph_one(r, r->objects->commit_graph, c);

}

struct packed_commit_list {

};

struct packed_oid_list {

};

struct write_commit_graph_context {

};

static void write_graph_chunk_fanout(struct hashfile *f,

struct write_commit_graph_context *ctx)

{

int i, count = 0;

struct commit **list = ctx->commits.list;

/*

for (i = 0; i < 256; i++) {

while (count < ctx->commits.nr) {

if ((*list)->object.oid.hash[0] != i)

break;

display_progress(ctx->progress, ++ctx->progress_cnt);

count++;

list++;

}

hashwrite_be32(f, count);

}

}

static void write_graph_chunk_oids(struct hashfile *f, int hash_len,

struct write_commit_graph_context *ctx)

{

struct commit **list = ctx->commits.list;

int count;

for (count = 0; count < ctx->commits.nr; count++, list++) {

display_progress(ctx->progress, ++ctx->progress_cnt);

hashwrite(f, (*list)->object.oid.hash, (int)hash_len);

}

}

static const unsigned char *commit_to_sha1(size_t index, void *table)

{

struct commit **commits = table;

return commits[index]->object.oid.hash;

}

static void write_graph_chunk_data(struct hashfile *f, int hash_len,

struct write_commit_graph_context *ctx)

{

struct commit **list = ctx->commits.list;

struct commit **last = ctx->commits.list + ctx->commits.nr;

uint32_t num_extra_edges = 0;

while (list < last) {

struct commit_list *parent;

struct object_id *tree;

int edge_value;

uint32_t packedDate[2];

display_progress(ctx->progress, ++ctx->progress_cnt);

if (parse_commit_no_graph(*list))

die(_("unable to parse commit %s"),

oid_to_hex(&(*list)->object.oid));

tree = get_commit_tree_oid(*list);

hashwrite(f, tree->hash, hash_len);

parent = (*list)->parents;

if (!parent)

edge_value = GRAPH_PARENT_NONE;

else {

edge_value = sha1_pos(parent->item->object.oid.hash,

ctx->commits.list,

ctx->commits.nr,

commit_to_sha1);

if (edge_value >= 0)

edge_value += ctx->new_num_commits_in_base;

else if (ctx->new_base_graph) {

uint32_t pos;

if (find_commit_in_graph(parent->item,

ctx->new_base_graph,

&pos))

edge_value = pos;

}

if (edge_value < 0)

BUG("missing parent %s for commit %s",

oid_to_hex(&parent->item->object.oid),

oid_to_hex(&(*list)->object.oid));

}

hashwrite_be32(f, edge_value);

if (parent)

parent = parent->next;

if (!parent)

edge_value = GRAPH_PARENT_NONE;

else if (parent->next)

edge_value = GRAPH_EXTRA_EDGES_NEEDED | num_extra_edges;

else {

edge_value = sha1_pos(parent->item->object.oid.hash,

ctx->commits.list,

ctx->commits.nr,

commit_to_sha1);

if (edge_value >= 0)

edge_value += ctx->new_num_commits_in_base;

else if (ctx->new_base_graph) {

uint32_t pos;

if (find_commit_in_graph(parent->item,

ctx->new_base_graph,

&pos))

edge_value = pos;