#include "notes-utils.h"
#include "rerere.h"
#include "prompt.h"
+#include "mailinfo.h"
/**
* Returns 1 if the file is empty or does not exist, 0 otherwise.
return !st.st_size;
}
-/**
- * Like strbuf_getline(), but treats both '\n' and "\r\n" as line terminators.
- */
-static int strbuf_getline_crlf(struct strbuf *sb, FILE *fp)
-{
- if (strbuf_getwholeline(sb, fp, '\n'))
- return EOF;
- if (sb->buf[sb->len - 1] == '\n') {
- strbuf_setlen(sb, sb->len - 1);
- if (sb->len > 0 && sb->buf[sb->len - 1] == '\r')
- strbuf_setlen(sb, sb->len - 1);
- }
- return 0;
-}
-
/**
* Returns the length of the first line of msg.
*/
struct strbuf sb = STRBUF_INIT;
const char *str;
- if (strbuf_getline(&sb, fp, '\n'))
+ if (strbuf_getline_lf(&sb, fp))
goto fail;
if (!skip_prefix(sb.buf, key, &str))
fp = xfopen(am_path(state, "rewritten"), "r");
- while (!strbuf_getline(&sb, fp, '\n')) {
+ while (!strbuf_getline_lf(&sb, fp)) {
unsigned char from_obj[GIT_SHA1_RAWSZ], to_obj[GIT_SHA1_RAWSZ];
if (sb.len != GIT_SHA1_HEXSZ * 2 + 1) {
if (regcomp(®ex, header_regex, REG_NOSUB | REG_EXTENDED))
die("invalid pattern: %s", header_regex);
- while (!strbuf_getline_crlf(&sb, fp)) {
+ while (!strbuf_getline(&sb, fp)) {
if (!sb.len)
break; /* End of header */
fp = xfopen(*paths, "r");
- while (!strbuf_getline_crlf(&l1, fp)) {
+ while (!strbuf_getline(&l1, fp)) {
if (l1.len)
break;
}
}
strbuf_reset(&l2);
- strbuf_getline_crlf(&l2, fp);
+ strbuf_getline(&l2, fp);
strbuf_reset(&l3);
- strbuf_getline_crlf(&l3, fp);
+ strbuf_getline(&l3, fp);
/*
* If the second line is empty and the third is a From, Author or Date
struct strbuf sb = STRBUF_INIT;
int subject_printed = 0;
- while (!strbuf_getline(&sb, in, '\n')) {
+ while (!strbuf_getline_lf(&sb, in)) {
const char *str;
if (str_isspace(sb.buf))
return error(_("could not open '%s' for reading: %s"), *paths,
strerror(errno));
- while (!strbuf_getline(&sb, fp, '\n')) {
+ while (!strbuf_getline_lf(&sb, fp)) {
if (*sb.buf == '#')
continue; /* skip comment lines */
{
struct strbuf sb = STRBUF_INIT;
- while (!strbuf_getline(&sb, in, '\n')) {
+ while (!strbuf_getline_lf(&sb, in)) {
const char *str;
if (skip_prefix(sb.buf, "# User ", &str))
static int parse_mail(struct am_state *state, const char *mail)
{
FILE *fp;
- struct child_process cp = CHILD_PROCESS_INIT;
struct strbuf sb = STRBUF_INIT;
struct strbuf msg = STRBUF_INIT;
struct strbuf author_name = STRBUF_INIT;
struct strbuf author_date = STRBUF_INIT;
struct strbuf author_email = STRBUF_INIT;
int ret = 0;
+ struct mailinfo mi;
- cp.git_cmd = 1;
- cp.in = xopen(mail, O_RDONLY, 0);
- cp.out = xopen(am_path(state, "info"), O_WRONLY | O_CREAT, 0777);
+ setup_mailinfo(&mi);
- argv_array_push(&cp.args, "mailinfo");
- argv_array_push(&cp.args, state->utf8 ? "-u" : "-n");
+ if (state->utf8)
+ mi.metainfo_charset = get_commit_output_encoding();
+ else
+ mi.metainfo_charset = NULL;
switch (state->keep) {
case KEEP_FALSE:
break;
case KEEP_TRUE:
- argv_array_push(&cp.args, "-k");
+ mi.keep_subject = 1;
break;
case KEEP_NON_PATCH:
- argv_array_push(&cp.args, "-b");
+ mi.keep_non_patch_brackets_in_subject = 1;
break;
default:
die("BUG: invalid value for state->keep");
}
if (state->message_id)
- argv_array_push(&cp.args, "-m");
+ mi.add_message_id = 1;
switch (state->scissors) {
case SCISSORS_UNSET:
break;
case SCISSORS_FALSE:
- argv_array_push(&cp.args, "--no-scissors");
+ mi.use_scissors = 0;
break;
case SCISSORS_TRUE:
- argv_array_push(&cp.args, "--scissors");
+ mi.use_scissors = 1;
break;
default:
die("BUG: invalid value for state->scissors");
}
- argv_array_push(&cp.args, am_path(state, "msg"));
- argv_array_push(&cp.args, am_path(state, "patch"));
-
- if (run_command(&cp) < 0)
+ mi.input = fopen(mail, "r");
+ if (!mi.input)
+ die("could not open input");
+ mi.output = fopen(am_path(state, "info"), "w");
+ if (!mi.output)
+ die("could not open output 'info'");
+ if (mailinfo(&mi, am_path(state, "msg"), am_path(state, "patch")))
die("could not parse patch");
- close(cp.in);
- close(cp.out);
+ fclose(mi.input);
+ fclose(mi.output);
/* Extract message and author information */
fp = xfopen(am_path(state, "info"), "r");
- while (!strbuf_getline(&sb, fp, '\n')) {
+ while (!strbuf_getline_lf(&sb, fp)) {
const char *x;
if (skip_prefix(sb.buf, "Subject: ", &x)) {
}
strbuf_addstr(&msg, "\n\n");
- if (strbuf_read_file(&msg, am_path(state, "msg"), 0) < 0)
- die_errno(_("could not read '%s'"), am_path(state, "msg"));
+ strbuf_addbuf(&msg, &mi.log_message);
strbuf_stripspace(&msg, 0);
if (state->signoff)
strbuf_release(&author_email);
strbuf_release(&author_name);
strbuf_release(&sb);
+ clear_mailinfo(&mi);
return ret;
}
FILE *fp = xfopen(mail, "r");
const char *x;
- if (strbuf_getline(&sb, fp, '\n'))
+ if (strbuf_getline_lf(&sb, fp))
return -1;
if (!skip_prefix(sb.buf, "From ", &x))
assert(!state->msg);
msg = strstr(buffer, "\n\n");
if (!msg)
- die(_("unable to parse commit %s"), sha1_to_hex(commit->object.sha1));
+ die(_("unable to parse commit %s"), oid_to_hex(&commit->object.oid));
state->msg = xstrdup(msg + 2);
state->msg_len = strlen(state->msg);
}
init_revisions(&rev_info, NULL);
rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;
- diff_opt_parse(&rev_info.diffopt, &diff_filter_str, 1);
+ diff_opt_parse(&rev_info.diffopt, &diff_filter_str, 1, rev_info.prefix);
add_pending_sha1(&rev_info, "HEAD", our_tree, 0);
diff_setup_done(&rev_info.diffopt);
run_diff_index(&rev_info, 1);
*/
if (!state->rebasing) {
am_destroy(state);
+ close_all_packs();
run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
}
}
*/
if (ent1->item->flags & UNINTERESTING)
swap = 1;
- sha1[swap] = ent0->item->sha1;
- sha1[1 - swap] = ent1->item->sha1;
+ sha1[swap] = ent0->item->oid.hash;
+ sha1[1 - swap] = ent1->item->oid.hash;
diff_tree_sha1(sha1[0], sha1[1], "", &revs->diffopt);
log_tree_diff_flush(revs);
return 0;
if (!revs->dense_combined_merges && !revs->combine_merges)
revs->dense_combined_merges = revs->combine_merges = 1;
for (i = 1; i < ents; i++)
- sha1_array_append(&parents, ent[i].item->sha1);
- diff_tree_combined(ent[0].item->sha1, &parents,
+ sha1_array_append(&parents, ent[i].item->oid.hash);
+ diff_tree_combined(ent[0].item->oid.hash, &parents,
revs->dense_combined_merges, revs);
sha1_array_clear(&parents);
return 0;
}
if (no_index)
/* If this is a no-index diff, just run it and exit there. */
- diff_no_index(&rev, argc, argv, prefix);
+ diff_no_index(&rev, argc, argv);
/* Otherwise, we are doing the usual "git" diff */
rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index;
const char *name = entry->name;
int flags = (obj->flags & UNINTERESTING);
if (!obj->parsed)
- obj = parse_object(obj->sha1);
+ obj = parse_object(obj->oid.hash);
obj = deref_tag(obj, NULL, 0);
if (!obj)
die(_("invalid object '%s' given."), name);
} else if (obj->type == OBJ_BLOB) {
if (2 <= blobs)
die(_("more than two blobs given: '%s'"), name);
- hashcpy(blob[blobs].sha1, obj->sha1);
+ hashcpy(blob[blobs].sha1, obj->oid.hash);
blob[blobs].name = name;
blob[blobs].mode = entry->mode;
blobs++;
if (name1) {
strbuf_addstr(&buffer1, name1);
- if (buffer1.len && buffer1.buf[buffer1.len - 1] != '/')
- strbuf_addch(&buffer1, '/');
+ strbuf_complete(&buffer1, '/');
len1 = buffer1.len;
}
if (name2) {
strbuf_addstr(&buffer2, name2);
- if (buffer2.len && buffer2.buf[buffer2.len - 1] != '/')
- strbuf_addch(&buffer2, '/');
+ strbuf_complete(&buffer2, '/');
len2 = buffer2.len;
}
}
void diff_no_index(struct rev_info *revs,
- int argc, const char **argv,
- const char *prefix)
+ int argc, const char **argv)
{
int i, prefixlen;
const char *paths[2];
struct strbuf replacement = STRBUF_INIT;
+ const char *prefix = revs->prefix;
diff_setup(&revs->diffopt);
for (i = 1; i < argc - 2; ) {
else if (!strcmp(argv[i], "--"))
i++;
else {
- j = diff_opt_parse(&revs->diffopt, argv + i, argc - i);
+ j = diff_opt_parse(&revs->diffopt, argv + i, argc - i,
+ revs->prefix);
if (j <= 0)
die("invalid diff option/value: %s", argv[i]);
i += j;
#include "run-command.h"
#include "utf8.h"
#include "userdiff.h"
-#include "sigchain.h"
#include "submodule-config.h"
#include "submodule.h"
#include "ll-merge.h"
*/
const char *name;
- char hex[41];
+ char hex[GIT_SHA1_HEXSZ + 1];
char mode[10];
/*
die_errno("unable to write temp-file");
close_tempfile(&temp->tempfile);
temp->name = get_tempfile_path(&temp->tempfile);
- strcpy(temp->hex, sha1_to_hex(sha1));
- temp->hex[40] = 0;
- sprintf(temp->mode, "%06o", mode);
+ sha1_to_hex_r(temp->hex, sha1);
+ xsnprintf(temp->mode, sizeof(temp->mode), "%06o", mode);
strbuf_release(&buf);
strbuf_release(&template);
free(path_dup);
* a '+' entry produces this for file-1.
*/
temp->name = "/dev/null";
- strcpy(temp->hex, ".");
- strcpy(temp->mode, ".");
+ xsnprintf(temp->hex, sizeof(temp->hex), ".");
+ xsnprintf(temp->mode, sizeof(temp->mode), ".");
return temp;
}
/* we can borrow from the file in the work tree */
temp->name = name;
if (!one->sha1_valid)
- strcpy(temp->hex, sha1_to_hex(null_sha1));
+ sha1_to_hex_r(temp->hex, null_sha1);
else
- strcpy(temp->hex, sha1_to_hex(one->sha1));
+ sha1_to_hex_r(temp->hex, one->sha1);
/* Even though we may sometimes borrow the
* contents from the work tree, we always want
* one->mode. mode is trustworthy even when
* !(one->sha1_valid), as long as
* DIFF_FILE_VALID(one).
*/
- sprintf(temp->mode, "%06o", one->mode);
+ xsnprintf(temp->mode, sizeof(temp->mode), "%06o", one->mode);
}
return temp;
}
return 1;
}
- int diff_opt_parse(struct diff_options *options, const char **av, int ac)
+ int diff_opt_parse(struct diff_options *options,
+ const char **av, int ac, const char *prefix)
{
const char *arg = av[0];
const char *optarg;
int argcount;
+ if (!prefix)
+ prefix = "";
+
/* Output format options */
if (!strcmp(arg, "-p") || !strcmp(arg, "-u") || !strcmp(arg, "--patch")
|| opt_arg(arg, 'U', "unified", &options->context))
else if (!strcmp(arg, "--pickaxe-regex"))
options->pickaxe_opts |= DIFF_PICKAXE_REGEX;
else if ((argcount = short_opt('O', av, &optarg))) {
- options->orderfile = optarg;
+ const char *path = prefix_filename(prefix, strlen(prefix), optarg);
+ options->orderfile = xstrdup(path);
return argcount;
}
else if ((argcount = parse_long_opt("diff-filter", av, &optarg))) {
else if (!strcmp(arg, "--no-function-context"))
DIFF_OPT_CLR(options, FUNCCONTEXT);
else if ((argcount = parse_long_opt("output", av, &optarg))) {
- options->file = fopen(optarg, "w");
+ const char *path = prefix_filename(prefix, strlen(prefix), optarg);
+ options->file = fopen(path, "w");
if (!options->file)
- die_errno("Could not open '%s'", optarg);
+ die_errno("Could not open '%s'", path);
options->close_file = 1;
return argcount;
} else
if (abblen < 37) {
static char hex[41];
if (len < abblen && abblen <= len + 2)
- sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
+ xsnprintf(hex, sizeof(hex), "%s%.*s", abbrev, len+3-abblen, "..");
else
- sprintf(hex, "%s...", abbrev);
+ xsnprintf(hex, sizeof(hex), "%s...", abbrev);
return hex;
}
return sha1_to_hex(sha1);
#define DIFF_OPT_DIRSTAT_BY_LINE (1 << 28)
#define DIFF_OPT_FUNCCONTEXT (1 << 29)
#define DIFF_OPT_PICKAXE_IGNORE_CASE (1 << 30)
-#define DIFF_OPT_DEFAULT_FOLLOW_RENAMES (1 << 31)
+#define DIFF_OPT_DEFAULT_FOLLOW_RENAMES (1U << 31)
#define DIFF_OPT_TST(opts, flag) ((opts)->flags & DIFF_OPT_##flag)
#define DIFF_OPT_TOUCHED(opts, flag) ((opts)->touched_flags & DIFF_OPT_##flag)
extern int git_diff_basic_config(const char *var, const char *value, void *cb);
extern int git_diff_ui_config(const char *var, const char *value, void *cb);
extern void diff_setup(struct diff_options *);
- extern int diff_opt_parse(struct diff_options *, const char **, int);
+ extern int diff_opt_parse(struct diff_options *, const char **, int, const char *);
extern void diff_setup_done(struct diff_options *);
#define DIFF_DETECT_RENAME 1
extern int diff_result_code(struct diff_options *, int);
- extern void diff_no_index(struct rev_info *, int, const char **, const char *);
+ extern void diff_no_index(struct rev_info *, int, const char **);
extern int index_differs_from(const char *def, int diff_flags);
}
n = xmalloc(len);
m = n + len - (nlen + 1);
- strcpy(m, name);
+ memcpy(m, name, nlen + 1);
for (p = path; p; p = p->up) {
if (p->elem_len) {
m -= p->elem_len + 1;
leaf.elem = component;
leaf.elem_len = strlen(component);
- fprintf(out, "%s ", sha1_to_hex(obj->sha1));
+ fprintf(out, "%s ", oid_to_hex(&obj->oid));
show_path_truncated(out, &leaf);
fputc('\n', out);
}
struct name_entry entry;
struct object *obj = &tree->object;
- if (!has_sha1_file(obj->sha1))
+ if (!has_object_file(&obj->oid))
return;
if (parse_tree(tree) < 0)
- die("bad tree %s", sha1_to_hex(obj->sha1));
+ die("bad tree %s", oid_to_hex(&obj->oid));
init_tree_desc(&desc, tree->buffer, tree->size);
while (tree_entry(&desc, &entry)) {
* it is popped next time around, we won't be trying
* to parse it and get an error.
*/
- if (!has_sha1_file(commit->object.sha1))
+ if (!has_object_file(&commit->object.oid))
commit->object.parsed = 1;
if (commit->object.flags & UNINTERESTING)
add_pending_object(revs, object, tag->tag);
if (!tag->tagged)
die("bad tag");
- object = parse_object(tag->tagged->sha1);
+ object = parse_object(tag->tagged->oid.hash);
if (!object) {
if (flags & UNINTERESTING)
return NULL;
- die("bad object %s", sha1_to_hex(tag->tagged->sha1));
+ die("bad object %s", oid_to_hex(&tag->tagged->oid));
}
object->flags |= flags;
/*
tree_difference = REV_TREE_SAME;
DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
- if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "",
+ if (diff_tree_sha1(t1->object.oid.hash, t2->object.oid.hash, "",
&revs->pruning) < 0)
return REV_TREE_DIFFERENT;
return tree_difference;
tree_difference = REV_TREE_SAME;
DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
- retval = diff_tree_sha1(NULL, t1->object.sha1, "", &revs->pruning);
+ retval = diff_tree_sha1(NULL, t1->object.oid.hash, "", &revs->pruning);
return retval >= 0 && (tree_difference == REV_TREE_SAME);
}
st = lookup_decoration(&revs->treesame, &commit->object);
if (!st)
- die("update_treesame %s", sha1_to_hex(commit->object.sha1));
+ die("update_treesame %s", oid_to_hex(&commit->object.oid));
relevant_parents = 0;
relevant_change = irrelevant_change = 0;
for (p = commit->parents, n = 0; p; n++, p = p->next) {
}
if (parse_commit(p) < 0)
die("cannot simplify commit %s (because of %s)",
- sha1_to_hex(commit->object.sha1),
- sha1_to_hex(p->object.sha1));
+ oid_to_hex(&commit->object.oid),
+ oid_to_hex(&p->object.oid));
switch (rev_compare_tree(revs, p, commit)) {
case REV_TREE_SAME:
if (!revs->simplify_history || !relevant_commit(p)) {
*/
if (parse_commit(p) < 0)
die("cannot simplify commit %s (invalid %s)",
- sha1_to_hex(commit->object.sha1),
- sha1_to_hex(p->object.sha1));
+ oid_to_hex(&commit->object.oid),
+ oid_to_hex(&p->object.oid));
p->parents = NULL;
}
/* fallthrough */
irrelevant_change = 1;
continue;
}
- die("bad tree compare for commit %s", sha1_to_hex(commit->object.sha1));
+ die("bad tree compare for commit %s", oid_to_hex(&commit->object.oid));
}
/*
{
while (commit_list) {
struct object *object = &commit_list->item->object;
- add_rev_cmdline(revs, object, sha1_to_hex(object->sha1),
+ add_rev_cmdline(revs, object, oid_to_hex(&object->oid),
whence, flags);
commit_list = commit_list->next;
}
break;
if (!((struct tag*)it)->tagged)
return 0;
- hashcpy(sha1, ((struct tag*)it)->tagged->sha1);
+ hashcpy(sha1, ((struct tag*)it)->tagged->oid.hash);
}
if (it->type != OBJ_COMMIT)
return 0;
while (commit_list) {
struct object *object = &commit_list->item->object;
object->flags |= flags;
- add_pending_object(revs, object, sha1_to_hex(object->sha1));
+ add_pending_object(revs, object, oid_to_hex(&object->oid));
commit_list = commit_list->next;
}
}
a = (a_obj->type == OBJ_COMMIT
? (struct commit *)a_obj
- : lookup_commit_reference(a_obj->sha1));
+ : lookup_commit_reference(a_obj->oid.hash));
b = (b_obj->type == OBJ_COMMIT
? (struct commit *)b_obj
- : lookup_commit_reference(b_obj->sha1));
+ : lookup_commit_reference(b_obj->oid.hash));
if (!a || !b)
goto missing;
exclude = get_merge_bases(a, b);
static void read_pathspec_from_stdin(struct rev_info *revs, struct strbuf *sb,
struct cmdline_pathspec *prune)
{
- while (strbuf_getwholeline(sb, stdin, '\n') != EOF) {
- int len = sb->len;
- if (len && sb->buf[len - 1] == '\n')
- sb->buf[--len] = '\0';
+ while (strbuf_getline(sb, stdin) != EOF) {
ALLOC_GROW(prune->path, prune->nr + 1, prune->alloc);
prune->path[prune->nr++] = xstrdup(sb->buf);
}
warn_on_object_refname_ambiguity = 0;
strbuf_init(&sb, 1000);
- while (strbuf_getwholeline(&sb, stdin, '\n') != EOF) {
+ while (strbuf_getline(&sb, stdin) != EOF) {
int len = sb.len;
- if (len && sb.buf[len - 1] == '\n')
- sb.buf[--len] = '\0';
if (!len)
break;
if (sb.buf[0] == '-') {
} else if (!strcmp(arg, "--ignore-missing")) {
revs->ignore_missing = 1;
} else {
- int opts = diff_opt_parse(&revs->diffopt, argv, argc);
+ int opts = diff_opt_parse(&revs->diffopt, argv, argc, revs->prefix);
if (!opts)
unkv[(*unkc)++] = arg;
return opts;
if (opt->show_notes) {
if (!buf.len)
strbuf_addstr(&buf, message);
- format_display_notes(commit->object.sha1, &buf, encoding, 1);
+ format_display_notes(commit->object.oid.hash, &buf, encoding, 1);
}
/*
{
if (commit->object.flags & SHOWN)
return commit_ignore;
- if (revs->unpacked && has_sha1_pack(commit->object.sha1))
+ if (revs->unpacked && has_sha1_pack(commit->object.oid.hash))
return commit_ignore;
if (revs->show_all)
return commit_show;
struct commit_list *p;
for (p = revs->previous_parents; p; p = p->next)
if (p->item == NULL || /* first commit */
- !hashcmp(p->item->object.sha1, commit->object.sha1))
+ !oidcmp(&p->item->object.oid, &commit->object.oid))
break;
revs->linear = p != NULL;
}
if (add_parents_to_list(revs, commit, &revs->commits, NULL) < 0) {
if (!revs->ignore_missing_links)
die("Failed to traverse parents of commit %s",
- sha1_to_hex(commit->object.sha1));
+ oid_to_hex(&commit->object.oid));
}
}
continue;
case commit_error:
die("Failed to simplify parents of commit %s",
- sha1_to_hex(commit->object.sha1));
+ oid_to_hex(&commit->object.oid));
default:
if (revs->track_linear)
track_linear(revs, commit);