#include "preload-index.h"

#include "diff.h"

#include "read-cache.h"

#include "revision.h"

#include "bulk-checkin.h"

#include "strvec.h"

static int include_sparse;

static const char *pathspec_from_file;

{

int err;

if (!include_sparse &&

(ce_skip_worktree(ce) ||

continue;

continue;

if (!show_only)

else

err = S_ISREG(ce->ce_mode) ? 0 : -1;

return ret;

}

{

if (!include_sparse &&

(ce_skip_worktree(ce) ||

continue;

if (ce_stage(ce))

continue; /* do not touch unmerged paths */

if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))

continue; /* do not touch non blobs */

continue;

flags | ADD_CACHE_RENORMALIZE);

}

return retval;

}

{

char *seen;

int i;

i = dir->nr;

while (--i >= 0) {

struct dir_entry *entry = *src++;

*dst++ = entry;

}

dir->nr = dst - dir->entries;

PS_IGNORE_SKIP_WORKTREE);

return seen;

}

{

char *seen;

int i, ret = 0;

(verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET);

seen = xcalloc(pathspec->nr, 1);

_("Unstaged changes after refreshing the index:"));

for (i = 0; i < pathspec->nr; i++) {

if (!seen[i]) {

const char *path = pathspec->items[i].original;

if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) ||

string_list_append(&only_match_skip_worktree,

pathspec->items[i].original);

} else {

return ret;

}

{

struct pathspec pathspec;

int ret;

prefix, argv);

if (patch)

else

clear_pathspec(&pathspec);

return ret;

}

{

struct child_process child = CHILD_PROCESS_INIT;

struct rev_info rev;

int out;

struct stat st;

die(_("could not read the index"));

rev.diffopt.context = 7;

argc = setup_revisions(argc, argv, &rev, NULL);

strbuf_release(&name);

}

{

int i, exit_status = 0;

struct string_list matched_sparse_paths = STRING_LIST_INIT_NODUP;

for (i = 0; i < dir->nr; i++) {

if (!include_sparse &&

string_list_append(&matched_sparse_paths,

dir->entries[i]->name);

continue;

}

if (!ignore_add_errors)

die(_("adding files failed"));

exit_status = 1;

return exit_status;

}

{

int exit_status = 0;

struct pathspec pathspec;

char *ps_matched = NULL;

struct lock_file lock_file = LOCK_INIT;

argc = parse_options(argc, argv, prefix, builtin_add_options,

builtin_add_usage, PARSE_OPT_KEEP_ARGV0);

die(_("options '%s' and '%s' cannot be used together"), "--dry-run", "--interactive/--patch");

if (pathspec_from_file)

die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--interactive/--patch");

}

if (edit_interactive) {

if (pathspec_from_file)

die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--edit");

}

argc--;

argv++;

add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;

require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));

/*

* Check the "pathspec '%s' did not match any files" block

(!(addremove || take_worktree_changes)

? ADD_CACHE_IGNORE_REMOVAL : 0));

die(_("index file corrupt"));

if (add_new_files) {

int baselen;

}

/* This picks up the paths that are not tracked */

if (pathspec.nr)

}

if (refresh_only) {

goto finish;

}

if (!seen)

seen = find_pathspecs_matching_against_index(&pathspec,

/*

* file_exists() assumes exact match

!file_exists(path)) {

if (ignore_missing) {

int dtype = DT_UNKNOWN;

path, pathspec.items[i].len);

} else

die(_("pathspec '%s' did not match any files"),

ps_matched = xcalloc(pathspec.nr, 1);

if (add_renormalize)

else

&pathspec, ps_matched,

include_sparse, flags);

exit(128);

if (add_new_files)

if (chmod_arg && pathspec.nr)

end_odb_transaction();

finish:

COMMIT_LOCK | SKIP_IF_UNCHANGED))

die(_("unable to write new index file"));

* Based on git-am.sh by Junio C Hamano.

*/

#include "builtin.h"

#include "abspath.h"

#include "advice.h"

#include "string-list.h"

#include "pager.h"

#include "path.h"

#include "pretty.h"

/**

assert(state->msg);

if (!state->no_verify)

if (!ret) {

FREE_AND_NULL(state->msg);

strvec_push(&opt.args, "rebase");

opt.path_to_stdin = am_path(state, "rewritten");

}

/**

int ret = 0;

struct mailinfo mi;

if (state->utf8)

mi.metainfo_charset = get_commit_output_encoding();

if (index_file) {

/* Reload index as apply_all_patches() will have modified it. */

discard_index(the_repository->index);

}

return 0;

return error("could not build fake ancestor");

discard_index(the_repository->index);

if (write_index_as_tree(&bases[0], the_repository->index, index_path, 0, NULL))

return error(_("Repository lacks necessary blobs to fall back on 3-way merge."));

* changes.

*/

o.branch1 = "HEAD";

their_tree_name = xstrfmt("%.*s", linelen(state->msg), state->msg);

const char *reflog_msg, *author, *committer = NULL;

struct strbuf sb = STRBUF_INIT;

exit(1);

die(_("git write-tree failed to write a tree"));

if (!repo_get_oid_commit(the_repository, "HEAD", &parent)) {

fclose(fp);

}

free_commit_list(parents);

strbuf_release(&sb);

}

strbuf_release(&msg);

} else if (*reply == 'v' || *reply == 'V') {

struct child_process cp = CHILD_PROCESS_INIT;

if (!pager)

if (fast_forward_to(head_tree, head_tree, 1))

return -1;

return -1;

index_tree = parse_tree_indirect(&index);

if (len < 0)

die_errno(_("failed to read '%s'"), patch_path);

write_in_full(1, sb.buf, sb.len);

strbuf_release(&sb);

return 0;

return 0;

}

{

struct am_state state;

int binary = -1;

*

* Copyright (C) 2006 Ryan Anderson

*/

#include "git-compat-util.h"

#include "builtin.h"

#include "strvec.h"

{

struct strvec args = STRVEC_INIT;

strvec_pushl(&args, "annotate", "-c", NULL);

strvec_push(&args, argv[i]);

}

#include "builtin.h"

#include "gettext.h"

#include "hash.h"

#include "apply.h"

NULL

};

{

int force_apply = 0;

int options = 0;

#include "transport.h"

#include "parse-options.h"

#include "pkt-line.h"

static void create_output_file(const char *output_file)

{

PARSE_OPT_KEEP_UNKNOWN_OPT | \

PARSE_OPT_NO_INTERNAL_HELP )

{

const char *exec = "git-upload-archive";

char *output = NULL;

if (output)

create_output_file(output);

setvbuf(stderr, NULL, _IOLBF, BUFSIZ);

free(output);

return ret;

}

#include "builtin.h"

#include "copy.h"

#include "environment.h"

}

static int inc_nr(const char *refname UNUSED,

const struct object_id *oid UNUSED,

int flag UNUSED, void *cb_data)

{

return res;

}

int flags UNUSED, void *cb)

{

struct add_bisect_ref_data *data = cb;

refs_for_each_glob_ref_in(get_main_ref_store(the_repository),

add_bisect_ref, good, "refs/bisect/", &cb);

if (prepare_revision_walk(revs))

free(good);

free(bad);

setup_revisions(2, argv + i - 1, &revs, NULL);

if (prepare_revision_walk(&revs))

while ((commit = get_revision(&revs)) != NULL)

strvec_push(&argv_state,

oid_to_hex(&commit->object.oid));

}

static int get_first_good(const char *refname UNUSED,

const struct object_id *oid,

int flag UNUSED, void *cb_data)

{

return res;

}

{

if (argc > 1)

return error(_("'%s' requires either no argument or a commit"),

return bisect_reset(argc ? argv[0] : NULL);

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

return bisect_log();

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res = 0;

parse_opt_subcommand_fn *fn = NULL;

} else {

argc--;

argv++;

}

return is_bisect_success(res) ? 0 : -res;

* See COPYING for licensing conditions

*/

#include "builtin.h"

#include "config.h"

#include "color.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "commit.h"

#include "diff.h"

#include "revision.h"

reset = GIT_COLOR_RESET;

}

for (cnt = 0; cnt < ent->num_lines; cnt++) {

char ch;

if (opt & OUTPUT_COLOR_LINE) {

if (cnt > 0) {

fputs(color, stdout);

if (suspect->commit->object.flags & UNINTERESTING) {

length--;

putchar('^');

}

length--;

putchar('?');

}

if (opt & OUTPUT_ANNOTATE_COMPAT) {

const char *name;

if (opt & OUTPUT_SHOW_EMAIL)

}

}

{

struct rev_info revs;

char *path = NULL;

path = add_prefix(prefix, argv[1]);

argv[1] = argv[2];

} else { /* (2a) */

die("missing <path> to blame");

path = add_prefix(prefix, argv[argc - 1]);

}

sb.found_guilty_entry = &found_guilty_entry;

sb.found_guilty_entry_data = &pi;

if (show_progress)

assign_blame(&sb, opt);

stop_progress(&pi.progress);

if (!incremental)

else

goto cleanup;

output_option &= ~(OUTPUT_COLOR_LINE | OUTPUT_SHOW_AGE_WITH_COLOR);

output(&sb, output_option);

if (show_stats) {

printf("num read blob: %d\n", sb.num_read_blob);

}

cleanup:

free(path);

cleanup_scoreboard(&sb);

release_revisions(&revs);

* Based on git-branch.sh by Junio C Hamano.

*/

#include "builtin.h"

#include "config.h"

#include "color.h"

{

struct strbuf buf = STRBUF_INIT;

strbuf_addf(&buf, "branch.%s", branchname);

warning(_("update of config-file failed"));

strbuf_release(&buf);

}

char *target = NULL;

int flags = 0;

free(name);

name = mkpathdup(fmt, bname.buf);

int recovery = 0, oldref_usage = 0;

struct worktree **worktrees = get_worktrees();

/*

* Bad name --- this could be an attempt to rename a

* ref that we used to allow to be created by accident.

strbuf_addf(&oldsection, "branch.%s", interpreted_oldname);

strbuf_addf(&newsection, "branch.%s", interpreted_newname);

die(_("branch is renamed, but update of config-file failed"));

die(_("branch is copied, but update of config-file failed"));

strbuf_release(&oldref);

strbuf_release(&newref);

return 0;

}

{

/* possible actions */

int delete = 0, rename = 0, copy = 0, list = 0,

static struct ref_sorting *sorting;

struct string_list sorting_options = STRING_LIST_INIT_DUP;

struct ref_format format = REF_FORMAT_INIT;

struct option options[] = {

OPT_GROUP(N_("Generic options")),

if (list)

setup_auto_pager("branch", 1);

if (delete) {

if (!argc)

die(_("branch name required"));

} else if (show_current) {

print_current_branch_name();

} else if (list) {

/* git branch --list also shows HEAD when it is detached */

if ((filter.kind & FILTER_REFS_BRANCHES) && filter.detached)

string_list_clear(&output, 0);

ref_sorting_release(sorting);

ref_filter_clear(&filter);

} else if (edit_description) {

const char *branch_name;

struct strbuf branch_ref = STRBUF_INIT;

struct strbuf buf = STRBUF_INIT;

if (!argc) {

if (filter.detached)

die(_("cannot give description to detached HEAD"));

branch_name = head;

} else if (argc == 1) {

branch_name = buf.buf;

} else {

die(_("cannot edit description of more than one branch"));

}

strbuf_addf(&branch_ref, "refs/heads/%s", branch_name);

error((!argc || branch_checked_out(branch_ref.buf))

? _("no commit on branch '%s' yet")

: _("no branch named '%s'"),

branch_name);

ret = 0; /* happy */

strbuf_release(&branch_ref);

strbuf_release(&buf);

} else if (copy || rename) {

if (!argc)

die(_("branch name required"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to set new upstream"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to unset upstream"));

create_branches_recursively(the_repository, branch_name,

start_name, NULL, force,

reflog, quiet, track, 0);

}

create_branch(the_repository, branch_name, start_name, force, 0,

reflog, quiet, track, 0);

} else

usage_with_options(builtin_branch_usage, options);

}

#include "builtin.h"

#include "abspath.h"

#include "editor.h"

for (p = hook_name_list; *p; p++) {

const char *hook = *p;

strbuf_addf(hook_info, "%s\n", hook);

}

}

strbuf_addf(buf, "\n\n[%s]\n", title);

}

{

struct strbuf buffer = STRBUF_INIT;

struct strbuf report_path = STRBUF_INIT;

strbuf_addftime(&zip_path, option_suffix, localtime_r(&now, &tm), 0, 0);

strbuf_addstr(&zip_path, ".zip");

die_errno(_("unable to create diagnostics archive %s"), zip_path.buf);

strbuf_release(&zip_path);

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

#include "strvec.h"

#include "parse-options.h"

#include "pkt-line.h"

#include "bundle.h"

/*

return argc;

}

struct strvec pack_opts = STRVEC_INIT;

int version = -1;

int ret;

return read_bundle_header(path, header);

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int quiet = 0;

return ret;

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int ret;

return ret;

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int ret;

builtin_bundle_unbundle_usage, options, &bundle_file);

/* bundle internals use argv[1] as further parameters */

if ((bundle_fd = open_bundle(bundle_file, &header, NULL)) < 0) {

ret = 1;

goto cleanup;

}

if (progress)

strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",

_("Unbundling objects"), NULL);

ret = !!unbundle(the_repository, &header, bundle_fd,

list_bundle_refs(&header, argc, argv);

bundle_header_release(&header);

cleanup:

free(bundle_file);

return ret;

}

{

parse_opt_subcommand_fn *fn = NULL;

struct option options[] = {

packet_trace_identity("bundle");

}

* Copyright (C) Linus Torvalds, 2005

*/

#include "builtin.h"

#include "config.h"

#include "convert.h"

const char *ls_args[3] = { NULL };

ls_args[0] = "ls-tree";

ls_args[1] = obj_name;

goto cleanup;

}

cb.seen = &seen;

for_each_loose_object(batch_unordered_loose, &cb, 0);

oidset_clear(&seen);

} else {

struct oid_array sa = OID_ARRAY_INIT;

for_each_loose_object(collect_loose_object, &sa, 0);

oid_array_for_each_unique(&sa, batch_object_cb, &cb);

return 0;

}

{

int opt = 0;

int opt_cw = 0;

if (batch.buffer_output < 0)

batch.buffer_output = batch.all_objects;

/* Return early if we're in batch mode? */

if (batch.enabled) {

if (opt_cw)

#include "builtin.h"

#include "config.h"

#include "attr.h"

#include "gettext.h"

#include "object-name.h"

#include "quote.h"

#include "setup.h"

#include "parse-options.h"

#include "write-or-die.h"

usage_with_options(check_attr_usage, check_attr_options);

}

{

struct attr_check *check;

struct object_id initialized_oid;

#include "builtin.h"

#include "config.h"

#include "dir.h"

#include "quote.h"

#include "pathspec.h"

#include "parse-options.h"

#include "submodule.h"

#include "write-or-die.h"

return num_ignored;

}

{

int num_ignored;

struct dir_struct dir = DIR_INIT;

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#include "write-or-die.h"

static int use_stdin;

static const char * const check_mailmap_usage[] = {

N_("git check-mailmap [<options>] <contact>..."),

NULL

static const struct option check_mailmap_options[] = {

OPT_BOOL(0, "stdin", &use_stdin, N_("also read contacts from stdin")),

OPT_END()

};

size_t namelen, maillen;

struct ident_split ident;

map_user(mailmap, &mail, &maillen, &name, &namelen);

printf("<%.*s>\n", (int)maillen, mail);

}

{

int i;

struct string_list mailmap = STRING_LIST_INIT_NODUP;

die(_("no contacts specified"));

read_mailmap(&mailmap);

for (i = 0; i < argc; ++i)

check_mailmap(&mailmap, argv[i]);

/*

* GIT - The information manager from hell

*/

#include "builtin.h"

#include "refs.h"

#include "setup.h"

int nongit;

setup_git_directory_gently(&nongit);

!skip_prefix(sb.buf, "refs/heads/", &name))

die("'%s' is not a valid branch name", arg);

printf("%s\n", name);

return 0;

}

{

int i;

int normalize = 0;

#include "builtin.h"

#include "config.h"

#include "entry.h"

NULL

};

{

struct checkout state = CHECKOUT_INIT;

struct option checkout_worker_options[] = {

*

*/

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#include "lockfile.h"

#include "quote.h"

#include "cache-tree.h"

#include "parse-options.h"

#include "entry.h"

return 0;

}

{

int i;

struct lock_file lock_file = LOCK_INIT;

#include "builtin.h"

#include "advice.h"

#include "branch.h"

#include "read-cache.h"

#include "refs.h"

#include "remote.h"

#include "resolve-undo.h"

#include "revision.h"

#include "setup.h"

static int post_checkout_hook(struct commit *old_commit, struct commit *new_commit,

int changed)

{

oid_to_hex(old_commit ? &old_commit->object.oid : null_oid()),

oid_to_hex(new_commit ? &new_commit->object.oid : null_oid()),

changed ? "1" : "0", NULL);

&branch->oid, &branch->refname, 0))

repo_get_oid_committish(the_repository, branch->name, &branch->oid);

if (strcmp(buf.buf, branch->name)) {

free(branch->name);

branch->name = xstrdup(buf.buf);

add_files_to_cache(the_repository, NULL, NULL, NULL, 0,

0);

o.verbosity = 0;

work = write_in_core_index_as_tree(the_repository);

const char *old_desc, *reflog_msg;

if (opts->new_branch) {

if (opts->new_orphan_branch) {

char *refname;

refname = mkpathdup("refs/heads/%s", opts->new_orphan_branch);

if (opts->new_branch_log &&

int ret;

struct strbuf err = STRBUF_INIT;

report_tracking(new_branch_info);

}

const struct object_id *oid,

int flags UNUSED, void *cb_data)

{

static int checkout_branch(struct checkout_opts *opts,

struct branch_info *new_branch_info)

{

if (opts->pathspec.nr)

die(_("paths cannot be used with switching branches"));

die(_("'%s' cannot be used with switching branches"),

"--[no]-overlay");

if (opts->force && opts->merge)

die(_("'%s' cannot be used with '%s'"), "-f", "-m");

die(_("Cannot switch branch to a non-commit '%s'"),

new_branch_info->name);

die(_("missing branch or commit argument"));

if (!opts->implicit_detach &&

N_("update ignored files (default)"),

PARSE_OPT_NOCOMPLETE),

OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,

OPT_END()

};

struct option *newopts = parse_options_concat(prevopts, options);

return ret;

}

{

struct checkout_opts opts = CHECKOUT_OPTS_INIT;

struct option *options;

checkout_usage);

}

{

struct checkout_opts opts = CHECKOUT_OPTS_INIT;

struct option *options = NULL;

switch_branch_usage);

}

{

struct checkout_opts opts = CHECKOUT_OPTS_INIT;

struct option *options;

* Based on git-clean.sh by Pavel Roskin

*/

#include "builtin.h"

#include "abspath.h"

#include "config.h"

#include "parse-options.h"

#include "path.h"

#include "read-cache-ll.h"

#include "setup.h"

#include "string-list.h"

#include "quote.h"

dir->nr = dst;

}

{

int i, res;

int dry_run = 0, remove_directories = 0, quiet = 0, ignored = 0;

* Clone a repository into a different directory that does not yet exist.

*/

#include "builtin.h"

#include "abspath.h"

#include "advice.h"

#include "config.h"

N_("create a shallow clone of that depth")),

OPT_STRING(0, "shallow-since", &option_since, N_("time"),

N_("create a shallow clone since a specific time")),

OPT_BOOL(0, "single-branch", &option_single_branch,

N_("clone only one branch, HEAD or --branch")),

OPT_BOOL(0, "no-tags", &option_no_tags,

struct strbuf err = STRBUF_INIT;

t = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!t)

die("%s", err.buf);

die("%s", err.buf);

}

die("%s", err.buf);

strbuf_release(&err);

return result;

}

{

struct object_id oid;

char *head;

if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))

die(_("unable to write new index file"));

oid_to_hex(&oid), "1", NULL);

if (!err && (option_recurse_submodules.nr > 0)) {

strvec_push(&cmd.args, "--no-fetch");

}

if (filter_submodules && filter_options.choice)

strvec_pushf(&cmd.args, "--filter=%s",

expand_list_objects_filter_spec(&filter_options));

return !stat(path, &sb);

}

{

int is_bundle = 0, is_local;

int reject_shallow = 0;

* data from the --bundle-uri option.

*/

if (bundle_uri) {

int has_heuristic = 0;

/* At this point, we need the_repository to match the cloned repo. */

if (repo_init(the_repository, git_dir, work_tree))

warning(_("failed to initialize the repo, skipping bundle URI"));

bundle_uri);

else if (has_heuristic)

git_config_set_gently("fetch.bundleuri", bundle_uri);

} else {

/*

* Populate transport->got_remote_bundle_uri and

if (transport->bundles &&

hashmap_get_size(&transport->bundles->bundles)) {

/* At this point, we need the_repository to match the cloned repo. */

if (repo_init(the_repository, git_dir, work_tree))

warning(_("failed to initialize the repo, skipping bundle URI"));

else if (fetch_bundle_list(the_repository,

transport->bundles))

warning(_("failed to fetch advertised bundles"));

} else {

clear_bundle_list(transport->bundles);

FREE_AND_NULL(transport->bundles);

return 1;

junk_mode = JUNK_LEAVE_REPO;

free(remote_name);

strbuf_release(&reflog_msg);

free(dir);

free(path);

free(repo_to_free);

junk_mode = JUNK_LEAVE_ALL;

transport_ls_refs_options_release(&transport_ls_refs_options);

#include "builtin.h"

#include "config.h"

#include "gettext.h"

return git_column_config(var, value, cb, &colopts);

}

{

struct string_list list = STRING_LIST_INIT_DUP;

struct strbuf sb = STRBUF_INIT;

#include "builtin.h"

#include "commit.h"

#include "config.h"

#include "gettext.h"

#include "hex.h"

#include "parse-options.h"

#include "commit-graph.h"

#include "object-store-ll.h"

#include "progress.h"

return parse_options_concat(common_opts, to);

}

{

struct commit_graph *graph = NULL;

struct object_directory *odb = NULL;

usage_with_options(builtin_commit_graph_verify_usage, options);

if (!opts.obj_dir)

if (opts.shallow)

flags |= COMMIT_GRAPH_VERIFY_SHALLOW;

if (opts.progress)

return 0;

}

{

struct string_list pack_indexes = STRING_LIST_INIT_DUP;

struct strbuf buf = STRBUF_INIT;

if (opts.reachable + opts.stdin_packs + opts.stdin_commits > 1)

die(_("use at most one of --reachable, --stdin-commits, or --stdin-packs"));

if (!opts.obj_dir)

if (opts.append)

flags |= COMMIT_GRAPH_WRITE_APPEND;

if (opts.split)

oidset_init(&commits, 0);

if (opts.progress)

progress = start_delayed_progress(

_("Collecting commits from input"), 0);

while (strbuf_getline(&buf, stdin) != EOF) {

return result;

}

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_commit_graph_options[] = {

builtin_commit_graph_usage, 0);

FREE_AND_NULL(options);

}

*

* Copyright (C) Linus Torvalds, 2005

*/

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#include "hex.h"

#include "object-name.h"

#include "object-store-ll.h"

#include "commit.h"

#include "parse-options.h"

return 0;

}

{

static struct strbuf buffer = STRBUF_INIT;

struct commit_list *parents = NULL;

* Based on git-commit.sh by Junio C Hamano and Linus Torvalds

*/

#include "builtin.h"

#include "advice.h"

#include "config.h"

#include "path.h"

#include "preload-index.h"

#include "read-cache.h"

#include "string-list.h"

#include "rerere.h"

#include "unpack-trees.h"

static const char * const builtin_commit_usage[] = {

N_("git commit [-a | --interactive | --patch] [-s] [-v] [-u<mode>] [--amend]\n"

" [-F <file> | -m <msg>] [--reset-author] [--allow-empty]\n"

" [--allow-empty-message] [--no-verify] [-e] [--author=<author>]\n"

" [--date=<date>] [--cleanup=<mode>] [--[no-]status]\n"

* is specified explicitly.

*/

static enum commit_msg_cleanup_mode cleanup_mode;

static enum commit_whence whence;

static int use_editor = 1, include_status = 1;

old_index_env = xstrdup_or_null(getenv(INDEX_ENVIRONMENT));

setenv(INDEX_ENVIRONMENT, the_repository->index_file, 1);

die(_("interactive add failed"));

the_repository->index_file = old_repo_index_file;

discard_index(the_repository->index);

read_index_from(the_repository->index, get_lock_file_path(&index_lock),

if (cache_tree_update(the_repository->index, WRITE_TREE_SILENT) == 0) {

if (reopen_lock_file(&index_lock) < 0)

die(_("unable to write index file"));

COMMIT_LOCK | SKIP_IF_UNCHANGED))

die(_("unable to write new index file"));

commit_style = COMMIT_AS_IS;

goto out;

}

discard_index(the_repository->index);

ret = get_lock_file_path(&false_lock);

out:

string_list_clear(&partial, 0);

clear_pathspec(&pathspec);

const char *p;

if (!memchr(sb->buf, candidates[0], sb->len)) {

return;

}

if (!*p)

die(_("unable to select a comment character that is not used\n"

"in the current commit message"));

}

static void prepare_amend_commit(struct commit *commit, struct strbuf *sb,

repo_unuse_commit_buffer(the_repository, commit, buffer);

}

static int prepare_to_commit(const char *index_file, const char *prefix,

struct commit *current_head,

struct wt_status *s,

s->use_color = 0;

committable = run_status(s->fp, index_file, prefix, 1, s);

s->use_color = saved_color_setting;

} else {

struct object_id oid;

const char *parent = "HEAD";

*/

discard_index(the_repository->index);

}

if (cache_tree_update(the_repository->index, 0)) {

error(_("Error building trees"));

if (0 <= edit_flag)

use_editor = edit_flag;

handle_untracked_files_arg(s);

if (all && argc > 0)

return git_diff_ui_config(k, v, ctx, NULL);

}

{

static int no_renames = -1;

static const char *rename_score_arg = (const char *)-1;

include_status = git_config_bool(k, v);

return 0;

}

if (!strcmp(k, "commit.gpgsign")) {

sign_commit = git_config_bool(k, v) ? "" : NULL;

return 0;

return git_status_config(k, v, ctx, s);

}

{

static struct wt_status s;

static struct option builtin_commit_options[] = {

OPT__QUIET(&quiet, N_("suppress summary after successful commit")),

OPT__VERBOSE(&verbose, N_("show diff in commit message template")),

if (verbose == -1)

verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;

if (dry_run)

return dry_run_commit(argv, prefix, current_head, &s);

index_file = prepare_index(argv, prefix, current_head, 0);

repo_rerere(the_repository, 0);

run_auto_maintenance(quiet);

if (amend && !no_post_rewrite) {

commit_post_rewrite(the_repository, current_head, &oid);

}

#include "builtin.h"

#include "abspath.h"

#include "config.h"

#include "color.h"

#include "editor.h"

#include "environment.h"

#include "gettext.h"

#include "ident.h"

#include "parse-options.h"

static const char *const builtin_config_usage[] = {

N_("git config list [<file-option>] [<display-option>] [--includes]"),

N_("git config set [<file-option>] [--type=<type>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),

N_("git config rename-section [<file-option>] <old-name> <new-name>"),

N_("git config remove-section [<file-option>] <name>"),

N_("git config edit [<file-option>]"),

};

static const char *const builtin_config_unset_usage[] = {

NULL

};

else

opts->options.respect_includes = opts->respect_includes_opt;

if (startup_info->have_repository) {

}

}

}

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

return 0;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

const char *value_pattern = NULL, *comment_arg = NULL;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

const char *value_pattern = NULL;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

location_options_init(&location_opts, prefix);

check_write(&location_opts.source);

if (ret < 0)

goto out;

else if (!ret)

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

location_options_init(&location_opts, prefix);

check_write(&location_opts.source);

if (ret < 0)

goto out;

else if (!ret)

return 0;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

else if (actions == ACTION_RENAME_SECTION) {

check_write(&location_opts.source);

check_argc(argc, 2, 2);

if (ret < 0)

goto out;

else if (!ret)

else if (actions == ACTION_REMOVE_SECTION) {

check_write(&location_opts.source);

check_argc(argc, 1, 1);

if (ret < 0)

goto out;

else if (!ret)

return ret;

}

{

parse_opt_subcommand_fn *subcommand = NULL;

struct option subcommand_opts[] = {

if (subcommand) {

argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,

PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_UNKNOWN_OPT);

}

return cmd_config_actions(argc, argv, prefix);

*

* Copyright (c) 2006 Junio C Hamano

*/

#include "builtin.h"

#include "config.h"

#include "dir.h"

#include "gettext.h"

#include "path.h"

#include "parse-options.h"

#include "quote.h"

#include "packfile.h"

else {

loose_size += on_disk_bytes(st);

loose++;

packed_loose++;

}

return 0;

NULL

};

{

int human_readable = 0;

struct option opts[] = {

usage_with_options(count_objects_usage, opts);

if (verbose) {

report_garbage = real_report_garbage;

}

count_loose, count_cruft, NULL, NULL);

if (verbose) {

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

free(path_copy);

}

{

struct tempfile *socket_file;

const char *socket_path;

#else

{

const char * const usage[] = {

"git credential-cache--daemon [--debug] <socket-path>",

static int connection_closed(int error)

{

}

static int connection_fatally_broken(int error)

die_errno("unable to read result code from cache daemon");

if (r != 3 || memcmp(buf, "ok\n", 3))

die("cache daemon did not start: %.*s", r, buf);

close(daemon.out);

}

credential_announce_capabilities(&c, stdout);

}

{

int timeout = 900;

const char *op;

const char * const usage[] = {

struct option options[] = {

OPT_INTEGER(0, "timeout", &timeout,

"number of seconds to cache credentials"),

"path of cache-daemon socket"),

OPT_END()

};

if (!have_unix_sockets())

die(_("credential-cache unavailable; no unix socket support"));

if (!socket_path)

socket_path = get_socket_path();

if (!socket_path)

else

; /* ignore unknown operation */

return 0;

}

#else

{

const char * const usage[] = {

"git credential-cache [options] <action>",

#include "builtin.h"

#include "config.h"

#include "gettext.h"

return; /* Found credential */

}

{

const char * const usage[] = {

"git credential-store [<options>] <action>",

; /* Ignore unknown operation. */

string_list_clear(&fns, 0);

return 0;

}

#include "git-compat-util.h"

#include "credential.h"

#include "builtin.h"

static const char usage_msg[] =

"git credential (fill|approve|reject)";

{

const char *op;

struct credential c = CREDENTIAL_INIT;

die("unable to read credential from stdin");

if (!strcmp(op, "fill")) {

credential_next_state(&c);

credential_write(&c, stdout, CREDENTIAL_OP_RESPONSE);

} else if (!strcmp(op, "approve")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else if (!strcmp(op, "reject")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else {

usage(usage_msg);

}

#include "builtin.h"

#include "config.h"

#include "environment.h"

}

}

int flag UNUSED, void *cb_data UNUSED)

{

int is_tag = 0;

struct commit_name **slot;

seen_commits++;

slot = commit_names_peek(&commit_names, c);

n = slot ? *slot : NULL;

if (n) {

if (n->prio == 2)

annotated_cnt++;

}

}

for (cur_match = 0; cur_match < match_cnt; cur_match++) {

struct possible_tag *t = &all_matches[cur_match];

fprintf(stderr, _("traversed %lu commits\n"), seen_commits);

if (gave_up_on) {

fprintf(stderr,

oid_to_hex(&gave_up_on->object.oid));

}

}

traverse_commit_list(&revs, process_commit, process_object, &pcd);

reset_revision_walk();

release_revisions(&revs);

}

static void describe(const char *arg, int last_one)

return 0;

}

{

int contains = 0;

struct option options[] = {

if (contains) {

struct string_list_item *item;

struct strvec args;

strvec_init(&args);

strvec_pushl(&args, "name-rev",

strvec_pushv(&args, argv);

else

strvec_push(&args, "HEAD");

}

hashmap_init(&names, commit_name_neq, NULL, 0);

} else if (dirty) {

struct lock_file index_lock = LOCK_INIT;

struct rev_info revs;

int fd;

setup_work_tree();

repo_update_index_if_able(the_repository, &index_lock);

repo_init_revisions(the_repository, &revs, prefix);

BUG("malformed internal diff-index command line");

run_diff_index(&revs, 0);

suffix = NULL;

else

suffix = dirty;

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

NULL

};

{

struct strbuf zip_path = STRBUF_INIT;

time_t now = time(NULL);

}

/* Prepare diagnostics */

die_errno(_("unable to create diagnostics archive %s"),

zip_path.buf);

*

* Copyright (C) Linus Torvalds, 2005

*/

#include "builtin.h"

#include "config.h"

#include "diff.h"

#include "diff-merges.h"

#include "commit.h"

#include "preload-index.h"

#include "revision.h"

static const char diff_files_usage[] =

"\n"

COMMON_DIFF_OPTIONS_HELP;

{

struct rev_info rev;

int result;

if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0)

die_errno("repo_read_index_preload");

run_diff_files(&rev, options);

release_revisions(&rev);

return result;

}

#include "builtin.h"

#include "config.h"

#include "diff.h"

#include "diff-merges.h"

#include "commit.h"

#include "preload-index.h"

#include "revision.h"

#include "setup.h"

"\n"

COMMON_DIFF_OPTIONS_HELP;

{

struct rev_info rev;

unsigned int option = 0;

usage(diff_cache_usage);

git_config(git_diff_basic_config, NULL); /* no "diff" UI options */

repo_init_revisions(the_repository, &rev, prefix);

rev.abbrev = 0;

prefix = precompose_argv_prefix(argc, argv, prefix);

return -1;

}

run_diff_index(&rev, option);

release_revisions(&rev);

return result;

}

#include "builtin.h"

#include "config.h"

#include "diff.h"

#include "hex.h"

#include "log-tree.h"

#include "read-cache-ll.h"

#include "revision.h"

#include "tree.h"

static struct rev_info log_tree_opt;

}

}

{

char line[1000];

struct object *tree1, *tree2;

diff_free(&opt->diffopt);

}

}

* Copyright (c) 2006 Junio C Hamano

*/

#include "builtin.h"

#include "config.h"

#include "ewah/ewok.h"

sym->skip = map;

}

{

int i;

struct rev_info rev;

builtin_diff_combined(&rev, argc, argv,

ent.objects, ent.nr,

first_non_parent);

if (1 < rev.diffopt.skip_stat_unmatch)

refresh_index_quietly();

release_revisions(&rev);

object_array_clear(&ent);

return result;

}

* Copyright (C) 2016 Johannes Schindelin

*/

#include "builtin.h"

#include "abspath.h"

#include "config.h"

#include "copy.h"

#include "hex.h"

#include "parse-options.h"

#include "read-cache-ll.h"

#include "sparse-index.h"

#include "strvec.h"

#include "strbuf.h"

struct child_process update_index = CHILD_PROCESS_INIT;

struct child_process diff_files = CHILD_PROCESS_INIT;

struct strbuf buf = STRBUF_INIT;

FILE *fp;

strvec_pushl(&update_index.args,

/* Write the file contents for the left and right sides of the difftool

* dir-diff representation for submodules and symlinks. Symlinks and submodules

* are written as regular text files so that external diff tools can diff them

* displays for symlink and submodule diffs.

*/

static void write_standin_files(struct pair_entry *entry,

char *lbase_dir = NULL, *rbase_dir = NULL;

size_t ldir_len, rdir_len, wtdir_len;

const char *workdir, *tmp;

FILE *fp = NULL;

struct hashmap working_tree_dups = HASHMAP_INIT(working_tree_entry_cmp,

NULL);

struct checkout lstate, rstate;

int err = 0;

struct child_process cmd = CHILD_PROCESS_INIT;

int indices_loaded = 0;

/* Setup temp directories */

tmp = getenv("TMPDIR");

* in the common case of --symlinks and the difftool updating

* files through the symlink.

*/

for (i = 0; i < wtindex.cache_nr; i++) {

struct hashmap_entry dummy;

const char *name = wtindex.cache[i]->name;

if (fp)

fclose(fp);

free(lbase_dir);

free(rbase_dir);

strbuf_release(&info);

return run_command(child);

}

{

int use_gui_tool = -1, dir_diff = 0, prompt = -1, symlinks = 0,

tool_help = 0, no_index = 0;

if (!no_index){

setup_work_tree();

} else if (dir_diff)

die(_("options '%s' and '%s' cannot be used together"), "--dir-diff", "--no-index");

*

* Copyright (C) 2007 Johannes E. Schindelin

*/

#include "builtin.h"

#include "config.h"

#include "gettext.h"

static int reference_excluded_commits;

static int show_original_ids;

static int mark_tags;

static struct refspec refspecs = REFSPEC_INIT_FETCH;

static int anonymize;

static struct hashmap anonymized_seeds;

free(buf);

}

{

switch (e->item->type) {

case OBJ_COMMIT:

struct rev_cmdline_entry *e = info->rev + i;

struct object_id oid;

struct commit *commit;

if (e->flags & UNINTERESTING)

continue;

if (repo_dwim_ref(the_repository, e->name, strlen(e->name),

continue;

if (refspecs.nr) {

char *private;

warning("%s: Unexpected object of type %s, skipping.",

e->name,

type_name(e->item->type));

continue;

}

break;

case OBJ_BLOB:

export_blob(&commit->object.oid);

continue;

default: /* OBJ_TAG (nested tags) is already handled */

warning("Tag points to object of unexpected type %s, skipping.",

type_name(commit->object.type));

continue;

}

if (!*revision_sources_at(&revision_sources, commit))

*revision_sources_at(&revision_sources, commit) = full_name;

}

string_list_sort(&extra_refs);

return 0;

}

{

struct rev_info revs;

struct commit *commit;

revs.diffopt.format_callback = show_filemodify;

revs.diffopt.format_callback_data = &paths_of_changed_objects;

revs.diffopt.flags.recursive = 1;

revs.diffopt.no_free = 1;

while ((commit = get_revision(&revs)))

handle_commit(commit, &revs, &paths_of_changed_objects);

handle_tags_and_duplicates(&extra_refs);

handle_tags_and_duplicates(&tag_refs);

#include "builtin.h"

#include "abspath.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "config.h"

#include "lockfile.h"

#include "object.h"

#include "delta.h"

#include "pack.h"

#include "path.h"

#include "refs.h"

#include "csum-file.h"

#include "quote.h"

static int failure;

static FILE *pack_edges;

static unsigned int show_stats = 1;

static int global_argc;

static const char **global_argv;

static const char *global_prefix;

static struct object_entry_pool *blocks;

static struct hashmap object_table;

static struct mark_set *marks;

static int import_marks_file_from_stream;

static int import_marks_file_ignore_missing;

static int import_marks_file_done;

p->pack_fd = pack_fd;

p->do_not_close = 1;

pack_file = hashfd(pack_fd, p->pack_name);

pack_data = p;

struct strbuf name = STRBUF_INIT;

int keep_fd;

keep_fd = odb_pack_keep(name.buf);

if (keep_fd < 0)

die_errno("cannot create keep file");

if (close(keep_fd))

die_errno("failed to write keep file");

if (finalize_object_file(pack_data->pack_name, name.buf))

die("cannot store pack file");

if (finalize_object_file(curr_index_name, name.buf))

die("cannot store index file");

free((void *)curr_index_name);

for (k = 0; k < pack_id; k++) {

struct packed_git *p = all_packs[k];

unlink_or_warn(name.buf);

}

strbuf_release(&name);

idx_name = keep_pack(create_index());

/* Register the packfile with core git's machinery. */

if (!new_p)

die("core git rejected index %s", idx_name);

all_packs[pack_id] = new_p;

if (e->idx.offset) {

duplicate_count_by_type[type]++;

return 1;

e->type = type;

e->pack_id = MAX_PACK_ID;

e->idx.offset = 1; /* just not zero! */

|| (pack_size + PACK_SIZE_THRESHOLD + len) < pack_size)

cycle_packfile();

hashfile_checkpoint(pack_file, &checkpoint);

offset = checkpoint.offset;

duplicate_count_by_type[OBJ_BLOB]++;

truncate_pack(&checkpoint);

e->type = OBJ_BLOB;

e->pack_id = MAX_PACK_ID;

e->idx.offset = 1; /* just not zero! */

struct ref_transaction *transaction;

struct object_id old_oid;

struct strbuf err = STRBUF_INIT;

if (is_null_oid(&b->oid)) {

if (b->delete)

refs_delete_ref(get_main_ref_store(the_repository),

}

}

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction ||

ref_transaction_update(transaction, b->name, &b->oid, &old_oid,

NULL, NULL, 0, msg, &err) ||

struct ref_transaction *transaction;

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

failure |= error("%s", err.buf);

goto cleanup;

tree_content_replace(&b->branch_tree, &oid, mode, NULL);

return;

}

tree_content_set(&b->branch_tree, path.buf, &oid, mode, NULL);

}

leaf.tree);

return;

}

tree_content_set(&b->branch_tree, dest.buf,

&leaf.versions[1].oid,

leaf.versions[1].mode,

read_marks();

}

import_marks_file = make_fast_import_path(marks);

import_marks_file_from_stream = from_stream;

import_marks_file_ignore_missing = ignore_missing;

static void option_export_marks(const char *marks)

{

export_marks_file = make_fast_import_path(marks);

}

free(f);

string_list_insert(list, s)->util = ms;

}

static int parse_one_option(const char *option)

option_export_pack_edges(option);

} else if (!strcmp(option, "quiet")) {

show_stats = 0;

} else if (!strcmp(option, "stats")) {

show_stats = 1;

} else if (!strcmp(option, "allow-unsafe-features")) {

if (!git_config_get_int("pack.indexversion", &indexversion_value)) {

pack_idx_opts.version = indexversion_value;

if (pack_idx_opts.version > 2)

}

if (!git_config_get_ulong("pack.packsizelimit", &packsizelimit_value))

max_packsize = packsizelimit_value;

build_mark_map(&sub_marks_from, &sub_marks_to);

}

{

unsigned int i;

fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)((tree_entry_allocd + fi_mem_pool.pool_alloc) /1024));

fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "\n");

}

#include "builtin.h"

#include "gettext.h"

#include "hex.h"

(*sought)[*nr - 1] = ref;

}

{

int i, ret;

const char *dest = NULL;

struct ref **sought = NULL;

int nr_sought = 0, alloc_sought = 0;

int fd[2];

struct string_list pack_lockfiles = STRING_LIST_INIT_DUP;

version = discover_version(&reader);

switch (version) {

case protocol_v2:

args.stateless_rpc);

break;

case protocol_v1:

case protocol_v0:

break;

case protocol_unknown_version:

BUG("unknown protocol version");

}

&shallow, pack_lockfiles_ptr, version);

if (pack_lockfiles.nr) {

int i;

if (finish_connect(conn))

return 1;

/*

* If the heads to pull were given, we should have consumed

*/

ret |= report_unmatched_refs(sought, nr_sought);

printf("%s %s\n",

oid_to_hex(&ref->old_oid), ref->name);

return ret;

}

/*

* "git fetch"

*/

#include "builtin.h"

#include "advice.h"

#include "config.h"

#include "gettext.h"

#include "environment.h"

#include "hex.h"

#include "refs.h"

#include "refspec.h"

#include "object-name.h"

return ent;

}

const struct object_id *oid,

int flag UNUSED, void *cbdata)

{

ref_namespace[NAMESPACE_TAGS].ref))) {

int j;

rs->items[j - 1] = rs->items[j];

rs->nr--;

i--;

continue;

*/

if (!transaction) {

transaction = our_transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

ret = STORE_REF_ERROR_OTHER;

goto out;

opt.exclude_hidden_refs_section = "fetch";

rm = ref_map;

if (check_connected(iterate_ref_map, &rm, &opt)) {

display_state->url);

goto abort;

}

die(_("option \"%s\" value \"%s\" is not valid for %s"),

name, value, transport->url);

if (r > 0)

name, transport->url);

}

static int add_oid(const char *refname UNUSED,

const struct object_id *oid,

int flags UNUSED, void *cb_data)

{

return retcode;

}

static int do_fetch(struct transport *transport,

struct refspec *rs,

const struct fetch_config *config)

"refs/tags/");

}

if (must_list_refs) {

trace2_region_enter("fetch", "remote_refs", the_repository);

remote_refs = transport_get_remote_refs(transport,

if (atomic_fetch) {

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

retcode = -1;

goto cleanup;

goto cleanup;

retcode = ref_transaction_commit(transaction, &err);

goto cleanup;

}

commit_fetch_head(&fetch_head);

"you need to specify exactly one branch with the --set-upstream option"));

}

}

cleanup:

if (retcode) {

if (transaction && ref_transaction_abort(transaction, &err) &&

err.len)

error("%s", err.buf);

}

display_state_release(&display_state);

close_fetch_head(&fetch_head);

strbuf_release(&err);

strvec_pushl(&argv, "-c", "fetch.bundleURI=",

"fetch", "--append", "--no-auto-gc",

"--no-write-commit-graph", NULL);

add_options_to_argv(&argv, config);

if (max_children != 1 && list->nr != 1) {

return exit_code;

}

{

struct fetch_config config = {

.display_format = DISPLAY_FORMAT_FULL,

N_("deepen history of shallow clone")),

OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),

N_("deepen history of shallow repository based on time")),

OPT_INTEGER(0, "deepen", &deepen_relative,

N_("deepen history of shallow clone")),

OPT_SET_INT_F(0, "unshallow", &unshallow,

struct oidset_iter iter;

const struct object_id *oid;

if (!remote)

die(_("must supply remote when using --negotiate-only"));

gtransport = prepare_transport(remote, 1);

} else {

warning(_("protocol does not support --negotiate-only, exiting"));

result = 1;

goto cleanup;

}

if (server_options.nr)

while ((oid = oidset_iter_next(&iter)))

printf("%s\n", oid_to_hex(oid));

oidset_clear(&acked_commits);

} else if (remote) {

fetch_one_setup_partial(remote);

result = fetch_one(remote, argc, argv, prune_tags_ok, stdin_refspecs,

&config);

} else {

int max_children = max_jobs;

max_children = config.parallel;

/* TODO should this also die if we have a previous partial-clone? */

result = fetch_multiple(&list, max_children, &config);

}

/*

max_children = config.parallel;

add_options_to_argv(&options, &config);

result = fetch_submodules(the_repository,

&options,

submodule_prefix,

recurse_submodules_default,

verbosity < 0,

max_children);

strvec_clear(&options);

}

if (progress)

commit_graph_flags |= COMMIT_GRAPH_WRITE_PROGRESS;

write_commit_graph_reachable(the_repository->objects->odb,

commit_graph_flags,

NULL);

}

if (enable_auto_gc) {

#include "builtin.h"

#include "config.h"

#include "fmt-merge-msg.h"

NULL

};

{

char *inpath = NULL;

const char *message = NULL;

return ret;

write_in_full(STDOUT_FILENO, output.buf, output.len);

free(inpath);

return 0;

}

#include "builtin.h"

#include "commit.h"

#include "config.h"

NULL

};

{

struct ref_sorting *sorting;

struct string_list sorting_options = STRING_LIST_INIT_DUP;

filter_and_format_refs(&filter, flags, sorting, &format);

ref_filter_clear(&filter);

ref_sorting_release(sorting);

strvec_clear(&vec);

return 0;

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#include "parse-options.h"

#include "path.h"

#include "run-command.h"

#include "string-list.h"

return run_command(&child);

}

{

static const char *config_key = NULL;

int keep_going = 0;

const struct string_list *values;

int err;

else if (err)

return 0;

int ret = run_command_on_repo(values->items[i].string, argc, argv);

if (ret) {

if (!keep_going)

#include "builtin.h"

#include "gettext.h"

#include "hex.h"

#include "config.h"

#include "commit.h"

#include "tree.h"

return -1;

}

{

switch (msg_type) {

case FSCK_WARN:

/* TRANSLATORS: e.g. warning in tree 01bfda: <more explanation> */

return 0;

obj->flags |= REACHABLE;

/*

* Further recursion does not need to be performed on this

* object since it is a promisor object (so it does not need to

unsigned int nr = 0;

int result = 0;

if (show_progress)

while (pending.nr) {

result |= traverse_one_object(object_array_pop(&pending));

display_progress(progress, ++nr);

* do a full fsck

*/

if (!(obj->flags & HAS_OBJ)) {

return;

return; /* it is in pack - forget about it */

printf_ln(_("missing %s %s"),

printable_type(&obj->oid, obj->type),

* traversal.

*/

for_each_loose_object(mark_loose_unreachable_referents, NULL, 0);

}

/* Look up all the requirements, warn about missing objects.. */

refname, timestamp);

obj->flags |= USED;

mark_object_reachable(obj);

error(_("%s: invalid reflog entry %s"),

refname, oid_to_hex(oid));

errors_found |= ERROR_REACHABLE;

return 0;

}

int flag UNUSED, void *cb_data UNUSED)

{

struct object *obj;

obj = parse_object(the_repository, oid);

if (!obj) {

/*

* Increment default_refs anyway, because this is a

* valid ref.

strbuf_worktree_ref(wt, &ref, "HEAD");

fsck_head_link(ref.buf, &head_points_at, &head_oid);

if (head_points_at && !is_null_oid(&head_oid))

strbuf_release(&ref);

if (include_reflogs)

fprintf_ln(stderr, _("Checking object directory"));

if (show_progress)

for_each_loose_file_in_objdir(path, fsck_loose, fsck_cruft, fsck_subdir,

&cb_data);

if (show_progress) {

for (struct packed_git *p = get_all_packs(r); p; p = p->next)

pack_count++;

pack_count = 0;

}

OPT_END(),

};

{

int i;

struct object_directory *odb;

fsck_walk_options.walk = mark_object;

fsck_obj_options.walk = mark_used;

if (check_strict)

fsck_obj_options.strict = 1;

if (connectivity_only) {

for_each_loose_object(mark_loose_for_connectivity, NULL, 0);

} else {

prepare_alt_odb(the_repository);

for (odb = the_repository->objects->odb; odb; odb = odb->next)

total += p->num_objects;

}

}

for (p = get_all_packs(the_repository); p;

p = p->next) {

&oid);

if (!obj || !(obj->flags & HAS_OBJ)) {

continue;

error(_("%s: object missing"), oid_to_hex(&oid));

errors_found |= ERROR_OBJECT;

* and may get overwritten by other calls

* while we're examining the index.

*/

read_index_from(&istate, path, get_worktree_git_dir(wt));

fsck_index(&istate, path, wt->is_current);

discard_index(&istate);

#include "builtin.h"

#include "abspath.h"

#include "config.h"

#include "dir.h"

#include "gettext.h"

#include "parse-options.h"

#include "fsmonitor-ll.h"

#include "compat/fsmonitor/fsm-health.h"

#include "compat/fsmonitor/fsm-listen.h"

#include "fsmonitor--daemon.h"

#include "simple-ipc.h"

#include "khash.h"

#include "run-command.h"

* system event listener thread so that we have the IPC handle

* before we need it.

*/

return error_errno(

_("could not start IPC thread pool on '%s'"),

state->path_ipc.buf);

/* Prepare to (recursively) watch the <worktree-root> directory. */

strbuf_init(&state.path_worktree_watch, 0);

state.nr_paths_watching = 1;

strbuf_init(&state.alias.alias, 0);

strbuf_addstr(&state.path_gitdir_watch, "/.git");

if (!is_directory(state.path_gitdir_watch.buf)) {

strbuf_reset(&state.path_gitdir_watch);

state.nr_paths_watching = 2;

}

}

}

{

const char *subcmd;

enum fsmonitor_reason reason;

}

#else

{

struct option options[] = {

OPT_END()

* Copyright (c) 2006 Shawn O. Pearce

*/

#include "builtin.h"

#include "abspath.h"

#include "date.h"

#include "environment.h"

#include "hex.h"

#include "config.h"

#include "tempfile.h"

#include "lockfile.h"

NULL

};

static timestamp_t gc_log_expire_time;

static struct strvec reflog = STRVEC_INIT;

static struct strvec repack = STRVEC_INIT;

process_log_file();

}

static int gc_config_is_timestamp_never(const char *var)

{

const char *value;

return 0;

}

{

const char *value;

if (!git_config_get_value("gc.packrefs", &value)) {

if (value && !strcmp(value, "notbare"))

else

}

if (gc_config_is_timestamp_never("gc.reflogexpire") &&

gc_config_is_timestamp_never("gc.reflogexpireunreachable"))

git_config(git_default_config, NULL);

}

struct maintenance_run_opts {

int auto_flag;

int quiet;

enum schedule_priority schedule;

};

{

/*

* The auto-repacking logic for refs is handled by the ref backends and

return 1;

}

{

struct child_process cmd = CHILD_PROCESS_INIT;

return run_command(&cmd);

}

{

/*

* Quickly check if a "gc" is needed, by estimating how

if (!dir)

return 0;

while ((ent = readdir(dir)) != NULL) {

if (strspn(ent->d_name, "0123456789abcdef") != hexsz_loose ||

ent->d_name[hexsz_loose] != '\0')

return base;

}

{

struct packed_git *p;

int cnt;

return 0;

for (cnt = 0, p = get_all_packs(the_repository); p; p = p->next) {

*/

cnt++;

}

}

static uint64_t total_ram(void)

return 0;

}

{

unsigned long nr_objects = repo_approximate_object_count(the_repository);

size_t os_cache, heap;

* read_sha1_file() (either at delta calculation phase, or

* writing phase) also fills up the delta base cache

*/

/* and of course pack-objects has its own delta cache */

return os_cache + heap;

}

return 0;

}

{

strvec_push(&repack, "-a");

strvec_push(&repack, "--cruft");

strvec_pushf(&repack, "--max-cruft-size=%lu",

} else {

strvec_push(&repack, "-A");

}

if (keep_pack)

for_each_string_list(keep_pack, keep_one_pack, NULL);

}

static void add_repack_incremental_option(void)

strvec_push(&repack, "--no-write-bitmap-index");

}

{

/*

* Setting gc.auto to 0 or negative can disable the

* automatic gc.

*/

return 0;

/*

* we run "repack -A -d -l". Otherwise we tell the caller

* there is no need.

*/

struct string_list keep_pack = STRING_LIST_INIT_NODUP;

string_list_clear(&keep_pack, 0);

find_base_packs(&keep_pack, 0);

}

uint64_t mem_have, mem_want;

mem_have = total_ram();

/*

* Only allow 1/2 of memory for pack-objects, leave

string_list_clear(&keep_pack, 0);

}

string_list_clear(&keep_pack, 0);

add_repack_incremental_option();

else

return 0;

return 0;

return 1;

}

return ret;

}

{

/*

* We may be called twice, as both the pre- and

if (done++)

return;

die(FAILED_RUN, "pack-refs");

struct child_process cmd = CHILD_PROCESS_INIT;

cmd.git_cmd = 1;

}

}

{

int aggressive = 0;

int quiet = 0;

int keep_largest_pack = -1;

timestamp_t dummy;

struct child_process rerere_cmd = CHILD_PROCESS_INIT;

struct option builtin_gc_options[] = {

OPT__QUIET(&quiet, N_("suppress progress reporting")),

N_("prune unreferenced objects"),

N_("with --cruft, limit the size of new cruft packs")),

OPT_BOOL(0, "aggressive", &aggressive, N_("be more thorough (increased runtime)")),

OPT_BOOL_F(0, "auto", &opts.auto_flag, N_("enable auto-gc mode"),

PARSE_OPT_NOCOMPLETE),

OPT_BOOL_F(0, "force", &force,

N_("force running gc even if there may be another gc running"),

PARSE_OPT_NOCOMPLETE),

strvec_pushl(&prune_worktrees, "worktree", "prune", "--expire", NULL);

strvec_pushl(&rerere, "rerere", "gc", NULL);

argc = parse_options(argc, argv, prefix, builtin_gc_options,

builtin_gc_usage, 0);

if (argc > 0)

usage_with_options(builtin_gc_usage, builtin_gc_options);

if (aggressive) {

strvec_push(&repack, "-f");

}

if (quiet)

strvec_push(&repack, "-q");

if (opts.auto_flag) {

/*

* Auto-gc should be least intrusive as possible.

*/

if (!quiet) {

fprintf(stderr, _("Auto packing the repository in background for optimum performance.\n"));

else

fprintf(stderr, _("Auto packing the repository for optimum performance.\n"));

fprintf(stderr, _("See \"git help gc\" for manual housekeeping.\n"));

}

} else {

struct string_list keep_pack = STRING_LIST_INIT_NODUP;

if (keep_largest_pack != -1) {

if (keep_largest_pack)

find_base_packs(&keep_pack, 0);

}

string_list_clear(&keep_pack, 0);

}

name = lock_repo_for_gc(force, &pid);

if (name) {

die(_("gc is already running on machine '%s' pid %"PRIuMAX" (use --force if not)"),

name, (uintmax_t)pid);

}

git_path("gc.log"),

LOCK_DIE_ON_ERROR);

dup2(get_lock_file_fd(&log_lock), 2);

atexit(process_log_file_at_exit);

}

if (!repository_format_precious_objects) {

struct child_process repack_cmd = CHILD_PROCESS_INIT;

if (run_command(&repack_cmd))

die(FAILED_RUN, repack.v[0]);

struct child_process prune_cmd = CHILD_PROCESS_INIT;

/* run `git prune` even if using cruft packs */

if (quiet)

strvec_push(&prune, "--no-progress");

if (repo_has_promisor_remote(the_repository))

}

}

struct child_process prune_worktrees_cmd = CHILD_PROCESS_INIT;

prune_worktrees_cmd.git_cmd = 1;

strvec_pushv(&prune_worktrees_cmd.args, prune_worktrees.v);

if (run_command(&prune_worktrees_cmd))

!quiet && !daemonized ? COMMIT_GRAPH_WRITE_PROGRESS : 0,

NULL);

warning(_("There are too many unreachable loose objects; "

"run 'git prune' to remove them."));

if (!daemonized)

unlink(git_path("gc.log"));

return 0;

}

};

static int dfs_on_ref(const char *refname UNUSED,

const struct object_id *oid,

int flags UNUSED,

void *cb_data)

return result;

}

{

int result;

struct cg_auto_data data;

return !!run_command(&child);

}

{

prepare_repo_settings(the_repository);

if (!the_repository->settings.core_commit_graph)

return !!run_command(&child);

}

{

if (for_each_remote(fetch_remote, opts)) {

error(_("failed to prefetch remotes"));

return 0;

}

{

struct child_process child = CHILD_PROCESS_INIT;

strvec_push(&child.args, "--quiet");

else

strvec_push(&child.args, "--no-quiet");

return run_command(&child);

}

return 0;

}

{

int count = 0;

pack_proc.in = -1;

if (start_command(&pack_proc)) {

error(_("failed to start 'git pack-objects' process"));

return 1;

return result;

}

{

return prune_packed(opts) || pack_loose(opts);

}

{

struct packed_git *p;

int incremental_repack_auto_limit = 10;

return 0;

}

{

prepare_repo_settings(the_repository);

if (!the_repository->settings.core_multi_pack_index) {

return 0;

}

/*

* An auto condition function returns 1 if the task should run

* and 0 if the task should NOT run. See needs_to_gc() for an

* example.

*/

struct maintenance_task {

const char *name;

return b->selected_order - a->selected_order;

}

{

int i, found_selected = 0;

int result = 0;

}

free(lock_path);

for (i = 0; !found_selected && i < TASK__COUNT; i++)

found_selected = tasks[i].selected_order >= 0;

if (opts->auto_flag &&

(!tasks[i].auto_condition ||

continue;

if (opts->schedule && tasks[i].schedule < opts->schedule)

continue;

trace2_region_enter("maintenance", tasks[i].name, r);

error(_("task '%s' failed"), tasks[i].name);

result = 1;

}

static void initialize_maintenance_strategy(void)

{

return;

if (!strcasecmp(config_str, "incremental")) {

{

int i;

struct strbuf config_name = STRBUF_INIT;

if (schedule)

initialize_maintenance_strategy();

return 0;

}

{

int i;

struct option builtin_maintenance_run_options[] = {

OPT_BOOL(0, "auto", &opts.auto_flag,

N_("run tasks based on the state of the repository")),

OPT_CALLBACK(0, "schedule", &opts.schedule, N_("frequency"),

N_("run tasks based on frequency"),

maintenance_opt_schedule),

PARSE_OPT_NONEG, task_option_parse),

OPT_END()

};

opts.quiet = !isatty(2);

if (opts.auto_flag && opts.schedule)

die(_("use at most one of --auto and --schedule=<frequency>"));

initialize_task_config(opts.schedule);

if (argc != 0)

usage_with_options(builtin_maintenance_run_usage,

builtin_maintenance_run_options);

}

static char *get_maintpath(void)

NULL

};

{

char *config_file = NULL;

struct option options[] = {

NULL

};

{

int force = 0;

char *config_file = NULL;

}

}

/*

* get_schedule_cmd` reads the GIT_TEST_MAINT_SCHEDULER environment variable

* to mock the schedulers that `git maintenance start` rely on.

* * If $GIT_TEST_MAINT_SCHEDULER is set, return true.

* In this case, the *cmd value is read as input.

*

* the mock command.

*

* * if the input value *cmd isn’t the key of any of the comma-separated list

*

* Ex.:

* GIT_TEST_MAINT_SCHEDULER not set

* +-------+-------------------------------------------------+

* | Input | Output |

* +-------+-------------+-------------------+---------------+

* +-------+-------------+-------------------+---------------+

*

* GIT_TEST_MAINT_SCHEDULER set to “foo:./mock_foo.sh,bar:./mock_bar.sh”

* +-------+-------------------------------------------------+

* | Input | Output |

* +-------+-------------+-------------------+---------------+

* | "foo" | true | "./mock.foo.sh" | true |

* +-------+-------------+-------------------+---------------+

*/

{

char *testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER"));

struct string_list_item *item;

struct string_list list = STRING_LIST_INIT_NODUP;

return 0;

if (is_available)

*is_available = 0;

if (string_list_split_in_place(&pair, item->string, ":", 2) != 2)

continue;

if (is_available)

*is_available = 1;

}

}

string_list_clear(&list, 0);

free(testing);

return 1;

if (getenv("GIT_TEST_MAINT_SCHEDULER"))

return 13;

}

static int is_launchctl_available(void)

{

int is_available;

return is_available;

#ifdef __APPLE__

static int launchctl_boot_plist(int enable, const char *filename)

{

int result;

struct child_process child = CHILD_PROCESS_INIT;

char *uid = launchctl_get_uid();

strvec_split(&child.args, cmd);

strvec_pushl(&child.args, enable ? "bootstrap" : "bootout", uid,

filename, NULL);

result = finish_command(&child);

free(uid);

return result;

}

static unsigned long lock_file_timeout_ms = ULONG_MAX;

struct strbuf plist = STRBUF_INIT, plist2 = STRBUF_INIT;

struct stat st;

int minute = get_random_minute();

preamble = "<?xml version=\"1.0\"?>\n"

"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"

"<plist version=\"1.0\">"

"<array>\n"

"<string>%s/git</string>\n"

"<string>--exec-path=%s</string>\n"

"<string>for-each-repo</string>\n"

"<string>--keep-going</string>\n"

"<string>--config=maintenance.repo</string>\n"

"</array>\n"

"<key>StartCalendarInterval</key>\n"

"<array>\n";

switch (schedule) {

case SCHEDULE_HOURLY:

free(filename);

free(name);

strbuf_release(&plist);

strbuf_release(&plist2);

return 0;

static int is_schtasks_available(void)

{

int is_available;

return is_available;

#ifdef GIT_WINDOWS_NATIVE

static int schtasks_remove_task(enum schedule_priority schedule)

{

struct child_process child = CHILD_PROCESS_INIT;

const char *frequency = get_frequency(schedule);

char *name = schtasks_task_name(frequency);

strvec_split(&child.args, cmd);

strvec_pushl(&child.args, "/delete", "/tn", name, "/f", NULL);

free(name);

return run_command(&child);

}

static int schtasks_schedule_task(const char *exec_path, enum schedule_priority schedule)

{

int result;

struct child_process child = CHILD_PROCESS_INIT;

const char *xml;

struct strbuf tfilename = STRBUF_INIT;

int minute = get_random_minute();

strbuf_addf(&tfilename, "%s/schedule_%s_XXXXXX",

tfile = xmks_tempfile(tfilename.buf);

strbuf_release(&tfilename);

"<Actions Context=\"Author\">\n"

"<Exec>\n"

"<Command>\"%s\\headless-git.exe\"</Command>\n"

"</Exec>\n"

"</Actions>\n"

"</Task>\n";

strvec_split(&child.args, cmd);

strvec_pushl(&child.args, "/create", "/tn", name, "/f", "/xml",

get_tempfile_path(tfile), NULL);

delete_tempfile(&tfile);

free(name);

return result;

}

static int is_crontab_available(void)

{

int is_available;

#ifdef __APPLE__

/*

* macOS has cron, but it requires special permissions and will

* create a UI alert when attempting to run this command.

*/

#else

#endif

}

#define BEGIN_LINE "# BEGIN GIT MAINTENANCE SCHEDULE"

static int crontab_update_schedule(int run_maintenance, int fd)

{

int result = 0;

int in_old_region = 0;

struct child_process crontab_list = CHILD_PROCESS_INIT;

struct tempfile *tmpedit = NULL;

int minute = get_random_minute();

strvec_split(&crontab_list.args, cmd);

strvec_push(&crontab_list.args, "-l");

crontab_list.in = -1;

crontab_list.out = dup(fd);

crontab_list.git_cmd = 0;

/* Ignore exit code, as an empty crontab will return error. */

finish_command(&crontab_list);

"# replaced in the future by a Git command.\n\n");

strbuf_addf(&line_format,

fprintf(cron_in, line_format.buf, minute, "1-23", "*", "hourly");

fprintf(cron_in, line_format.buf, minute, "0", "1-6", "daily");

fprintf(cron_in, line_format.buf, minute, "0", "0", "weekly");

result = error(_("'crontab' died"));

else

fclose(cron_list);

out:

delete_tempfile(&tmpedit);

return result;

}

static int is_systemd_timer_available(void)

{

int is_available;

return is_available;

return real_is_systemd_timer_available();

"\n"

"[Service]\n"

"Type=oneshot\n"

"LockPersonality=yes\n"

"MemoryDenyWriteExecute=yes\n"

"NoNewPrivileges=yes\n"

"RestrictSUIDSGID=yes\n"

"SystemCallArchitectures=native\n"

"SystemCallFilter=@system-service\n";

error(_("failed to write to '%s'"), filename);

fclose(file);

goto error;

enum schedule_priority schedule,

int minute)

{

struct child_process child = CHILD_PROCESS_INIT;

const char *frequency = get_frequency(schedule);

/*

* Disabling the systemd unit while it is already disabled makes

* On the other hand, enabling a systemd unit which is already enabled

* produces no error.

*/

child.no_stderr = 1;

strvec_split(&child.args, cmd);

strvec_pushl(&child.args, "--user", enable ? "enable" : "disable",

"--now", NULL);

strvec_pushf(&child.args, SYSTEMD_UNIT_FORMAT, frequency, "timer");

/*

* Disabling an already disabled systemd unit makes

* systemctl fail.

*

* Enabling an enabled systemd unit doesn't fail.

*/

}

/*

char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path);

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

free(lock_path);

}

for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) {

NULL

};

{

struct maintenance_start_opts opts = { 0 };

struct option options[] = {

if (update_background_schedule(&opts, 1))

die(_("failed to set up maintenance schedule"));

warning(_("failed to add repo to global config"));

return 0;

}

NULL

};

{

struct option options[] = {

OPT_END()

NULL,

};

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_maintenance_options[] = {

argc = parse_options(argc, argv, prefix, builtin_maintenance_options,

builtin_maintenance_usage, 0);

}

#define RECORDSIZE (512)

#define HEADERSIZE (2 * RECORDSIZE)

{

char buffer[HEADERSIZE];

struct ustar_header *header = (struct ustar_header *)buffer;

if (header->typeflag[0] != TYPEFLAG_GLOBAL_HEADER)

return 1;

len = strtol(content, &end, 10);

if (errno == ERANGE || end == content || len < 0)

return 1;

*

* Copyright (c) 2006 Junio C Hamano

*/

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

#include "hex.h"

#include "config.h"

#include "tag.h"

#include "tree-walk.h"

return 0;

}

{

int hit = 0;

int cached = 0, untracked = 0, opt_exclude = -1;

int dummy;

int use_index = 1;

int allow_revs;

struct option options[] = {

OPT_BOOL(0, "cached", &cached,

}

if (show_in_pager == default_pager)

if (show_in_pager) {

opt.color = 0;

opt.name_only = 1;

&oid, &oc)) {

if (seen_dashdash)

die(_("unable to resolve revision: %s"), arg);

break;

}

* Optimize out the case where the amount of matches is limited to zero.

* We do this to keep results consistent with GNU grep(1).

*/

if (show_in_pager) {

if (num_threads > 1)

}

if (!show_in_pager && !opt.status_only)

die_for_incompatible_opt3(!use_index, "--no-index",

untracked, "--untracked",

hit |= wait_all();

if (hit && show_in_pager)

run_pager(&opt, prefix);

clear_pathspec(&pathspec);

string_list_clear(&path_list, 0);

free_grep_patterns(&opt);

object_array_clear(&list);

free_repos();

}

* Copyright (C) Linus Torvalds, 2005

* Copyright (C) Junio C Hamano, 2005

*/

#include "builtin.h"

#include "abspath.h"

#include "config.h"

strbuf_release(&unquoted);

}

{

static const char * const hash_object_usage[] = {

N_("git hash-object [-t <type>] [-w] [--path=<file> | --no-filters]\n"

/*

* Builtin help command

*/

#include "builtin.h"

#include "config.h"

#include "exec-cmd.h"

HELP_ACTION_CONFIG_SECTIONS_FOR_COMPLETION,

} cmd_mode;

static int verbose = 1;

static enum help_format help_format = HELP_FORMAT_NONE;

static int exclude_guides;

struct string_list keys = STRING_LIST_INIT_DUP;

struct string_list keys_uniq = STRING_LIST_INIT_DUP;

struct string_list_item *item;

for (p = config_name_list; *p; p++) {

const char *var = *p;

e->prefix, e->placeholder);

string_list_sort(&keys);

const char *var = keys.items[i].string;

const char *wildcard, *tag, *cut;

const char *dot = NULL;

if (!strcmp(var, "help.htmlpath")) {

if (!value)

return config_error_nonbool(var);

html_path = xstrdup(value);

return 0;

}

static void get_html_page_path(struct strbuf *page_path, const char *page)

{

struct stat st;

char *to_free = NULL;

/*

* Check that the page we're looking for exists.

*/

|| !S_ISREG(st.st_mode))

die("'%s/%s.html': documentation file not found.",

}

strbuf_init(page_path, 0);

free(to_free);

}

static void show_html_page(const char *page)

{

get_html_page_path(&page_path, page);

open_html(page_path.buf);

}

{

char *alias;

if (is_git_command(cmd))

alias = alias_lookup(cmd);

if (alias) {

die(_("bad alias.%s string: %s"), cmd,

split_cmdline_strerror(count));

free(argv);

return alias;

}

if (exclude_guides)

return help_unknown_cmd(cmd);

}

static void no_help_format(const char *opt_mode, enum help_format fmt)

no_help_format(opt_mode, fmt);

}

{

int nongit;

enum help_format parsed_help_format;

const char *page;

argc = parse_options(argc, argv, prefix, builtin_help_options,

case HELP_ACTION_ALL:

opt_mode_usage(argc, "--all", help_format);

if (verbose) {

list_all_cmds_help(show_external_commands,

show_aliases);

return 0;

return 0;

case HELP_ACTION_CONFIG:

opt_mode_usage(argc, "--config", help_format);

list_config_help(SHOW_CONFIG_HUMAN);

printf("\n%s\n", _("'git help config' for more information"));

return 0;

if (help_format == HELP_FORMAT_NONE)

help_format = parse_help_format(DEFAULT_HELP_FORMAT);

switch (help_format) {

case HELP_FORMAT_NONE:

case HELP_FORMAT_MAN:

break;

}

return 0;

}

#include "builtin.h"

#include "config.h"

#include "gettext.h"

NULL

};

{

int i;

struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;

hook_name = argv[0];

if (!ignore_missing)

opt.error_if_missing = 1;

if (ret < 0) /* error() return */

ret = 1;

return ret;

usage_with_options(builtin_hook_run_usage, run_options);

}

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_hook_options[] = {

argc = parse_options(argc, argv, NULL, builtin_hook_options,

builtin_hook_usage, 0);

}

#include "builtin.h"

#include "config.h"

#include "delta.h"

#include "csum-file.h"

#include "blob.h"

#include "commit.h"

#include "tree.h"

#include "progress.h"

#include "fsck.h"

#include "object-file.h"

#include "object-store-ll.h"

#include "oid-array.h"

#include "replace-object.h"

#include "promisor-remote.h"

#include "setup.h"

static const char index_pack_usage[] =

"git index-pack [-v] [-o <index-file>] [--keep | --keep=<msg>] [--[no-]rev-index] [--verify] [--strict[=<msg-id>=<severity>...]] [--fsck-objects[=<msg-id>=<severity>...]] (<pack-file> | --stdin [--fix-thin] [<pack-file>])";

static size_t base_cache_used;

static size_t base_cache_limit;

pthread_t thread;

int pack_fd;

};

static struct object_stat *obj_stat;

static struct ofs_delta_entry *ofs_deltas;

static struct ref_delta_entry *ref_deltas;

static int nr_objects;

static int nr_ofs_deltas;

static int nr_ref_deltas;

static int input_fd, output_fd;

static const char *curr_pack;

static int nr_dispatched;

static int threads_active;

max = get_max_object_index();

if (verbose)

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

foreign_nr += check_object(get_indexed_object(i));

(uintmax_t)offset, buf);

}

{

if (HAVE_THREADS) {

if (threads_active)

return &nothread_data;

}

{

if (threads_active)

pthread_setspecific(key, data);

return 0;

}

static void sha1_object(const void *data, struct object_entry *obj_entry,

unsigned long size, enum object_type type,

const struct object_id *oid)

free(has_data);

}

read_lock();

if (type == OBJ_BLOB) {

struct blob *blob = lookup_blob(the_repository, oid);

die(_("fsck error in packed object"));

if (strict && fsck_walk(obj, NULL, &fsck_options))

die(_("Not all child objects of %s are reachable"), oid_to_hex(&obj->oid));

if (obj->type == OBJ_TREE) {

struct tree *item = (struct tree *) obj;

if (verbose)

progress = start_progress(

progress_title ? progress_title :

from_stdin ? _("Receiving objects") : _("Indexing objects"),

nr_objects);

* recursively checking if the resulting object is used as a base

* for some more deltas.

*/

{

int i;

QSORT(ref_deltas, nr_ref_deltas, compare_ref_delta_entry);

if (verbose || show_resolving_progress)

nr_ref_deltas + nr_ofs_deltas);

nr_dispatched = 0;

if (nr_threads > 1 || getenv("GIT_FORCE_THREADS")) {

init_thread();

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

int ret = pthread_create(&thread_data[i].thread, NULL,

threaded_second_pass, thread_data + i);

die(_("unable to create thread: %s"),

strerror(ret));

}

for (i = 0; i < nr_threads; i++)

pthread_join(thread_data[i].thread, NULL);

cleanup_thread();

if (pack_name)

filename = derive_filename(pack_name, "pack", suffix, &name_buf);

else

fd = odb_pack_keep(filename);

if (fd < 0) {

struct strbuf *name, unsigned char *hash,

const char *ext, int make_read_only_if_same)

{

if (!*final_name)

if (finalize_object_file(curr_name, *final_name))

die(_("unable to rename temporary '*.%s' file to '%s'"),

ext, *final_name);

if (do_fsck_object) {

struct packed_git *p;

if (p)

install_packed_git(the_repository, p);

}

else

opts->flags &= ~WRITE_REV;

}

return git_default_config(k, v, ctx, cb);

}