}

static void update_callback(struct diff_queue_struct *q,

{

int i;

struct update_callback_data *data = cbdata;

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

dir_clear(&dir);

return exit_status;

}

/* various operating modes and command line options */

int interactive;

int threeway;

int quiet;

int signoff; /* enum signoff_type */

*/

static int run_applypatch_msg_hook(struct am_state *state)

{

assert(state->msg);

if (!ret) {

FREE_AND_NULL(state->msg);

int res, opts_left;

int force_apply = 0;

int options = 0;

if (init_apply_state(&apply_state, the_repository, NULL))

BUG("init_apply_state() failed");

strvec_push(&apply_opts, "apply");

strvec_pushv(&apply_opts, state->git_apply_opts.v);

&apply_state, &force_apply, &options,

NULL);

strvec_clear(&apply_paths);

strvec_clear(&apply_opts);

clear_apply_state(&apply_state);

if (res)

return res;

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

struct strbuf sb = STRBUF_INIT;

exit(1);

if (write_cache_as_tree(&tree, 0, NULL))

struct option options[] = {

OPT_BOOL('i', "interactive", &state.interactive,

N_("run interactively")),

OPT_HIDDEN_BOOL('b', "binary", &binary,

N_("historical option -- no-op")),

OPT_BOOL('3', "3way", &state.threeway,

static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")

static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")

static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")

static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")

static GIT_PATH_FUNC(git_path_bisect_first_parent, "BISECT_FIRST_PARENT")

static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")

NULL

};

return bisect_next(terms, prefix);

}

{

int no_checkout = 0;

int first_parent_only = 0;

strbuf_addstr(&start_head, oid_to_hex(&head_oid));

} else if (!get_oid(head, &head_oid) &&

skip_prefix(head, "refs/heads/", &head)) {

strbuf_addstr(&start_head, head);

} else {

return error(_("bad HEAD - strange symbolic ref"));

yesno = git_prompt(_("Do you want me to do it for you "

"[Y/n]? "), PROMPT_ECHO);

res = tolower(*yesno) == 'n' ?

return res;

}

{

const char *state;

int i, verify_expected = 1;

struct strvec argv = STRVEC_INIT;

int res;

sq_dequote_to_strvec(rev, &argv);

strvec_clear(&argv);

return res;

}

return bisect_auto_next(terms, NULL);

}

{

int i;

enum bisect_error res;

strvec_push(&argv_state, argv[i]);

}

}

strvec_clear(&argv_state);

return res;

}

{

struct child_process cmd = CHILD_PROCESS_INIT;

struct strbuf sb = STRBUF_INIT;

return rc;

}

{

int res = BISECT_OK;

struct strbuf command = STRBUF_INIT;

if (bisect_next_check(terms, NULL))

return BISECT_FAILED;

error(_("bisect run failed: no command provided."));

return BISECT_FAILED;

}

while (1) {

res = do_bisect_run(command.buf);

if (is_first_run && (res == 126 || res == 127)) {

int rc = verify_good(terms, command.buf);

is_first_run = 0;

" revision"), command.buf);

res = BISECT_FAILED;

break;

if (res < 0 || 128 <= res) {

error(_("bisect run failed: exit code %d from"

break;

}

saved_stdout = dup(1);

dup2(temporary_stdout_fd, 1);

fflush(stdout);

dup2(saved_stdout, 1);

if (res == BISECT_ONLY_SKIPPED_LEFT)

error(_("bisect run cannot continue any more"));

else if (res == BISECT_INTERNAL_SUCCESS_MERGE_BASE) {

res = BISECT_OK;

} else if (res == BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND) {

res = BISECT_OK;

} else if (res) {

} else {

continue;

}

static int cmd_bisect__reset(int argc, const char **argv, const char *prefix UNUSED)

{

if (argc > 1)

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

}

struct bisect_terms terms = { 0 };

if (argc > 1)

res = bisect_terms(&terms, argc == 1 ? argv[0] : NULL);

free_terms(&terms);

return res;

struct bisect_terms terms = { 0 };

set_terms(&terms, "bad", "good");

free_terms(&terms);

return res;

}

struct bisect_terms terms = { 0 };

if (argc)

get_terms(&terms);

res = bisect_next(&terms, prefix);

free_terms(&terms);

return res;

}

{

return bisect_log();

}

set_terms(&terms, "bad", "good");

get_terms(&terms);

free_terms(&terms);

return res;

}

struct bisect_terms terms = { 0 };

get_terms(&terms);

free_terms(&terms);

return res;

}

struct bisect_terms terms = { 0 };

if (!argc)

get_terms(&terms);

free_terms(&terms);

return res;

}

{

int res = 0;

parse_opt_subcommand_fn *fn = NULL;

OPT_SUBCOMMAND("terms", &fn, cmd_bisect__terms),

OPT_SUBCOMMAND("start", &fn, cmd_bisect__start),

OPT_SUBCOMMAND("next", &fn, cmd_bisect__next),

OPT_SUBCOMMAND("log", &fn, cmd_bisect__log),

OPT_SUBCOMMAND("replay", &fn, cmd_bisect__replay),

OPT_SUBCOMMAND("skip", &fn, cmd_bisect__skip),

OPT_SUBCOMMAND("run", &fn, cmd_bisect__run),

OPT_END()

};

}

strbuf_release(&logmsg);

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

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

if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0)

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

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

strbuf_release(&oldsection);

strbuf_release(&newsection);

}

const char *user_relative_path = NULL;

char *prefixed_filename;

size_t output_path_len;

const struct option bugreport_options[] = {

OPT_CALLBACK_F(0, "diagnose", &diagnose, N_("mode"),

user_relative_path);

free(prefixed_filename);

}

const char * const usagestr[],

const struct option options[],

char **bundle_file) {

PARSE_OPT_STOP_AT_NON_OPTION);

*bundle_file = prefix_filename(prefix, argv[0]);

}

static int cmd_bundle_create(int argc, const char **argv, const char *prefix) {

case 's':

oi.sizep = &size;

if (oid_object_info_extended(the_repository, &oid, &oi, flags) < 0)

die("git cat-file: could not get object info");

printf("%"PRIuMAX"\n", (uintmax_t)size);

ret = 0;

goto cleanup;

if (!data->skip_object_info) {

int ret;

if (pack)

ret = packed_object_info(the_repository, pack, offset,

&data->info);

fflush(stdout);

return;

}

}

strbuf_reset(scratch);

static int all_attrs;

static int cached_attrs;

static int stdin_paths;

static const char * const check_attr_usage[] = {

NULL

};

OPT_BOOL(0 , "stdin", &stdin_paths, N_("read file names from stdin")),

OPT_BOOL('z', NULL, &nul_term_line,

N_("terminate input and output records by a NUL character")),

OPT_END()

};

}

}

const char *file)

{

char *full_path =

prefix_path(prefix, prefix ? strlen(prefix) : 0, file);

if (collect_all) {

} else {

}

output_attr(check, file);

free(full_path);

}

{

struct strbuf buf = STRBUF_INIT;

struct strbuf unquoted = STRBUF_INIT;

die("line is badly quoted");

strbuf_swap(&buf, &unquoted);

}

maybe_flush_or_die(stdout, "attribute to stdout");

}

strbuf_release(&buf);

int cmd_check_attr(int argc, const char **argv, const char *prefix)

{

struct attr_check *check;

int cnt, i, doubledash, filei;

if (!is_bare_repository())

}

}

if (stdin_paths)

else {

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

maybe_flush_or_die(stdout, "attribute to stdout");

}

pos++;

}

if (!overlay_mode) {

return 0;

}

if (stage == 2)

* between A and B, A...B names that merge base.

*

* (b) If <something> is _not_ a commit, either "--" is present

* and there is a tracking branch whose name is <something>

* in one and only one remote (or if the branch exists on the

* remote named in checkout.defaultRemote), then this is a

"or \"git worktree add\"."));

if (state.bisect_in_progress)

warning(_("you are switching branch while bisecting"));

}

static int checkout_branch(struct checkout_opts *opts,

if (refs)

mapped_refs = wanted_peer_refs(refs, &remote->fetch);

if (mapped_refs) {

int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));

struct object_id oid;

const char *parent = "HEAD";

if (amend)

parent = "HEAD^1";

apply_autostash(git_path_merge_autostash(the_repository));

cleanup:

return ret;

}

int cmd_config(int argc, const char **argv, const char *prefix)

{

int nongit = !startup_info->have_repository;

int flags = 0;

given_config_source.file = xstrdup_or_null(getenv(CONFIG_ENVIRONMENT));

free(config_file);

}

else if (actions == ACTION_SET) {

check_write();

check_argc(argc, 2, 2);

value = normalize_value(argv[0], argv[1]);

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

if (ret == CONFIG_NOTHING_SET)

error(_("cannot overwrite multiple values with a single value\n"

" Use a regexp, --add or --replace-all to change %s."), argv[0]);

}

else if (actions == ACTION_SET_ALL) {

check_write();

check_argc(argc, 2, 3);

value = normalize_value(argv[0], argv[1]);

}

else if (actions == ACTION_ADD) {

check_write();

check_argc(argc, 2, 2);

value = normalize_value(argv[0], argv[1]);

}

else if (actions == ACTION_REPLACE_ALL) {

check_write();

check_argc(argc, 2, 3);

value = normalize_value(argv[0], argv[1]);

}

else if (actions == ACTION_GET) {

check_argc(argc, 1, 2);

flags | CONFIG_FLAGS_MULTI_REPLACE);

}

else if (actions == ACTION_RENAME_SECTION) {

check_write();

check_argc(argc, 2, 2);

ret = git_config_rename_section_in_file(given_config_source.file,

argv[0], argv[1]);

if (ret < 0)

return ret;

die(_("no such section: %s"), argv[0]);

}

else if (actions == ACTION_REMOVE_SECTION) {

check_write();

check_argc(argc, 1, 1);

ret = git_config_rename_section_in_file(given_config_source.file,

argv[0], NULL);

if (ret < 0)

return ret;

die(_("no such section: %s"), argv[0]);

}

else if (actions == ACTION_GET_COLOR) {

check_argc(argc, 1, 2);

return get_colorbool(argv[0], argc == 2);

}

}

if (1 < rev.diffopt.skip_stat_unmatch)

refresh_index_quietly();

release_revisions(&rev);

UNLEAK(blob);

return result;

}

struct hashmap symlinks2 = HASHMAP_INIT(pair_cmp, NULL);

struct hashmap_iter iter;

struct pair_entry *entry;

struct checkout lstate, rstate;

int err = 0;

struct child_process cmd = CHILD_PROCESS_INIT;

mkdir(ldir.buf, 0700);

mkdir(rdir.buf, 0700);

memset(&lstate, 0, sizeof(lstate));

lstate.base_dir = lbase_dir = xstrdup(ldir.buf);

lstate.base_dir_len = ldir.len;

}

static void show_filemodify(struct diff_queue_struct *q,

{

int i;

struct string_list *changed = data;

argv++;

}

}

if (negotiate_only) {

struct oidset acked_commits = OIDSET_INIT;

"fsmonitor: unsupported V1 protocol '%s'"),

command);

do_trivial = 1;

} else {

/* We have "builtin:*" */

"fsmonitor: invalid V2 protocol token '%s'",

command);

do_trivial = 1;

} else {

/*

* events.

*/

if (pthread_create(&state->listener_thread, NULL,

ipc_server_stop_async(state->ipc_server_data);

err = error(_("could not start fsmonitor listener thread"));

goto cleanup;

* Start the health thread to watch over our process.

*/

if (pthread_create(&state->health_thread, NULL,

ipc_server_stop_async(state->ipc_server_data);

err = error(_("could not start fsmonitor health thread"));

goto cleanup;

else

ret = write_object_file_literally(buf.buf, buf.len, type, oid,

flags);

strbuf_release(&buf);

return ret;

}

static int decoration_given;

static int use_mailmap_config = 1;

static unsigned int force_in_body_from;

static const char *fmt_patch_subject_prefix = "PATCH";

static int fmt_patch_name_max = FORMAT_PATCH_NAME_MAX_DEFAULT;

static const char *fmt_pretty;

cover_from_description_mode = parse_cover_from_description(value);

return 0;

}

return git_log_config(var, value, cb);

}

struct strbuf rdiff1 = STRBUF_INIT;

struct strbuf rdiff2 = STRBUF_INIT;

struct strbuf rdiff_title = STRBUF_INIT;

int creation_factor = -1;

const struct option builtin_format_patch_options[] = {

cover_from_description_mode = parse_cover_from_description(cover_from_description_arg);

if (reroll_count) {

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

rev.subject_prefix, reroll_count);

rev.reroll_count = reroll_count;

}

for (i = 0; i < extra_hdr.nr; i++) {

rev.diffopt.close_file, "--output",

!!output_directory, "--output-directory");

if (use_stdout) {

setup_pager();

} else if (!rev.diffopt.close_file) {

strbuf_release(&rdiff1);

strbuf_release(&rdiff2);

strbuf_release(&rdiff_title);

free(to_free);

if (rev.ref_message_ids)

string_list_clear(rev.ref_message_ids, 0);

if (!fn)

fn = read_one_entry_quick;

err = read_tree(the_repository, tree, &pathspec, fn, istate);

if (err)

die("unable to read tree entries %s", tree_name);

#include "parse-options.h"

#include "pathspec.h"

N_("git ls-tree [<options>] <tree-ish> [<path>...]"),

NULL

};

static void expand_objectsize(struct strbuf *line, const struct object_id *oid,

const enum object_type type, unsigned int padded)

{

}

}

static size_t expand_show_tree(struct strbuf *sb, const char *start,

void *context)

{

struct show_tree_data *data = context;

const char *end;

const char *p;

unsigned int errlen;

} else if (skip_prefix(start, "(objectsize)", &p)) {

expand_objectsize(sb, data->oid, data->type, 0);

} else if (skip_prefix(start, "(objectname)", &p)) {

} else if (skip_prefix(start, "(path)", &p)) {

const char *name = data->base->buf;

struct strbuf sbuf = STRBUF_INIT;

strbuf_addstr(data->base, data->pathname);

name = relative_path(data->base->buf, prefix, &sbuf);

strbuf_release(&sbuf);

} else {

errlen = (unsigned long)len;

die(_("bad ls-tree format: %%%.*s"), errlen, start);

return len;

}

{

int i;

return 1;

return 0;

size_t len, speclen;

if (strncmp(base, spec, baselen))

}

static int show_tree_fmt(const struct object_id *oid, struct strbuf *base,

{

int recurse = 0;

struct strbuf sb = STRBUF_INIT;

enum object_type type = object_type(mode);

.mode = mode,

.type = type,

.oid = oid,

.base = base,

};

recurse = READ_TREE_RECURSIVE;

return recurse;

return 0;

fwrite(sb.buf, sb.len, 1, stdout);

strbuf_release(&sb);

return recurse;

}

{

int ret = -1;

*recurse = 0;

if (type == OBJ_BLOB) {

ret = 0;

} else if (type == OBJ_TREE &&

*recurse = READ_TREE_RECURSIVE;

ret = *recurse;

}

return ret;

}

const char *pathname,

const size_t baselen)

{

strbuf_addstr(base, pathname);

strbuf_setlen(base, baselen);

}

static int show_tree_default(const struct object_id *oid, struct strbuf *base,

const char *pathname, unsigned mode,

{

int early;

int recurse;

if (early >= 0)

return early;

return recurse;

}

static int show_tree_long(const struct object_id *oid, struct strbuf *base,

const char *pathname, unsigned mode,

{

int early;

int recurse;

char size_text[24];

if (early >= 0)

return early;

unsigned long size;

xsnprintf(size_text, sizeof(size_text), "BAD");

else

xsnprintf(size_text, sizeof(size_text),

xsnprintf(size_text, sizeof(size_text), "-");

}

return recurse;

}

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

const char *pathname, unsigned mode,

{

int early;

int recurse;

const size_t baselen = base->len;

if (early >= 0)

return early;

strbuf_addstr(base, pathname);

strbuf_setlen(base, baselen);

return recurse;

}

static int show_tree_object(const struct object_id *oid, struct strbuf *base,

const char *pathname, unsigned mode,

{

int early;

int recurse;

if (early >= 0)

return early;

return recurse;

}

struct ls_tree_cmdmode_to_fmt {

enum ls_tree_cmdmode mode;

const char *const fmt;

struct tree *tree;

int i, full_tree = 0;

read_tree_fn_t fn = NULL;

const struct option ls_tree_options[] = {

LS_TREE_ONLY),

LS_RECURSIVE),

LS_SHOW_TREES),

OPT_CMDMODE('l', "long", &cmdmode, N_("include object size"),

MODE_LONG),

OPT_CMDMODE(0, "name-only", &cmdmode, N_("list only filenames"),

MODE_NAME_STATUS),

OPT_CMDMODE(0, "object-only", &cmdmode, N_("list only objects"),

MODE_OBJECT_ONLY),

N_("use full path names"), 0),

OPT_BOOL(0, "full-tree", &full_tree,

N_("list entire tree; not just current directory "

"(implies --full-name)")),

N_("format to use for the output"),

PARSE_OPT_NONEG),

OPT_END()

};

struct ls_tree_cmdmode_to_fmt *m2f = ls_tree_cmdmode_format;

git_config(git_default_config, NULL);

if (prefix)

argc = parse_options(argc, argv, prefix, ls_tree_options,

ls_tree_usage, 0);

if (full_tree) {

}

/*

* We wanted to detect conflicts between --name-only and

/* -d -r should imply -t, but -d by itself should not have to. */

if ( (LS_TREE_ONLY|LS_RECURSIVE) ==

usage_msg_opt(

_("--format can't be combined with other format-altering options"),

ls_tree_usage, ls_tree_options);

* cannot be lifted until it is converted to use

* match_pathspec() or tree_entry_interesting()

*/

PATHSPEC_PREFER_CWD,

prefix, argv + 1);

tree = parse_tree_indirect(&oid);

if (!tree)

die("not a tree object");

*/

while (m2f) {

if (!m2f->fmt) {

cmdmode = m2f->mode;

fn = m2f->fn;

fn = m2f->fn;

} else {

m2f++;

break;

}

}

#include "tree-walk.h"

#include "xdiff-interface.h"

#include "help.h"

#include "commit-reach.h"

#include "merge-ort.h"

#include "object-store.h"

return NULL;

}

{

int i;

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

};

static int real_merge(struct merge_tree_options *o,

const char *branch1, const char *branch2,

const char *prefix)

{

opt.branch1 = branch1;

opt.branch2 = branch2;

if (result.clean < 0)

die(_("failure to merge"));

struct merge_tree_options o = { .show_messages = -1 };

int expected_remaining_argc;

int original_argc;

const char * const merge_tree_usage[] = {

N_("git merge-tree [--write-tree] [<options>] <branch1> <branch2>"),

&o.use_stdin,

N_("perform multiple merges, one per line of input"),

PARSE_OPT_NONEG),

OPT_END()

};

if (o.mode == MODE_TRIVIAL)

die(_("--trivial-merge is incompatible with all other options"));

line_termination = '\0';

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

struct strbuf **split;

int result;

split = strbuf_split(&buf, ' ');

die(_("malformed input line: '%s'."), buf.buf);

strbuf_rtrim(split[0]);

if (result < 0)

die(_("merging cannot continue; got unclean result of %d"), result);

strbuf_list_free(split);

/* Do the relevant type of merge */

if (o.mode == MODE_REAL)

else

return trivial_merge(argv[0], argv[1], argv[2]);

}

for (i = 0; i < main_cmds.cnt; i++) {

int j, found = 0;

struct cmdname *ent = main_cmds.names[i];

if (!strncmp(ent->name, all_strategy[j].name, ent->len)

&& !all_strategy[j].name[ent->len])

found = 1;

}

static void count_diff_files(struct diff_queue_struct *q,

{

int *count = data;

}

strbuf_release(&buf);

free(branch_to_free);

return ret;

}

if (!check)

check = attr_check_initl("delta", NULL);

if (ATTR_FALSE(check->items[0].value))

return 1;

return 0;

return 0;

}

int cmd_pack_objects(int argc, const char **argv, const char *prefix)

{

int use_internal_rev_list = 0;

int rev_list_index = 0;

int stdin_packs = 0;

struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;

struct option pack_objects_options[] = {

OPT_SET_INT('q', "quiet", &progress,

&write_bitmap_index,

N_("write a bitmap index if possible"),

WRITE_BITMAP_QUIET, PARSE_OPT_HIDDEN),

OPT_CALLBACK_F(0, "missing", NULL, N_("action"),

N_("handling for missing objects"), PARSE_OPT_NONEG,

option_parse_missing_action),

if (!rev_list_all || !rev_list_reflog || !rev_list_index)

unpack_unreachable_expiration = 0;

if (!pack_to_stdout)

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

if (stdin_packs)

read_cruft_objects();

} else if (!use_internal_rev_list) {

read_object_list_from_stdin();

} else {

struct rev_info revs;

repo_init_revisions(the_repository, &revs, NULL);

get_object_list(&revs, rp.nr, rp.v);

release_revisions(&revs);

}

reuse_packfile_objects);

cleanup:

strvec_clear(&rp);

return 0;

repo_diff_setup(the_repository, &diffopt);

argc = parse_options(argc, argv, prefix, options,

builtin_range_diff_usage, PARSE_OPT_KEEP_DASHDASH);

int prefix_set = 0;

struct lock_file lock_file = LOCK_INIT;

const struct option read_tree_options[] = {

OPT_CALLBACK_F(0, "index-output", NULL, N_("file"),

N_("write resulting index to <file>"),

PARSE_OPT_NONEG, index_output_cb),

int autostash;

int committer_date_is_author_date;

int ignore_date;

int allow_empty_message;

int rebase_merges, rebase_cousins;

char *strategy, *strategy_opts;

int reapply_cherry_picks;

int fork_point;

int update_refs;

};

#define REBASE_OPTIONS_INIT { \

.default_backend = "merge", \

.flags = REBASE_NO_QUIET, \

.git_am_opts = STRVEC_INIT, \

.git_format_patch_opt = STRBUF_INIT, \

.fork_point = -1, \

}

static struct replay_opts get_replay_opts(const struct rebase_options *opts)

return write_basic_state(opts, head_name, onto, orig_head);

}

static int do_interactive_rebase(struct rebase_options *opts, unsigned flags)

{

int ret;

struct strvec make_script_args = STRVEC_INIT;

struct todo_list todo_list = TODO_LIST_INIT;

struct replay_opts replay = get_replay_opts(opts);

if (get_revision_ranges(opts->upstream, opts->onto, &opts->orig_head->object.oid,

&revisions, &shortrevisions))

&todo_list))

BUG("unusable todo list");

ret = complete_action(the_repository, &replay, flags,

shortrevisions, opts->onto_name, opts->onto,

opts->autosquash, opts->update_refs, &todo_list);

}

free(revisions);

free(shortrevisions);

todo_list_release(&todo_list);

}

if (!strcmp(var, "rebase.autosquash")) {

return 0;

}

}

if (!strcmp(var, "rebase.updaterefs")) {

return 0;

}

BUG_ON_OPT_NEG(unset);

BUG_ON_OPT_ARG(arg);

opts->type = REBASE_APPLY;

return 0;

BUG_ON_OPT_NEG(unset);

BUG_ON_OPT_ARG(arg);

return 0;

}

BUG_ON_OPT_NEG(unset);

BUG_ON_OPT_ARG(arg);

opts->type = REBASE_MERGE;

opts->flags |= REBASE_INTERACTIVE_EXPLICIT;

struct object_id branch_base;

int ignore_whitespace = 0;

const char *gpg_sign = NULL;

const char *rebase_merges = NULL;

struct string_list strategy_options = STRING_LIST_INIT_NODUP;

struct object_id squash_onto;

N_("GPG-sign commits"),

PARSE_OPT_OPTARG, NULL, (intptr_t) "" },

OPT_AUTOSTASH(&options.autostash),

N_("add exec lines after each commit of the "

"editable list")),

OPT_BOOL_F(0, "allow-empty-message",

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

git_config(rebase_config, &options);

/* options.gpg_sign_opt will be either "-S" or NULL */

gpg_sign = options.gpg_sign_opt ? "" : NULL;

if (options.fork_point < 0)

options.fork_point = 0;

}

if (options.root && options.fork_point > 0)

die(_("options '%s' and '%s' cannot be used together"), "--root", "--fork-point");

if (trace2_is_enabled()) {

if (is_merge(&options))

trace2_cmd_mode("interactive");

trace2_cmd_mode("interactive-exec");

else

trace2_cmd_mode(action_names[options.action]);

if (reset_head(the_repository, &ropts) < 0)

die(_("could not move back to %s"),

oid_to_hex(&options.orig_head->object.oid));

remove_branch_state(the_repository, 0);

ret = finish_rebase(&options);

goto cleanup;

if ((options.flags & REBASE_INTERACTIVE_EXPLICIT) ||

(options.action != ACTION_NONE) ||

allow_preemptive_ff = 0;

}

if (options.committer_date_is_author_date || options.ignore_date)

}

}

exit(1);

if (!(options.flags & REBASE_NO_QUIET))

if (options.empty != EMPTY_UNSPECIFIED)

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

if (gpg_sign)

options.gpg_sign_opt = xstrfmt("-S%s", gpg_sign);

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

if (rebase_merges) {

if (!*rebase_merges)

; /* default mode; do nothing */

if (strcmp(options.git_am_opts.v[i], "-q"))

break;

if (is_merge(&options))

die(_("apply options and merge options "

"cannot be used together"));

else

options.type = REBASE_APPLY;

}

}

if (options.type == REBASE_UNSPECIFIED) {

if (!strcmp(options.default_backend, "merge"))

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

if (options.empty == EMPTY_UNSPECIFIED) {

if (options.flags & REBASE_INTERACTIVE_EXPLICIT)

options.empty = EMPTY_ASK;

options.empty = EMPTY_KEEP;

else

options.empty = EMPTY_DROP;

strbuf_release(&revisions);

free(options.reflog_action);

free(options.head_name);

free(options.gpg_sign_opt);

free(options.strategy);

strbuf_release(&options.git_format_patch_opt);

free(squash_onto_name);

return !!ret;

}

while (1) {

size_t i;

if (!fgets(buffer, MAXCOMMAND - 1, stdin)) {

if (ferror(stdin))

die("Command input error");

if (!strcmp(buffer, "capabilities")) {

printf("*connect\n\n");

fflush(stdout);

printf("\n");

fflush(stdout);

} else {

fprintf(stderr, "Bad command");

return 1;

if (!strcmp(buffer, "capabilities")) {

printf("*connect\n\n");

fflush(stdout);

printf("\n");

fflush(stdout);

if (bidirectional_transfer_loop(input_fd,

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

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

}

fclose(out);

ret = finish_command(&cmd);

if (ret)

string_list_clear(&existing_nonkept_packs, 0);

string_list_clear(&existing_kept_packs, 0);

clear_pack_geometry(geometry);

return 0;

}

NULL,

};

{

int i;

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

}

static void update_index_from_diff(struct diff_queue_struct *q,

{

int i;

int intent_to_add = *(int *)data;

if (!pathspec.nr)

remove_branch_state(the_repository, 0);

return update_ref_status;

}

strbuf_addstr(&parsed, " --");

sq_quote_argv(&parsed, argv);

puts(parsed.buf);

return 0;

}

opts->strategy = xstrdup_or_null(opts->strategy);

if (!opts->strategy && getenv("GIT_TEST_MERGE_ALGORITHM"))

opts->strategy = xstrdup(getenv("GIT_TEST_MERGE_ALGORITHM"));

if (cmd == 'q') {

int ret = sequencer_remove_state(opts);

opts.action = REPLAY_PICK;

sequencer_init_config(&opts);

res = run_sequencer(argc, argv, &opts);

if (res < 0)

die(_("cherry-pick failed"));

return res;

continue;

if (!submodule_uses_gitfile(name))

}

}

o.head_idx = -1;

o.src_index = r->index;

o.dst_index = r->index;

o.skip_sparse_checkout = 0;

o.pl = pl;

int ret = 0;

struct strbuf untracked_msg = STRBUF_INIT;

struct child_process cp_upd_index = CHILD_PROCESS_INIT;

cp_upd_index.git_cmd = 1;

strvec_pushl(&cp_upd_index.args, "update-index", "-z", "--add",

}

done:

strbuf_release(&untracked_msg);

remove_path(stash_index_path.buf);

return ret;

{

int ret = 0;

struct child_process cp_diff_tree = CHILD_PROCESS_INIT;

if (write_index_as_tree(&info->w_tree, &istate, the_repository->index_file,

0, NULL)) {

}

done:

return ret;

}

int ret = 0;

struct child_process cp_read_tree = CHILD_PROCESS_INIT;

struct child_process cp_diff_tree = CHILD_PROCESS_INIT;

char *old_index_env = NULL, *old_repo_index_file;

remove_path(stash_index_path.buf);

}

done:

remove_path(stash_index_path.buf);

return ret;

}

struct rev_info rev;

struct child_process cp_upd_index = CHILD_PROCESS_INIT;

struct strbuf diff_output = STRBUF_INIT;

init_revisions(&rev, NULL);

copy_pathspec(&rev.prune_data, ps);

}

done:

release_revisions(&rev);

strbuf_release(&diff_output);

remove_path(stash_index_path.buf);

}

done:

free_stash_info(&info);

strbuf_release(&stash_msg_buf);

return ret;

}

}

/* the result should be freed by the caller. */

{

if (prefix && super_prefix) {

BUG("cannot have prefix '%s' and superprefix '%s'",

prefix, super_prefix);

int argc;

const char **argv;

const char *prefix;

int quiet;

int recursive;

};

struct child_process cp = CHILD_PROCESS_INIT;

char *displaypath;

sub = submodule_from_path(the_repository, null_oid(), path);

cpr.dir = path;

prepare_submodule_repo_env(&cpr.env);

strvec_pushl(&cpr.args, "submodule--helper", "foreach", "--recursive",

NULL);

if (info->quiet)

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

struct pathspec pathspec = { 0 };

struct module_list list = MODULE_LIST_INIT;

struct option module_foreach_options[] = {

OPT__QUIET(&info.quiet, N_("suppress output of entering each submodule command")),

OPT_BOOL(0, "recursive", &info.recursive,

N_("recurse into nested submodules")),

struct init_cb {

const char *prefix;

unsigned int flags;

};

#define INIT_CB_INIT { 0 }

static void init_submodule(const char *path, const char *prefix,

unsigned int flags)

{

const struct submodule *sub;

const char *upd;

char *url = NULL, *displaypath;

sub = submodule_from_path(the_repository, null_oid(), path);

{

struct init_cb *info = cb_data;

}

static int module_init(int argc, const char **argv, const char *prefix)

struct status_cb {

const char *prefix;

unsigned int flags;

};

#define STATUS_CB_INIT { 0 }

static void status_submodule(const char *path, const struct object_id *ce_oid,

unsigned int ce_flags, const char *prefix,

{

char *displaypath;

struct strvec diff_files_args = STRVEC_INIT;

die(_("no submodule mapping found in .gitmodules for path '%s'"),

path);

if ((CE_STAGEMASK & ce_flags) >> CE_STAGESHIFT) {

print_status(flags, 'U', path, null_oid(), displaypath);

cpr.dir = path;

prepare_submodule_repo_env(&cpr.env);

strvec_pushl(&cpr.args, "submodule--helper", "status",

"--recursive", NULL);

if (flags & OPT_CACHED)

strvec_push(&cpr.args, "--cached");

struct status_cb *info = cb_data;

status_submodule(list_item->name, &list_item->oid, list_item->ce_flags,

}

static int module_status(int argc, const char **argv, const char *prefix)

struct module_list list = MODULE_LIST_INIT;

int quiet = 0;

struct option module_status_options[] = {

OPT__QUIET(&quiet, N_("suppress submodule status output")),

OPT_BIT(0, "cached", &info.flags, N_("use commit stored in the index instead of the one stored in the submodule HEAD"), OPT_CACHED),

OPT_BIT(0, "recursive", &info.flags, N_("recurse into nested submodules"), OPT_RECURSIVE),

int argc;

const char **argv;

const char *prefix;

unsigned int cached: 1;

unsigned int for_status: 1;

unsigned int files: 1;

dst_abbrev = xstrndup(oid_to_hex(&p->oid_dst), 7);

}

if (!missing_src && !missing_dst) {

struct child_process cp_rev_list = CHILD_PROCESS_INIT;

}

static void submodule_summary_callback(struct diff_queue_struct *q,

void *data)

{

int i;

struct sync_cb {

const char *prefix;

unsigned int flags;

};

#define SYNC_CB_INIT { 0 }

static void sync_submodule(const char *path, const char *prefix,

{

const struct submodule *sub;

char *remote_key = NULL;

super_config_url = xstrdup("");

}

if (!(flags & OPT_QUIET))

printf(_("Synchronizing submodule url for '%s'\n"),

cpr.dir = path;

prepare_submodule_repo_env(&cpr.env);

strvec_pushl(&cpr.args, "submodule--helper", "sync",

"--recursive", NULL);

if (flags & OPT_QUIET)

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

{

struct sync_cb *info = cb_data;

}

static int module_sync(int argc, const char **argv, const char *prefix)

int quiet = 0;

int recursive = 0;

struct option module_sync_options[] = {

OPT__QUIET(&quiet, N_("suppress output of synchronizing submodule url")),

OPT_BOOL(0, "recursive", &recursive,

N_("recurse into nested submodules")),

if (!sub || !sub->name)

goto cleanup;

/* remove the submodule work tree (unless the user already did it) */

if (is_directory(path)) {

".git file by using absorbgitdirs."),

displaypath);

}

struct update_data {

const char *prefix;

char *displaypath;

enum submodule_update_type update_default;

struct object_id suboid;

enum submodule_update_type update_type;

char *key;

const struct update_data *ud = suc->update_data;

struct strbuf sb = STRBUF_INIT;

int needs_cloning = 0;

int need_free_url = 0;

{

enum submodule_update_type update_type = update_data->update_default;

if (update_data->displaypath) {

strvec_push(args, "--super-prefix");

strvec_pushf(args, "%s/", update_data->displaypath);

}

strvec_pushf(args, "--jobs=%d", update_data->max_jobs);

if (update_data->quiet)

strvec_push(args, "--quiet");

goto fail;

update_data->displaypath = get_submodule_displaypath(

code = update_submodule(update_data);

FREE_AND_NULL(update_data->displaypath);

fail:

LIST_OBJECTS_FILTER_INIT;

int ret;

struct option module_update_options[] = {

OPT__FORCE(&opt.force, N_("force checkout updates"), 0),

OPT_BOOL(0, "init", &opt.init,

N_("initialize uninitialized submodules before update")),

module_list_active(&list);

info.prefix = opt.prefix;

if (opt.quiet)

info.flags |= OPT_QUIET;

int i;

struct pathspec pathspec = { 0 };

struct module_list list = MODULE_LIST_INIT;

struct option embed_gitdir_options[] = {

OPT_END()

};

const char *const git_submodule_helper_usage[] = {

goto cleanup;

for (i = 0; i < list.nr; i++)

ret = 0;

cleanup:

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

config_set_in_gitmodules_file_gently(config_name, newurl);

free(config_name);

ensure_full_index(&the_index);

/*

*/

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

ce_path_match(&the_index, the_index.cache[i], &ps,

int cmd_submodule__helper(int argc, const char **argv, const char *prefix)

{

parse_opt_subcommand_fn *fn = NULL;

const char *const usage[] = {

N_("git submodule--helper <command>"),

OPT_END()

};

argc = parse_options(argc, argv, prefix, options, usage, 0);

return fn(argc, argv, prefix);

}

if (write_in_full(fd, buf, size) < 0)

die_errno("unable to write temp-file");

close(fd);

return path;

}

static const char *editor(int flag)

{

}

static const char *pager(int flag)

{ "GIT_COMMITTER_IDENT", git_committer_info },

{ "GIT_AUTHOR_IDENT", git_author_info },

{ "GIT_EDITOR", editor },

{ "GIT_PAGER", pager },

{ "GIT_DEFAULT_BRANCH", default_branch },

{ "", NULL },

printf("%s=%s\n", ptr->name, val);

}

{

struct git_var *ptr;

for (ptr = git_vars; ptr->read; ptr++) {

if (strcmp(var, ptr->name) == 0) {

}

}

}

static int show_config(const char *var, const char *value, void *cb)

int cmd_var(int argc, const char **argv, const char *prefix)

{

if (argc != 2)

usage(var_usage);

return 0;

}

git_config(git_default_config, NULL);

usage(var_usage);

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

return 0;

N_("try to match the new branch name with a remote-tracking branch")),

OPT_END()

};

memset(&opts, 0, sizeof(opts));

opts.checkout = 1;

die(_("--[no-]track can only be used if a new branch is created"));

}

}

static void show_worktree_porcelain(struct worktree *wt, int line_terminator)

static void validate_no_submodules(const struct worktree *wt)

{

struct strbuf path = STRBUF_INIT;

int i, found_submodules = 0;