static int rebase_init( git_rebase *rebase, git_repository *repo, const git_annotated_commit *branch, const git_annotated_commit *upstream, const git_annotated_commit *onto, const git_rebase_options *opts) { git_buf state_path = GIT_BUF_INIT; int error; if ((error = git_buf_joinpath(&state_path, repo->path_repository, REBASE_MERGE_DIR)) < 0) return error; rebase->repo = repo; rebase->type = GIT_REBASE_TYPE_MERGE; rebase->state_path = git_buf_detach(&state_path); rebase->orig_head_name = git__strdup(branch->ref_name ? branch->ref_name : ORIG_DETACHED_HEAD); rebase->quiet = opts->quiet; git_oid_cpy(&rebase->orig_head_id, git_annotated_commit_id(branch)); git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto)); if (!rebase->orig_head_name || !rebase->state_path) return -1; error = rebase_init_merge(rebase, repo, branch, upstream, onto); git_buf_free(&state_path); return error; }
static int hash_and_save(git_indexer *idx, git_rawobj *obj, git_off_t entry_start) { git_oid oid; size_t entry_size; struct entry *entry; struct git_pack_entry *pentry = NULL; entry = (struct entry *) git__calloc(1, sizeof(*entry)); GITERR_CHECK_ALLOC(entry); if (git_odb__hashobj(&oid, obj) < 0) { giterr_set(GITERR_INDEXER, "Failed to hash object"); goto on_error; } pentry = (git_pack_entry*) git__calloc(1, sizeof(struct git_pack_entry)); GITERR_CHECK_ALLOC(pentry); git_oid_cpy(&pentry->sha1, &oid); git_oid_cpy(&entry->oid, &oid); entry->crc = crc32(0L, Z_NULL, 0); entry_size = (size_t)(idx->off - entry_start); if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0) goto on_error; return save_entry(idx, entry, pentry, entry_start); on_error: git__free(pentry); git__free(entry); git__free(obj->data); return -1; }
void test_refs_overwrite__object_id(void) { // Overwrite an existing object id reference git_reference *ref; git_oid id; cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); git_reference_free(ref); /* Create it */ cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 0)); git_reference_free(ref); cl_git_pass(git_reference_lookup(&ref, g_repo, ref_test_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); git_reference_free(ref); /* Ensure we can't overwrite unless we force it */ cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0)); cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1)); git_reference_free(ref); /* Ensure it has been overwritten */ cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name)); cl_assert(!git_oid_cmp(&id, git_reference_target(ref))); git_reference_free(ref); }
int git_odb_exists_prefix( git_oid *out, git_odb *db, const git_oid *short_id, size_t len) { int error = GIT_ENOTFOUND, num_found = 0; size_t i; git_oid key = {{0}}, last_found = {{0}}, found; assert(db && short_id); if (len < GIT_OID_MINPREFIXLEN) return git_odb__error_ambiguous("prefix length too short"); if (len > GIT_OID_HEXSZ) len = GIT_OID_HEXSZ; if (len == GIT_OID_HEXSZ) { if (git_odb_exists(db, short_id)) { if (out) git_oid_cpy(out, short_id); return 0; } else { return git_odb__error_notfound("no match for id prefix", short_id); } } /* just copy valid part of short_id */ memcpy(&key.id, short_id->id, (len + 1) / 2); if (len & 1) key.id[len / 2] &= 0xF0; for (i = 0; i < db->backends.length; ++i) { backend_internal *internal = (backend_internal *) git_vector_get(&db->backends, i); git_odb_backend *b = internal->backend; if (!b->exists_prefix) continue; error = b->exists_prefix(&found, b, &key, len); if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH) continue; if (error) return error; /* make sure found item doesn't introduce ambiguity */ if (num_found) { if (git_oid__cmp(&last_found, &found)) return git_odb__error_ambiguous("multiple matches for prefix"); } else { git_oid_cpy(&last_found, &found); num_found++; } } if (!num_found) return git_odb__error_notfound("no match for id prefix", &key); if (out) git_oid_cpy(out, &last_found); return 0; }
static int store_object(git_indexer *idx) { int i, error; khiter_t k; git_oid oid; struct entry *entry; git_off_t entry_size; struct git_pack_entry *pentry; git_off_t entry_start = idx->entry_start; entry = (struct entry*) git__calloc(1, sizeof(*entry)); GITERR_CHECK_ALLOC(entry); pentry = (git_pack_entry*) git__calloc(1, sizeof(struct git_pack_entry)); GITERR_CHECK_ALLOC(pentry); git_hash_final(&oid, &idx->hash_ctx); entry_size = idx->off - entry_start; if (entry_start > UINT31_MAX) { entry->offset = UINT32_MAX; entry->offset_long = entry_start; } else { entry->offset = (uint32_t)entry_start; } git_oid_cpy(&pentry->sha1, &oid); pentry->offset = entry_start; k = kh_put(oid, idx->pack->idx_cache, &pentry->sha1, &error); if (!error) { git__free(pentry); giterr_set(GITERR_INDEXER, "cannot handle duplicate objects in pack"); goto on_error; } kh_value(idx->pack->idx_cache, k) = pentry; git_oid_cpy(&entry->oid, &oid); if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0) goto on_error; /* Add the object to the list */ if (git_vector_insert(&idx->objects, entry) < 0) goto on_error; for (i = oid.id[0]; i < 256; ++i) { idx->fanout[i]++; } return 0; on_error: git__free(entry); return -1; }
static int rebase_init_merge( git_rebase *rebase, git_repository *repo, const git_annotated_commit *branch, const git_annotated_commit *upstream, const git_annotated_commit *onto) { git_reference *head_ref = NULL; git_commit *onto_commit = NULL; git_buf reflog = GIT_BUF_INIT; git_buf state_path = GIT_BUF_INIT; int error; GIT_UNUSED(upstream); if ((error = git_buf_joinpath(&state_path, repo->path_repository, REBASE_MERGE_DIR)) < 0) goto done; rebase->state_path = git_buf_detach(&state_path); GITERR_CHECK_ALLOC(rebase->state_path); if (branch->ref_name) { rebase->orig_head_name = git__strdup(branch->ref_name); GITERR_CHECK_ALLOC(rebase->orig_head_name); } else { rebase->head_detached = 1; } rebase->onto_name = git__strdup(rebase_onto_name(onto)); GITERR_CHECK_ALLOC(rebase->onto_name); rebase->quiet = rebase->options.quiet; git_oid_cpy(&rebase->orig_head_id, git_annotated_commit_id(branch)); git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto)); if ((error = rebase_setupfiles(rebase)) < 0 || (error = git_buf_printf(&reflog, "rebase: checkout %s", rebase_onto_name(onto))) < 0 || (error = git_commit_lookup( &onto_commit, repo, git_annotated_commit_id(onto))) < 0 || (error = git_checkout_tree(repo, (git_object *)onto_commit, &rebase->options.checkout_options)) < 0 || (error = git_reference_create(&head_ref, repo, GIT_HEAD_FILE, git_annotated_commit_id(onto), 1, reflog.ptr)) < 0) goto done; done: git_reference_free(head_ref); git_commit_free(onto_commit); git_buf_free(&reflog); git_buf_free(&state_path); return error; }
static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned int identifier) { git_reflog *reflog; int error = -1; unsigned int numentries; const git_reflog_entry *entry; bool search_by_pos = (identifier <= 100000000); if (git_reflog_read(&reflog, ref) < 0) return -1; numentries = git_reflog_entrycount(reflog); if (search_by_pos) { if (numentries < identifier + 1) { giterr_set( GITERR_REFERENCE, "Reflog for '%s' has only %d entries, asked for %d", git_reference_name(ref), numentries, identifier); error = GIT_ENOTFOUND; goto cleanup; } entry = git_reflog_entry_byindex(reflog, identifier); git_oid_cpy(oid, git_reflog_entry_oidold(entry)); error = 0; goto cleanup; } else { int i; git_time commit_time; for (i = numentries - 1; i >= 0; i--) { entry = git_reflog_entry_byindex(reflog, i); commit_time = git_reflog_entry_committer(entry)->when; if (commit_time.time - identifier > 0) continue; git_oid_cpy(oid, git_reflog_entry_oidnew(entry)); error = 0; goto cleanup; } error = GIT_ENOTFOUND; } cleanup: git_reflog_free(reflog); return error; }
static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier) { git_reflog *reflog; int error = -1; size_t numentries; const git_reflog_entry *entry; bool search_by_pos = (identifier <= 100000000); if (git_reflog_read(&reflog, git_reference_owner(ref), git_reference_name(ref)) < 0) return -1; numentries = git_reflog_entrycount(reflog); if (search_by_pos) { if (numentries < identifier + 1) { giterr_set( GITERR_REFERENCE, "Reflog for '%s' has only %"PRIuZ" entries, asked for %"PRIuZ, git_reference_name(ref), numentries, identifier); error = GIT_ENOTFOUND; goto cleanup; } entry = git_reflog_entry_byindex(reflog, identifier); git_oid_cpy(oid, git_reflog_entry_id_new(entry)); error = 0; goto cleanup; } else { size_t i; git_time commit_time; for (i = 0; i < numentries; i++) { entry = git_reflog_entry_byindex(reflog, i); commit_time = git_reflog_entry_committer(entry)->when; if (commit_time.time > (git_time_t)identifier) continue; git_oid_cpy(oid, git_reflog_entry_id_new(entry)); error = 0; goto cleanup; } error = GIT_ENOTFOUND; } cleanup: git_reflog_free(reflog); return error; }
int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg) { git_reflog_entry *entry; const git_reflog_entry *previous; const char *newline; assert(reflog && new_oid && committer); entry = git__calloc(1, sizeof(git_reflog_entry)); GITERR_CHECK_ALLOC(entry); if ((git_signature_dup(&entry->committer, committer)) < 0) goto cleanup; if (msg != NULL) { if ((entry->msg = git__strdup(msg)) == NULL) goto cleanup; newline = strchr(msg, '\n'); if (newline) { if (newline[1] != '\0') { giterr_set(GITERR_INVALID, "Reflog message cannot contain newline"); goto cleanup; } entry->msg[newline - msg] = '\0'; } } previous = git_reflog_entry_byindex(reflog, 0); if (previous == NULL) git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO); else git_oid_cpy(&entry->oid_old, &previous->oid_cur); git_oid_cpy(&entry->oid_cur, new_oid); if (git_vector_insert(&reflog->entries, entry) < 0) goto cleanup; return 0; cleanup: git_reflog_entry__free(entry); return -1; }
void test_refs_rename__prefix(void) { // can be renamed to a new name prefixed with the old name git_reference *ref, *ref_two, *looked_up_ref, *renamed_ref; git_oid id; cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); /* Create loose references */ cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0, NULL)); /* An existing reference... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name)); /* Can be rename to a new name starting with the old name. */ cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name_new, 0, NULL)); git_reference_free(looked_up_ref); git_reference_free(renamed_ref); /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new)); cl_assert_equal_s(looked_up_ref->name, ref_two_name_new); git_reference_free(looked_up_ref); cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name)); git_reference_free(ref); git_reference_free(ref_two); git_reference_free(looked_up_ref); }
void test_refs_rename__overwrite(void) { // can not overwrite name of existing reference git_reference *ref, *ref_one, *ref_one_new, *ref_two; git_refdb *refdb; git_oid id; cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); /* Create loose references */ cl_git_pass(git_reference_create(&ref_one, g_repo, ref_one_name, &id, 0, NULL)); cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0, NULL)); /* Pack everything */ cl_git_pass(git_repository_refdb(&refdb, g_repo)); cl_git_pass(git_refdb_compress(refdb)); /* Attempt to create illegal reference */ cl_git_fail(git_reference_create(&ref_one_new, g_repo, ref_one_name_new, &id, 0, NULL)); /* Illegal reference couldn't be created so this is supposed to fail */ cl_git_fail(git_reference_lookup(&ref_one_new, g_repo, ref_one_name_new)); git_reference_free(ref); git_reference_free(ref_one); git_reference_free(ref_one_new); git_reference_free(ref_two); git_refdb_free(refdb); }
void test_refs_rename__force_loose(void) { // can force-rename a loose reference with the name of an existing loose reference git_reference *looked_up_ref, *renamed_ref; git_oid oid; /* An existing reference... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/br2")); git_oid_cpy(&oid, git_reference_target(looked_up_ref)); /* Can be force-renamed to the name of another existing reference. */ cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, "refs/heads/test", 1, NULL)); git_reference_free(looked_up_ref); git_reference_free(renamed_ref); /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/test")); cl_assert_equal_s(looked_up_ref->name, "refs/heads/test"); cl_assert_equal_oid(&oid, git_reference_target(looked_up_ref)); git_reference_free(looked_up_ref); /* And that the previous one doesn't exist any longer */ cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/br2")); git_reference_free(looked_up_ref); }
int py_str_to_git_oid_expand(git_repository *repo, PyObject *py_str, git_oid *oid) { int err; int len; git_odb *odb; git_odb_object *obj; len = py_str_to_git_oid(py_str, oid); if (len == GIT_OID_HEXSZ || len < 0) return len; err = git_repository_odb(&odb, repo); if (err < 0) { Error_set(err); return -1; } err = git_odb_read_prefix(&obj, odb, oid, len); if (err < 0) { git_odb_free(odb); Error_set(err); return err; } git_oid_cpy(oid, git_odb_object_id(obj)); git_odb_object_free(obj); git_odb_free(odb); return 0; }
void git_tree_entry_set_id(git_tree_entry *entry, const git_oid *oid) { assert(entry && entry->owner); git_oid_cpy(&entry->oid, oid); entry->owner->object.modified = 1; }
void test_refs_overwrite__symbolic_with_object_id(void) { // Overwrite an existing symbolic reference with an object id one git_reference *ref; git_oid id; cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); git_reference_free(ref); /* Create the symbolic ref */ cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0)); git_reference_free(ref); /* It shouldn't overwrite unless we tell it to */ cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0)); cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1)); git_reference_free(ref); /* Ensure it points to the right place */ cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); cl_assert(!git_oid_cmp(git_reference_target(ref), &id)); git_reference_free(ref); }
static int write_back(git_object *object) { int error; git_oid new_id; assert(object); assert(object->source.open); assert(object->modified); object->source.raw.len = object->source.written_bytes; if ((error = git_odb_write(&new_id, object->repo->db, &object->source.raw)) < GIT_SUCCESS) return error; if (!object->in_memory) git_hashtable_remove(object->repo->objects, &object->id); git_oid_cpy(&object->id, &new_id); git_hashtable_insert(object->repo->objects, &object->id, object); object->source.write_ptr = NULL; object->source.written_bytes = 0; object->modified = 0; object->in_memory = 0; git_object__source_close(object); return GIT_SUCCESS; }
static void setup_uptodate_files(void) { git_buf path = GIT_BUF_INIT; git_index *index; const git_index_entry *a_entry; git_index_entry new_entry = {{0}}; cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A")); cl_git_mkfile(path.ptr, "A"); /* Put 'A' into the index */ cl_git_pass(git_index_add_bypath(index, "A")); cl_assert((a_entry = git_index_get_bypath(index, "A", 0))); /* Put 'B' into the index */ new_entry.path = "B"; new_entry.mode = GIT_FILEMODE_BLOB; git_oid_cpy(&new_entry.id, &a_entry->id); cl_git_pass(git_index_add(index, &new_entry)); /* Put 'C' into the index */ new_entry.path = "C"; new_entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_index_add_frombuffer(index, &new_entry, "hello!\n", 7)); git_index_free(index); git_buf_dispose(&path); }
int git_diff_file_content__init_from_blob( git_diff_file_content *fc, git_repository *repo, const git_diff_options *opts, const git_blob *blob, git_diff_file *as_file) { memset(fc, 0, sizeof(*fc)); fc->repo = repo; fc->file = as_file; fc->blob = blob; if (!blob) { fc->flags |= GIT_DIFF_FLAG__NO_DATA; } else { fc->flags |= GIT_DIFF_FLAG__LOADED; fc->file->flags |= GIT_DIFF_FLAG_VALID_OID; fc->file->size = git_blob_rawsize(blob); fc->file->mode = GIT_FILEMODE_BLOB; git_oid_cpy(&fc->file->oid, git_blob_id(blob)); fc->map.len = (size_t)fc->file->size; fc->map.data = (char *)git_blob_rawcontent(blob); } return diff_file_content_init_common(fc, opts); }
void test_refs_rename__move_up(void) { // can move a reference to a upper reference hierarchy git_reference *ref, *ref_two, *looked_up_ref, *renamed_ref; git_oid id; cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name)); cl_assert(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_target(ref)); /* Create loose references */ cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name_new, &id, 0, NULL)); git_reference_free(ref_two); /* An existing reference... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new)); /* Can be renamed upward the reference tree. */ cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name, 0, NULL)); git_reference_free(looked_up_ref); git_reference_free(renamed_ref); /* Check we actually renamed it */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name)); cl_assert_equal_s(looked_up_ref->name, ref_two_name); git_reference_free(looked_up_ref); cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new)); git_reference_free(ref); git_reference_free(looked_up_ref); }
static int index_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { index_reader *reader = (index_reader *)_reader; const git_index_entry *entry; git_blob *blob; int error; if ((entry = git_index_get_bypath(reader->index, filename, 0)) == NULL) return GIT_ENOTFOUND; if ((error = git_blob_lookup(&blob, reader->repo, &entry->id)) < 0) goto done; if (out_id) git_oid_cpy(out_id, &entry->id); if (out_filemode) *out_filemode = entry->mode; error = git_blob__getbuf(out, blob); done: git_blob_free(blob); return error; }
static int note_write(git_oid *out, git_repository *repo, const git_signature *author, const git_signature *committer, const char *notes_ref, const char *note, git_tree *commit_tree, const char *target, git_commit **parents) { int error; git_oid oid; git_tree *tree = NULL; // TODO: should we apply filters? /* create note object */ if ((error = git_blob_create_frombuffer(&oid, repo, note, strlen(note))) < 0) goto cleanup; if ((error = manipulate_note_in_tree_r( &tree, repo, commit_tree, &oid, target, 0, insert_note_in_tree_eexists_cb, insert_note_in_tree_enotfound_cb)) < 0) goto cleanup; if (out) git_oid_cpy(out, &oid); error = git_commit_create(&oid, repo, notes_ref, author, committer, NULL, GIT_NOTES_DEFAULT_MSG_ADD, tree, *parents == NULL ? 0 : 1, (const git_commit **) parents); cleanup: git_tree_free(tree); return error; }
GIT__USE_OIDMAP git_commit_list_node *git_revwalk__commit_lookup( git_revwalk *walk, const git_oid *oid) { git_commit_list_node *commit; khiter_t pos; int ret; /* lookup and reserve space if not already present */ pos = kh_get(oid, walk->commits, oid); if (pos != kh_end(walk->commits)) return kh_value(walk->commits, pos); commit = git_commit_list_alloc_node(walk); if (commit == NULL) return NULL; git_oid_cpy(&commit->oid, oid); pos = kh_put(oid, walk->commits, &commit->oid, &ret); assert(ret != 0); kh_value(walk->commits, pos) = commit; return commit; }
int git_tree_add_entry(git_tree_entry **entry_out, git_tree *tree, const git_oid *id, const char *filename, int attributes) { git_tree_entry *entry; assert(tree && id && filename); if ((entry = git__malloc(sizeof(git_tree_entry))) == NULL) return GIT_ENOMEM; memset(entry, 0x0, sizeof(git_tree_entry)); entry->filename = git__strdup(filename); git_oid_cpy(&entry->oid, id); entry->attr = attributes; entry->owner = tree; if (git_vector_insert(&tree->entries, entry) < 0) return GIT_ENOMEM; git_vector_sort(&tree->entries); if (entry_out != NULL) *entry_out = entry; tree->object.modified = 1; return GIT_SUCCESS; }
void test_stash_drop__dropping_an_entry_rewrites_reflog_history(void) { git_reference *stash; git_reflog *reflog; const git_reflog_entry *entry; git_oid oid; size_t count; push_three_states(); cl_git_pass(git_reference_lookup(&stash, repo, GIT_REFS_STASH_FILE)); cl_git_pass(git_reflog_read(&reflog, stash)); entry = git_reflog_entry_byindex(reflog, 1); git_oid_cpy(&oid, git_reflog_entry_id_old(entry)); count = git_reflog_entrycount(reflog); git_reflog_free(reflog); cl_git_pass(git_stash_drop(repo, 1)); cl_git_pass(git_reflog_read(&reflog, stash)); entry = git_reflog_entry_byindex(reflog, 0); cl_assert_equal_i(0, git_oid_cmp(&oid, git_reflog_entry_id_old(entry))); cl_assert_equal_sz(count - 1, git_reflog_entrycount(reflog)); git_reflog_free(reflog); git_reference_free(stash); }
int git_fetchhead_ref_create( git_fetchhead_ref **out, git_oid *oid, unsigned int is_merge, const char *ref_name, const char *remote_url) { git_fetchhead_ref *fetchhead_ref; assert(out && oid); *out = NULL; fetchhead_ref = git__malloc(sizeof(git_fetchhead_ref)); GITERR_CHECK_ALLOC(fetchhead_ref); memset(fetchhead_ref, 0x0, sizeof(git_fetchhead_ref)); git_oid_cpy(&fetchhead_ref->oid, oid); fetchhead_ref->is_merge = is_merge; if (ref_name) fetchhead_ref->ref_name = git__strdup(ref_name); if (remote_url) fetchhead_ref->remote_url = git__strdup(remote_url); *out = fetchhead_ref; return 0; }
int IndexEntry_init(IndexEntry *self, PyObject *args, PyObject *kwds) { char *c_path = NULL; Oid *id = NULL; unsigned int mode; char *keywords[] = {"path", "oid", "mode", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!I", keywords, &c_path, &OidType, &id, &mode)) return -1; memset(&self->entry, 0, sizeof(struct git_index_entry)); self->entry.path = strdup(c_path); if (!self->entry.path) return -1; if (id) git_oid_cpy(&self->entry.oid, &id->oid); if (mode) self->entry.mode = mode; return 0; }
static int tree_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { tree_reader *reader = (tree_reader *)_reader; git_tree_entry *tree_entry = NULL; git_blob *blob = NULL; int error; if ((error = git_tree_entry_bypath(&tree_entry, reader->tree, filename)) < 0 || (error = git_blob_lookup(&blob, git_tree_owner(reader->tree), git_tree_entry_id(tree_entry))) < 0 || (error = git_buf_set(out, git_blob_rawcontent(blob), git_blob_rawsize(blob))) < 0) goto done; if (out_id) git_oid_cpy(out_id, git_tree_entry_id(tree_entry)); if (out_filemode) *out_filemode = git_tree_entry_filemode(tree_entry); done: git_blob_free(blob); git_tree_entry_free(tree_entry); return error; }
//go through history using the revwalker object bool MainWindow::walkHistory(git_commit* commit) { git_commit* wcommit; const char* cmsg; const git_oid* oid = git_commit_id(commit); git_oid commit_oid; git_oid_cpy(&commit_oid, oid); git_revwalk* walker; git_revwalk_new(&walker, repo); git_revwalk_sorting(walker, GIT_SORT_TOPOLOGICAL | GIT_SORT_TIME); git_revwalk_push(walker, &commit_oid); while (git_revwalk_next(&commit_oid, walker) == 0) { int error = git_commit_lookup(&wcommit, repo, &commit_oid); cmsg = git_commit_message(wcommit); qDebug() << "Commit msg = " << cmsg; git_commit_free(wcommit); } git_revwalk_free(walker); }
int git_revwalk_next(git_oid *oid, git_revwalk *walk) { int error; git_commit_list_node *next; assert(walk && oid); if (!walk->walking) { if ((error = prepare_walk(walk)) < 0) return error; } error = walk->get_next(&next, walk); if (error == GIT_ITEROVER) { git_revwalk_reset(walk); giterr_clear(); return GIT_ITEROVER; } if (!error) git_oid_cpy(oid, &next->oid); return error; }
static int rebase_commit_inmemory( git_oid *commit_id, git_rebase *rebase, const git_signature *author, const git_signature *committer, const char *message_encoding, const char *message) { git_commit *commit = NULL; int error = 0; assert(rebase->index); assert(rebase->last_commit); assert(rebase->current < rebase->operations.size); if ((error = rebase_commit__create(&commit, rebase, rebase->index, rebase->last_commit, author, committer, message_encoding, message)) < 0) goto done; git_commit_free(rebase->last_commit); rebase->last_commit = commit; git_oid_cpy(commit_id, git_commit_id(commit)); done: if (error < 0) git_commit_free(commit); return error; }