int git_do_diff(GIT_DIFF diff, GIT_HASH hash1, GIT_HASH hash2, GIT_FILE * file, int *count,int isstat)
{
struct rev_info *p_Rev;
int ret;
int i;
struct diff_queue_struct *q = &diff_queued_diff;
p_Rev = (struct rev_info *)diff;
ret = diff_tree_sha1(hash1,hash2,"",&p_Rev->diffopt);
if( ret )
{
free_all_pack();
return ret;
}
if(isstat)
{
diffcore_std(&p_Rev->diffopt);
memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
//if (check_pair_status(p))
diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
}
}
free_all_pack();
if(file)
*file = q;
if(count)
*count = q->nr;
return 0;
}
int git_read_tree(GIT_HASH hash,read_tree_fn_t fn, void *context)
{
struct tree * root;
int ret;
reprepare_packed_git();
root = parse_tree_indirect(hash);
if (!root)
{
free_all_pack();
return -1;
}
ret = read_tree_recursive(root, NULL, 0, 0, NULL, fn, context);
free_all_pack();
return ret;
}
int git_run_cmd(char *cmd, char *arg)
{
int i=0;
char ** argv=0;
int argc=0;
git_init();
for(i=0;i< sizeof(commands) / sizeof(struct cmd_struct);i++)
{
if(strcmp(cmd,commands[i].cmd)==0)
{
int ret;
if(arg != NULL)
argv = strtoargv(arg,&argc);
ret = commands[i].fn(argc, argv, NULL);
if(argv)
free(argv);
discard_cache();
free_all_pack();
return ret;
}
}
return -1;
}
int git_checkout_file(const char *ref, const char *path, const char *outputpath)
{
struct cache_entry *ce;
int ret;
GIT_HASH sha1;
struct tree * root;
struct checkout state;
struct pathspec pathspec;
const char *match[2];
ret = get_sha1(ref, sha1);
if(ret)
return ret;
reprepare_packed_git();
root = parse_tree_indirect(sha1);
if(!root)
{
free_all_pack();
return -1;
}
ce = xcalloc(1, cache_entry_size(strlen(path)));
match[0] = path;
match[1] = NULL;
init_pathspec(&pathspec, match);
pathspec.items[0].use_wildcard = 0;
ret = read_tree_recursive(root, "", 0, 0, &pathspec, update_some, ce);
free_pathspec(&pathspec);
if(ret)
{
free_all_pack();
free(ce);
return ret;
}
memset(&state, 0, sizeof(state));
state.force = 1;
state.refresh_cache = 0;
ret = write_entry(ce, outputpath, &state, 0);
free_all_pack();
free(ce);
return ret;
}
int git_for_each_ref_in(const char * refname, each_ref_fn fn, void * data)
{
int ret;
invalidate_ref_cache(NULL);
ret = for_each_ref_in(refname, fn, data);
free_all_pack();
return ret;
}
int git_checkout_file(const char* ref, const char* path, char* outputpath)
{
struct cache_entry *ce;
int ret;
struct object_id oid;
struct tree * root;
struct checkout state;
struct pathspec pathspec;
const char *matchbuf[1];
ret = get_oid(ref, &oid);
if(ret)
return ret;
reprepare_packed_git(the_repository);
root = parse_tree_indirect(&oid);
if(!root)
{
free_all_pack();
return -1;
}
ce = xcalloc(1, cache_entry_size(strlen(path)));
matchbuf[0] = NULL;
parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC, PATHSPEC_PREFER_CWD, path, matchbuf);
pathspec.items[0].nowildcard_len = pathspec.items[0].len;
ret = read_tree_recursive(root, "", 0, 0, &pathspec, update_some, ce);
clear_pathspec(&pathspec);
if(ret)
{
free_all_pack();
free(ce);
return ret;
}
memset(&state, 0, sizeof(state));
state.force = 1;
state.refresh_cache = 0;
ret = write_entry(ce, outputpath, &state, 0);
free_all_pack();
free(ce);
return ret;
}
int git_do_diff(GIT_DIFF diff, const GIT_HASH hash1, const GIT_HASH hash2, GIT_FILE* file, int* count, int isstat)
{
struct rev_info *p_Rev;
int ret;
struct object_id oid1, oid2;
struct diff_queue_struct *q = &diff_queued_diff;
p_Rev = (struct rev_info *)diff;
hashcpy(oid1.hash, hash1);
hashcpy(oid2.hash, hash2);
ret = diff_tree_oid(&oid1, &oid2, "", &p_Rev->diffopt);
if( ret )
{
free_all_pack();
return ret;
}
if(isstat)
{
diffcore_std(&p_Rev->diffopt);
memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
for (int i = 0; i < q->nr; ++i) {
struct diff_filepair *p = q->queue[i];
//if (check_pair_status(p))
diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
}
}
free_all_pack();
if(file)
*file = q;
if(count)
*count = q->nr;
return 0;
}
int git_close_log(GIT_LOG handle)
{
if(handle)
{
struct rev_info *p_Rev;
p_Rev=(struct rev_info *)handle;
if(p_Rev->pPrivate)
free(p_Rev->pPrivate);
free(handle);
}
free_all_pack();
free_notes(*display_notes_trees);
display_notes_trees = 0;
return 0;
}
int git_update_index(void)
{
char** argv = NULL;
int argc = 0;
int ret;
argv = strtoargv("-q --refresh", &argc);
if (!argv)
return -1;
cleanup_chdir_notify();
drop_all_attr_stacks();
ret = cmd_update_index(argc, argv, NULL);
free(argv);
discard_cache();
free_all_pack();
return ret;
}
int git_run_cmd(char *cmd, char *arg)
{
int i=0;
char ** argv=0;
int argc=0;
static struct cmd_struct commands[] = {
{ "add", cmd_add, RUN_SETUP | NEED_WORK_TREE },
{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
{ "annotate", cmd_annotate, RUN_SETUP },
{ "apply", cmd_apply },
{ "archive", cmd_archive },
{ "bisect--helper", cmd_bisect__helper, RUN_SETUP | NEED_WORK_TREE },
{ "blame", cmd_blame, RUN_SETUP },
{ "branch", cmd_branch, RUN_SETUP },
{ "bundle", cmd_bundle },
{ "cat-file", cmd_cat_file, RUN_SETUP },
{ "checkout", cmd_checkout, RUN_SETUP | NEED_WORK_TREE },
{ "checkout-index", cmd_checkout_index,
RUN_SETUP | NEED_WORK_TREE},
{ "check-ref-format", cmd_check_ref_format },
{ "check-attr", cmd_check_attr, RUN_SETUP },
{ "cherry", cmd_cherry, RUN_SETUP },
{ "cherry-pick", cmd_cherry_pick, RUN_SETUP | NEED_WORK_TREE },
{ "clone", cmd_clone },
{ "clean", cmd_clean, RUN_SETUP | NEED_WORK_TREE },
{ "commit", cmd_commit, RUN_SETUP | NEED_WORK_TREE },
{ "commit-tree", cmd_commit_tree, RUN_SETUP },
{ "config", cmd_config },
{ "count-objects", cmd_count_objects, RUN_SETUP },
{ "describe", cmd_describe, RUN_SETUP },
{ "diff", cmd_diff },
{ "diff-files", cmd_diff_files, RUN_SETUP | NEED_WORK_TREE },
{ "diff-index", cmd_diff_index, RUN_SETUP },
{ "diff-tree", cmd_diff_tree, RUN_SETUP },
{ "fast-export", cmd_fast_export, RUN_SETUP },
{ "fetch", cmd_fetch, RUN_SETUP },
{ "fetch-pack", cmd_fetch_pack, RUN_SETUP },
{ "fmt-merge-msg", cmd_fmt_merge_msg, RUN_SETUP },
{ "for-each-ref", cmd_for_each_ref, RUN_SETUP },
{ "format-patch", cmd_format_patch, RUN_SETUP },
{ "fsck", cmd_fsck, RUN_SETUP },
{ "fsck-objects", cmd_fsck, RUN_SETUP },
{ "gc", cmd_gc, RUN_SETUP },
{ "get-tar-commit-id", cmd_get_tar_commit_id },
{ "grep", cmd_grep },
{ "hash-object", cmd_hash_object },
{ "help", cmd_help },
{ "index-pack", cmd_index_pack },
{ "init", cmd_init_db },
{ "init-db", cmd_init_db },
{ "log", cmd_log, RUN_SETUP },
{ "ls-files", cmd_ls_files, RUN_SETUP },
{ "ls-tree", cmd_ls_tree, RUN_SETUP },
{ "ls-remote", cmd_ls_remote },
{ "mailinfo", cmd_mailinfo },
{ "mailsplit", cmd_mailsplit },
{ "merge", cmd_merge, RUN_SETUP | NEED_WORK_TREE },
{ "merge-base", cmd_merge_base, RUN_SETUP },
{ "merge-file", cmd_merge_file },
{ "merge-index", cmd_merge_index, RUN_SETUP },
{ "merge-ours", cmd_merge_ours, RUN_SETUP },
{ "merge-recursive", cmd_merge_recursive, RUN_SETUP | NEED_WORK_TREE },
{ "merge-recursive-ours", cmd_merge_recursive, RUN_SETUP | NEED_WORK_TREE },
{ "merge-recursive-theirs", cmd_merge_recursive, RUN_SETUP | NEED_WORK_TREE },
{ "merge-subtree", cmd_merge_recursive, RUN_SETUP | NEED_WORK_TREE },
{ "merge-tree", cmd_merge_tree, RUN_SETUP },
{ "mktag", cmd_mktag, RUN_SETUP },
{ "mktree", cmd_mktree, RUN_SETUP },
{ "mv", cmd_mv, RUN_SETUP | NEED_WORK_TREE },
{ "name-rev", cmd_name_rev, RUN_SETUP },
{ "notes", cmd_notes, RUN_SETUP },
{ "pack-objects", cmd_pack_objects, RUN_SETUP },
{ "pack-redundant", cmd_pack_redundant, RUN_SETUP },
{ "patch-id", cmd_patch_id },
{ "peek-remote", cmd_ls_remote },
{ "pickaxe", cmd_blame, RUN_SETUP },
{ "prune", cmd_prune, RUN_SETUP },
{ "prune-packed", cmd_prune_packed, RUN_SETUP },
{ "push", cmd_push, RUN_SETUP },
{ "read-tree", cmd_read_tree, RUN_SETUP },
{ "receive-pack", cmd_receive_pack },
{ "reflog", cmd_reflog, RUN_SETUP },
{ "remote", cmd_remote, RUN_SETUP },
{ "replace", cmd_replace, RUN_SETUP },
{ "repo-config", cmd_config },
{ "rerere", cmd_rerere, RUN_SETUP },
{ "reset", cmd_reset, RUN_SETUP },
{ "rev-list", cmd_rev_list, RUN_SETUP },
{ "rev-parse", cmd_rev_parse },
{ "revert", cmd_revert, RUN_SETUP | NEED_WORK_TREE },
{ "rm", cmd_rm, RUN_SETUP },
{ "send-pack", cmd_send_pack, RUN_SETUP },
{ "shortlog", cmd_shortlog, USE_PAGER },
{ "show-branch", cmd_show_branch, RUN_SETUP },
{ "show", cmd_show, RUN_SETUP },
{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
{ "stripspace", cmd_stripspace },
{ "symbolic-ref", cmd_symbolic_ref, RUN_SETUP },
{ "tag", cmd_tag, RUN_SETUP },
{ "tar-tree", cmd_tar_tree },
{ "unpack-file", cmd_unpack_file, RUN_SETUP },
{ "unpack-objects", cmd_unpack_objects, RUN_SETUP },
{ "update-index", cmd_update_index, RUN_SETUP },
{ "update-ref", cmd_update_ref, RUN_SETUP },
{ "update-server-info", cmd_update_server_info, RUN_SETUP },
{ "upload-archive", cmd_upload_archive },
{ "var", cmd_var },
{ "verify-tag", cmd_verify_tag, RUN_SETUP },
{ "version", cmd_version },
{ "whatchanged", cmd_whatchanged, RUN_SETUP },
{ "write-tree", cmd_write_tree, RUN_SETUP },
{ "verify-pack", cmd_verify_pack },
{ "show-ref", cmd_show_ref, RUN_SETUP },
{ "pack-refs", cmd_pack_refs, RUN_SETUP },
};
git_init();
for(i=0;i< sizeof(commands) / sizeof(struct cmd_struct);i++)
{
if(strcmp(cmd,commands[i].cmd)==0)
{
int ret;
if(arg != NULL)
argv = strtoargv(arg,&argc);
ret = commands[i].fn(argc, argv, NULL);
if(argv)
free(argv);
discard_cache();
free_all_pack();
return ret;
}
}
return -1;
}
