nth = 0;
while (parents) {
struct commit *p = parents->item;
- char newname[1000];
+ char newname[1000], *en;
parents = parents->next;
nth++;
if (p->object.util)
continue;
- sprintf(newname, "%s^%d", n->head_name, nth);
+ en = newname;
+ switch (n->generation) {
+ case 0:
+ en += sprintf(en, "%s", n->head_name);
+ break;
+ case 1:
+ en += sprintf(en, "%s^", n->head_name);
+ break;
+ default:
+ en += sprintf(en, "%s~%d",
+ n->head_name, n->generation);
+ break;
+ }
+ if (nth == 1)
+ en += sprintf(en, "^");
+ else
+ en += sprintf(en, "^%d", nth);
name_commit(p, strdup(newname), 0);
i++;
name_first_parent_chain(p);
while (*list_p) {
struct commit_list *parents;
+ int still_interesting = !!interesting(*list_p);
struct commit *commit = pop_one_commit(list_p);
int flags = commit->object.flags & all_mask;
- int still_interesting = !!interesting(*list_p);
- if (!still_interesting && extra < 0)
+ if (!still_interesting && extra <= 0)
break;
mark_seen(commit, seen_p);
parents = parents->next;
if ((this_flag & flags) == flags)
continue;
- parse_commit(p);
+ if (!p->object.parsed)
+ parse_commit(p);
if (mark_seen(p, seen_p) && !still_interesting)
extra--;
p->object.flags |= flags;
insert_by_date(p, list_p);
}
}
+
+ /*
+ * Postprocess to complete well-poisoning.
+ *
+ * At this point we have all the commits we have seen in
+ * seen_p list (which happens to be sorted chronologically but
+ * it does not really matter). Mark anything that can be
+ * reached from uninteresting commits not interesting.
+ */
+ for (;;) {
+ int changed = 0;
+ struct commit_list *s;
+ for (s = *seen_p; s; s = s->next) {
+ struct commit *c = s->item;
+ struct commit_list *parents;
+
+ if (((c->object.flags & all_revs) != all_revs) &&
+ !(c->object.flags & UNINTERESTING))
+ continue;
+
+ /* The current commit is either a merge base or
+ * already uninteresting one. Mark its parents
+ * as uninteresting commits _only_ if they are
+ * already parsed. No reason to find new ones
+ * here.
+ */
+ parents = c->parents;
+ while (parents) {
+ struct commit *p = parents->item;
+ parents = parents->next;
+ if (!(p->object.flags & UNINTERESTING)) {
+ p->object.flags |= UNINTERESTING;
+ changed = 1;
+ }
+ }
+ }
+ if (!changed)
+ break;
+ }
}
-static void show_one_commit(struct commit *commit)
+static void show_one_commit(struct commit *commit, int no_name)
{
- char pretty[128], *cp;
+ char pretty[256], *cp;
struct commit_name *name = commit->object.util;
- pretty_print_commit(CMIT_FMT_ONELINE, commit->buffer, ~0,
- pretty, sizeof(pretty));
+ if (commit->object.parsed)
+ pretty_print_commit(CMIT_FMT_ONELINE, commit->buffer, ~0,
+ pretty, sizeof(pretty));
+ else
+ strcpy(pretty, "(unavailable)");
if (!strncmp(pretty, "[PATCH] ", 8))
cp = pretty + 8;
else
cp = pretty;
- if (name && name->head_name) {
- printf("[%s", name->head_name);
- if (name->generation)
- printf("~%d", name->generation);
- printf("] ");
+
+ if (!no_name) {
+ if (name && name->head_name) {
+ printf("[%s", name->head_name);
+ if (name->generation) {
+ if (name->generation == 1)
+ printf("^");
+ else
+ printf("~%d", name->generation);
+ }
+ printf("] ");
+ }
+ else
+ printf("[%s] ",
+ find_unique_abbrev(commit->object.sha1, 7));
}
puts(cp);
}
struct commit *commit = lookup_commit_reference_gently(sha1, 1);
if (!commit)
return 0;
- if (MAX_REVS < ref_name_cnt) {
+ if (MAX_REVS <= ref_name_cnt) {
fprintf(stderr, "warning: ignoring %s; "
"cannot handle more than %d refs",
refname, MAX_REVS);
static int append_head_ref(const char *refname, const unsigned char *sha1)
{
- if (strncmp(refname, "refs/heads/", 11))
+ unsigned char tmp[20];
+ int ofs = 11;
+ if (strncmp(refname, "refs/heads/", ofs))
return 0;
- return append_ref(refname + 11, sha1);
+ /* If both heads/foo and tags/foo exists, get_sha1 would
+ * get confused.
+ */
+ if (get_sha1(refname + ofs, tmp) || memcmp(tmp, sha1, 20))
+ ofs = 5;
+ return append_ref(refname + ofs, sha1);
}
static int append_tag_ref(const char *refname, const unsigned char *sha1)
unsigned int rev_mask[MAX_REVS];
int num_rev, i, extra = 0;
int all_heads = 0, all_tags = 0;
- int all_mask, all_revs, shown_merge_point;
+ int all_mask, all_revs;
char head_path[128];
+ const char *head_path_p;
int head_path_len;
unsigned char head_sha1[20];
int merge_base = 0;
int independent = 0;
- char **label;
+ int no_name = 0;
+ int sha1_name = 0;
+ int shown_merge_point = 0;
+ int topo_order = 0;
setup_git_directory();
extra = 1;
else if (!strcmp(arg, "--list"))
extra = -1;
+ else if (!strcmp(arg, "--no-name"))
+ no_name = 1;
+ else if (!strcmp(arg, "--sha1-name"))
+ sha1_name = 1;
else if (!strncmp(arg, "--more=", 7))
extra = atoi(arg + 7);
else if (!strcmp(arg, "--merge-base"))
merge_base = 1;
else if (!strcmp(arg, "--independent"))
independent = 1;
+ else if (!strcmp(arg, "--topo-order"))
+ topo_order = 1;
else
usage(show_branch_usage);
ac--; av++;
if (MAX_REVS <= num_rev)
die("cannot handle more than %d revs.", MAX_REVS);
if (get_sha1(ref_name[num_rev], revkey))
- usage(show_branch_usage);
+ die("'%s' is not a valid ref.\n", ref_name[num_rev]);
commit = lookup_commit_reference(revkey);
if (!commit)
die("cannot find commit %s (%s)",
if (0 <= extra)
join_revs(&list, &seen, num_rev, extra);
- head_path_len = readlink(".git/HEAD", head_path, sizeof(head_path)-1);
- if ((head_path_len < 0) || get_sha1("HEAD", head_sha1))
+ head_path_p = resolve_ref(git_path("HEAD"), head_sha1, 1);
+ if (head_path_p) {
+ head_path_len = strlen(head_path_p);
+ memcpy(head_path, head_path_p, head_path_len + 1);
+ }
+ else {
+ head_path_len = 0;
head_path[0] = 0;
- else
- head_path[head_path_len] = 0;
+ }
if (merge_base)
return show_merge_base(seen, num_rev);
printf("%c [%s] ",
is_head ? '*' : '!', ref_name[i]);
}
- show_one_commit(rev[i]);
+ /* header lines never need name */
+ show_one_commit(rev[i], 1);
}
if (0 <= extra) {
for (i = 0; i < num_rev; i++)
exit(0);
/* Sort topologically */
- sort_in_topological_order(&seen);
+ if (topo_order)
+ sort_in_topological_order(&seen);
/* Give names to commits */
- name_commits(seen, rev, ref_name, num_rev);
+ if (!sha1_name && !no_name)
+ name_commits(seen, rev, ref_name, num_rev);
all_mask = ((1u << (REV_SHIFT + num_rev)) - 1);
all_revs = all_mask & ~((1u << REV_SHIFT) - 1);
- shown_merge_point = 0;
while (seen) {
struct commit *commit = pop_one_commit(&seen);
int this_flag = commit->object.flags;
- int is_merge_point = (this_flag & all_revs) == all_revs;
- static char *obvious[] = { "" };
- if (is_merge_point)
- shown_merge_point = 1;
+ shown_merge_point |= ((this_flag & all_revs) == all_revs);
if (1 < num_rev) {
for (i = 0; i < num_rev; i++)
? '+' : ' ');
putchar(' ');
}
- show_one_commit(commit);
- if (num_rev == 1)
- label = obvious;
- if (shown_merge_point && is_merge_point)
- if (--extra < 0)
- break;
+ show_one_commit(commit, no_name);
+
+ if (shown_merge_point && --extra < 0)
+ break;
}
return 0;
}