mirror of
https://github.com/git/git.git
synced 2024-11-17 22:44:49 +01:00
Merge branch 'lt/logopt' into next
* lt/logopt: combine-diff: show diffstat with the first parent. git.c: LOGSIZE is unused after log printing cleanup. Log message printout cleanups (#3): fix --pretty=oneline Log message printout cleanups (#2) Log message printout cleanups rev-list --header: output format fix
This commit is contained in:
Junio C Hamano
commit
80608a61f0
11 changed files with 197 additions and 197 deletions
|
|
@ -5,6 +5,7 @@
|
|||
#include "diffcore.h"
|
||||
#include "quote.h"
|
||||
#include "xdiff-interface.h"
|
||||
#include "log-tree.h"
|
||||
|
||||
static int uninteresting(struct diff_filepair *p)
|
||||
{
|
||||
|
|
@ -584,10 +585,20 @@ static void reuse_combine_diff(struct sline *sline, unsigned long cnt,
|
|||
sline->p_lno[i] = sline->p_lno[j];
|
||||
}
|
||||
|
||||
static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
|
||||
int dense, const char *header,
|
||||
struct diff_options *opt)
|
||||
static void dump_quoted_path(const char *prefix, const char *path)
|
||||
{
|
||||
fputs(prefix, stdout);
|
||||
if (quote_c_style(path, NULL, NULL, 0))
|
||||
quote_c_style(path, NULL, stdout, 0);
|
||||
else
|
||||
printf("%s", path);
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
|
||||
int dense, struct rev_info *rev)
|
||||
{
|
||||
struct diff_options *opt = &rev->diffopt;
|
||||
unsigned long result_size, cnt, lno;
|
||||
char *result, *cp;
|
||||
struct sline *sline; /* survived lines */
|
||||
|
|
@ -688,16 +699,9 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
|
|||
if (show_hunks || mode_differs || working_tree_file) {
|
||||
const char *abb;
|
||||
|
||||
if (header) {
|
||||
shown_header++;
|
||||
printf("%s%c", header, opt->line_termination);
|
||||
}
|
||||
printf("diff --%s ", dense ? "cc" : "combined");
|
||||
if (quote_c_style(elem->path, NULL, NULL, 0))
|
||||
quote_c_style(elem->path, NULL, stdout, 0);
|
||||
else
|
||||
printf("%s", elem->path);
|
||||
putchar('\n');
|
||||
if (rev->loginfo)
|
||||
show_log(rev, rev->loginfo, "\n");
|
||||
dump_quoted_path(dense ? "diff --cc " : "diff --combined ", elem->path);
|
||||
printf("index ");
|
||||
for (i = 0; i < num_parent; i++) {
|
||||
abb = find_unique_abbrev(elem->parent[i].sha1,
|
||||
|
|
@ -728,6 +732,8 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
|
|||
}
|
||||
putchar('\n');
|
||||
}
|
||||
dump_quoted_path("--- a/", elem->path);
|
||||
dump_quoted_path("+++ b/", elem->path);
|
||||
dump_sline(sline, cnt, num_parent);
|
||||
}
|
||||
free(result);
|
||||
|
|
@ -749,8 +755,9 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
|
|||
|
||||
#define COLONS "::::::::::::::::::::::::::::::::"
|
||||
|
||||
static void show_raw_diff(struct combine_diff_path *p, int num_parent, const char *header, struct diff_options *opt)
|
||||
static void show_raw_diff(struct combine_diff_path *p, int num_parent, struct rev_info *rev)
|
||||
{
|
||||
struct diff_options *opt = &rev->diffopt;
|
||||
int i, offset;
|
||||
const char *prefix;
|
||||
int line_termination, inter_name_termination;
|
||||
|
|
@ -760,8 +767,8 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, const cha
|
|||
if (!line_termination)
|
||||
inter_name_termination = 0;
|
||||
|
||||
if (header)
|
||||
printf("%s%c", header, line_termination);
|
||||
if (rev->loginfo)
|
||||
show_log(rev, rev->loginfo, "\n");
|
||||
|
||||
if (opt->output_format == DIFF_FORMAT_RAW) {
|
||||
offset = strlen(COLONS) - num_parent;
|
||||
|
|
@ -802,40 +809,44 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, const cha
|
|||
}
|
||||
}
|
||||
|
||||
int show_combined_diff(struct combine_diff_path *p,
|
||||
void show_combined_diff(struct combine_diff_path *p,
|
||||
int num_parent,
|
||||
int dense,
|
||||
const char *header,
|
||||
struct diff_options *opt)
|
||||
struct rev_info *rev)
|
||||
{
|
||||
struct diff_options *opt = &rev->diffopt;
|
||||
if (!p->len)
|
||||
return 0;
|
||||
return;
|
||||
switch (opt->output_format) {
|
||||
case DIFF_FORMAT_RAW:
|
||||
case DIFF_FORMAT_NAME_STATUS:
|
||||
case DIFF_FORMAT_NAME:
|
||||
show_raw_diff(p, num_parent, header, opt);
|
||||
return 1;
|
||||
|
||||
default:
|
||||
show_raw_diff(p, num_parent, rev);
|
||||
return;
|
||||
case DIFF_FORMAT_PATCH:
|
||||
return show_patch_diff(p, num_parent, dense, header, opt);
|
||||
show_patch_diff(p, num_parent, dense, rev);
|
||||
return;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const char *diff_tree_combined_merge(const unsigned char *sha1,
|
||||
const char *header, int dense,
|
||||
struct diff_options *opt)
|
||||
void diff_tree_combined_merge(const unsigned char *sha1,
|
||||
int dense, struct rev_info *rev)
|
||||
{
|
||||
struct diff_options *opt = &rev->diffopt;
|
||||
struct commit *commit = lookup_commit(sha1);
|
||||
struct diff_options diffopts;
|
||||
struct commit_list *parents;
|
||||
struct combine_diff_path *p, *paths = NULL;
|
||||
int num_parent, i, num_paths;
|
||||
int do_diffstat;
|
||||
|
||||
do_diffstat = (opt->output_format == DIFF_FORMAT_DIFFSTAT ||
|
||||
opt->with_stat);
|
||||
diffopts = *opt;
|
||||
diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
|
||||
diffopts.with_raw = 0;
|
||||
diffopts.with_stat = 0;
|
||||
diffopts.recursive = 1;
|
||||
|
||||
/* count parents */
|
||||
|
|
@ -849,11 +860,24 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
|
|||
parents;
|
||||
parents = parents->next, i++) {
|
||||
struct commit *parent = parents->item;
|
||||
/* show stat against the first parent even
|
||||
* when doing combined diff.
|
||||
*/
|
||||
if (i == 0 && do_diffstat)
|
||||
diffopts.output_format = DIFF_FORMAT_DIFFSTAT;
|
||||
else
|
||||
diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
|
||||
diff_tree_sha1(parent->object.sha1, commit->object.sha1, "",
|
||||
&diffopts);
|
||||
diffcore_std(&diffopts);
|
||||
paths = intersect_paths(paths, i, num_parent);
|
||||
|
||||
if (do_diffstat && rev->loginfo)
|
||||
show_log(rev, rev->loginfo,
|
||||
opt->with_stat ? "---\n" : "\n");
|
||||
diff_flush(&diffopts);
|
||||
if (opt->with_stat)
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
/* find out surviving paths */
|
||||
|
|
@ -866,17 +890,13 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
|
|||
int saved_format = opt->output_format;
|
||||
opt->output_format = DIFF_FORMAT_RAW;
|
||||
for (p = paths; p; p = p->next) {
|
||||
if (show_combined_diff(p, num_parent, dense,
|
||||
header, opt))
|
||||
header = NULL;
|
||||
show_combined_diff(p, num_parent, dense, rev);
|
||||
}
|
||||
opt->output_format = saved_format;
|
||||
putchar(opt->line_termination);
|
||||
}
|
||||
for (p = paths; p; p = p->next) {
|
||||
if (show_combined_diff(p, num_parent, dense,
|
||||
header, opt))
|
||||
header = NULL;
|
||||
show_combined_diff(p, num_parent, dense, rev);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -886,5 +906,4 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
|
|||
paths = paths->next;
|
||||
free(tmp);
|
||||
}
|
||||
return header;
|
||||
}
|
||||
|
|
|
|||
27
diff-files.c
27
diff-files.c
|
|
@ -5,12 +5,14 @@
|
|||
*/
|
||||
#include "cache.h"
|
||||
#include "diff.h"
|
||||
#include "commit.h"
|
||||
#include "revision.h"
|
||||
|
||||
static const char diff_files_usage[] =
|
||||
"git-diff-files [-q] [-0/-1/2/3 |-c|--cc] [<common diff options>] [<path>...]"
|
||||
COMMON_DIFF_OPTIONS_HELP;
|
||||
|
||||
static struct diff_options diff_options;
|
||||
static struct rev_info rev;
|
||||
static int silent = 0;
|
||||
static int diff_unmerged_stage = 2;
|
||||
static int combine_merges = 0;
|
||||
|
|
@ -18,12 +20,12 @@ static int dense_combined_merges = 0;
|
|||
|
||||
static void show_unmerge(const char *path)
|
||||
{
|
||||
diff_unmerge(&diff_options, path);
|
||||
diff_unmerge(&rev.diffopt, path);
|
||||
}
|
||||
|
||||
static void show_file(int pfx, struct cache_entry *ce)
|
||||
{
|
||||
diff_addremove(&diff_options, pfx, ntohl(ce->ce_mode),
|
||||
diff_addremove(&rev.diffopt, pfx, ntohl(ce->ce_mode),
|
||||
ce->sha1, ce->name, NULL);
|
||||
}
|
||||
|
||||
|
|
@ -31,7 +33,7 @@ static void show_modified(int oldmode, int mode,
|
|||
const unsigned char *old_sha1, const unsigned char *sha1,
|
||||
char *path)
|
||||
{
|
||||
diff_change(&diff_options, oldmode, mode, old_sha1, sha1, path, NULL);
|
||||
diff_change(&rev.diffopt, oldmode, mode, old_sha1, sha1, path, NULL);
|
||||
}
|
||||
|
||||
int main(int argc, const char **argv)
|
||||
|
|
@ -41,7 +43,7 @@ int main(int argc, const char **argv)
|
|||
int entries, i;
|
||||
|
||||
git_config(git_diff_config);
|
||||
diff_setup(&diff_options);
|
||||
diff_setup(&rev.diffopt);
|
||||
while (1 < argc && argv[1][0] == '-') {
|
||||
if (!strcmp(argv[1], "--")) {
|
||||
argv++;
|
||||
|
|
@ -74,7 +76,7 @@ int main(int argc, const char **argv)
|
|||
dense_combined_merges = combine_merges = 1;
|
||||
else {
|
||||
int diff_opt_cnt;
|
||||
diff_opt_cnt = diff_opt_parse(&diff_options,
|
||||
diff_opt_cnt = diff_opt_parse(&rev.diffopt,
|
||||
argv+1, argc-1);
|
||||
if (diff_opt_cnt < 0)
|
||||
usage(diff_files_usage);
|
||||
|
|
@ -89,13 +91,13 @@ int main(int argc, const char **argv)
|
|||
argv++; argc--;
|
||||
}
|
||||
if (dense_combined_merges)
|
||||
diff_options.output_format = DIFF_FORMAT_PATCH;
|
||||
rev.diffopt.output_format = DIFF_FORMAT_PATCH;
|
||||
|
||||
/* Find the directory, and set up the pathspec */
|
||||
pathspec = get_pathspec(prefix, argv + 1);
|
||||
entries = read_cache();
|
||||
|
||||
if (diff_setup_done(&diff_options) < 0)
|
||||
if (diff_setup_done(&rev.diffopt) < 0)
|
||||
usage(diff_files_usage);
|
||||
|
||||
/* At this point, if argc == 1, then we are doing everything.
|
||||
|
|
@ -167,8 +169,7 @@ int main(int argc, const char **argv)
|
|||
if (combine_merges && num_compare_stages == 2) {
|
||||
show_combined_diff(&combine.p, 2,
|
||||
dense_combined_merges,
|
||||
NULL,
|
||||
&diff_options);
|
||||
&rev);
|
||||
free(combine.p.path);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -194,7 +195,7 @@ int main(int argc, const char **argv)
|
|||
continue;
|
||||
}
|
||||
changed = ce_match_stat(ce, &st, 0);
|
||||
if (!changed && !diff_options.find_copies_harder)
|
||||
if (!changed && !rev.diffopt.find_copies_harder)
|
||||
continue;
|
||||
oldmode = ntohl(ce->ce_mode);
|
||||
|
||||
|
|
@ -207,7 +208,7 @@ int main(int argc, const char **argv)
|
|||
ce->sha1, (changed ? null_sha1 : ce->sha1),
|
||||
ce->name);
|
||||
}
|
||||
diffcore_std(&diff_options);
|
||||
diff_flush(&diff_options);
|
||||
diffcore_std(&rev.diffopt);
|
||||
diff_flush(&rev.diffopt);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ int main(int argc, const char **argv)
|
|||
nr_sha1 = 0;
|
||||
init_revisions(opt);
|
||||
opt->abbrev = 0;
|
||||
opt->diff = 1;
|
||||
argc = setup_revisions(argc, argv, opt, NULL);
|
||||
|
||||
while (--argc > 0) {
|
||||
|
|
|
|||
8
diff.h
8
diff.h
|
|
@ -6,6 +6,7 @@
|
|||
|
||||
#include "tree-walk.h"
|
||||
|
||||
struct rev_info;
|
||||
struct diff_options;
|
||||
|
||||
typedef void (*change_fn_t)(struct diff_options *options,
|
||||
|
|
@ -70,11 +71,10 @@ struct combine_diff_path {
|
|||
(sizeof(struct combine_diff_path) + \
|
||||
sizeof(struct combine_diff_parent) * (n) + (l) + 1)
|
||||
|
||||
extern int show_combined_diff(struct combine_diff_path *elem, int num_parent,
|
||||
int dense, const char *header,
|
||||
struct diff_options *);
|
||||
extern void show_combined_diff(struct combine_diff_path *elem, int num_parent,
|
||||
int dense, struct rev_info *);
|
||||
|
||||
extern const char *diff_tree_combined_merge(const unsigned char *sha1, const char *, int, struct diff_options *opt);
|
||||
extern void diff_tree_combined_merge(const unsigned char *sha1, int, struct rev_info *);
|
||||
|
||||
extern void diff_addremove(struct diff_options *,
|
||||
int addremove,
|
||||
|
|
|
|||
59
git.c
59
git.c
|
|
@ -276,81 +276,26 @@ static int cmd_help(int argc, const char **argv, char **envp)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define LOGSIZE (65536)
|
||||
|
||||
static int cmd_log_wc(int argc, const char **argv, char **envp,
|
||||
struct rev_info *rev)
|
||||
{
|
||||
struct commit *commit;
|
||||
char *buf = xmalloc(LOGSIZE);
|
||||
const char *commit_prefix = "commit ";
|
||||
int shown = 0;
|
||||
|
||||
rev->abbrev = DEFAULT_ABBREV;
|
||||
rev->commit_format = CMIT_FMT_DEFAULT;
|
||||
rev->verbose_header = 1;
|
||||
argc = setup_revisions(argc, argv, rev, "HEAD");
|
||||
|
||||
if (argc > 1)
|
||||
die("unrecognized argument: %s", argv[1]);
|
||||
if (rev->commit_format == CMIT_FMT_ONELINE)
|
||||
commit_prefix = "";
|
||||
|
||||
prepare_revision_walk(rev);
|
||||
setup_pager();
|
||||
while ((commit = get_revision(rev)) != NULL) {
|
||||
unsigned long ofs = 0;
|
||||
|
||||
if (shown && rev->diff &&
|
||||
rev->commit_format != CMIT_FMT_ONELINE)
|
||||
putchar('\n');
|
||||
|
||||
ofs = sprintf(buf, "%s", commit_prefix);
|
||||
if (rev->abbrev_commit && rev->abbrev)
|
||||
ofs += sprintf(buf + ofs, "%s",
|
||||
find_unique_abbrev(commit->object.sha1,
|
||||
rev->abbrev));
|
||||
else
|
||||
ofs += sprintf(buf + ofs, "%s",
|
||||
sha1_to_hex(commit->object.sha1));
|
||||
if (rev->parents) {
|
||||
struct commit_list *parents = commit->parents;
|
||||
while (parents) {
|
||||
struct object *o = &(parents->item->object);
|
||||
parents = parents->next;
|
||||
if (o->flags & TMP_MARK)
|
||||
continue;
|
||||
ofs += sprintf(buf + ofs, " %s",
|
||||
sha1_to_hex(o->sha1));
|
||||
o->flags |= TMP_MARK;
|
||||
}
|
||||
/* TMP_MARK is a general purpose flag that can
|
||||
* be used locally, but the user should clean
|
||||
* things up after it is done with them.
|
||||
*/
|
||||
for (parents = commit->parents;
|
||||
parents;
|
||||
parents = parents->next)
|
||||
parents->item->object.flags &= ~TMP_MARK;
|
||||
}
|
||||
buf[ofs++] =
|
||||
(rev->commit_format == CMIT_FMT_ONELINE) ? ' ' : '\n';
|
||||
ofs += pretty_print_commit(rev->commit_format, commit, ~0,
|
||||
buf + ofs,
|
||||
LOGSIZE - ofs - 20,
|
||||
rev->abbrev);
|
||||
|
||||
if (rev->diff) {
|
||||
rev->use_precomputed_header = buf;
|
||||
strcpy(buf + ofs, "\n---\n");
|
||||
log_tree_commit(rev, commit);
|
||||
}
|
||||
else
|
||||
printf("%s\n", buf);
|
||||
shown = 1;
|
||||
log_tree_commit(rev, commit);
|
||||
free(commit->buffer);
|
||||
commit->buffer = NULL;
|
||||
}
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
176
log-tree.c
176
log-tree.c
|
|
@ -3,9 +3,58 @@
|
|||
#include "commit.h"
|
||||
#include "log-tree.h"
|
||||
|
||||
void show_log(struct rev_info *opt, struct log_info *log, const char *sep)
|
||||
{
|
||||
static char this_header[16384];
|
||||
struct commit *commit = log->commit, *parent = log->parent;
|
||||
int abbrev = opt->diffopt.abbrev;
|
||||
int abbrev_commit = opt->abbrev_commit ? opt->abbrev : 40;
|
||||
const char *extra;
|
||||
int len;
|
||||
|
||||
opt->loginfo = NULL;
|
||||
if (!opt->verbose_header) {
|
||||
puts(sha1_to_hex(commit->object.sha1));
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* The "oneline" format has several special cases:
|
||||
* - The pretty-printed commit lacks a newline at the end
|
||||
* of the buffer, but we do want to make sure that we
|
||||
* have a newline there. If the separator isn't already
|
||||
* a newline, add an extra one.
|
||||
* - unlike other log messages, the one-line format does
|
||||
* not have an empty line between entries.
|
||||
*/
|
||||
extra = "";
|
||||
if (*sep != '\n' && opt->commit_format == CMIT_FMT_ONELINE)
|
||||
extra = "\n";
|
||||
if (opt->shown_one && opt->commit_format != CMIT_FMT_ONELINE)
|
||||
putchar('\n');
|
||||
opt->shown_one = 1;
|
||||
|
||||
/*
|
||||
* Print header line of header..
|
||||
*/
|
||||
printf("%s%s",
|
||||
opt->commit_format == CMIT_FMT_ONELINE ? "" : "commit ",
|
||||
diff_unique_abbrev(commit->object.sha1, abbrev_commit));
|
||||
if (parent)
|
||||
printf(" (from %s)", diff_unique_abbrev(parent->object.sha1, abbrev_commit));
|
||||
putchar(opt->commit_format == CMIT_FMT_ONELINE ? ' ' : '\n');
|
||||
|
||||
/*
|
||||
* And then the pretty-printed message itself
|
||||
*/
|
||||
len = pretty_print_commit(opt->commit_format, commit, ~0u, this_header, sizeof(this_header), abbrev);
|
||||
printf("%s%s%s", this_header, extra, sep);
|
||||
}
|
||||
|
||||
int log_tree_diff_flush(struct rev_info *opt)
|
||||
{
|
||||
diffcore_std(&opt->diffopt);
|
||||
|
||||
if (diff_queue_is_empty()) {
|
||||
int saved_fmt = opt->diffopt.output_format;
|
||||
opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
|
||||
|
|
@ -13,12 +62,9 @@ int log_tree_diff_flush(struct rev_info *opt)
|
|||
opt->diffopt.output_format = saved_fmt;
|
||||
return 0;
|
||||
}
|
||||
if (opt->header) {
|
||||
if (!opt->no_commit_id)
|
||||
printf("%s%c", opt->header,
|
||||
opt->diffopt.line_termination);
|
||||
opt->header = NULL;
|
||||
}
|
||||
|
||||
if (opt->loginfo && !opt->no_commit_id)
|
||||
show_log(opt, opt->loginfo, opt->diffopt.with_stat ? "---\n" : "\n");
|
||||
diff_flush(&opt->diffopt);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -43,96 +89,78 @@ static int diff_root_tree(struct rev_info *opt,
|
|||
return retval;
|
||||
}
|
||||
|
||||
static const char *get_header(struct rev_info *opt,
|
||||
const unsigned char *commit_sha1,
|
||||
const unsigned char *parent_sha1,
|
||||
const struct commit *commit)
|
||||
{
|
||||
static char this_header[16384];
|
||||
int offset;
|
||||
unsigned long len;
|
||||
int abbrev = opt->diffopt.abbrev;
|
||||
const char *msg = commit->buffer;
|
||||
|
||||
if (opt->use_precomputed_header)
|
||||
return opt->use_precomputed_header;
|
||||
|
||||
if (!opt->verbose_header)
|
||||
return sha1_to_hex(commit_sha1);
|
||||
|
||||
len = strlen(msg);
|
||||
|
||||
offset = sprintf(this_header, "%s%s ",
|
||||
opt->header_prefix,
|
||||
diff_unique_abbrev(commit_sha1, abbrev));
|
||||
if (commit_sha1 != parent_sha1)
|
||||
offset += sprintf(this_header + offset, "(from %s)\n",
|
||||
parent_sha1
|
||||
? diff_unique_abbrev(parent_sha1, abbrev)
|
||||
: "root");
|
||||
else
|
||||
offset += sprintf(this_header + offset, "(from parents)\n");
|
||||
offset += pretty_print_commit(opt->commit_format, commit, len,
|
||||
this_header + offset,
|
||||
sizeof(this_header) - offset, abbrev);
|
||||
return this_header;
|
||||
}
|
||||
|
||||
static const char *generate_header(struct rev_info *opt,
|
||||
const unsigned char *commit_sha1,
|
||||
const unsigned char *parent_sha1,
|
||||
const struct commit *commit)
|
||||
{
|
||||
const char *header = get_header(opt, commit_sha1, parent_sha1, commit);
|
||||
|
||||
if (opt->always_show_header) {
|
||||
puts(header);
|
||||
header = NULL;
|
||||
}
|
||||
return header;
|
||||
}
|
||||
|
||||
static int do_diff_combined(struct rev_info *opt, struct commit *commit)
|
||||
{
|
||||
unsigned const char *sha1 = commit->object.sha1;
|
||||
|
||||
opt->header = generate_header(opt, sha1, sha1, commit);
|
||||
opt->header = diff_tree_combined_merge(sha1, opt->header,
|
||||
opt->dense_combined_merges,
|
||||
&opt->diffopt);
|
||||
if (!opt->header && opt->verbose_header)
|
||||
opt->header_prefix = "\ndiff-tree ";
|
||||
return 0;
|
||||
diff_tree_combined_merge(sha1, opt->dense_combined_merges, opt);
|
||||
return !opt->loginfo;
|
||||
}
|
||||
|
||||
int log_tree_commit(struct rev_info *opt, struct commit *commit)
|
||||
/*
|
||||
* Show the diff of a commit.
|
||||
*
|
||||
* Return true if we printed any log info messages
|
||||
*/
|
||||
static int log_tree_diff(struct rev_info *opt, struct commit *commit, struct log_info *log)
|
||||
{
|
||||
int showed_log;
|
||||
struct commit_list *parents;
|
||||
unsigned const char *sha1 = commit->object.sha1;
|
||||
|
||||
if (!opt->diff)
|
||||
return 0;
|
||||
|
||||
/* Root commit? */
|
||||
if (opt->show_root_diff && !commit->parents) {
|
||||
opt->header = generate_header(opt, sha1, NULL, commit);
|
||||
diff_root_tree(opt, sha1, "");
|
||||
parents = commit->parents;
|
||||
if (!parents) {
|
||||
if (opt->show_root_diff)
|
||||
diff_root_tree(opt, sha1, "");
|
||||
return !opt->loginfo;
|
||||
}
|
||||
|
||||
/* More than one parent? */
|
||||
if (commit->parents && commit->parents->next) {
|
||||
if (parents && parents->next) {
|
||||
if (opt->ignore_merges)
|
||||
return 0;
|
||||
else if (opt->combine_merges)
|
||||
return do_diff_combined(opt, commit);
|
||||
|
||||
/* If we show individual diffs, show the parent info */
|
||||
log->parent = parents->item;
|
||||
}
|
||||
|
||||
for (parents = commit->parents; parents; parents = parents->next) {
|
||||
showed_log = 0;
|
||||
for (;;) {
|
||||
struct commit *parent = parents->item;
|
||||
unsigned const char *psha1 = parent->object.sha1;
|
||||
opt->header = generate_header(opt, sha1, psha1, commit);
|
||||
diff_tree_sha1(psha1, sha1, "", &opt->diffopt);
|
||||
log_tree_diff_flush(opt);
|
||||
|
||||
if (!opt->header && opt->verbose_header)
|
||||
opt->header_prefix = "\ndiff-tree ";
|
||||
diff_tree_sha1(parent->object.sha1, sha1, "", &opt->diffopt);
|
||||
log_tree_diff_flush(opt);
|
||||
|
||||
showed_log |= !opt->loginfo;
|
||||
|
||||
/* Set up the log info for the next parent, if any.. */
|
||||
parents = parents->next;
|
||||
if (!parents)
|
||||
break;
|
||||
log->parent = parents->item;
|
||||
opt->loginfo = log;
|
||||
}
|
||||
return showed_log;
|
||||
}
|
||||
|
||||
int log_tree_commit(struct rev_info *opt, struct commit *commit)
|
||||
{
|
||||
struct log_info log;
|
||||
|
||||
log.commit = commit;
|
||||
log.parent = NULL;
|
||||
opt->loginfo = &log;
|
||||
|
||||
if (!log_tree_diff(opt, commit, &log) && opt->loginfo && opt->always_show_header) {
|
||||
log.parent = NULL;
|
||||
show_log(opt, opt->loginfo, "");
|
||||
}
|
||||
opt->loginfo = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,14 @@
|
|||
|
||||
#include "revision.h"
|
||||
|
||||
struct log_info {
|
||||
struct commit *commit, *parent;
|
||||
};
|
||||
|
||||
void init_log_tree_opt(struct rev_info *);
|
||||
int log_tree_diff_flush(struct rev_info *);
|
||||
int log_tree_commit(struct rev_info *, struct commit *);
|
||||
int log_tree_opt_parse(struct rev_info *, const char **, int);
|
||||
void show_log(struct rev_info *opt, struct log_info *log, const char *sep);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
12
rev-list.c
12
rev-list.c
|
|
@ -41,13 +41,14 @@ struct rev_info revs;
|
|||
static int bisect_list = 0;
|
||||
static int show_timestamp = 0;
|
||||
static int hdr_termination = 0;
|
||||
static const char *header_prefix;
|
||||
|
||||
static void show_commit(struct commit *commit)
|
||||
{
|
||||
if (show_timestamp)
|
||||
printf("%lu ", commit->date);
|
||||
if (*revs.header_prefix)
|
||||
fputs(revs.header_prefix, stdout);
|
||||
if (header_prefix)
|
||||
fputs(header_prefix, stdout);
|
||||
if (commit->object.flags & BOUNDARY)
|
||||
putchar('-');
|
||||
if (revs.abbrev_commit && revs.abbrev)
|
||||
|
|
@ -322,10 +323,13 @@ int main(int argc, const char **argv)
|
|||
/* The command line has a --pretty */
|
||||
hdr_termination = '\n';
|
||||
if (revs.commit_format == CMIT_FMT_ONELINE)
|
||||
revs.header_prefix = "";
|
||||
header_prefix = "";
|
||||
else
|
||||
revs.header_prefix = "commit ";
|
||||
header_prefix = "commit ";
|
||||
}
|
||||
else if (revs.verbose_header)
|
||||
/* Only --header was specified */
|
||||
revs.commit_format = CMIT_FMT_RAW;
|
||||
|
||||
list = revs.commits;
|
||||
|
||||
|
|
|
|||
|
|
@ -498,7 +498,6 @@ void init_revisions(struct rev_info *revs)
|
|||
revs->topo_setter = topo_sort_default_setter;
|
||||
revs->topo_getter = topo_sort_default_getter;
|
||||
|
||||
revs->header_prefix = "";
|
||||
revs->commit_format = CMIT_FMT_DEFAULT;
|
||||
|
||||
diff_setup(&revs->diffopt);
|
||||
|
|
@ -675,12 +674,10 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
|
|||
}
|
||||
if (!strcmp(arg, "-v")) {
|
||||
revs->verbose_header = 1;
|
||||
revs->header_prefix = "diff-tree ";
|
||||
continue;
|
||||
}
|
||||
if (!strncmp(arg, "--pretty", 8)) {
|
||||
revs->verbose_header = 1;
|
||||
revs->header_prefix = "diff-tree ";
|
||||
revs->commit_format = get_commit_format(arg+8);
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
#define ADDED (1u<<7) /* Parents already parsed and added? */
|
||||
|
||||
struct rev_info;
|
||||
struct log_info;
|
||||
|
||||
typedef void (prune_fn_t)(struct rev_info *revs, struct commit *commit);
|
||||
|
||||
|
|
@ -52,12 +53,11 @@ struct rev_info {
|
|||
always_show_header:1;
|
||||
|
||||
/* Format info */
|
||||
unsigned int abbrev_commit:1;
|
||||
unsigned int shown_one:1,
|
||||
abbrev_commit:1;
|
||||
unsigned int abbrev;
|
||||
enum cmit_fmt commit_format;
|
||||
const char *header_prefix;
|
||||
const char *header;
|
||||
const char *use_precomputed_header;
|
||||
struct log_info *loginfo;
|
||||
|
||||
/* special limits */
|
||||
int max_count;
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ test_expect_success 'git diff HEAD' 'cmp diff.expect diff.output'
|
|||
#test_expect_success 'git-read-tree --reset HEAD' "git-read-tree --reset HEAD ; test \"hello: needs update\" = \"$(git-update-index --refresh)\""
|
||||
|
||||
cat > whatchanged.expect << EOF
|
||||
diff-tree VARIABLE (from root)
|
||||
commit VARIABLE
|
||||
Author: VARIABLE
|
||||
Date: VARIABLE
|
||||
|
||||
|
|
@ -72,7 +72,7 @@ index 0000000..557db03
|
|||
EOF
|
||||
|
||||
git-whatchanged -p --root | \
|
||||
sed -e "1s/^\(.\{10\}\).\{40\}/\1VARIABLE/" \
|
||||
sed -e "1s/^\(.\{7\}\).\{40\}/\1VARIABLE/" \
|
||||
-e "2,3s/^\(.\{8\}\).*$/\1VARIABLE/" \
|
||||
> whatchanged.output
|
||||
test_expect_success 'git-whatchanged -p --root' 'cmp whatchanged.expect whatchanged.output'
|
||||
|
|
|
|||
Loading…
Reference in a new issue