{

int i;

char *fixed_buf, *buf, *orig, *target;

int preimage_limit;

if (preimage->nr + try_lno <= img->nr) {

if (match_end && (preimage->nr + try_lno != img->nr))

return 0;

} else if (ws_error_action == correct_ws_error &&

/*

*/

preimage_limit = img->nr - try_lno;

} else {

* use the whitespace from the preimage.

*/

extra_chars = preimage_end - preimage_eof;

update_pre_post_images(preimage, postimage,

return 1;

}

* but in this loop we will only handle the part of the

* preimage that falls within the file.

*/

orig = preimage->buf;

target = img->buf + try;

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

size_t oldlen = preimage->line[i].len;

size_t tgtlen = img->line[try_lno + i].len;

int match;

/* Try fixing the line in the preimage */

/* Try fixing the line in the target */

/*

* If they match, either the preimage was based on

* so we might as well take the fix together with their

* real change.

*/

if (!match)

goto unmatch_exit;

orig += oldlen;

target += tgtlen;

}

* false).

*/

for ( ; i < preimage->nr; i++) {

size_t oldlen = preimage->line[i].len;

int j;

/* Try fixing the line in the preimage */

goto unmatch_exit;

orig += oldlen;

}

/*

* has whitespace breakages unfixed, and fixing them makes the

* hunk match. Update the context lines in the postimage.

*/

update_pre_post_images(preimage, postimage,

return 1;

unmatch_exit:

return 0;

}

int match_beginning, match_end;

const char *patch = frag->patch;

int size = frag->size;

int new_blank_lines_at_end = 0;

unsigned long leading, trailing;

int pos, applied_pos;

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

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

oldlines = xmalloc(size);

old = oldlines;

while (size > 0) {

char first;

int len = linelen(patch, size);

int added_blank_line = 0;

int is_blank_context = 0;

if (!len)

break;

/* ... followed by '\No newline'; nothing */

break;

*old++ = '\n';

add_line_info(&preimage, "\n", 1, LINE_COMMON);

add_line_info(&postimage, "\n", 1, LINE_COMMON);

is_blank_context = 1;

if (first == '+' && no_add)

break;

if (first != '+' ||

!whitespace_error ||

ws_error_action != correct_ws_error) {

}

else {

}

(first == '+' ? 0 : LINE_COMMON));

if (first == '+' &&

(ws_rule & WS_BLANK_AT_EOF) &&

ws_blank_line(patch + 1, plen, ws_rule))

}

if (inaccurate_eof &&

old > oldlines && old[-1] == '\n' &&

old--;

}

leading = frag->leading;

pos = frag->newpos ? (frag->newpos - 1) : 0;

preimage.buf = oldlines;

preimage.len = old - oldlines;

preimage.line = preimage.line_allocated;

postimage.line = postimage.line_allocated;

}

free(oldlines);

free(preimage.line_allocated);

free(postimage.line_allocated);

if (stat_ret < 0) {

struct checkout costate;

/* checkout */

costate.base_dir = "";

costate.refresh_cache = 1;

if (checkout_entry(*ce, &costate, NULL) ||

lstat(old_name, st))

die("unable to remove %s from index", patch->old_name);

}

if (!cached) {

remove_path(patch->old_name);

}

}

int writeout_error;

const char *new_branch;

int new_branch_log;

enum branch_track track;

};

read_mmblob(&ours, active_cache[pos+1]->sha1);

read_mmblob(&theirs, active_cache[pos+2]->sha1);

&ours, "ours", &theirs, "theirs", 0);

free(ancestor.ptr);

free(ours.ptr);

ret = reset_tree(new->commit->tree, opts, 1);

if (ret)

return ret;

o.branch1 = new->name;

o.branch2 = "local";

merge_trees(&o, new->commit->tree, work,

struct strbuf msg = STRBUF_INIT;

const char *old_desc;

if (opts->new_branch) {

new->name = opts->new_branch;

setup_branch_path(new);

}

OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),

OPT_SET_INT('t', "track", &opts.track, "track",

BRANCH_TRACK_EXPLICIT),

OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",

2),

OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",

opts.new_branch = argv0 + 1;

}

if (conflict_style) {

opts.merge = 1; /* implied */

git_xmerge_config("merge.conflictstyle", conflict_style, NULL);

transport = transport_get(remote, src_repo);

ret = transport_get_remote_refs(transport);

transport_disconnect(transport);

return ret;

}

die("could not create leading directories of '%s'", git_dir);

set_git_dir(make_absolute_path(git_dir));

/*

* At this point, the config exists, so we do not need the

#include "builtin.h"

#include "utf8.h"

static const char commit_tree_usage[] = "git commit-tree <sha1> [-p <sha1>]* < changelog";

static void new_parent(struct commit *parent, struct commit_list **parents_p)

commit_list_insert(parent, parents_p);

}

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

{

int i;

if (get_sha1(b, sha1))

die("Not a valid object name %s", b);

new_parent(lookup_commit(sha1), &parents);

}

static char *author_name, *author_email, *author_date;

static int all, edit_flag, also, interactive, only, amend, signoff;

static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;

static char *untracked_files_arg, *force_date;

/*

* The default commit message cleanup mode will remove the lines

OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),

OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),

{ OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },

/* end commit contents options */

OPT_END()

};

* (B) on failure, rollback the real index.

*/

if (all || (also && pathspec && *pathspec)) {

add_files_to_cache(also ? prefix : NULL, pathspec, 0);

refresh_cache_or_die(refresh_flags);

if (write_cache(fd, active_cache, active_nr) ||

*

* (1) return the name of the real index file.

*

* We still need to refresh the index here.

*/

if (!pathspec || !*pathspec) {

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

{

struct wt_status s;

unsigned char sha1[20];

static struct option builtin_status_options[] = {

OPT__VERBOSE(&verbose),

read_cache_preload(s.pathspec);

refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);

s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;

s.in_merge = in_merge;

wt_status_collect(&s);

if (cleanup_mode != CLEANUP_NONE)

stripspace(&sb, cleanup_mode == CLEANUP_ALL);

rollback_index_files();

fprintf(stderr, "Aborting commit due to empty commit message.\n");

exit(1);

git_config_from_file(show_config, system_wide, NULL);

if (do_all && global)

git_config_from_file(show_config, global, NULL);

if (!do_all && !seen && global)

git_config_from_file(show_config, global, NULL);

if (!do_all && !seen && system_wide)

f = fopen(file, "w");

if (!f)

for (i = 0; i < idnums.size; i++) {

if (deco->base && deco->base->type == 1) {

#include "transport.h"

static const char * const builtin_fetch_usage[] = {

NULL

};

#include "diff.h"

#include "revision.h"

#include "tag.h"

static const char * const fmt_merge_msg_usage[] = {

"git fmt-merge-msg [--log|--no-log] [--file <file>]",

return 0;

}

};

{

}

static int handle_line(char *line)

{

unsigned char *sha1;

char *src, *origin;

struct src_data *src_data;

int pulling_head = 0;

if (len < 43 || line[40] != '\t')

pulling_head = 1;

}

}

if (pulling_head) {

src_data->head_status |= 1;

} else if (!prefixcmp(line, "branch ")) {

src_data->head_status |= 2;

} else if (!prefixcmp(line, "tag ")) {

origin = line;

src_data->head_status |= 2;

} else if (!prefixcmp(line, "remote branch ")) {

src_data->head_status |= 2;

} else {

src_data->head_status |= 2;

}

if (!strcmp(".", src) || !strcmp(src, origin)) {

int len = strlen(origin);

origin = xmemdupz(origin + 1, len - 2);

} else {

char *new_origin = xmalloc(strlen(origin) + strlen(src) + 5);

sprintf(new_origin, "%s of %s", origin, src);

origin = new_origin;

}

return 0;

}

static void print_joined(const char *singular, const char *plural,

{

if (list->nr == 0)

return;

if (list->nr == 1) {

} else {

int i;

strbuf_addstr(out, plural);

for (i = 0; i < list->nr - 1; i++)

}

}

int i, count = 0;

struct commit *commit;

struct object *branch;

int flags = UNINTERESTING | TREESAME | SEEN | SHOWN | ADDED;

branch = deref_tag(parse_object(sha1), sha1_to_hex(sha1), 40);

if (!branch || branch->type != OBJ_COMMIT)

if (prepare_revision_walk(rev))

die("revision walk setup failed");

while ((commit = get_revision(rev)) != NULL) {

/* ignore merges */

if (commit->parents && commit->parents->next)

if (subjects.nr > limit)

continue;

}

if (count > limit)

if (i >= limit)

strbuf_addf(out, " ...\n");

else

clear_commit_marks((struct commit *)branch, flags);

clear_commit_marks(head, flags);

rev->commits = NULL;

rev->pending.nr = 0;

}

int fmt_merge_msg(int merge_summary, struct strbuf *in, struct strbuf *out) {

die ("Error in line %d: %.*s", i, len, p);

}

strbuf_addstr(out, "Merge ");

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

const char *subsep = "";

strbuf_addstr(out, sep);

sep = "; ";

if (src_data->head_status == 1) {

continue;

}

if (src_data->head_status == 3) {

print_joined("commit ", "commits ", &src_data->generic,

out);

}

}

if (!strcmp("master", current_branch))

rev.limited = 1;

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

head, &rev, limit, out);

}

return 0;

const char *inpath = NULL;

struct option options[] = {

OPT_BOOLEAN(0, "log", &merge_summary, "populate log with the shortlog"),

OPT_FILENAME('F', "file", &inpath, "file to read from"),

OPT_END()

};

strcpy(s, sha1_to_hex(obj->sha1));

v->s = s;

}

}

}

/* Signalled when we are finished with everything. */

static pthread_cond_t cond_result;

static void add_work(enum work_type type, char *name, void *id)

{

grep_lock();

for(; todo[todo_done].done && todo_done != todo_start;

todo_done = (todo_done+1) % ARRAY_SIZE(todo)) {

w = &todo[todo_done];

free(w->name);

free(w->identifier);

}

if (online_cpus() == 1 || !grep_threads_ok(&opt))

use_threads = 0;

start_threads(&opt);

#else

use_threads = 0;

#endif

#include "exec_cmd.h"

static const char index_pack_usage[] =

struct object_entry

{

static char git_dir[PATH_MAX+1];

setenv(GIT_DIR_ENVIRONMENT,

}

if (init_shared_repository != -1)

static const char *default_date_mode = NULL;

static int default_show_root = 1;

static const char *fmt_patch_subject_prefix = "PATCH";

static const char *fmt_pretty;

"git log [<options>] [<since>..<until>] [[--] <path>...]\n"

" or: git show [options] <object>...";

static void cmd_log_init(int argc, const char **argv, const char *prefix,

struct rev_info *rev, struct setup_revision_opt *opt)

{

int i;

rev->abbrev = DEFAULT_ABBREV;

rev->commit_format = CMIT_FMT_DEFAULT;

usage(builtin_log_usage);

argc = setup_revisions(argc, argv, rev, opt);

rev->show_notes = 1;

if (rev->show_notes)

init_display_notes(&rev->notes_opt);

const char *arg = argv[i];

if (!strcmp(arg, "--decorate")) {

decoration_style = DECORATE_SHORT_REFS;

} else if (!prefixcmp(arg, "--decorate=")) {

const char *v = skip_prefix(arg, "--decorate=");

die("invalid --decorate option: %s", arg);

} else if (!strcmp(arg, "--source")) {

rev->show_source = 1;

} else if (!strcmp(arg, "-h")) {

} else

die("unrecognized argument: %s", arg);

}

if (decoration_style) {

rev->show_decorations = 1;

load_ref_decorations(decoration_style);

return git_config_string(&fmt_patch_subject_prefix, var, value);

if (!strcmp(var, "log.date"))

return git_config_string(&default_date_mode, var, value);

if (!strcmp(var, "log.showroot")) {

default_show_root = git_config_bool(var, value);

return 0;

return 0;

}

get_patch_ids(&rev, &ids, prefix);

if (!use_stdout)

realstdout = xfdopen(xdup(1), "w");

return -1;

}

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

{

struct rev_info revs;

const char *upstream;

const char *head = "HEAD";

const char *limit = NULL;

switch (argc) {

case 3:

/* FALLTHROUGH */

case 2:

break;

default:

current_branch = branch_get(NULL);

fprintf(stderr, "Could not find a tracked"

" remote branch, please"

" specify <upstream> manually.\n");

}

upstream = current_branch->merge[0]->dst;

pretty_print_commit(CMIT_FMT_ONELINE, commit,

&buf, &ctx);

printf("%c %s %s\n", sign,

strbuf_release(&buf);

}

else {

printf("%c %s\n", sign,

}

list = list->next;

printf("%s%06o %s %d\t",

tag,

ce->ce_mode,

ce_stage(ce));

}

write_name_quoted(ce->name + offset, stdout, line_terminator);

if (!ui->mode[i])

continue;

printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],

i + 1);

write_name_quoted(path + offset, stdout, line_terminator);

}

#include "remote.h"

static const char ls_remote_usage[] =

/*

* Is there one among the list of patterns that match the tail part

break;

}

if (argv[i]) {

int j;

pattern = xcalloc(sizeof(const char *), argc - i + 1);

}

}

remote = remote_get(dest);

if (!remote->url_nr)

die("remote %s has no configured URL", dest);

transport = transport_get(remote, NULL);

} else

strcpy(size_text, "-");

printf("%06o %s %s %7s\t", mode, type,

size_text);

} else

printf("%06o %s %s\t", mode, type,

}

write_name_quotedpfx(base + chomp_prefix, baselen - chomp_prefix,

pathname, stdout, line_termination);

continue;

}

if (i + 1 < len &&

in_perforation = 1;

perforation += 2;

scissors += 2;

argv[i]);

}

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

free(mmfs[i].ptr);

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

}

{

const char **args;

int i = 0, x = 0, ret;

struct commit_list *j;

struct strbuf buf = STRBUF_INIT;

int index_fd;

struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));

rollback_lock_file(lock);

if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree")) {

struct commit *result;

struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));

int index_fd;

struct commit_list *reversed = NULL;

struct merge_options o;

if (remoteheads->next) {

error("Not handling anything other than two heads merge.");

rollback_lock_file(lock);

return clean ? 0 : 1;

} else {

}

}

return ret;

}

{

struct tree *trees[MAX_UNPACK_TREES];

struct unpack_trees_options opts;

#include "string-list.h"

static const char * const git_notes_usage[] = {

"git notes [list [<object>]]",

"git notes edit [<object>]",

"git notes show [<object>]",

"git notes remove [<object>]",

"git notes prune",

NULL

};

return 0;

}

combine_notes_fn *parse_combine_notes_fn(const char *v)

{

if (!strcasecmp(v, "overwrite"))

return ret;

}

{

struct notes_tree *t;

const unsigned char *note;

const char *object_ref;

char logmsg[100];

struct msg_arg msg = { 0, 0, STRBUF_INIT };

struct option options[] = {

{ OPTION_CALLBACK, 'm', "message", &msg, "MSG",

"note contents as a string", PARSE_OPT_NONEG,

parse_msg_arg},

{ OPTION_CALLBACK, 'C', "reuse-message", &msg, "OBJECT",

"reuse specified note object", PARSE_OPT_NONEG,

parse_reuse_arg},

OPT_BOOLEAN('f', "force", &force, "replace existing notes"),

OPT_END()

};

}

}

}

}

error("too many parameters");

}

note = get_note(t, object);

}

}

}

}

if (is_null_sha1(new_note))

remove_note(t, object);

else

add_note(t, object, new_note, combine_notes_overwrite);

snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",

is_null_sha1(new_note) ? "removed" : "added", argv[0]);

commit_notes(t, logmsg);

free_notes(t);

strbuf_release(&(msg.buf));

return retval;

}

#include "parse-options.h"

static const char * const push_usage[] = {

NULL,

};

*/

static const char reflog_expire_usage[] =

static const char reflog_delete_usage[] =

"git reflog delete [--verbose] [--dry-run] [--rewrite] [--updateref] <refs>...";

FILE *newlog;

const char *ref;

struct commit *ref_commit;

struct cmd_reflog_expire_cb *cmd;

unsigned char last_kept_sha1[20];

};

return 1;

}

{

while (pending) {

struct commit_list *entry = pending;

struct commit_list *parent;

if (parse_commit(commit))

continue;

commit->object.flags |= REACHABLE;

continue;

parent = commit->parents;

while (parent) {

commit = parent->item;

commit_list_insert(commit, &pending);

}

}

}

static int expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,

cb.ref_commit = lookup_commit_reference_gently(sha1, 1);

cb.ref = ref;

cb.cmd = cmd;

for_each_reflog_ent(ref, expire_reflog_ent, &cb);

if (cb.ref_commit)

clear_commit_marks(cb.ref_commit, REACHABLE);

static const char * const git_reset_usage[] = {

"git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]",

NULL

};

*/

if (graph_show_remainder(revs->graph))

putchar('\n');

}

} else {

printf("%s%c", buf.buf, info->hdr_termination);

}

strbuf_release(&buf);

git_config(git_default_config, NULL);

init_revisions(&revs, prefix);

revs.commit_format = CMIT_FMT_UNSPECIFIED;

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

#include "revision.h"

#include "rerere.h"

#include "merge-recursive.h"

/*

* This implements the builtins revert and cherry-pick.

NULL

};

static enum { REVERT, CHERRY_PICK } action;

static struct commit *commit;

static const char *commit_name;

static int allow_rerere_auto;

static const char *me;

#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"

static void parse_args(int argc, const char **argv)

{

const char * const * usage_str =

OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),

OPT_INTEGER('m', "mainline", &mainline, "parent number"),

OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),

OPT_END(),

};

if (parse_options(argc, argv, NULL, options, usage_str, 0) != 1)

usage_with_options(usage_str, options);

exit(1);

}

{

int abbrev_len, oneline_len;

while (*p && (*p != '\n' || p[1] != '\n'))

p++;

if (*p) {

p += 2;

for (eol = p + 1; *eol && *eol != '\n'; eol++)

; /* do nothing */

} else

eol = p;

oneline_len = eol - p;

}

static char *get_encoding(const char *message)

return NULL;

}

{

const char *p = message;

while (*p && (*p != '\n' || p[1] != '\n'))

p++;

if (!*p)

p += 2;

}

static void set_author_ident_env(const char *message)

return strbuf_detach(&helpbuf, NULL);

}

static struct tree *empty_tree(void)

{

struct tree *tree = xcalloc(1, sizeof(struct tree));

}

}

{

struct merge_options o;

struct tree *result, *next_tree, *base_tree, *head_tree;

static struct lock_file index_lock;

git_config(git_default_config, NULL);

me = action == REVERT ? "revert" : "cherry-pick";

setenv(GIT_REFLOG_ACTION, me, 0);

if (action == REVERT && !no_replay)

die("revert is incompatible with replay");

if (read_cache() < 0)

die("git %s: failed to read the index", me);

if (no_commit) {

}

discard_cache();

if (!commit->parents) {

if (action == REVERT)

die ("Cannot revert a root commit");

else

parent = commit->parents->item;

if (parent && parse_commit(parent) < 0)

die("%s: cannot parse parent commit %s",

me, sha1_to_hex(parent->object.sha1));

/*

* "commit" is an existing commit. We would want to apply

* the difference it introduces since its first parent "prev"

* reverse of it if we are revert.

*/

if (action == REVERT) {

base = commit;

next = parent;

if (commit->parents->next) {

}

} else {

base = parent;

next = commit;

if (no_replay) {

}

}

}

}

/*

*

args[i] = NULL;

return execv_git_cmd(args);

}

free(defmsg);

return 0;

static int verify_tag(const char *name, const char *ref,

const unsigned char *sha1)

{

"-v", "SHA1_HEX", NULL};

argv_verify_tag[2] = sha1_to_hex(sha1);

return error("could not verify the tag '%s'", name);

return 0;

}