- die(_("Could not read the index"));

- if (run_diff_files(&rev, 0))

- die(_("Could not write patch"));

- die_errno(_("Could not stat '%s'"), file);

- die(_("Empty patch. Aborted."));

- die(_("Could not apply '%s'"), file);

- die(_("Unable to write new index file"));

-enum show_patch_type {

- SHOW_PATCH_RAW = 0,

- SHOW_PATCH_DIFF = 1,

- run_diff_index(&rev_info, 1);

- run_diff_index(&rev_info, 1);

-static int show_patch(struct am_state *state, enum show_patch_type sub_mode)

- switch (sub_mode) {

- case SHOW_PATCH_RAW:

- case SHOW_PATCH_DIFF:

-enum resume_type {

- RESUME_FALSE = 0,

- RESUME_APPLY,

- RESUME_RESOLVED,

- RESUME_SKIP,

- RESUME_ABORT,

- RESUME_QUIT,

- RESUME_SHOW_PATCH,

- RESUME_ALLOW_EMPTY,

-};

-

-struct resume_mode {

- enum resume_type mode;

- enum show_patch_type sub_mode;

-};

-

- struct resume_mode *resume = container_of(opt_value, struct resume_mode, mode);

- const char *valid_modes[] = {

- [SHOW_PATCH_DIFF] = "diff",

- [SHOW_PATCH_RAW] = "raw"

- };

- int new_value = SHOW_PATCH_RAW;

-

- BUG_ON_OPT_NEG(unset);

-

- if (arg) {

- for (new_value = 0; new_value < ARRAY_SIZE(valid_modes); new_value++) {

- if (!strcmp(arg, valid_modes[new_value]))

- break;

- }

- if (new_value >= ARRAY_SIZE(valid_modes))

- return error(_("invalid value for '%s': '%s'"),

- "--show-current-patch", arg);

- }

-

- if (resume->mode == RESUME_SHOW_PATCH && new_value != resume->sub_mode)

- return error(_("options '%s=%s' and '%s=%s' "

- "cannot be used together"),

- "--show-current-patch", "--show-current-patch", arg, valid_modes[resume->sub_mode]);

-

- resume->mode = RESUME_SHOW_PATCH;

- resume->sub_mode = new_value;

- struct resume_mode resume = { .mode = RESUME_FALSE };

- OPT_CMDMODE(0, "continue", &resume.mode,

- OPT_CMDMODE('r', "resolved", &resume.mode,

- OPT_CMDMODE(0, "skip", &resume.mode,

- OPT_CMDMODE(0, "abort", &resume.mode,

- OPT_CMDMODE(0, "quit", &resume.mode,

- { OPTION_CALLBACK, 0, "show-current-patch", &resume.mode,

- parse_opt_show_current_patch, RESUME_SHOW_PATCH },

- OPT_CMDMODE(0, "allow-empty", &resume.mode,

- OPT_CALLBACK_F(STOP_ON_EMPTY_COMMIT, "empty", &state.empty_type, "{stop,drop,keep}",

- if (argc || (resume.mode == RESUME_FALSE && !isatty(0)))

- if (resume.mode == RESUME_FALSE)

- resume.mode = RESUME_APPLY;

- if (resume.mode == RESUME_ABORT || resume.mode == RESUME_QUIT) {

- if (resume.mode)

- switch (resume.mode) {

- am_resolve(&state, resume.mode == RESUME_ALLOW_EMPTY ? 1 : 0);

- case RESUME_SHOW_PATCH:

- ret = show_patch(&state, resume.sub_mode);

- N_("git bisect start [--term-{new,bad}=<term> --term-{old,good}=<term>]" \

- N_("git bisect run <cmd>...")

- " '%s', but not yet merged to HEAD."),

- " '%s', even though it is merged to HEAD."),

- error(_("Couldn't look up commit object for '%s'"), refname);

- error(_("The branch '%s' is not fully merged.\n"

- "run 'git branch -D %s'."), branchname, branchname);

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

- error(_("Cannot delete branch '%s' "

- "checked out at '%s'"),

- error(_("remote-tracking branch '%s' not found."), bname.buf);

- error(_("branch '%s' not found."), bname.buf);

- die(_("Branch %s is being rebased at %s"),

- die(_("Branch %s is being bisected at %s"),

- die(_("Invalid branch name: '%s'"), oldname);

- die(_("No commit on branch '%s' yet."), oldname);

- die(_("No branch named '%s'."), oldname);

- die(_("Branch rename failed"));

- die(_("Branch copy failed"));

- warning(_("Created a copy of a misnamed branch '%s'"),

- warning(_("Renamed a misnamed branch '%s' away"),

- die(_("Branch renamed to %s, but HEAD is not updated!"), newname);

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

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

- die(_("Failed to resolve HEAD as a valid ref."));

- die(_("Cannot give description to detached HEAD"));

- ? _("No commit on branch '%s' yet.")

- : _("No branch named '%s'."),

- die(copy? _("cannot copy the current branch while not on any.")

- : _("cannot rename the current branch while not on any."));

- "it does not point to any branch."),

- die(_("No commit on branch '%s' yet."), branch->name);

- "it does not point to any branch."));

- die(_("Branch '%s' has no upstream information"), branch->name);

- die(_("The -a, and -r, options to 'git branch' do not take a branch name.\n"

- die(_("the '--set-upstream' option is no longer supported. Please use '--track' or '--set-upstream-to' instead."));

- N_("git cat-file (--textconv | --filters)\n"

- " [<rev>:<path|tree-ish> | --path=<path|tree-ish> <rev>]"),

-static int to_tempfile;

- to_tempfile = 1;

- checkout_stage = CHECKOUT_ALL;

- checkout_stage = arg[0] - '0';

- OPT_CALLBACK_F(0, "stage", NULL, "(1|2|3|all)",

- /* "checkout -m path" to recreate conflicted state */

- if (opts->merge)

- unmerge_marked_index(&the_index);

-

- int open_ok;

- open_ok = open_commit_graph(graph_name, &fd, &st);

- if (!open_ok && errno != ENOENT)

- if (open_ok)

- graph = read_commit_graph_one(the_repository, odb);

- /* Return failure if open_ok predicted success */

- return !!open_ok;

- die(_("unable to write new_index file"));

- die(_("unable to write new_index file"));

- die(_("unable to write new_index file"));

- "new_index file. Check that disk is not full and quota is\n"

- max_candidates = unset ? DEFAULT_CANDIDATES : 0;

- OPT_CALLBACK_F(0, "exact-match", NULL, NULL,

- int fd, result;

- result = run_diff_index(&revs, 0);

- if (!diff_result_code(&revs.diffopt, result))

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

- perror("repo_read_index_preload");

- result = -1;

- goto cleanup;

- }

- result = run_diff_files(&rev, options);

- result = diff_result_code(&rev.diffopt, result);

-cleanup:

- result = run_diff_index(&rev, option);

- result = diff_result_code(&rev.diffopt, result);

- return diff_result_code(&opt->diffopt, 0);

-static int builtin_diff_b_f(struct rev_info *revs,

- int argc, const char **argv UNUSED,

- struct object_array_entry **blob)

- return 0;

-static int builtin_diff_blobs(struct rev_info *revs,

- int argc, const char **argv UNUSED,

- struct object_array_entry **blob)

- return 0;

-static int builtin_diff_index(struct rev_info *revs,

- int argc, const char **argv)

- perror("repo_read_index_preload");

- return -1;

- perror("repo_read_cache");

- return -1;

- return run_diff_index(revs, option);

-static int builtin_diff_tree(struct rev_info *revs,

- int argc, const char **argv,

- struct object_array_entry *ent0,

- struct object_array_entry *ent1)

- return 0;

-static int builtin_diff_combined(struct rev_info *revs,

- int argc, const char **argv UNUSED,

- struct object_array_entry *ent,

- int ents, int first_non_parent)

- return 0;

-static int builtin_diff_files(struct rev_info *revs, int argc, const char **argv)

- else

- return error(_("invalid option: %s"), argv[1]);

- perror("repo_read_index_preload");

- return -1;

- return run_diff_files(revs, options);

- int result = 0;

- rev.diffopt.stat_width = -1;

- rev.diffopt.stat_graph_width = -1;

- result = builtin_diff_files(&rev, argc, argv);

- result = builtin_diff_b_f(&rev, argc, argv, blob);

- result = builtin_diff_blobs(&rev, argc, argv, blob);

- result = builtin_diff_index(&rev, argc, argv);

- result = builtin_diff_tree(&rev, argc, argv,

- &ent.objects[0], &ent.objects[1]);

- result = builtin_diff_combined(&rev, argc, argv,

- ent.objects, ent.nr,

- first_non_parent);

- result = diff_result_code(&rev.diffopt, result);

-static enum { SIGNED_TAG_ABORT, VERBATIM, WARN, WARN_STRIP, STRIP } signed_tag_mode = SIGNED_TAG_ABORT;

-static enum { TAG_FILTERING_ABORT, DROP, REWRITE } tag_of_filtered_mode = TAG_FILTERING_ABORT;

-static enum { REENCODE_ABORT, REENCODE_YES, REENCODE_NO } reencode_mode = REENCODE_ABORT;

- signed_tag_mode = SIGNED_TAG_ABORT;

- signed_tag_mode = VERBATIM;

- signed_tag_mode = WARN;

- signed_tag_mode = WARN_STRIP;

- signed_tag_mode = STRIP;

- tag_of_filtered_mode = TAG_FILTERING_ABORT;

- tag_of_filtered_mode = DROP;

- tag_of_filtered_mode = REWRITE;

- reencode_mode = REENCODE_ABORT;

- reencode_mode = REENCODE_NO;

- reencode_mode = REENCODE_YES;

- reencode_mode = REENCODE_ABORT;

- refspec_append(&refmap, arg);

- const struct object_id *old_oid,

- OPT_CALLBACK_F(0, "refmap", NULL, N_("refmap"),

-static int cookies_cmp(const void *data, const struct hashmap_entry *he1,

- const struct hashmap_entry *he2, const void *keydata)

-static int try_to_run_foreground_daemon(int detach_console)

-static int bg_wait_cb(const struct child_process *cp, void *cb_data)

-static int task_option_parse(const struct option *opt,

- "<key>Minute</key><integer>0</integer>\n"

- strbuf_addf(&plist, repeat, i);

- "<key>Minute</key><integer>0</integer>\n"

- strbuf_addf(&plist, repeat, i);

- strbuf_addstr(&plist,

- "<dict>\n"

- "<key>Day</key><integer>0</integer>\n"

- "<key>Hour</key><integer>0</integer>\n"

- "<key>Minute</key><integer>0</integer>\n"

- "</dict>\n");

-static int launchctl_update_schedule(int run_maintenance, int fd)

- "<StartBoundary>2020-01-01T01:00:00</StartBoundary>\n"

- "</Repetition>\n");

- "<StartBoundary>2020-01-01T00:00:00</StartBoundary>\n"

- "</ScheduleByWeek>\n");

- "<StartBoundary>2020-01-01T00:00:00</StartBoundary>\n"

- "</ScheduleByWeek>\n");

-static int schtasks_update_schedule(int run_maintenance, int fd)

- "%%s %%s * * %%s \"%s/git\" --exec-path=\"%s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%s\n",

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

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

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

-static int systemd_timer_enable_unit(int enable,

- enum schedule_priority schedule)

-{

- const char *cmd = "systemctl";

- struct child_process child = CHILD_PROCESS_INIT;

- const char *frequency = get_frequency(schedule);

- /*

- * Disabling the systemd unit while it is already disabled makes

- * systemctl print an error.

- * Let's ignore it since it means we already are in the expected state:

- * the unit is disabled.

- *

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

- * produces no error.

- */

- if (!enable)

- child.no_stderr = 1;

-

- get_schedule_cmd(&cmd, NULL);

- strvec_split(&child.args, cmd);

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

- "--now", NULL);

- strvec_pushf(&child.args, "git-maintenance@%s.timer", frequency);

-

- if (start_command(&child))

- return error(_("failed to start systemctl"));

- if (finish_command(&child))

- /*

- * Disabling an already disabled systemd unit makes

- * systemctl fail.

- * Let's ignore this failure.

- *

- * Enabling an enabled systemd unit doesn't fail.

- */

- if (enable)

- return error(_("failed to run systemctl"));

- return 0;

-}

-

-static int systemd_timer_delete_unit_templates(void)

- char *filename = xdg_config_home_systemd("git-maintenance@.timer");

- if (unlink(filename) && !is_missing_file_error(errno))

- ret = error_errno(_("failed to delete '%s'"), filename);

- FREE_AND_NULL(filename);

- filename = xdg_config_home_systemd("git-maintenance@.service");

-static int systemd_timer_delete_units(void)

- return systemd_timer_enable_unit(0, SCHEDULE_HOURLY) ||

- systemd_timer_enable_unit(0, SCHEDULE_DAILY) ||

- systemd_timer_enable_unit(0, SCHEDULE_WEEKLY) ||

- systemd_timer_delete_unit_templates();

-static int systemd_timer_write_unit_templates(const char *exec_path)

- filename = xdg_config_home_systemd("git-maintenance@.timer");

- "OnCalendar=%i\n"

- if (fputs(unit, file) == EOF) {

- filename = xdg_config_home_systemd("git-maintenance@.service");

- "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n"

-error:

- systemd_timer_delete_unit_templates();

- return -1;

- int ret = systemd_timer_write_unit_templates(exec_path) ||

- systemd_timer_enable_unit(1, SCHEDULE_HOURLY) ||

- systemd_timer_enable_unit(1, SCHEDULE_DAILY) ||

- systemd_timer_enable_unit(1, SCHEDULE_WEEKLY);

-static int systemd_timer_update_schedule(int run_maintenance, int fd)

- return update_background_schedule(&opts, 1);

- from_stdin = !strcmp(arg, "-");

- patterns = from_stdin ? stdin : fopen(arg, "r");

- { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, N_("depth"),

- N_("descend at most <depth> levels"), PARSE_OPT_NONEG,

- NULL, 1 },

- OPT_BOOL(0, "or", &dummy, ""),

- the_hash_algo->final_fn(hash, &input_ctx);

- " [(--trailer <token>[(=|:)<value>])...]\n"

- const char *arg, int unset)

- return trailer_set_where(&where, arg);

- const char *arg, int unset)

- return trailer_set_if_exists(&if_exists, arg);

- const char *arg, int unset)

- return trailer_set_if_missing(&if_missing, arg);

- OPT_CALLBACK(0, "where", NULL, N_("action"),

- OPT_CALLBACK(0, "if-exists", NULL, N_("action"),

- OPT_CALLBACK(0, "if-missing", NULL, N_("action"),

- OPT_BOOL(0, "only-input", &opts.only_input, N_("do not apply config rules")),

- OPT_BOOL(0, "unfold", &opts.unfold, N_("join whitespace-continued values")),

- OPT_CALLBACK_F(0, "parse", &opts, NULL, N_("set parsing options"),

- OPT_BOOL(0, "no-divider", &opts.no_divider, N_("do not treat --- specially")),

-static int clear_decorations_callback(const struct option *opt,

- const char *arg, int unset)

-static int decorate_callback(const struct option *opt, const char *arg, int unset)

- rev->diffopt.stat_width = -1; /* use full terminal width */

- rev->diffopt.stat_graph_width = -1; /* respect statGraphWidth config */

- rev->diffopt.flags.allow_textconv = 1;

- return diff_result_code(&rev->diffopt, 0);

- if (branch_name && *branch_name)

- prepare_cover_text(&pp, branch_name, &sb, encoding, need_8bit_cte);

- ((struct rev_info *)opt->value)->subject_prefix = arg;

-static int rfc_callback(const struct option *opt, const char *arg, int unset)

-{

- BUG_ON_OPT_NEG(unset);

- BUG_ON_OPT_ARG(arg);

- return subject_prefix_callback(opt, "RFC PATCH", unset);

-}

-

-static int header_callback(const struct option *opt, const char *arg, int unset)

-static int to_callback(const struct option *opt, const char *arg, int unset)

-{

- if (unset)

- string_list_clear(&extra_to, 0);

- else

- string_list_append(&extra_to, arg);

- return 0;

-}

-

-static int cc_callback(const struct option *opt, const char *arg, int unset)

-{

- if (unset)

- string_list_clear(&extra_cc, 0);

- else

- string_list_append(&extra_cc, arg);

- return 0;

-}

-

- OPT_CALLBACK_F(0, "rfc", &rev, NULL,

- N_("use [RFC PATCH] instead of [PATCH]"),

- PARSE_OPT_NOARG | PARSE_OPT_NONEG, rfc_callback),

- OPT_CALLBACK_F(0, "subject-prefix", &rev, N_("prefix"),

- OPT_CALLBACK(0, "to", NULL, N_("email"), N_("add To: header"), to_callback),

- OPT_CALLBACK(0, "cc", NULL, N_("email"), N_("add Cc: header"), cc_callback),

- rev.subject_prefix = fmt_patch_subject_prefix;

- strbuf_addf(&sprefix, "%s v%s",

- rev.subject_prefix, reroll_count);

- rev.subject_prefix = sprefix.buf;

- origin, nr, list, branch_name, quiet);

-static int show_tree_name_only(const struct object_id *oid, struct strbuf *base,

- int ret = 0, i = 0, to_stdout = 0;

- if (read_mmfile(mmf, fname))

- else if (mmf->size > MAX_XDIFF_SIZE ||

- buffer_is_binary(mmf->ptr, mmf->size))

- const char *filename = argv[0];

- char *fpath = prefix_filename(prefix, argv[0]);

- FILE *f = to_stdout ? stdout : fopen(fpath, "wb");

-

- if (!f)

- ret = error_errno("Could not open %s for writing",

- filename);

- else if (result.size &&

- fwrite(result.ptr, result.size, 1, f) != 1)

- ret = error_errno("Could not write to %s", filename);

- else if (fclose(f))

- ret = error_errno("Could not close %s", filename);

- free(fpath);

- struct merge_options opt;

- init_merge_options(&opt, the_repository);

-

-static const char **xopts;

-static size_t xopts_nr, xopts_alloc;

-static int option_parse_strategy(const struct option *opt,

-static int option_parse_x(const struct option *opt,

- const char *arg, int unset)

-{

- if (unset)

- return 0;

-

- ALLOC_GROW(xopts, xopts_nr + 1, xopts_alloc);

- xopts[xopts_nr++] = xstrdup(arg);

- return 0;

-}

-

-static int option_parse_n(const struct option *opt,

- const char *arg, int unset)

-{

- BUG_ON_OPT_ARG(arg);

- show_diffstat = unset;

- return 0;

-}

-

- OPT_CALLBACK_F('n', NULL, NULL, NULL,

- N_("do not show a diffstat at the end of the merge"),

- PARSE_OPT_NOARG, option_parse_n),

- OPT_CALLBACK('s', "strategy", &use_strategies, N_("strategy"),

- OPT_CALLBACK('X', "strategy-option", &xopts, N_("option=value"),

- N_("option for selected merge strategy"), option_parse_x),

- opts.stat_width = -1; /* use full terminal width */

- opts.stat_graph_width = -1; /* respect statGraphWidth config */

- for (x = 0; x < xopts_nr; x++)

- if (parse_merge_opt(&o, xopts[x]))

- die(_("unknown strategy option: -X%s"), xopts[x]);

- strategy, xopts_nr, xopts,

- if (!oideq(&common_one->item->object.oid, &j->item->object.oid)) {

- bad = _("cannot move directory over file");

- {

- /* A Hidden OPT_BOOL */

- OPTION_SET_INT, 0, "peel-tag", &peel_tag, NULL,

- N_("dereference tags in the input (internal use)"),

- PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 1,

- },

- strbuf_reset(&buf);

-static int option_parse_missing_action(const struct option *opt,

- progress = 0;

- else if (!progress)

- progress = 1;

- pack_idx_opts.version = strtoul(val, &c, 10);

- if (pack_idx_opts.version > 2)

- pack_idx_opts.off32_limit = strtoul(c+1, &c, 0);

- if (*c || pack_idx_opts.off32_limit & 0x80000000)

-static int option_parse_unpack_unreachable(const struct option *opt,

-static int option_parse_cruft_expiration(const struct option *opt,

- OPT_CALLBACK_F('q', "quiet", NULL, NULL,

- OPT_CALLBACK_F(0, "index-version", NULL, N_("<version>[,<offset>]"),

- if (!pack_to_stdout && !pack_size_limit && !cruft)

- if (filter_options.choice) {

- if (!pack_to_stdout)

- die(_("cannot use --filter without --stdout"));

- if (stdin_packs)

- die(_("cannot use --filter with --stdin-packs"));

- }

- if (pack_size_limit)

- die(_("cannot use --max-pack-size with --cruft"));

-static int index_output_cb(const struct option *opt, const char *arg,

-static void imply_merge(struct rebase_options *opts, const char *option);

-static int parse_opt_keep_empty(const struct option *opt, const char *arg,

- int unset)

-{

- struct rebase_options *opts = opt->value;

-

- BUG_ON_OPT_ARG(arg);

-

- imply_merge(opts, unset ? "--no-keep-empty" : "--keep-empty");

- opts->keep_empty = !unset;

- opts->type = REBASE_MERGE;

- return 0;

-}

-

- OPT_CALLBACK_F(0, "empty", &options, "{drop,keep,ask}",

- switch (options.type) {

- case REBASE_APPLY:

- die(_("--strategy requires --merge or --interactive"));

- case REBASE_MERGE:

- /* compatible */

- break;

- case REBASE_UNSPECIFIED:

- options.type = REBASE_MERGE;

- break;

- default:

- BUG("unhandled rebase type (%d)", options.type);

- }

- if (options.type == REBASE_MERGE)

- imply_merge(&options, "--merge");

-

- imply_merge(&options, "--merge");

- opts.stat_width = -1; /* use full terminal width */

- opts.stat_graph_width = -1; /* respect statGraphWidth config */

- if (0 <= transfer_unpack_limit)

- unpack_limit = transfer_unpack_limit;

- else if (0 <= receive_unpack_limit)

- int i, status, do_all, all_worktrees = 1;

- OPT_BOOL(1, "single-worktree", &all_worktrees,

- revs.do_not_die_on_missing_tree = 1;

- if (!all_worktrees && !(*p)->is_current)

-#define CRUFT_PACK 2

- const char *max_pack_size;

- * Adds all packs hex strings (pack-$HASH) to either fname_nonkept_list

- * or fname_kept_list based on whether each pack has a corresponding

-static void collect_pack_filenames(struct string_list *fname_nonkept_list,

- struct string_list *fname_kept_list,

- string_list_append(fname_kept_list, buf.buf);

- else {

- struct string_list_item *item;

- item = string_list_append(fname_nonkept_list, buf.buf);

- if (p->is_cruft)

- item->util = (void*)(uintptr_t)CRUFT_PACK;

- }

- string_list_sort(fname_kept_list);

- strbuf_release(&buf);

-}

-

-static void remove_redundant_pack(const char *dir_name, const char *base_name)

-{

- struct strbuf buf = STRBUF_INIT;

- struct multi_pack_index *m = get_local_multi_pack_index(the_repository);

- strbuf_addf(&buf, "%s.pack", base_name);

- if (m && midx_contains_pack(m, buf.buf))

- clear_midx_file(the_repository);

- strbuf_insertf(&buf, 0, "%s/", dir_name);

- unlink_pack_path(buf.buf, 1);

- strvec_pushf(&cmd->args, "--max-pack-size=%s", args->max_pack_size);

-static void init_pack_geometry(struct pack_geometry **geometry_p,

- struct string_list *existing_kept_packs,

- struct pack_geometry *geometry;

- *geometry_p = xcalloc(1, sizeof(struct pack_geometry));

- geometry = *geometry_p;

-

- * Any pack that has its pack_keep bit set will appear

- * in existing_kept_packs below, but this saves us from

- * doing a more expensive check.

- * The pack may be kept via the --keep-pack option;

- * check 'existing_kept_packs' to determine whether to

- * ignore it.

- if (string_list_has_string(existing_kept_packs, buf.buf))

-static void split_pack_geometry(struct pack_geometry *geometry, int factor)

- if (unsigned_mult_overflows(factor, geometry_pack_weight(prev)))

- if (geometry_pack_weight(ours) < factor * geometry_pack_weight(prev))

- if (unsigned_mult_overflows(factor, total_size))

- if (geometry_pack_weight(ours) < factor * total_size) {

- free(geometry);

- struct string_list *existing_nonkept_packs,

- struct string_list *existing_kept_packs,

- for_each_string_list_item(item, existing_kept_packs)

- if (geometry) {

-

- for_each_string_list_item(item, existing_nonkept_packs) {

- if (!((uintptr_t)item->util & CRUFT_PACK)) {

- /*

- * no need to check DELETE_PACK, since we're not

- * doing an ALL_INTO_ONE repack

- */

- continue;

- }

- string_list_insert(include, xstrfmt("%s.idx", item->string));

- }

- for_each_string_list_item(item, existing_nonkept_packs) {

- if ((uintptr_t)item->util & DELETE_PACK)

- struct string_list *existing_packs,

- struct string_list *existing_kept_packs)

- struct strbuf line = STRBUF_INIT;

- FILE *in, *out;

- strvec_push(&cmd.args, "--max-pack-size=0");

- for_each_string_list_item(item, existing_packs)

- fprintf(in, "-%s.pack\n", item->string);

- for_each_string_list_item(item, existing_kept_packs)

- out = xfdopen(cmd.out, "r");

- while (strbuf_getline_lf(&line, out) != EOF) {

- struct string_list_item *item;

-

- if (line.len != the_hash_algo->hexsz)

- die(_("repack: Expecting full hex object ID lines only "

- "from pack-objects."));

- /*

- * avoid putting packs written outside of the repository in the

- * list of names

- */

- if (local) {

- item = string_list_append(names, line.buf);

- item->util = populate_pack_exts(line.buf);

- }

- }

- fclose(out);

-

- strbuf_release(&line);

- return finish_command(&cmd);

- struct string_list existing_nonkept_packs = STRING_LIST_INIT_DUP;

- struct string_list existing_kept_packs = STRING_LIST_INIT_DUP;

- struct pack_geometry *geometry = NULL;

- struct strbuf line = STRBUF_INIT;

- FILE *out;

- int geometric_factor = 0;

- OPT_STRING(0, "max-pack-size", &po_args.max_pack_size, N_("bytes"),

- OPT_INTEGER('g', "geometric", &geometric_factor,

- collect_pack_filenames(&existing_nonkept_packs, &existing_kept_packs,

- &keep_pack_list);

- if (geometric_factor) {

- init_pack_geometry(&geometry, &existing_kept_packs, &po_args);

- split_pack_geometry(geometry, geometric_factor);

- if (!geometry) {

- if (existing_nonkept_packs.nr && delete_redundant &&

- } else if (geometry) {

- if (geometry)

- if (geometry) {

- for (i = 0; i < geometry->split; i++)

- fprintf(in, "%s\n", pack_basename(geometry->pack[i]));

- for (i = geometry->split; i < geometry->pack_nr; i++)

- fprintf(in, "^%s\n", pack_basename(geometry->pack[i]));

- out = xfdopen(cmd.out, "r");

- while (strbuf_getline_lf(&line, out) != EOF) {

- struct string_list_item *item;

-

- if (line.len != the_hash_algo->hexsz)

- die(_("repack: Expecting full hex object ID lines only from pack-objects."));

- item = string_list_append(&names, line.buf);

- item->util = populate_pack_exts(item->string);

- }

- strbuf_release(&line);

- fclose(out);

- ret = finish_command(&cmd);

- const char *pack_prefix;

- if (!skip_prefix(packtmp, packdir, &pack_prefix))

- die(_("pack prefix %s does not begin with objdir %s"),

- packtmp, packdir);

- if (*pack_prefix == '/')

- pack_prefix++;

- &existing_nonkept_packs,

- &existing_kept_packs);

- &existing_nonkept_packs,

- &existing_kept_packs);

- if (delete_redundant && pack_everything & ALL_INTO_ONE) {

- const int hexsz = the_hash_algo->hexsz;

- for_each_string_list_item(item, &existing_nonkept_packs) {

- char *sha1;

- size_t len = strlen(item->string);

- if (len < hexsz)

- continue;

- sha1 = item->string + len - hexsz;

- /*

- * Mark this pack for deletion, which ensures that this

- * pack won't be included in a MIDX (if `--write-midx`

- * was given) and that we will actually delete this pack

- * (if `-d` was given).

- */

- if (!string_list_has_string(&names, sha1))

- item->util = (void*)(uintptr_t)((size_t)item->util | DELETE_PACK);

- }

- }

- midx_included_packs(&include, &existing_nonkept_packs,

- &existing_kept_packs, &names, geometry);

- ret = write_midx_included_packs(&include, geometry,

- for_each_string_list_item(item, &existing_nonkept_packs) {

- if (!((uintptr_t)item->util & DELETE_PACK))

- continue;

- remove_redundant_pack(packdir, item->string);

- }

-

- if (geometry) {

- struct strbuf buf = STRBUF_INIT;

-

- uint32_t i;

- for (i = 0; i < geometry->split; i++) {

- struct packed_git *p = geometry->pack[i];

- if (string_list_has_string(&names,

- hash_to_hex(p->hash)))

- continue;

- strbuf_reset(&buf);

- strbuf_addstr(&buf, pack_basename(p));

- strbuf_strip_suffix(&buf, ".pack");

-

- if ((p->pack_keep) ||

- (string_list_has_string(&existing_kept_packs,

- buf.buf)))

- continue;

-

- remove_redundant_pack(packdir, buf.buf);

- }

- strbuf_release(&buf);

- }

- string_list_clear(&existing_nonkept_packs, 0);

- string_list_clear(&existing_kept_packs, 0);

- free_pack_geometry(geometry);

-static void finish_commit(struct commit *commit);

-static void finish_commit(struct commit *commit)

-{

- free_commit_list(commit->parents);

- commit->parents = NULL;

- free_commit_buffer(the_repository->parsed_objects,

- commit);

-}

-

-static inline void finish_object__ma(struct object *obj)

-{

- /*

- * Whether or not we try to dynamically fetch missing objects

- * from the server, we currently DO NOT have the object. We

- * can either print, allow (ignore), or conditionally allow

- * (ignore) them.

- */

- switch (arg_missing_action) {

- case MA_ERROR:

- die("missing %s object '%s'",

- type_name(obj->type), oid_to_hex(&obj->oid));

- return;

-

- case MA_ALLOW_ANY:

- return;

-

- case MA_PRINT:

- oidset_insert(&missing_objects, &obj->oid);

- return;

-

- case MA_ALLOW_PROMISOR:

- if (is_promisor_object(&obj->oid))

- return;

- die("unexpected missing %s object '%s'",

- type_name(obj->type), oid_to_hex(&obj->oid));

- return;

-

- default:

- BUG("unhandled missing_action");

- return;

- }

-}

-

- revs.do_not_die_on_missing_tree = 1;

-#include "refs.h"

- N_("git show-ref [-q | --quiet] [--verify] [--head] [-d | --dereference]\n"

-static int deref_tags, show_head, tags_only, heads_only, found_match, verify,

- quiet, hash_only, abbrev, exclude_arg;

-static const char **pattern;

-static const char *exclude_existing_arg;

-static void show_one(const char *refname, const struct object_id *oid)

- if (quiet)

- hex = repo_find_unique_abbrev(the_repository, oid, abbrev);

- if (hash_only)

- if (!deref_tags)

- hex = repo_find_unique_abbrev(the_repository, &peeled, abbrev);

- int flag UNUSED, void *cbdata UNUSED)

- if (show_head && !strcmp(refname, "HEAD"))

- if (pattern) {

- const char **p = pattern, *m;

- found_match++;

- show_one(refname, oid);

-static int exclude_existing(const char *match)

- static struct string_list existing_refs = STRING_LIST_INIT_DUP;

- int matchlen = match ? strlen(match) : 0;

- if (match) {

- if (reflen < matchlen)

- if (strncmp(ref, match, matchlen))

- hash_only = 1;

- return parse_opt_abbrev_cb(opt, arg, unset);

- exclude_arg = 1;

- *(const char **)opt->value = arg;

-static const struct option show_ref_options[] = {

- OPT_BOOL(0, "tags", &tags_only, N_("only show tags (can be combined with heads)")),

- OPT_BOOL(0, "heads", &heads_only, N_("only show heads (can be combined with tags)")),

- OPT_BOOL(0, "verify", &verify, N_("stricter reference checking, "

- "requires exact ref path")),

- OPT_HIDDEN_BOOL('h', NULL, &show_head,

- N_("show the HEAD reference, even if it would be filtered out")),

- OPT_BOOL(0, "head", &show_head,

- N_("show the HEAD reference, even if it would be filtered out")),

- OPT_BOOL('d', "dereference", &deref_tags,

- N_("dereference tags into object IDs")),

- OPT_CALLBACK_F('s', "hash", &abbrev, N_("n"),

- N_("only show SHA1 hash using <n> digits"),

- PARSE_OPT_OPTARG, &hash_callback),

- OPT__ABBREV(&abbrev),

- OPT__QUIET(&quiet,

- N_("do not print results to stdout (useful with --verify)")),

- OPT_CALLBACK_F(0, "exclude-existing", &exclude_existing_arg,

- N_("pattern"), N_("show refs from stdin that aren't in local repository"),

- PARSE_OPT_OPTARG | PARSE_OPT_NONEG, exclude_existing_callback),

- OPT_END()

-};

-

- if (exclude_arg)

- return exclude_existing(exclude_existing_arg);

-

- pattern = argv;

- if (!*pattern)

- pattern = NULL;

-

- if (verify) {

- if (!pattern)

- die("--verify requires a reference");

- while (*pattern) {

- struct object_id oid;

-

- if ((starts_with(*pattern, "refs/") || !strcmp(*pattern, "HEAD")) &&

- !read_ref(*pattern, &oid)) {

- show_one(*pattern, &oid);

- }

- else if (!quiet)

- die("'%s' - not a valid ref", *pattern);

- else

- return 1;

- pattern++;

- }

- return 0;

- }

- if (show_head)

- head_ref(show_ref, NULL);

- if (heads_only || tags_only) {

- if (heads_only)

- for_each_fullref_in("refs/heads/", show_ref, NULL);

- if (tags_only)

- for_each_fullref_in("refs/tags/", show_ref, NULL);

- } else {

- for_each_ref(show_ref, NULL);

- }

- if (!found_match) {

- if (verify && !quiet)

- die("No match");

- return 1;

- }

- return 0;

- struct diff_options *options,

- ret = diff_result_code(&rev.diffopt, 0);

- int result;

- result = run_diff_index(&rev, 1);

- if (diff_result_code(&rev.diffopt, result)) {

- result = run_diff_files(&rev, 0);

- if (diff_result_code(&rev.diffopt, result)) {

- if (run_diff_index(&rev, 0)) {

- ret = -1;

- goto done;

- }

- int diff_files_result;

- diff_files_result = run_diff_files(&rev, 0);

- if (!diff_result_code(&rev.diffopt, diff_files_result)) {

- run_diff_index(&rev, info->cached);

- int quiet = 0;

- config_name = xstrfmt("submodule.%s.url", path);

- config_set_in_gitmodules_file_gently(config_name, newurl);

- sync_submodule(path, prefix, NULL, quiet ? OPT_QUIET : 0);

- free(config_name);

- return 0;

- config_name = xstrfmt("submodule.%s.branch", path);

- the_hash_algo->final_oid_fn(&oid, &ctx);

-static struct object_id head_oid;

-static struct object_id merge_head_oid;

-

- int namelen = strlen(path);

- int pos;

- int ret = 0;

- struct cache_entry *ce_2 = NULL, *ce_3 = NULL;

-

- /* See if there is such entry in the index. */

- pos = index_name_pos(&the_index, path, namelen);

- if (0 <= pos) {

- /* already merged */

- pos = unmerge_index_entry_at(&the_index, pos);

- if (pos < the_index.cache_nr) {

- const struct cache_entry *ce = the_index.cache[pos];

- if (ce_stage(ce) &&

- ce_namelen(ce) == namelen &&

- !memcmp(ce->name, path, namelen))

- return 0;

- }

- /* no resolve-undo information; fall back */

- } else {

- /* If there isn't, either it is unmerged, or

- * resolved as "removed" by mistake. We do not

- * want to do anything in the former case.

- */

- pos = -pos-1;

- if (pos < the_index.cache_nr) {

- const struct cache_entry *ce = the_index.cache[pos];

- if (ce_namelen(ce) == namelen &&

- !memcmp(ce->name, path, namelen)) {

- fprintf(stderr,

- "%s: skipping still unmerged path.\n",

- path);

- goto free_return;

- }

- }

- }

-

- /* Grab blobs from given path from HEAD and MERGE_HEAD,

- * stuff HEAD version in stage #2,

- * stuff MERGE_HEAD version in stage #3.

- */

- ce_2 = read_one_ent("our", &head_oid, path, namelen, 2);

- ce_3 = read_one_ent("their", &merge_head_oid, path, namelen, 3);

-

- if (!ce_2 || !ce_3) {

- ret = -1;

- goto free_return;

- }

- if (oideq(&ce_2->oid, &ce_3->oid) &&

- ce_2->ce_mode == ce_3->ce_mode) {

- fprintf(stderr, "%s: identical in both, skipping.\n",

- path);

- goto free_return;

- }

-

- remove_file_from_index(&the_index, path);

- if (add_index_entry(&the_index, ce_2, ADD_CACHE_OK_TO_ADD)) {

- error("%s: cannot add our version to the index.", path);

- ret = -1;

- goto free_return;

- }

- if (!add_index_entry(&the_index, ce_3, ADD_CACHE_OK_TO_ADD))

- return 0;

- error("%s: cannot add their version to the index.", path);

- ret = -1;

- free_return:

- discard_cache_entry(ce_2);

- discard_cache_entry(ce_3);

- return ret;

-}

-

-static void read_head_pointers(void)

-{

- if (read_ref("HEAD", &head_oid))

- die("No HEAD -- no initial commit yet?");

- if (read_ref("MERGE_HEAD", &merge_head_oid)) {

- fprintf(stderr, "Not in the middle of a merge.\n");

- exit(0);

- }

- /* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we

- * are not doing a merge, so exit with success status.

- */

- read_head_pointers();

-

-static int resolve_undo_clear_callback(const struct option *opt,

- struct parse_opt_ctx_t *ctx, const struct option *opt,

- if (preferred_index_format < INDEX_FORMAT_LB ||

- INDEX_FORMAT_UB < preferred_index_format)

-

- if (the_index.version != preferred_index_format)

- the_index.cache_changed |= SOMETHING_CHANGED;

- the_index.version = preferred_index_format;

-static void parse_cmd_option(struct ref_transaction *transaction,

- const char *next, const char *end)

-static void parse_cmd_start(struct ref_transaction *transaction,

- const char *next, const char *end)

- const char *next, const char *end)

- const char *next, const char *end)

- const char *next, const char *end)

- char *file = xstrdup(git_attr_global_file());

-static int first_valid_ref(const char *refname,

- const struct object_id *oid,

- int flags,

- void *cb_data)

- "present, stopping; use 'add -f' to overide or fetch a remote first"));