+ int unused, ret;

+ ret = !!run_add_p(the_repository, ADD_P_ADD, NULL, &pathspec);

+ ret = !!run_add_i(the_repository, &pathspec);

+

+ clear_pathspec(&pathspec);

+ return ret;

+ if (!adviced_on_embedded_repo) {

+ advise_if_enabled(ADVICE_ADD_EMBEDDED_REPO,

+ embedded_advice, name.buf, name.buf);

+ advise_if_enabled(ADVICE_ADD_IGNORED_FILE,

+ _("Use -f if you really want to add them."));

+ char *ps_matched = NULL;

+ advise_if_enabled(ADVICE_ADD_EMPTY_PATHSPEC,

+ _("Maybe you wanted to say 'git add .'?"));

+ ps_matched = xcalloc(pathspec.nr, 1);

+ &pathspec, ps_matched,

+ include_sparse, flags);

+

+ if (take_worktree_changes && !add_renormalize && !ignore_add_errors &&

+ report_path_error(ps_matched, &pathspec))

+ exit(128);

+ free(ps_matched);

+ advise_if_enabled(ADVICE_MERGE_CONFLICT, "%s", state->resolvemsg);

+ struct strbuf sb = STRBUF_INIT;

+ strbuf_addf(&sb, _("When you have resolved this problem, run \"%s --continue\".\n"), cmdline);

+ strbuf_addf(&sb, _("If you prefer to skip this patch, run \"%s --skip\" instead.\n"), cmdline);

+ strbuf_addf(&sb, _("To record the empty patch as an empty commit, run \"%s --allow-empty\".\n"), cmdline);

+ strbuf_addf(&sb, _("To restore the original branch and stop patching, run \"%s --abort\"."), cmdline);

+

+ advise_if_enabled(ADVICE_MERGE_CONFLICT, "%s", sb.buf);

+ strbuf_release(&sb);

+ strbuf_stripspace(&msg, NULL);

+ init_tree_desc(&t[0], &head->object.oid, head->buffer, head->size);

+ init_tree_desc(&t[1], &remote->object.oid, remote->buffer, remote->size);

+ init_tree_desc(&t[0], &tree->object.oid, tree->buffer, tree->size);

+ time_str = show_date(time, tz, blame_date_mode);

+ blame_date_width = strlen(show_date(0, 0, blame_date_mode)) + 1; /* add the null */

+ strbuf_commented_addf(&buf, comment_line_str,

+ "Lines starting with '%s' will be stripped.\n"),

+ branch_name, comment_line_str);

+ strbuf_stripspace(&buf, comment_line_str);

+ N_("git bugreport [(-o | --output-directory) <path>]\n"

+ " [(-s | --suffix) <format> | --no-suffix]\n"

+ strbuf_addstr(&report_path, "git-bugreport");

+ if (option_suffix) {

+ strbuf_addch(&report_path, '-');

+ strbuf_addftime(&report_path, option_suffix, localtime_r(&now, &tm), 0, 0);

+ }

+ unsigned get_oid_flags =

+ GET_OID_RECORD_PATH |

+ GET_OID_ONLY_TO_DIE |

+ GET_OID_HASH_ANY;

+ get_oid_hex_algop(target, &blob_oid,

+ &hash_algos[oid.algo]))

+static int expand_atom(struct strbuf *sb, const char *atom, int len,

+ struct expand_data *data)

+ return 0;

+ return 1;

+ else if ((end = strchr(start + 1, ')')) &&

+ expand_atom(sb, start + 1, end - start - 1, data))

+ else

+ strbuf_expand_bad_format(start, "cat-file");

+ int flags =

+ GET_OID_HASH_ANY |

+ (opt->follow_symlinks ? GET_OID_FOLLOW_SYMLINKS : 0);

+ int conflict_style;

+#define CHECKOUT_OPTS_INIT { .conflict_style = -1, .merge = -1 }

+

+ int *nr_checkouts, struct mem_pool *ce_mem_pool,

+ int conflict_style)

+ struct ll_merge_options ll_opts = LL_MERGE_OPTIONS_INIT;

+ ll_opts.conflict_style = conflict_style;

+ &ce_mem_pool,

+ opts->conflict_style);

+ init_tree_desc(&tree_desc, &tree->object.oid, tree->buffer, tree->size);

+ init_tree_desc(&trees[0], &tree->object.oid,

+ tree->buffer, tree->size);

+ init_tree_desc(&trees[1], &tree->object.oid,

+ tree->buffer, tree->size);

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

+ 0);

+ o.conflict_style = opts->conflict_style;

+ !opts->force_detach &&

+ (new_branch_info->path || !strcmp(new_branch_info->name, "HEAD")))

+static int parse_opt_conflict(const struct option *o, const char *arg, int unset)

+{

+ struct checkout_opts *opts = o->value;

+

+ if (unset) {

+ opts->conflict_style = -1;

+ return 0;

+ }

+ opts->conflict_style = parse_conflict_style_name(arg);

+ if (opts->conflict_style < 0)

+ return error(_("unknown conflict style '%s'"), arg);

+ /* --conflict overrides a previous --no-merge */

+ if (!opts->merge)

+ opts->merge = -1;

+

+ return 0;

+}

+

+ OPT_CALLBACK(0, "conflict", opts, N_("style"),

+ N_("conflict style (merge, diff3, or zdiff3)"),

+ parse_opt_conflict),

+ const char * const usagestr[])

+ struct branch_info new_branch_info = { 0 };

+ int ret;

+ /* --conflicts implies --merge */

+ if (opts->merge == -1)

+ opts->merge = opts->conflict_style >= 0;

+

+ &new_branch_info, opts, &rev);

+ setup_new_branch_info_and_source_tree(&new_branch_info,

+ if (opts->new_branch && argc == 1 && !new_branch_info.commit)

+ ret = checkout_paths(opts, &new_branch_info);

+ ret = checkout_branch(opts, &new_branch_info);

+

+ branch_info_release(&new_branch_info);

+ clear_pathspec(&opts->pathspec);

+ free(opts->pathspec_from_file);

+ free(options);

+

+ return ret;

+ struct checkout_opts opts = CHECKOUT_OPTS_INIT;

+ return checkout_main(argc, argv, prefix, &opts, options,

+ checkout_usage);

+ struct checkout_opts opts = CHECKOUT_OPTS_INIT;

+ return checkout_main(argc, argv, prefix, &opts, options,

+ switch_branch_usage);

+ struct checkout_opts opts = CHECKOUT_OPTS_INIT;

+ return checkout_main(argc, argv, prefix, &opts, options,

+ restore_usage);

+ init_tree_desc(&t, &tree->object.oid, tree->buffer, tree->size);

+ init_tree_desc(&t, &tree->object.oid, tree->buffer, tree->size);

+ char *ps_matched = xcalloc(pathspec.nr, 1);

+ &pathspec, ps_matched, 0, 0);

+ if (!all && report_path_error(ps_matched, &pathspec))

+ exit(128);

+

+ free(ps_matched);

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

+ comment_line_str = xstrfmt("%c", candidates[0]);

+ }

+ comment_line_str = xstrfmt("%c", *p);

+ strbuf_stripspace(&sb, NULL);

+ " Lines starting\nwith '%s' will be ignored.\n") :

+ " Lines starting\nwith '%s' will be ignored, and an empty"

+ "with '%s' will be kept; you may remove them"

+ "with '%s' will be kept; you may remove them"

+ status_printf(s, GIT_COLOR_NORMAL, hint_cleanup_all, comment_line_str);

+ status_printf(s, GIT_COLOR_NORMAL, hint_cleanup_space, comment_line_str);

+static enum untracked_status_type parse_untracked_setting_name(const char *u)

+ switch (git_parse_maybe_bool(u)) {

+ case 0:

+ u = "no";

+ break;

+ case 1:

+ u = "normal";

+ break;

+ default:

+ break;

+ }

+

+ if (!strcmp(u, "no"))

+ return SHOW_NO_UNTRACKED_FILES;

+ else if (!strcmp(u, "normal"))

+ return SHOW_NORMAL_UNTRACKED_FILES;

+ else if (!strcmp(u, "all"))

+ return SHOW_ALL_UNTRACKED_FILES;

+ return SHOW_UNTRACKED_FILES_ERROR;

+}

+

+static void handle_untracked_files_arg(struct wt_status *s)

+{

+ enum untracked_status_type u;

+

+ if (!untracked_files_arg)

+ return; /* default already initialized */

+

+ u = parse_untracked_setting_name(untracked_files_arg);

+ if (u == SHOW_UNTRACKED_FILES_ERROR)

+ die(_("Invalid untracked files mode '%s'"),

+ untracked_files_arg);

+ s->show_untracked_files = u;

+ enum untracked_status_type u;

+

+ u = parse_untracked_setting_name(v);

+ if (u == SHOW_UNTRACKED_FILES_ERROR)

+ s->show_untracked_files = u;

+static const char *comment;

+ OPT_STRING(0, "comment", &comment, N_("value"), N_("human-readable comment string (# will be prepended as needed)")),

+ if (comment &&

+ !(actions & (ACTION_ADD|ACTION_SET|ACTION_SET_ALL|ACTION_REPLACE_ALL))) {

+ error(_("--comment is only applicable to add/set/replace operations"));

+ usage_builtin_config();

+ }

+

+ comment = git_config_prepare_comment_string(comment);

+

+ ret = git_config_set_in_file_gently(given_config_source.file, argv[0], comment, value);

+ comment, flags);

+ comment, flags);

+ comment, flags | CONFIG_FLAGS_MULTI_REPLACE);

+ NULL, flags);

+ argv[0], NULL, NULL);

+ NULL, flags | CONFIG_FLAGS_MULTI_REPLACE);

+ if (!have_unix_sockets())

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

+ if (!have_unix_sockets())

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

+

+ c = parse_mode(c, &e->versions[1].mode);

+ * Update *endptr to point to the first character after the value.

+ * Parse the mark reference, demanding a trailing space. Update *p to

+ * point to the first character after the space.

+/*

+ * Parse the path string into the strbuf. The path can either be quoted with

+ * escape sequences or unquoted without escape sequences. Unquoted strings may

+ * contain spaces only if `is_last_field` is nonzero; otherwise, it stops

+ * parsing at the first space.

+ */

+static void parse_path(struct strbuf *sb, const char *p, const char **endp,

+ int is_last_field, const char *field)

+{

+ if (*p == '"') {

+ if (unquote_c_style(sb, p, endp))

+ die("Invalid %s: %s", field, command_buf.buf);

+ if (strlen(sb->buf) != sb->len)

+ die("NUL in %s: %s", field, command_buf.buf);

+ } else {

+ /*

+ * Unless we are parsing the last field of a line,

+ * SP is the end of this field.

+ */

+ *endp = is_last_field

+ ? p + strlen(p)

+ : strchrnul(p, ' ');

+ strbuf_add(sb, p, *endp - p);

+ }

+}

+

+/*

+ * Parse the path string into the strbuf, and complain if this is not the end of

+ * the string. Unquoted strings may contain spaces.

+ */

+static void parse_path_eol(struct strbuf *sb, const char *p, const char *field)

+{

+ const char *end;

+

+ parse_path(sb, p, &end, 1, field);

+ if (*end)

+ die("Garbage after %s: %s", field, command_buf.buf);

+}

+

+/*

+ * Parse the path string into the strbuf, and ensure it is followed by a space.

+ * Unquoted strings may not contain spaces. Update *endp to point to the first

+ * character after the space.

+ */

+static void parse_path_space(struct strbuf *sb, const char *p,

+ const char **endp, const char *field)

+{

+ parse_path(sb, p, endp, 0, field);

+ if (**endp != ' ')

+ die("Missing space after %s: %s", field, command_buf.buf);

+ (*endp)++;

+}

+

+ static struct strbuf path = STRBUF_INIT;

+ p = parse_mode(p, &mode);

+ strbuf_reset(&path);

+ parse_path_eol(&path, p, "path");

+ if (S_ISDIR(mode) && is_empty_tree_oid(&oid) && *path.buf) {

+ tree_content_remove(&b->branch_tree, path.buf, NULL, 0);

+ if (!*path.buf) {

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

+ static struct strbuf path = STRBUF_INIT;

+ strbuf_reset(&path);

+ parse_path_eol(&path, p, "path");

+ tree_content_remove(&b->branch_tree, path.buf, NULL, 1);

+static void file_change_cr(const char *p, struct branch *b, int rename)

+ static struct strbuf source = STRBUF_INIT;

+ static struct strbuf dest = STRBUF_INIT;

+ strbuf_reset(&source);

+ parse_path_space(&source, p, &p, "source");

+ strbuf_reset(&dest);

+ parse_path_eol(&dest, p, "dest");

+ tree_content_remove(&b->branch_tree, source.buf, &leaf, 1);

+ tree_content_get(&b->branch_tree, source.buf, &leaf, 1);

+ die("Path %s not in branch", source.buf);

+ if (!*dest.buf) { /* C "path/to/subdir" "" */

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

+ static struct strbuf path = STRBUF_INIT;

+ strbuf_reset(&path);

+ parse_path_eol(&path, p, "path");

+ tree_content_get(root, path.buf, &leaf, 1);

+ print_ls(leaf.versions[1].mode, leaf.versions[1].oid.hash, path.buf);

+ return 0;

+ int keep_going = 0;

+ OPT_BOOL(0, "keep-going", &keep_going,

+ N_("keep going even if command fails in a repository")),

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

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

+ if (ret) {

+ if (!keep_going)

+ return ret;

+ result = 1;

+ }

+ }

+enum schedule_priority {

+ SCHEDULE_NONE = 0,

+ SCHEDULE_WEEKLY = 1,

+ SCHEDULE_DAILY = 2,

+ SCHEDULE_HOURLY = 3,

+};

+

+static enum schedule_priority parse_schedule(const char *value)

+{

+ if (!value)

+ return SCHEDULE_NONE;

+ if (!strcasecmp(value, "hourly"))

+ return SCHEDULE_HOURLY;

+ if (!strcasecmp(value, "daily"))

+ return SCHEDULE_DAILY;

+ if (!strcasecmp(value, "weekly"))

+ return SCHEDULE_WEEKLY;

+ return SCHEDULE_NONE;

+}

+

+struct maintenance_run_opts {

+ int auto_flag;

+ int quiet;

+ enum schedule_priority schedule;

+};

+

+static int pack_refs_condition(void)

+{

+ /*

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

+ * exposed via `git pack-refs --auto`. We thus always return truish

+ * here and let the backend decide for us.

+ */

+ return 1;

+}

+

+ if (opts->auto_flag)

+ strvec_push(&cmd.args, "--auto");

+

+static void gc_before_repack(struct maintenance_run_opts *opts)

+ if (pack_refs && maintenance_task_pack_refs(opts))

+ struct maintenance_run_opts opts = {0};

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

+ if (opts.auto_flag) {

+ gc_before_repack(&opts); /* dies on failure */

+ if (opts.auto_flag)

+ gc_before_repack(&opts);

+ if (opts.auto_flag && too_many_loose_objects())

+ pack_refs_condition,

+ CONFIG_REGEX_NONE, NULL, 0);

+ config_file, key, NULL, maintpath, NULL,

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

+ "<Arguments>--exec-path=\"%s\" for-each-repo --keep-going --config=maintenance.repo maintenance run --schedule=%s</Arguments>\n"

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

+ "ExecStart=\"%s/git\" --exec-path=\"%s\" for-each-repo --keep-going --config=maintenance.repo maintenance run --schedule=%%i\n"

+ init_tree_desc(&tree, oid, data, size);

+ init_tree_desc(&tree, &ce->oid, data, size);

+ init_tree_desc(&sub, &entry.oid, data, size);

+ init_tree_desc(&tree, &obj->oid, data, size);

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

+ pp_email_subject(pp, &subject, sb, encoding, need_8bit_cte);

+ free(pp.after_subject);

+static int rfc_callback(const struct option *opt, const char *arg,

+ int unset)

+{

+ const char **rfc = opt->value;

+

+ *rfc = opt->value;

+ if (unset)

+ *rfc = NULL;

+ else

+ *rfc = arg ? arg : "RFC";

+ return 0;

+}

+

+ const char *rfc = NULL;

+ OPT_CALLBACK_F(0, "rfc", &rfc, N_("rfc"),

+ N_("add <rfc> (default 'RFC') before 'PATCH'"),

+ PARSE_OPT_OPTARG, rfc_callback),

+ if (rfc && rfc[0]) {

+ subject_prefix = 1;

+ if (rfc[0] == '-')

+ strbuf_addf(&sprefix, " %s", rfc + 1);

+ else

+ strbuf_insertf(&sprefix, 0, "%s ", rfc);

+ }

+ strbuf_expand_bad_format(format, "ls-files");

+ strbuf_expand_bad_format(format, "ls-tree");

+ struct object_context obj_context;

+ if (get_oid_with_context(the_repository, argv[0],

+ GET_OID_HASH_ANY, &oid,

+ &obj_context))

+ N_("tree-ish"),

+ init_tree_desc(t+i, &trees[i]->object.oid,

+ trees[i]->buffer, trees[i]->size);

+N_("Lines starting with '%s' will be ignored, and an empty message aborts\n"

+ strbuf_commented_addf(&msg, comment_line_str, "\n");

+ strbuf_commented_addf(&msg, comment_line_str,

+ strbuf_commented_addf(&msg, comment_line_str,

+ strbuf_commented_addf(&msg, comment_line_str,

+ _(no_scissors_editor_comment), comment_line_str);

+#include "replace-object.h"

+ disable_replace_refs();

+

+ strbuf_add_commented_lines(&cbuf, buf.buf, buf.len, comment_line_str);

+ strbuf_add_commented_lines(&buf, "\n", strlen("\n"), comment_line_str);

+ comment_line_str);

+ strbuf_add_commented_lines(&buf, "\n", strlen("\n"), comment_line_str);

+ strbuf_stripspace(&d->buf, comment_line_str);

+ strbuf_stripspace(&d->buf, NULL);

+ init_tree_desc(&sub, &tree->oid,

+ tree->tree_data, tree->tree_size);

+ init_tree_desc(&tree, &it->pcache.oid,

+ it->pcache.tree_data, it->pcache.tree_size);

+ N_("git pack-refs [--all] [--no-prune] [--auto] [--include <pattern>] [--exclude <pattern>]"),

+ struct ref_exclusions excludes = REF_EXCLUSIONS_INIT;

+ struct string_list included_refs = STRING_LIST_INIT_NODUP;

+ struct pack_refs_opts pack_refs_opts = {

+ .exclusions = &excludes,

+ .includes = &included_refs,

+ .flags = PACK_REFS_PRUNE,

+ };

+ struct string_list option_excluded_refs = STRING_LIST_INIT_NODUP;

+ int pack_all = 0;

+ int ret;

+ OPT_BOOL(0, "all", &pack_all, N_("pack everything")),

+ OPT_BIT(0, "auto", &pack_refs_opts.flags, N_("auto-pack refs as needed"), PACK_REFS_AUTO),

+ if (pack_all)

+ ret = refs_pack_refs(get_main_ref_store(the_repository), &pack_refs_opts);

+

+ clear_ref_exclusions(&excludes);

+ string_list_clear(&included_refs, 0);

+ string_list_clear(&option_excluded_refs, 0);

+ return ret;

+ init_tree_desc(t+i, &tree->object.oid, tree->buffer, tree->size);

+ EMPTY_STOP

+ strbuf_stripspace(&todo_list.buf, comment_line_str);

+ child_process_clear(&am);

+ child_process_clear(&am);

+ child_process_clear(&am);

+ else if (!strcasecmp(value, "stop"))

+ return EMPTY_STOP;

+ else if (!strcasecmp(value, "ask")) {

+ warning(_("--empty=ask is deprecated; use '--empty=stop' instead."));

+ return EMPTY_STOP;

+ }

+ die(_("unrecognized empty type '%s'; valid values are \"drop\", \"keep\", and \"stop\"."), value);

+ OPT_CALLBACK_F(0, "empty", &options, "(drop|keep|stop)",

+ options.empty = EMPTY_STOP;

+ if (prepare_auto_maintenance(1, &proc)) {

+ proc.no_stdin = 1;

+ proc.stdout_to_stderr = 1;

+ proc.err = use_sideband ? -1 : 0;

+

+ if (!start_command(&proc)) {

+ if (use_sideband)

+ copy_to_sideband(proc.err, -1, NULL);

+ finish_command(&proc);

+ }

+ ctx.rev = revs;

+#include "object-file-convert.h"

+ const struct git_hash_algo *output_algo = NULL;

+ const struct git_hash_algo *compat = NULL;

+ compat = the_repository->compat_hash_algo;

+ if (opt_with_value(arg, "--output-object-format", &arg)) {

+ if (!arg)

+ die(_("no object format specified"));

+ if (!strcmp(arg, the_hash_algo->name) ||

+ !strcmp(arg, "storage")) {

+ flags |= GET_OID_HASH_ANY;

+ output_algo = the_hash_algo;

+ continue;

+ }

+ else if (compat && !strcmp(arg, compat->name)) {

+ flags |= GET_OID_HASH_ANY;

+ output_algo = compat;

+ continue;

+ }

+ else die(_("unsupported object format: %s"), arg);

+ }

+ repo_for_each_abbrev(the_repository, arg, the_hash_algo,

+ if (output_algo)

+ repo_oid_to_algop(the_repository, &oid,

+ output_algo, &oid);

+enum empty_action {

+ EMPTY_COMMIT_UNSPECIFIED = -1,

+ STOP_ON_EMPTY_COMMIT, /* output errors and stop in the middle of a cherry-pick */

+ DROP_EMPTY_COMMIT, /* skip with a notice message */

+ KEEP_EMPTY_COMMIT, /* keep recording as empty commits */

+};

+

+static int parse_opt_empty(const struct option *opt, const char *arg, int unset)

+{

+ int *opt_value = opt->value;

+

+ BUG_ON_OPT_NEG(unset);

+

+ if (!strcmp(arg, "stop"))

+ *opt_value = STOP_ON_EMPTY_COMMIT;

+ else if (!strcmp(arg, "drop"))

+ *opt_value = DROP_EMPTY_COMMIT;

+ else if (!strcmp(arg, "keep"))

+ *opt_value = KEEP_EMPTY_COMMIT;

+ else

+ return error(_("invalid value for '%s': '%s'"), "--empty", arg);

+

+ return 0;

+}

+

+ enum empty_action empty_opt = EMPTY_COMMIT_UNSPECIFIED;

+ OPT_BOOL(0, "keep-redundant-commits", &opts->keep_redundant_commits, N_("deprecated: use --empty=keep instead")),

+ OPT_CALLBACK_F(0, "empty", &empty_opt, "(stop|drop|keep)",

+ N_("how to handle commits that become empty"),

+ PARSE_OPT_NONEG, parse_opt_empty),

+ if (opts->action == REPLAY_PICK) {

+ opts->drop_redundant_commits = (empty_opt == DROP_EMPTY_COMMIT);

+ opts->keep_redundant_commits = opts->keep_redundant_commits || (empty_opt == KEEP_EMPTY_COMMIT);

+ }

+

+ "--keep-redundant-commits", opts->keep_redundant_commits,

+ "--empty", empty_opt != EMPTY_COMMIT_UNSPECIFIED,

+ init_tree_desc(t, &tree->object.oid, tree->buffer, tree->size);

+ init_tree_desc(&tree_desc[i], &tree[i]->object.oid,

+ tree[i]->buffer, tree[i]->size);

+ strvec_pushl(&cp_diff_tree.args, "diff-tree", "-p", "--binary",

+ "-U1", "HEAD", oid_to_hex(&info->w_tree), "--", NULL);

+ strbuf_add_commented_lines(buf, msg, len, comment_line_str);

+ mode == STRIP_COMMENTS ? comment_line_str : NULL);

+ if (git_config_set_in_file_gently(sb.buf, remote_key, NULL, sub_origin_url))

+#include "object-file-convert.h"

+static int do_sign(struct strbuf *buffer, struct object_id **compat_oid,

+ struct object_id *compat_oid_buf)

+ const struct git_hash_algo *compat = the_repository->compat_hash_algo;

+ struct strbuf sig = STRBUF_INIT, compat_sig = STRBUF_INIT;

+ struct strbuf compat_buf = STRBUF_INIT;

+ const char *keyid = get_signing_key();

+ int ret = -1;

+

+ if (sign_buffer(buffer, &sig, keyid))

+ return -1;

+

+ if (compat) {

+ const struct git_hash_algo *algo = the_repository->hash_algo;

+

+ if (convert_object_file(&compat_buf, algo, compat,

+ buffer->buf, buffer->len, OBJ_TAG, 1))

+ goto out;

+ if (sign_buffer(&compat_buf, &compat_sig, keyid))

+ goto out;

+ add_header_signature(&compat_buf, &sig, algo);

+ strbuf_addbuf(&compat_buf, &compat_sig);

+ hash_object_file(compat, compat_buf.buf, compat_buf.len,

+ OBJ_TAG, compat_oid_buf);

+ *compat_oid = compat_oid_buf;

+ }

+

+ if (compat_sig.len)

+ add_header_signature(buffer, &compat_sig, compat);

+

+ strbuf_addbuf(buffer, &sig);

+ ret = 0;

+out:

+ strbuf_release(&sig);

+ strbuf_release(&compat_sig);

+ strbuf_release(&compat_buf);

+ return ret;

+ "Lines starting with '%s' will be ignored.\n");

+ "Lines starting with '%s' will be kept; you may remove them"

+ struct object_id *compat_oid = NULL, compat_oid_buf;

+ if (sign && do_sign(buf, &compat_oid, &compat_oid_buf) < 0)

+ if (write_object_file_flags(buf->buf, buf->len, OBJ_TAG, result,

+ compat_oid, 0) < 0)

+ strbuf_commented_addf(&buf, comment_line_str,

+ _(tag_template), tag, comment_line_str);

+ strbuf_commented_addf(&buf, comment_line_str,

+ _(tag_template_nocleanup), tag, comment_line_str);

+ opt->cleanup_mode == CLEANUP_ALL ? comment_line_str : NULL);

+ N_("git update-ref [<options>] -d <refname> [<old-oid>]"),

+ N_("git update-ref [<options>] <refname> <new-oid> [<old-oid>]"),

+ * The value being parsed is <old-oid> (as opposed to <new-oid>; the

+ * <new-oid> in binary mode to be equivalent to specifying zeros.

+ warning("%s %s: missing <new-oid>, treating as zero",

+ "%s %s: invalid <old-oid>: %s" :

+ "%s %s: invalid <new-oid>: %s",

+ "%s %s: unexpected end of input when reading <old-oid>" :

+ "%s %s: unexpected end of input when reading <new-oid>",

+ die("update %s: missing <new-oid>", refname);

+ die("create %s: missing <new-oid>", refname);

+ die("create %s: zero <new-oid>", refname);

+ die("delete %s: zero <old-oid>", refname);

+ to_file, "core.bare", NULL, "true", NULL, 0))

+ "core.worktree", NULL, NULL))

+ strbuf_stripspace(&contents, NULL);