#include "commit.h"
#include "log-tree.h"
-static struct rev_info log_tree_opt;
+static struct log_tree_opt log_tree_opt;
static int diff_tree_commit_sha1(const unsigned char *sha1)
{
{
int nr_sha1;
char line[1000];
- struct object *tree1, *tree2;
- static struct rev_info *opt = &log_tree_opt;
- struct object_list *list;
+ unsigned char sha1[2][20];
+ const char *prefix = setup_git_directory();
+ static struct log_tree_opt *opt = &log_tree_opt;
int read_stdin = 0;
git_config(git_diff_config);
nr_sha1 = 0;
- opt->abbrev = 0;
- argc = setup_revisions(argc, argv, opt, NULL);
+ init_log_tree_opt(opt);
- while (--argc > 0) {
- const char *arg = *++argv;
+ for (;;) {
+ int opt_cnt;
+ const char *arg;
+ argv++;
+ argc--;
+ arg = *argv;
+ if (!arg)
+ break;
+
+ if (*arg != '-') {
+ if (nr_sha1 < 2 && !get_sha1(arg, sha1[nr_sha1])) {
+ nr_sha1++;
+ continue;
+ }
+ break;
+ }
+
+ opt_cnt = log_tree_opt_parse(opt, argv, argc);
+ if (opt_cnt < 0)
+ usage(diff_tree_usage);
+ else if (opt_cnt) {
+ argv += opt_cnt - 1;
+ argc -= opt_cnt - 1;
+ continue;
+ }
+
+ if (!strcmp(arg, "--")) {
+ argv++;
+ argc--;
+ break;
+ }
if (!strcmp(arg, "--stdin")) {
read_stdin = 1;
continue;
usage(diff_tree_usage);
}
- /*
- * NOTE! "setup_revisions()" will have inserted the revisions
- * it parsed in reverse order. So if you do
- *
- * git-diff-tree a b
- *
- * the commit list will be "b" -> "a" -> NULL, so we reverse
- * the order of the objects if the first one is not marked
- * UNINTERESTING.
- */
- nr_sha1 = 0;
- list = opt->pending_objects;
- if (list) {
- nr_sha1++;
- tree1 = list->item;
- list = list->next;
- if (list) {
- nr_sha1++;
- tree2 = tree1;
- tree1 = list->item;
- if (list->next)
- usage(diff_tree_usage);
- /* Switch them around if the second one was uninteresting.. */
- if (tree2->flags & UNINTERESTING) {
- struct object *tmp = tree2;
- tree2 = tree1;
- tree1 = tmp;
- }
- }
- }
+ if (opt->combine_merges)
+ opt->ignore_merges = 0;
+
+ /* We can only do dense combined merges with diff output */
+ if (opt->dense_combined_merges)
+ opt->diffopt.output_format = DIFF_FORMAT_PATCH;
+
+ if (opt->diffopt.output_format == DIFF_FORMAT_PATCH)
+ opt->diffopt.recursive = 1;
+
+ diff_tree_setup_paths(get_pathspec(prefix, argv), opt);
+ diff_setup_done(&opt->diffopt);
switch (nr_sha1) {
case 0:
usage(diff_tree_usage);
break;
case 1:
- diff_tree_commit_sha1(tree1->sha1);
+ diff_tree_commit_sha1(sha1[0]);
break;
case 2:
- diff_tree_sha1(tree1->sha1,
- tree2->sha1,
- "", &opt->diffopt);
+ diff_tree_sha1(sha1[0], sha1[1], "", &opt->diffopt);
log_tree_diff_flush(opt);
break;
}
struct rev_info rev;
struct commit *commit;
char *buf = xmalloc(LOGSIZE);
+ static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
+ int abbrev = DEFAULT_ABBREV;
+ int abbrev_commit = 0;
const char *commit_prefix = "commit ";
+ struct log_tree_opt opt;
int shown = 0;
+ int do_diff = 0;
+ int full_diff = 0;
- rev.abbrev = DEFAULT_ABBREV;
+ init_log_tree_opt(&opt);
argc = setup_revisions(argc, argv, &rev, "HEAD");
- if (argc > 1)
- die("unrecognized argument: %s", argv[1]);
+ while (1 < argc) {
+ const char *arg = argv[1];
+ if (!strncmp(arg, "--pretty", 8)) {
+ commit_format = get_commit_format(arg + 8);
+ if (commit_format == CMIT_FMT_ONELINE)
+ commit_prefix = "";
+ }
+ else if (!strcmp(arg, "--no-abbrev")) {
+ abbrev = 0;
+ }
+ else if (!strcmp(arg, "--abbrev")) {
+ abbrev = DEFAULT_ABBREV;
+ }
+ else if (!strcmp(arg, "--abbrev-commit")) {
+ abbrev_commit = 1;
+ }
+ else if (!strncmp(arg, "--abbrev=", 9)) {
+ abbrev = strtoul(arg + 9, NULL, 10);
+ if (abbrev && abbrev < MINIMUM_ABBREV)
+ abbrev = MINIMUM_ABBREV;
+ else if (40 < abbrev)
+ abbrev = 40;
+ }
+ else if (!strcmp(arg, "--full-diff")) {
+ do_diff = 1;
+ full_diff = 1;
+ }
+ else {
+ int cnt = log_tree_opt_parse(&opt, argv+1, argc-1);
+ if (0 < cnt) {
+ do_diff = 1;
+ argv += cnt;
+ argc -= cnt;
+ continue;
+ }
+ die("unrecognized argument: %s", arg);
+ }
- rev.no_commit_id = 1;
- if (rev.commit_format == CMIT_FMT_ONELINE)
- commit_prefix = "";
+ argc--; argv++;
+ }
+
+ if (do_diff) {
+ opt.diffopt.abbrev = abbrev;
+ opt.verbose_header = 0;
+ opt.always_show_header = 0;
+ opt.no_commit_id = 1;
+ if (opt.combine_merges)
+ opt.ignore_merges = 0;
+ if (opt.dense_combined_merges)
+ opt.diffopt.output_format = DIFF_FORMAT_PATCH;
+ if (opt.diffopt.output_format == DIFF_FORMAT_PATCH)
+ opt.diffopt.recursive = 1;
+ if (!full_diff && rev.prune_data)
+ diff_tree_setup_paths(rev.prune_data, &opt.diffopt);
+ diff_setup_done(&opt.diffopt);
+ }
prepare_revision_walk(&rev);
setup_pager();
while ((commit = get_revision(&rev)) != NULL) {
- if (shown && rev.diff && rev.commit_format != CMIT_FMT_ONELINE)
+ if (shown && do_diff && commit_format != CMIT_FMT_ONELINE)
putchar('\n');
fputs(commit_prefix, stdout);
- if (rev.abbrev_commit && rev.abbrev)
- fputs(find_unique_abbrev(commit->object.sha1, rev.abbrev),
+ if (abbrev_commit && abbrev)
+ fputs(find_unique_abbrev(commit->object.sha1, abbrev),
stdout);
else
fputs(sha1_to_hex(commit->object.sha1), stdout);
parents = parents->next)
parents->item->object.flags &= ~TMP_MARK;
}
- if (rev.commit_format == CMIT_FMT_ONELINE)
+ if (commit_format == CMIT_FMT_ONELINE)
putchar(' ');
else
putchar('\n');
- pretty_print_commit(rev.commit_format, commit, ~0, buf,
- LOGSIZE, rev.abbrev);
+ pretty_print_commit(commit_format, commit, ~0, buf,
+ LOGSIZE, abbrev);
printf("%s\n", buf);
- if (rev.diff)
- log_tree_commit(&rev, commit);
+ if (do_diff)
+ log_tree_commit(&opt, commit);
shown = 1;
free(commit->buffer);
commit->buffer = NULL;
#include "commit.h"
#include "log-tree.h"
-int log_tree_diff_flush(struct rev_info *opt)
+void init_log_tree_opt(struct log_tree_opt *opt)
+{
+ memset(opt, 0, sizeof *opt);
+ opt->ignore_merges = 1;
+ opt->header_prefix = "";
+ opt->commit_format = CMIT_FMT_RAW;
+ diff_setup(&opt->diffopt);
+}
+
+int log_tree_opt_parse(struct log_tree_opt *opt, const char **av, int ac)
+{
+ const char *arg;
+ int cnt = diff_opt_parse(&opt->diffopt, av, ac);
+ if (0 < cnt)
+ return cnt;
+ arg = *av;
+ if (!strcmp(arg, "-r"))
+ opt->diffopt.recursive = 1;
+ else if (!strcmp(arg, "-t")) {
+ opt->diffopt.recursive = 1;
+ opt->diffopt.tree_in_recursive = 1;
+ }
+ else if (!strcmp(arg, "-m"))
+ opt->ignore_merges = 0;
+ else if (!strcmp(arg, "-c"))
+ opt->combine_merges = 1;
+ else if (!strcmp(arg, "--cc")) {
+ opt->dense_combined_merges = 1;
+ opt->combine_merges = 1;
+ }
+ else if (!strcmp(arg, "-v")) {
+ opt->verbose_header = 1;
+ opt->header_prefix = "diff-tree ";
+ }
+ else if (!strncmp(arg, "--pretty", 8)) {
+ opt->verbose_header = 1;
+ opt->header_prefix = "diff-tree ";
+ opt->commit_format = get_commit_format(arg+8);
+ }
+ else if (!strcmp(arg, "--root"))
+ opt->show_root_diff = 1;
+ else if (!strcmp(arg, "--no-commit-id"))
+ opt->no_commit_id = 1;
+ else if (!strcmp(arg, "--always"))
+ opt->always_show_header = 1;
+ else
+ return 0;
+ return 1;
+}
+
+int log_tree_diff_flush(struct log_tree_opt *opt)
{
diffcore_std(&opt->diffopt);
if (diff_queue_is_empty()) {
return 1;
}
-static int diff_root_tree(struct rev_info *opt,
+static int diff_root_tree(struct log_tree_opt *opt,
const unsigned char *new, const char *base)
{
int retval;
return retval;
}
-static const char *generate_header(struct rev_info *opt,
+static const char *generate_header(struct log_tree_opt *opt,
const unsigned char *commit_sha1,
const unsigned char *parent_sha1,
const struct commit *commit)
return this_header;
}
-static int do_diff_combined(struct rev_info *opt, struct commit *commit)
+static int do_diff_combined(struct log_tree_opt *opt, struct commit *commit)
{
unsigned const char *sha1 = commit->object.sha1;
return 0;
}
-int log_tree_commit(struct rev_info *opt, struct commit *commit)
+int log_tree_commit(struct log_tree_opt *opt, struct commit *commit)
{
struct commit_list *parents;
unsigned const char *sha1 = commit->object.sha1;
#ifndef LOG_TREE_H
#define LOG_TREE_H
-#include "revision.h"
+struct log_tree_opt {
+ struct diff_options diffopt;
+ int show_root_diff;
+ int no_commit_id;
+ int verbose_header;
+ int ignore_merges;
+ int combine_merges;
+ int dense_combined_merges;
+ int always_show_header;
+ const char *header_prefix;
+ const char *header;
+ enum cmit_fmt commit_format;
+};
-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 init_log_tree_opt(struct log_tree_opt *);
+int log_tree_diff_flush(struct log_tree_opt *);
+int log_tree_commit(struct log_tree_opt *, struct commit *);
+int log_tree_opt_parse(struct log_tree_opt *, const char **, int);
#endif
list = revs.commits;
- if ((!list &&
- (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) &&
- !revs.pending_objects)) ||
- revs.diff)
+ if (!list &&
+ (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) && !revs.pending_objects))
usage(rev_list_usage);
save_commit_buffer = verbose_header;
add_object(obj, &revs->pending_objects, NULL, name);
}
-static struct object *get_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
+static struct commit *get_commit_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
{
struct object *object;
object = parse_object(sha1);
if (!object)
die("bad object %s", name);
- object->flags |= flags;
- return object;
-}
-
-static struct commit *handle_commit(struct rev_info *revs, struct object *object, const char *name)
-{
- unsigned long flags = object->flags;
/*
* Tag object? Look what it points to..
*/
while (object->type == tag_type) {
struct tag *tag = (struct tag *) object;
- if (revs->tag_objects && !(flags & UNINTERESTING))
+ object->flags |= flags;
+ if (revs->tag_objects && !(object->flags & UNINTERESTING))
add_pending_object(revs, object, tag->tag);
object = parse_object(tag->tagged->sha1);
if (!object)
*/
if (object->type == commit_type) {
struct commit *commit = (struct commit *)object;
+ object->flags |= flags;
if (parse_commit(commit) < 0)
die("unable to parse commit %s", name);
if (flags & UNINTERESTING) {
return REV_TREE_DIFFERENT;
tree_difference = REV_TREE_SAME;
if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "",
- &revs->pruning) < 0)
+ &revs->diffopt) < 0)
return REV_TREE_DIFFERENT;
return tree_difference;
}
empty.size = 0;
tree_difference = 0;
- retval = diff_tree(&empty, &real, "", &revs->pruning);
+ retval = diff_tree(&empty, &real, "", &revs->diffopt);
free(tree);
return retval >= 0 && !tree_difference;
revs->commits = newlist;
}
+static void add_one_commit(struct commit *commit, struct rev_info *revs)
+{
+ if (!commit || (commit->object.flags & SEEN))
+ return;
+ commit->object.flags |= SEEN;
+ commit_list_insert(commit, &revs->commits);
+}
+
static int all_flags;
static struct rev_info *all_revs;
static int handle_one_ref(const char *path, const unsigned char *sha1)
{
- struct object *object = get_reference(all_revs, path, sha1, all_flags);
- add_pending_object(all_revs, object, "");
+ struct commit *commit = get_commit_reference(all_revs, path, sha1, all_flags);
+ add_one_commit(commit, all_revs);
return 0;
}
void init_revisions(struct rev_info *revs)
{
- unsigned abbrev = revs->abbrev;
-
memset(revs, 0, sizeof(*revs));
-
- revs->abbrev = abbrev;
- revs->ignore_merges = 1;
- revs->pruning.recursive = 1;
- revs->pruning.add_remove = file_add_remove;
- revs->pruning.change = file_change;
+ revs->diffopt.recursive = 1;
+ revs->diffopt.add_remove = file_add_remove;
+ revs->diffopt.change = file_change;
revs->lifo = 1;
revs->dense = 1;
revs->prefix = setup_git_directory();
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);
}
/*
flags = 0;
for (i = 1; i < argc; i++) {
- struct object *object;
+ struct commit *commit;
const char *arg = argv[i];
unsigned char sha1[20];
char *dotdot;
int local_flags;
if (*arg == '-') {
- int opts;
if (!strncmp(arg, "--max-count=", 12)) {
revs->max_count = atoi(arg + 12);
continue;
revs->unpacked = 1;
continue;
}
- if (!strcmp(arg, "-r")) {
- revs->diff = 1;
- revs->diffopt.recursive = 1;
- continue;
- }
- if (!strcmp(arg, "-t")) {
- revs->diff = 1;
- revs->diffopt.recursive = 1;
- revs->diffopt.tree_in_recursive = 1;
- continue;
- }
- if (!strcmp(arg, "-m")) {
- revs->ignore_merges = 0;
- continue;
- }
- if (!strcmp(arg, "-c")) {
- revs->diff = 1;
- revs->combine_merges = 1;
- continue;
- }
- if (!strcmp(arg, "--cc")) {
- revs->diff = 1;
- revs->dense_combined_merges = 1;
- revs->combine_merges = 1;
- continue;
- }
- 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;
- }
- if (!strcmp(arg, "--root")) {
- revs->show_root_diff = 1;
- continue;
- }
- if (!strcmp(arg, "--no-commit-id")) {
- revs->no_commit_id = 1;
- continue;
- }
- if (!strcmp(arg, "--always")) {
- revs->always_show_header = 1;
- continue;
- }
- if (!strcmp(arg, "--no-abbrev")) {
- revs->abbrev = 0;
- continue;
- }
- if (!strcmp(arg, "--abbrev")) {
- revs->abbrev = DEFAULT_ABBREV;
- continue;
- }
- if (!strcmp(arg, "--abbrev-commit")) {
- revs->abbrev_commit = 1;
- continue;
- }
- if (!strcmp(arg, "--full-diff")) {
- revs->diff = 1;
- revs->full_diff = 1;
- continue;
- }
- opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i);
- if (opts > 0) {
- revs->diff = 1;
- i += opts - 1;
- continue;
- }
*unrecognized++ = arg;
left++;
continue;
this = "HEAD";
if (!get_sha1(this, from_sha1) &&
!get_sha1(next, sha1)) {
- struct object *exclude;
- struct object *include;
+ struct commit *exclude;
+ struct commit *include;
- exclude = get_reference(revs, this, from_sha1, flags ^ UNINTERESTING);
- include = get_reference(revs, next, sha1, flags);
+ exclude = get_commit_reference(revs, this, from_sha1, flags ^ UNINTERESTING);
+ include = get_commit_reference(revs, next, sha1, flags);
if (!exclude || !include)
die("Invalid revision range %s..%s", arg, next);
- add_pending_object(revs, exclude, this);
- add_pending_object(revs, include, next);
+ add_one_commit(exclude, revs);
+ add_one_commit(include, revs);
continue;
}
*dotdot = '.';
revs->prune_data = get_pathspec(revs->prefix, argv + i);
break;
}
- object = get_reference(revs, arg, sha1, flags ^ local_flags);
- add_pending_object(revs, object, arg);
+ commit = get_commit_reference(revs, arg, sha1, flags ^ local_flags);
+ add_one_commit(commit, revs);
}
- if (def && !revs->pending_objects) {
+ if (def && !revs->commits) {
unsigned char sha1[20];
- struct object *object;
+ struct commit *commit;
if (get_sha1(def, sha1) < 0)
die("bad default revision '%s'", def);
- object = get_reference(revs, def, sha1, 0);
- add_pending_object(revs, object, def);
+ commit = get_commit_reference(revs, def, sha1, 0);
+ add_one_commit(commit, revs);
}
if (revs->topo_order || revs->unpacked)
revs->limited = 1;
if (revs->prune_data) {
- diff_tree_setup_paths(revs->prune_data, &revs->pruning);
+ diff_tree_setup_paths(revs->prune_data, &revs->diffopt);
revs->prune_fn = try_to_simplify_commit;
- if (!revs->full_diff)
- diff_tree_setup_paths(revs->prune_data, &revs->diffopt);
- }
- if (revs->combine_merges) {
- revs->ignore_merges = 0;
- if (revs->dense_combined_merges)
- revs->diffopt.output_format = DIFF_FORMAT_PATCH;
}
- if (revs->diffopt.output_format == DIFF_FORMAT_PATCH)
- revs->diffopt.recursive = 1;
- revs->diffopt.abbrev = revs->abbrev;
- diff_setup_done(&revs->diffopt);
return left;
}
void prepare_revision_walk(struct rev_info *revs)
{
- struct object_list *list;
-
- list = revs->pending_objects;
- revs->pending_objects = NULL;
- while (list) {
- struct commit *commit = handle_commit(revs, list->item, list->name);
- if (commit) {
- if (!(commit->object.flags & SEEN)) {
- commit->object.flags |= SEEN;
- insert_by_date(commit, &revs->commits);
- }
- }
- list = list->next;
- }
-
+ sort_by_date(&revs->commits);
if (revs->limited)
limit_list(revs);
if (revs->topo_order)
boundary:1,
parents:1;
- /* Diff flags */
- unsigned int diff:1,
- full_diff:1,
- show_root_diff:1,
- no_commit_id:1,
- verbose_header:1,
- ignore_merges:1,
- combine_merges:1,
- dense_combined_merges:1,
- always_show_header:1;
-
- /* Format info */
- unsigned int abbrev_commit:1;
- unsigned int abbrev;
- enum cmit_fmt commit_format;
- const char *header_prefix;
- const char *header;
-
/* special limits */
int max_count;
unsigned long max_age;
unsigned long min_age;
- /* diff info for patches and for paths limiting */
+ /* paths limiting */
struct diff_options diffopt;
- struct diff_options pruning;
topo_sort_set_fn_t topo_setter;
topo_sort_get_fn_t topo_getter;
projects / git.git / commitdiff