kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Merge branch 'ph/parseopt-step-blame' 

* ph/parseopt-step-blame:
  revisions: refactor handle_revision_opt into parse_revision_opt.
  git-shortlog: migrate to parse-options partially.
  git-blame: fix lapsus
  git-blame: migrate to incremental parse-option [2/2]
  git-blame: migrate to incremental parse-option [1/2]
  revisions: split handle_revision_opt() from setup_revisions()
  parse-opt: add PARSE_OPT_KEEP_ARGV0 parser option.
  parse-opt: fake short strings for callers to believe in.
  parse-opt: do not print errors on unknown options, return -2 intead.
  parse-opt: create parse_options_step.
  parse-opt: Export a non NORETURN usage dumper.
  parse-opt: have parse_options_{start,end}.
  git-blame --reverse
  builtin-blame.c: allow more than 16 parents
  builtin-blame.c: move prepare_final() into a separate function.
  rev-list --children
  revision traversal: --children option
maint
Junio C Hamano 17 years ago
parent
671d322035 6b61ec0564
commit
fa6200fc02
8 changed files with 788 additions and 673 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      Documentation/rev-list-options.txt
  2. 523
      builtin-blame.c
  3. 10
      builtin-rev-list.c
  4. 127
      builtin-shortlog.c
  5. 163
      parse-options.c
  6. 35
      parse-options.h
  7. 591
      revision.c
  8. 8
      revision.h

4
Documentation/rev-list-options.txt
Unescape View File

@ -45,6 +45,10 @@ endif::git-rev-list[]


Print the parents of the commit. Print the parents of the commit.


--children::

Print the children of the commit.

ifdef::git-rev-list[] ifdef::git-rev-list[]
--timestamp:: --timestamp::
Print the raw commit timestamp. Print the raw commit timestamp.

523
builtin-blame.c
Unescape View File

@ -18,24 +18,16 @@
#include "cache-tree.h" #include "cache-tree.h"
#include "path-list.h" #include "path-list.h"
#include "mailmap.h" #include "mailmap.h"
#include "parse-options.h"


static char blame_usage[] = static char blame_usage[] = "git-blame [options] [rev-opts] [rev] [--] file";
"git-blame [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [-L n,m] [-S <revs-file>] [-M] [-C] [-C] [--contents <filename>] [--incremental] [commit] [--] file\n"
" -c Use the same output mode as git-annotate (Default: off)\n" static const char *blame_opt_usage[] = {
" -b Show blank SHA-1 for boundary commits (Default: off)\n" blame_usage,
" -l Show long commit SHA1 (Default: off)\n" "",
" --root Do not treat root commits as boundaries (Default: off)\n" "[rev-opts] are documented in git-rev-list(1)",
" -t Show raw timestamp (Default: off)\n" NULL
" -f, --show-name Show original filename (Default: auto)\n" };
" -n, --show-number Show original linenumber (Default: off)\n"
" -s Suppress author name and timestamp (Default: off)\n"
" -p, --porcelain Show in a format designed for machine consumption\n"
" -w Ignore whitespace differences\n"
" -L n,m Process only line range n,m, counting from 1\n"
" -M, -C Find line movements within and across files\n"
" --incremental Show blame entries as we find them, incrementally\n"
" --contents file Use <file>'s contents as the final image\n"
" -S revs-file Use revisions from revs-file instead of calling git-rev-list\n";


static int longest_file; static int longest_file;
static int longest_author; static int longest_author;
@ -43,6 +35,7 @@ static int max_orig_digits;
static int max_digits; static int max_digits;
static int max_score_digits; static int max_score_digits;
static int show_root; static int show_root;
static int reverse;
static int blank_boundary; static int blank_boundary;
static int incremental; static int incremental;
static int cmd_is_annotate; static int cmd_is_annotate;
@ -91,7 +84,7 @@ struct origin {
* Given an origin, prepare mmfile_t structure to be used by the * Given an origin, prepare mmfile_t structure to be used by the
* diff machinery * diff machinery
*/ */
static char *fill_origin_blob(struct origin *o, mmfile_t *file) static void fill_origin_blob(struct origin *o, mmfile_t *file)
{ {
if (!o->file.ptr) { if (!o->file.ptr) {
enum object_type type; enum object_type type;
@ -106,7 +99,6 @@ static char *fill_origin_blob(struct origin *o, mmfile_t *file)
} }
else else
*file = o->file; *file = o->file;
return file->ptr;
} }


/* /*
@ -178,7 +170,7 @@ struct blame_entry {
struct scoreboard { struct scoreboard {
/* the final commit (i.e. where we started digging from) */ /* the final commit (i.e. where we started digging from) */
struct commit *final; struct commit *final;

struct rev_info *revs;
const char *path; const char *path;


/* /*
@ -1192,18 +1184,48 @@ static void pass_whole_blame(struct scoreboard *sb,
} }
} }


#define MAXPARENT 16 /*
* We pass blame from the current commit to its parents. We keep saying
* "parent" (and "porigin"), but what we mean is to find scapegoat to
* exonerate ourselves.
*/
static struct commit_list *first_scapegoat(struct rev_info *revs, struct commit *commit)
{
if (!reverse)
return commit->parents;
return lookup_decoration(&revs->children, &commit->object);
}

static int num_scapegoats(struct rev_info *revs, struct commit *commit)
{
int cnt;
struct commit_list *l = first_scapegoat(revs, commit);
for (cnt = 0; l; l = l->next)
cnt++;
return cnt;
}

#define MAXSG 16


static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt) static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
{ {
int i, pass; struct rev_info *revs = sb->revs;
int i, pass, num_sg;
struct commit *commit = origin->commit; struct commit *commit = origin->commit;
struct commit_list *parent; struct commit_list *sg;
struct origin *parent_origin[MAXPARENT], *porigin; struct origin *sg_buf[MAXSG];

struct origin *porigin, **sg_origin = sg_buf;
memset(parent_origin, 0, sizeof(parent_origin));
num_sg = num_scapegoats(revs, commit);
if (!num_sg)
goto finish;
else if (num_sg < ARRAY_SIZE(sg_buf))
memset(sg_buf, 0, sizeof(sg_buf));
else
sg_origin = xcalloc(num_sg, sizeof(*sg_origin));


/* The first pass looks for unrenamed path to optimize for /*
* The first pass looks for unrenamed path to optimize for
* common cases, then we look for renames in the second pass. * common cases, then we look for renames in the second pass.
*/ */
for (pass = 0; pass < 2; pass++) { for (pass = 0; pass < 2; pass++) {
@ -1211,13 +1233,13 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
struct commit *, struct origin *); struct commit *, struct origin *);
find = pass ? find_rename : find_origin; find = pass ? find_rename : find_origin;


for (i = 0, parent = commit->parents; for (i = 0, sg = first_scapegoat(revs, commit);
i < MAXPARENT && parent; i < num_sg && sg;
parent = parent->next, i++) { sg = sg->next, i++) {
struct commit *p = parent->item; struct commit *p = sg->item;
int j, same; int j, same;


if (parent_origin[i]) if (sg_origin[i])
continue; continue;
if (parse_commit(p)) if (parse_commit(p))
continue; continue;
@ -1230,24 +1252,24 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
goto finish; goto finish;
} }
for (j = same = 0; j < i; j++) for (j = same = 0; j < i; j++)
if (parent_origin[j] && if (sg_origin[j] &&
!hashcmp(parent_origin[j]->blob_sha1, !hashcmp(sg_origin[j]->blob_sha1,
porigin->blob_sha1)) { porigin->blob_sha1)) {
same = 1; same = 1;
break; break;
} }
if (!same) if (!same)
parent_origin[i] = porigin; sg_origin[i] = porigin;
else else
origin_decref(porigin); origin_decref(porigin);
} }
} }


num_commits++; num_commits++;
for (i = 0, parent = commit->parents; for (i = 0, sg = first_scapegoat(revs, commit);
i < MAXPARENT && parent; i < num_sg && sg;
parent = parent->next, i++) { sg = sg->next, i++) {
struct origin *porigin = parent_origin[i]; struct origin *porigin = sg_origin[i];
if (!porigin) if (!porigin)
continue; continue;
if (pass_blame_to_parent(sb, origin, porigin)) if (pass_blame_to_parent(sb, origin, porigin))
@ -1258,10 +1280,10 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
* Optionally find moves in parents' files. * Optionally find moves in parents' files.
*/ */
if (opt & PICKAXE_BLAME_MOVE) if (opt & PICKAXE_BLAME_MOVE)
for (i = 0, parent = commit->parents; for (i = 0, sg = first_scapegoat(revs, commit);
i < MAXPARENT && parent; i < num_sg && sg;
parent = parent->next, i++) { sg = sg->next, i++) {
struct origin *porigin = parent_origin[i]; struct origin *porigin = sg_origin[i];
if (!porigin) if (!porigin)
continue; continue;
if (find_move_in_parent(sb, origin, porigin)) if (find_move_in_parent(sb, origin, porigin))
@ -1272,23 +1294,25 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
* Optionally find copies from parents' files. * Optionally find copies from parents' files.
*/ */
if (opt & PICKAXE_BLAME_COPY) if (opt & PICKAXE_BLAME_COPY)
for (i = 0, parent = commit->parents; for (i = 0, sg = first_scapegoat(revs, commit);
i < MAXPARENT && parent; i < num_sg && sg;
parent = parent->next, i++) { sg = sg->next, i++) {
struct origin *porigin = parent_origin[i]; struct origin *porigin = sg_origin[i];
if (find_copy_in_parent(sb, origin, parent->item, if (find_copy_in_parent(sb, origin, sg->item,
porigin, opt)) porigin, opt))
goto finish; goto finish;
} }


finish: finish:
for (i = 0; i < MAXPARENT; i++) { for (i = 0; i < num_sg; i++) {
if (parent_origin[i]) { if (sg_origin[i]) {
drop_origin_blob(parent_origin[i]); drop_origin_blob(sg_origin[i]);
origin_decref(parent_origin[i]); origin_decref(sg_origin[i]);
} }
} }
drop_origin_blob(origin); drop_origin_blob(origin);
if (sg_buf != sg_origin)
free(sg_origin);
} }


/* /*
@ -1487,8 +1511,10 @@ static void found_guilty_entry(struct blame_entry *ent)
* is still unknown, pick one blame_entry, and allow its current * is still unknown, pick one blame_entry, and allow its current
* suspect to pass blames to its parents. * suspect to pass blames to its parents.
*/ */
static void assign_blame(struct scoreboard *sb, struct rev_info *revs, int opt) static void assign_blame(struct scoreboard *sb, int opt)
{ {
struct rev_info *revs = sb->revs;

while (1) { while (1) {
struct blame_entry *ent; struct blame_entry *ent;
struct commit *commit; struct commit *commit;
@ -1509,8 +1535,9 @@ static void assign_blame(struct scoreboard *sb, struct rev_info *revs, int opt)
commit = suspect->commit; commit = suspect->commit;
if (!commit->object.parsed) if (!commit->object.parsed)
parse_commit(commit); parse_commit(commit);
if (!(commit->object.flags & UNINTERESTING) && if (reverse ||
!(revs->max_age != -1 && commit->date < revs->max_age)) (!(commit->object.flags & UNINTERESTING) &&
!(revs->max_age != -1 && commit->date < revs->max_age)))
pass_blame(sb, suspect, opt); pass_blame(sb, suspect, opt);
else { else {
commit->object.flags |= UNINTERESTING; commit->object.flags |= UNINTERESTING;
@ -2006,6 +2033,10 @@ static int git_blame_config(const char *var, const char *value, void *cb)
return git_default_config(var, value, cb); return git_default_config(var, value, cb);
} }


/*
* Prepare a dummy commit that represents the work tree (or staged) item.
* Note that annotating work tree item never works in the reverse.
*/
static struct commit *fake_working_tree_commit(const char *path, const char *contents_from) static struct commit *fake_working_tree_commit(const char *path, const char *contents_from)
{ {
struct commit *commit; struct commit *commit;
@ -2122,6 +2153,108 @@ static struct commit *fake_working_tree_commit(const char *path, const char *con
return commit; return commit;
} }


static const char *prepare_final(struct scoreboard *sb)
{
int i;
const char *final_commit_name = NULL;
struct rev_info *revs = sb->revs;

/*
* There must be one and only one positive commit in the
* revs->pending array.
*/
for (i = 0; i < revs->pending.nr; i++) {
struct object *obj = revs->pending.objects[i].item;
if (obj->flags & UNINTERESTING)
continue;
while (obj->type == OBJ_TAG)
obj = deref_tag(obj, NULL, 0);
if (obj->type != OBJ_COMMIT)
die("Non commit %s?", revs->pending.objects[i].name);
if (sb->final)
die("More than one commit to dig from %s and %s?",
revs->pending.objects[i].name,
final_commit_name);
sb->final = (struct commit *) obj;
final_commit_name = revs->pending.objects[i].name;
}
return final_commit_name;
}

static const char *prepare_initial(struct scoreboard *sb)
{
int i;
const char *final_commit_name = NULL;
struct rev_info *revs = sb->revs;

/*
* There must be one and only one negative commit, and it must be
* the boundary.
*/
for (i = 0; i < revs->pending.nr; i++) {
struct object *obj = revs->pending.objects[i].item;
if (!(obj->flags & UNINTERESTING))
continue;
while (obj->type == OBJ_TAG)
obj = deref_tag(obj, NULL, 0);
if (obj->type != OBJ_COMMIT)
die("Non commit %s?", revs->pending.objects[i].name);
if (sb->final)
die("More than one commit to dig down to %s and %s?",
revs->pending.objects[i].name,
final_commit_name);
sb->final = (struct commit *) obj;
final_commit_name = revs->pending.objects[i].name;
}
if (!final_commit_name)
die("No commit to dig down to?");
return final_commit_name;
}

static int blame_copy_callback(const struct option *option, const char *arg, int unset)
{
int *opt = option->value;

/*
* -C enables copy from removed files;
* -C -C enables copy from existing files, but only
* when blaming a new file;
* -C -C -C enables copy from existing files for
* everybody
*/
if (*opt & PICKAXE_BLAME_COPY_HARDER)
*opt |= PICKAXE_BLAME_COPY_HARDEST;
if (*opt & PICKAXE_BLAME_COPY)
*opt |= PICKAXE_BLAME_COPY_HARDER;
*opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;

if (arg)
blame_copy_score = parse_score(arg);
return 0;
}

static int blame_move_callback(const struct option *option, const char *arg, int unset)
{
int *opt = option->value;

*opt |= PICKAXE_BLAME_MOVE;

if (arg)
blame_move_score = parse_score(arg);
return 0;
}

static int blame_bottomtop_callback(const struct option *option, const char *arg, int unset)
{
const char **bottomtop = option->value;
if (!arg)
return -1;
if (*bottomtop)
die("More than one '-L n,m' option given");
*bottomtop = arg;
return 0;
}

int cmd_blame(int argc, const char **argv, const char *prefix) int cmd_blame(int argc, const char **argv, const char *prefix)
{ {
struct rev_info revs; struct rev_info revs;
@ -2129,102 +2262,66 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
struct scoreboard sb; struct scoreboard sb;
struct origin *o; struct origin *o;
struct blame_entry *ent; struct blame_entry *ent;
int i, seen_dashdash, unk, opt; long dashdash_pos, bottom, top, lno;
long bottom, top, lno;
int output_option = 0;
int show_stats = 0;
const char *revs_file = NULL;
const char *final_commit_name = NULL; const char *final_commit_name = NULL;
enum object_type type; enum object_type type;
const char *bottomtop = NULL;
const char *contents_from = NULL; static const char *bottomtop = NULL;
static int output_option = 0, opt = 0;
static int show_stats = 0;
static const char *revs_file = NULL;
static const char *contents_from = NULL;
static const struct option options[] = {
OPT_BOOLEAN(0, "incremental", &incremental, "Show blame entries as we find them, incrementally"),
OPT_BOOLEAN('b', NULL, &blank_boundary, "Show blank SHA-1 for boundary commits (Default: off)"),
OPT_BOOLEAN(0, "root", &show_root, "Do not treat root commits as boundaries (Default: off)"),
OPT_BOOLEAN(0, "show-stats", &show_stats, "Show work cost statistics"),
OPT_BIT(0, "score-debug", &output_option, "Show output score for blame entries", OUTPUT_SHOW_SCORE),
OPT_BIT('f', "show-name", &output_option, "Show original filename (Default: auto)", OUTPUT_SHOW_NAME),
OPT_BIT('n', "show-number", &output_option, "Show original linenumber (Default: off)", OUTPUT_SHOW_NUMBER),
OPT_BIT('p', "porcelain", &output_option, "Show in a format designed for machine consumption", OUTPUT_PORCELAIN),
OPT_BIT('c', NULL, &output_option, "Use the same output mode as git-annotate (Default: off)", OUTPUT_ANNOTATE_COMPAT),
OPT_BIT('t', NULL, &output_option, "Show raw timestamp (Default: off)", OUTPUT_RAW_TIMESTAMP),
OPT_BIT('l', NULL, &output_option, "Show long commit SHA1 (Default: off)", OUTPUT_LONG_OBJECT_NAME),
OPT_BIT('s', NULL, &output_option, "Suppress author name and timestamp (Default: off)", OUTPUT_NO_AUTHOR),
OPT_BIT('w', NULL, &xdl_opts, "Ignore whitespace differences", XDF_IGNORE_WHITESPACE),
OPT_STRING('S', NULL, &revs_file, "file", "Use revisions from <file> instead of calling git-rev-list"),
OPT_STRING(0, "contents", &contents_from, "file", "Use <file>'s contents as the final image"),
{ OPTION_CALLBACK, 'C', NULL, &opt, "score", "Find line copies within and across files", PARSE_OPT_OPTARG, blame_copy_callback },
{ OPTION_CALLBACK, 'M', NULL, &opt, "score", "Find line movements within and across files", PARSE_OPT_OPTARG, blame_move_callback },
OPT_CALLBACK('L', NULL, &bottomtop, "n,m", "Process only line range n,m, counting from 1", blame_bottomtop_callback),
OPT_END()
};

struct parse_opt_ctx_t ctx;


cmd_is_annotate = !strcmp(argv[0], "annotate"); cmd_is_annotate = !strcmp(argv[0], "annotate");


git_config(git_blame_config, NULL); git_config(git_blame_config, NULL);
init_revisions(&revs, NULL);
save_commit_buffer = 0; save_commit_buffer = 0;

dashdash_pos = 0;
opt = 0;
seen_dashdash = 0; parse_options_start(&ctx, argc, argv, PARSE_OPT_KEEP_DASHDASH |
for (unk = i = 1; i < argc; i++) { PARSE_OPT_KEEP_ARGV0);
const char *arg = argv[i]; for (;;) {
if (*arg != '-') switch (parse_options_step(&ctx, options, blame_opt_usage)) {
break; case PARSE_OPT_HELP:
else if (!strcmp("-b", arg)) exit(129);
blank_boundary = 1; case PARSE_OPT_DONE:
else if (!strcmp("--root", arg)) if (ctx.argv[0])
show_root = 1; dashdash_pos = ctx.cpidx;
else if (!strcmp(arg, "--show-stats")) goto parse_done;
show_stats = 1;
else if (!strcmp("-c", arg))
output_option |= OUTPUT_ANNOTATE_COMPAT;
else if (!strcmp("-t", arg))
output_option |= OUTPUT_RAW_TIMESTAMP;
else if (!strcmp("-l", arg))
output_option |= OUTPUT_LONG_OBJECT_NAME;
else if (!strcmp("-s", arg))
output_option |= OUTPUT_NO_AUTHOR;
else if (!strcmp("-w", arg))
xdl_opts |= XDF_IGNORE_WHITESPACE;
else if (!strcmp("-S", arg) && ++i < argc)
revs_file = argv[i];
else if (!prefixcmp(arg, "-M")) {
opt |= PICKAXE_BLAME_MOVE;
blame_move_score = parse_score(arg+2);
}
else if (!prefixcmp(arg, "-C")) {
/*
* -C enables copy from removed files;
* -C -C enables copy from existing files, but only
* when blaming a new file;
* -C -C -C enables copy from existing files for
* everybody
*/
if (opt & PICKAXE_BLAME_COPY_HARDER)
opt |= PICKAXE_BLAME_COPY_HARDEST;
if (opt & PICKAXE_BLAME_COPY)
opt |= PICKAXE_BLAME_COPY_HARDER;
opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;
blame_copy_score = parse_score(arg+2);
}
else if (!prefixcmp(arg, "-L")) {
if (!arg[2]) {
if (++i >= argc)
usage(blame_usage);
arg = argv[i];
}
else
arg += 2;
if (bottomtop)
die("More than one '-L n,m' option given");
bottomtop = arg;
} }
else if (!strcmp("--contents", arg)) {
if (++i >= argc) if (!strcmp(ctx.argv[0], "--reverse")) {
usage(blame_usage); ctx.argv[0] = "--children";
contents_from = argv[i]; reverse = 1;
}
else if (!strcmp("--incremental", arg))
incremental = 1;
else if (!strcmp("--score-debug", arg))
output_option |= OUTPUT_SHOW_SCORE;
else if (!strcmp("-f", arg) ||
!strcmp("--show-name", arg))
output_option |= OUTPUT_SHOW_NAME;
else if (!strcmp("-n", arg) ||
!strcmp("--show-number", arg))
output_option |= OUTPUT_SHOW_NUMBER;
else if (!strcmp("-p", arg) ||
!strcmp("--porcelain", arg))
output_option |= OUTPUT_PORCELAIN;
else if (!strcmp("--", arg)) {
seen_dashdash = 1;
i++;
break;
} }
else parse_revision_opt(&revs, &ctx, options, blame_opt_usage);
argv[unk++] = arg;
} }
parse_done:
argc = parse_options_end(&ctx);


if (!blame_move_score) if (!blame_move_score)
blame_move_score = BLAME_DEFAULT_MOVE_SCORE; blame_move_score = BLAME_DEFAULT_MOVE_SCORE;
@ -2238,115 +2335,59 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
* *
* The remaining are: * The remaining are:
* *
* (1) if seen_dashdash, its either * (1) if dashdash_pos != 0, its either
* "-options -- <path>" or * "blame [revisions] -- <path>" or
* "-options -- <path> <rev>". * "blame -- <path> <rev>"
* but the latter is allowed only if there is no
* options that we passed to revision machinery.
* *
* (2) otherwise, we may have "--" somewhere later and * (2) otherwise, its one of the two:
* might be looking at the first one of multiple 'rev' * "blame [revisions] <path>"
* parameters (e.g. " master ^next ^maint -- path"). * "blame <path> <rev>"
* See if there is a dashdash first, and give the
* arguments before that to revision machinery.
* After that there must be one 'path'.
* *
* (3) otherwise, its one of the three: * Note that we must strip out <path> from the arguments: we do not
* "-options <path> <rev>" * want the path pruning but we may want "bottom" processing.
* "-options <rev> <path>"
* "-options <path>"
* but again the first one is allowed only if
* there is no options that we passed to revision
* machinery.
*/ */

if (dashdash_pos) {
if (seen_dashdash) { switch (argc - dashdash_pos - 1) {
/* (1) */ case 2: /* (1b) */
if (argc <= i) if (argc != 4)
usage(blame_usage); usage_with_options(blame_opt_usage, options);
path = add_prefix(prefix, argv[i]); /* reorder for the new way: <rev> -- <path> */
if (i + 1 == argc - 1) { argv[1] = argv[3];
if (unk != 1) argv[3] = argv[2];
usage(blame_usage); argv[2] = "--";
argv[unk++] = argv[i + 1]; /* FALLTHROUGH */
case 1: /* (1a) */
path = add_prefix(prefix, argv[--argc]);
argv[argc] = NULL;
break;
default:
usage_with_options(blame_opt_usage, options);
} }
else if (i + 1 != argc) } else {
/* garbage at end */ if (argc < 2)
usage(blame_usage); usage_with_options(blame_opt_usage, options);
} path = add_prefix(prefix, argv[argc - 1]);
else { if (argc == 3 && !has_path_in_work_tree(path)) { /* (2b) */
int j; path = add_prefix(prefix, argv[1]);
for (j = i; !seen_dashdash && j < argc; j++) argv[1] = argv[2];
if (!strcmp(argv[j], "--"))
seen_dashdash = j;
if (seen_dashdash) {
/* (2) */
if (seen_dashdash + 1 != argc - 1)
usage(blame_usage);
path = add_prefix(prefix, argv[seen_dashdash + 1]);
for (j = i; j < seen_dashdash; j++)
argv[unk++] = argv[j];
} }
else { argv[argc - 1] = "--";
/* (3) */
if (argc <= i)
usage(blame_usage);
path = add_prefix(prefix, argv[i]);
if (i + 1 == argc - 1) {
final_commit_name = argv[i + 1];

/* if (unk == 1) we could be getting
* old-style
*/
if (unk == 1 && !has_path_in_work_tree(path)) {
path = add_prefix(prefix, argv[i + 1]);
final_commit_name = argv[i];
}
}
else if (i != argc - 1)
usage(blame_usage); /* garbage at end */


setup_work_tree(); setup_work_tree();
if (!has_path_in_work_tree(path)) if (!has_path_in_work_tree(path))
die("cannot stat path %s: %s", die("cannot stat path %s: %s", path, strerror(errno));
path, strerror(errno));
}
} }


if (final_commit_name) setup_revisions(argc, argv, &revs, NULL);
argv[unk++] = final_commit_name;

/*
* Now we got rev and path. We do not want the path pruning
* but we may want "bottom" processing.
*/
argv[unk++] = "--"; /* terminate the rev name */
argv[unk] = NULL;

init_revisions(&revs, NULL);
setup_revisions(unk, argv, &revs, NULL);
memset(&sb, 0, sizeof(sb)); memset(&sb, 0, sizeof(sb));


/* sb.revs = &revs;
* There must be one and only one positive commit in the if (!reverse)
* revs->pending array. final_commit_name = prepare_final(&sb);
*/ else if (contents_from)
for (i = 0; i < revs.pending.nr; i++) { die("--contents and --children do not blend well.");
struct object *obj = revs.pending.objects[i].item; else
if (obj->flags & UNINTERESTING) final_commit_name = prepare_initial(&sb);
continue;
while (obj->type == OBJ_TAG)
obj = deref_tag(obj, NULL, 0);
if (obj->type != OBJ_COMMIT)
die("Non commit %s?",
revs.pending.objects[i].name);
if (sb.final)
die("More than one commit to dig from %s and %s?",
revs.pending.objects[i].name,
final_commit_name);
sb.final = (struct commit *) obj;
final_commit_name = revs.pending.objects[i].name;
}


if (!sb.final) { if (!sb.final) {
/* /*
@ -2425,7 +2466,7 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
if (!incremental) if (!incremental)
setup_pager(); setup_pager();


assign_blame(&sb, &revs, opt); assign_blame(&sb, opt);


if (incremental) if (incremental)
return 0; return 0;

10
builtin-rev-list.c
Unescape View File

@ -37,6 +37,7 @@ static const char rev_list_usage[] =
" --reverse\n" " --reverse\n"
" formatting output:\n" " formatting output:\n"
" --parents\n" " --parents\n"
" --children\n"
" --objects | --objects-edge\n" " --objects | --objects-edge\n"
" --unpacked\n" " --unpacked\n"
" --header | --pretty\n" " --header | --pretty\n"
@ -90,6 +91,15 @@ static void show_commit(struct commit *commit)
parents = parents->next; parents = parents->next;
} }
} }
if (revs.children.name) {
struct commit_list *children;

children = lookup_decoration(&revs.children, &commit->object);
while (children) {
printf(" %s", sha1_to_hex(children->item->object.sha1));
children = children->next;
}
}
show_decorations(commit); show_decorations(commit);
if (revs.commit_format == CMIT_FMT_ONELINE) if (revs.commit_format == CMIT_FMT_ONELINE)
putchar(' '); putchar(' ');

127
builtin-shortlog.c
Unescape View File

@ -7,9 +7,14 @@
#include "utf8.h" #include "utf8.h"
#include "mailmap.h" #include "mailmap.h"
#include "shortlog.h" #include "shortlog.h"
#include "parse-options.h"


static const char shortlog_usage[] = static char const * const shortlog_usage[] = {
"git-shortlog [-n] [-s] [-e] [-w] [<commit-id>... ]"; "git-shortlog [-n] [-s] [-e] [-w] [rev-opts] [--] [<commit-id>... ]",
"",
"[rev-opts] are documented in git-rev-list(1)",
NULL
};


static int compare_by_number(const void *a1, const void *a2) static int compare_by_number(const void *a1, const void *a2)
{ {
@ -164,21 +169,19 @@ static void get_from_rev(struct rev_info *rev, struct shortlog *log)
shortlog_add_commit(log, commit); shortlog_add_commit(log, commit);
} }


static int parse_uint(char const **arg, int comma) static int parse_uint(char const **arg, int comma, int defval)
{ {
unsigned long ul; unsigned long ul;
int ret; int ret;
char *endp; char *endp;


ul = strtoul(*arg, &endp, 10); ul = strtoul(*arg, &endp, 10);
if (endp != *arg && *endp && *endp != comma) if (*endp && *endp != comma)
return -1; return -1;
ret = (int) ul; if (ul > INT_MAX)
if (ret != ul)
return -1; return -1;
*arg = endp; ret = *arg == endp ? defval : (int)ul;
if (**arg) *arg = *endp ? endp + 1 : endp;
(*arg)++;
return ret; return ret;
} }


@ -187,30 +190,30 @@ static const char wrap_arg_usage[] = "-w[<width>[,<indent1>[,<indent2>]]]";
#define DEFAULT_INDENT1 6 #define DEFAULT_INDENT1 6
#define DEFAULT_INDENT2 9 #define DEFAULT_INDENT2 9


static void parse_wrap_args(const char *arg, int *in1, int *in2, int *wrap) static int parse_wrap_args(const struct option *opt, const char *arg, int unset)
{ {
arg += 2; /* skip -w */ struct shortlog *log = opt->value;


*wrap = parse_uint(&arg, ','); log->wrap_lines = !unset;
if (*wrap < 0) if (unset)
die(wrap_arg_usage); return 0;
*in1 = parse_uint(&arg, ','); if (!arg) {
if (*in1 < 0) log->wrap = DEFAULT_WRAPLEN;
die(wrap_arg_usage); log->in1 = DEFAULT_INDENT1;
*in2 = parse_uint(&arg, '\0'); log->in2 = DEFAULT_INDENT2;
if (*in2 < 0) return 0;
die(wrap_arg_usage); }


if (!*wrap) log->wrap = parse_uint(&arg, ',', DEFAULT_WRAPLEN);
*wrap = DEFAULT_WRAPLEN; log->in1 = parse_uint(&arg, ',', DEFAULT_INDENT1);
if (!*in1) log->in2 = parse_uint(&arg, '\0', DEFAULT_INDENT2);
*in1 = DEFAULT_INDENT1; if (log->wrap < 0 || log->in1 < 0 || log->in2 < 0)
if (!*in2) return error(wrap_arg_usage);
*in2 = DEFAULT_INDENT2; if (log->wrap &&
if (*wrap && ((log->in1 && log->wrap <= log->in1) ||
((*in1 && *wrap <= *in1) || (log->in2 && log->wrap <= log->in2)))
(*in2 && *wrap <= *in2))) return error(wrap_arg_usage);
die(wrap_arg_usage); return 0;
} }


void shortlog_init(struct shortlog *log) void shortlog_init(struct shortlog *log)
@ -227,38 +230,46 @@ void shortlog_init(struct shortlog *log)


int cmd_shortlog(int argc, const char **argv, const char *prefix) int cmd_shortlog(int argc, const char **argv, const char *prefix)
{ {
struct shortlog log; static struct shortlog log;
struct rev_info rev; static struct rev_info rev;
int nongit; int nongit;


static const struct option options[] = {
OPT_BOOLEAN('n', "numbered", &log.sort_by_number,
"sort output according to the number of commits per author"),
OPT_BOOLEAN('s', "summary", &log.summary,
"Suppress commit descriptions, only provides commit count"),
OPT_BOOLEAN('e', "email", &log.email,
"Show the email address of each author"),
{ OPTION_CALLBACK, 'w', NULL, &log, "w[,i1[,i2]]",
"Linewrap output", PARSE_OPT_OPTARG, &parse_wrap_args },
OPT_END(),
};

struct parse_opt_ctx_t ctx;

prefix = setup_git_directory_gently(&nongit); prefix = setup_git_directory_gently(&nongit);
shortlog_init(&log); shortlog_init(&log);

init_revisions(&rev, prefix);
/* since -n is a shadowed rev argument, parse our args first */ parse_options_start(&ctx, argc, argv, PARSE_OPT_KEEP_DASHDASH |
while (argc > 1) { PARSE_OPT_KEEP_ARGV0);
if (!strcmp(argv[1], "-n") || !strcmp(argv[1], "--numbered"))
log.sort_by_number = 1; for (;;) {
else if (!strcmp(argv[1], "-s") || switch (parse_options_step(&ctx, options, shortlog_usage)) {
!strcmp(argv[1], "--summary")) case PARSE_OPT_HELP:
log.summary = 1; exit(129);
else if (!strcmp(argv[1], "-e") || case PARSE_OPT_DONE:
!strcmp(argv[1], "--email")) goto parse_done;
log.email = 1;
else if (!prefixcmp(argv[1], "-w")) {
log.wrap_lines = 1;
parse_wrap_args(argv[1], &log.in1, &log.in2, &log.wrap);
} }
else if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) parse_revision_opt(&rev, &ctx, options, shortlog_usage);
usage(shortlog_usage); }
else parse_done:
break; argc = parse_options_end(&ctx);
argv++;
argc--; if (setup_revisions(argc, argv, &rev, NULL) != 1) {
error("unrecognized argument: %s", argv[1]);
usage_with_options(shortlog_usage, options);
} }
init_revisions(&rev, prefix);
argc = setup_revisions(argc, argv, &rev, NULL);
if (argc > 1)
die ("unrecognized argument: %s", argv[1]);


/* assume HEAD if from a tty */ /* assume HEAD if from a tty */
if (!nongit && !rev.pending.nr && isatty(0)) if (!nongit && !rev.pending.nr && isatty(0))

163
parse-options.c
Unescape View File

@ -1,17 +1,11 @@
#include "git-compat-util.h" #include "git-compat-util.h"
#include "parse-options.h" #include "parse-options.h"
#include "cache.h"


#define OPT_SHORT 1 #define OPT_SHORT 1
#define OPT_UNSET 2 #define OPT_UNSET 2


struct optparse_t { static inline const char *get_arg(struct parse_opt_ctx_t *p)
const char **argv;
const char **out;
int argc, cpidx;
const char *opt;
};

static inline const char *get_arg(struct optparse_t *p)
{ {
if (p->opt) { if (p->opt) {
const char *res = p->opt; const char *res = p->opt;
@ -37,7 +31,7 @@ static int opterror(const struct option *opt, const char *reason, int flags)
return error("option `%s' %s", opt->long_name, reason); return error("option `%s' %s", opt->long_name, reason);
} }


static int get_value(struct optparse_t *p, static int get_value(struct parse_opt_ctx_t *p,
const struct option *opt, int flags) const struct option *opt, int flags)
{ {
const char *s, *arg; const char *s, *arg;
@ -101,14 +95,14 @@ static int get_value(struct optparse_t *p,


case OPTION_CALLBACK: case OPTION_CALLBACK:
if (unset) if (unset)
return (*opt->callback)(opt, NULL, 1); return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
if (opt->flags & PARSE_OPT_NOARG) if (opt->flags & PARSE_OPT_NOARG)
return (*opt->callback)(opt, NULL, 0); return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
if (opt->flags & PARSE_OPT_OPTARG && !p->opt) if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
return (*opt->callback)(opt, NULL, 0); return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
if (!arg) if (!arg)
return opterror(opt, "requires a value", flags); return opterror(opt, "requires a value", flags);
return (*opt->callback)(opt, get_arg(p), 0); return (*opt->callback)(opt, get_arg(p), 0) ? (-1) : 0;


case OPTION_INTEGER: case OPTION_INTEGER:
if (unset) { if (unset) {
@ -131,7 +125,7 @@ static int get_value(struct optparse_t *p,
} }
} }


static int parse_short_opt(struct optparse_t *p, const struct option *options) static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options)
{ {
for (; options->type != OPTION_END; options++) { for (; options->type != OPTION_END; options++) {
if (options->short_name == *p->opt) { if (options->short_name == *p->opt) {
@ -139,10 +133,10 @@ static int parse_short_opt(struct optparse_t *p, const struct option *options)
return get_value(p, options, OPT_SHORT); return get_value(p, options, OPT_SHORT);
} }
} }
return error("unknown switch `%c'", *p->opt); return -2;
} }


static int parse_long_opt(struct optparse_t *p, const char *arg, static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg,
const struct option *options) const struct option *options)
{ {
const char *arg_end = strchr(arg, '='); const char *arg_end = strchr(arg, '=');
@ -224,7 +218,7 @@ is_abbreviated:
abbrev_option->long_name); abbrev_option->long_name);
if (abbrev_option) if (abbrev_option)
return get_value(p, abbrev_option, abbrev_flags); return get_value(p, abbrev_option, abbrev_flags);
return error("unknown option `%s'", arg); return -2;
} }


void check_typos(const char *arg, const struct option *options) void check_typos(const char *arg, const struct option *options)
@ -247,67 +241,126 @@ void check_typos(const char *arg, const struct option *options)
} }
} }


static NORETURN void usage_with_options_internal(const char * const *, void parse_options_start(struct parse_opt_ctx_t *ctx,
const struct option *, int); int argc, const char **argv, int flags)
{
memset(ctx, 0, sizeof(*ctx));
ctx->argc = argc - 1;
ctx->argv = argv + 1;
ctx->out = argv;
ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
ctx->flags = flags;
}


int parse_options(int argc, const char **argv, const struct option *options, static int usage_with_options_internal(const char * const *,
const char * const usagestr[], int flags) const struct option *, int);

int parse_options_step(struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[])
{ {
struct optparse_t args = { argv + 1, argv, argc - 1, 0, NULL }; /* we must reset ->opt, unknown short option leave it dangling */
ctx->opt = NULL;


for (; args.argc; args.argc--, args.argv++) { for (; ctx->argc; ctx->argc--, ctx->argv++) {
const char *arg = args.argv[0]; const char *arg = ctx->argv[0];


if (*arg != '-' || !arg[1]) { if (*arg != '-' || !arg[1]) {
if (flags & PARSE_OPT_STOP_AT_NON_OPTION) if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
break; break;
args.out[args.cpidx++] = args.argv[0]; ctx->out[ctx->cpidx++] = ctx->argv[0];
continue; continue;
} }


if (arg[1] != '-') { if (arg[1] != '-') {
args.opt = arg + 1; ctx->opt = arg + 1;
if (*args.opt == 'h') if (*ctx->opt == 'h')
usage_with_options(usagestr, options); return parse_options_usage(usagestr, options);
if (parse_short_opt(&args, options) < 0) switch (parse_short_opt(ctx, options)) {
usage_with_options(usagestr, options); case -1:
if (args.opt) return parse_options_usage(usagestr, options);
case -2:
return PARSE_OPT_UNKNOWN;
}
if (ctx->opt)
check_typos(arg + 1, options); check_typos(arg + 1, options);
while (args.opt) { while (ctx->opt) {
if (*args.opt == 'h') if (*ctx->opt == 'h')
usage_with_options(usagestr, options); return parse_options_usage(usagestr, options);
if (parse_short_opt(&args, options) < 0) switch (parse_short_opt(ctx, options)) {
usage_with_options(usagestr, options); case -1:
return parse_options_usage(usagestr, options);
case -2:
/* fake a short option thing to hide the fact that we may have
* started to parse aggregated stuff
*
* This is leaky, too bad.
*/
ctx->argv[0] = xstrdup(ctx->opt - 1);
*(char *)ctx->argv[0] = '-';
return PARSE_OPT_UNKNOWN;
}
} }
continue; continue;
} }


if (!arg[2]) { /* "--" */ if (!arg[2]) { /* "--" */
if (!(flags & PARSE_OPT_KEEP_DASHDASH)) { if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
args.argc--; ctx->argc--;
args.argv++; ctx->argv++;
} }
break; break;
} }


if (!strcmp(arg + 2, "help-all")) if (!strcmp(arg + 2, "help-all"))
usage_with_options_internal(usagestr, options, 1); return usage_with_options_internal(usagestr, options, 1);
if (!strcmp(arg + 2, "help")) if (!strcmp(arg + 2, "help"))
usage_with_options(usagestr, options); return parse_options_usage(usagestr, options);
if (parse_long_opt(&args, arg + 2, options)) switch (parse_long_opt(ctx, arg + 2, options)) {
usage_with_options(usagestr, options); case -1:
return parse_options_usage(usagestr, options);
case -2:
return PARSE_OPT_UNKNOWN;
}
} }
return PARSE_OPT_DONE;
}


memmove(args.out + args.cpidx, args.argv, args.argc * sizeof(*args.out)); int parse_options_end(struct parse_opt_ctx_t *ctx)
args.out[args.cpidx + args.argc] = NULL; {
return args.cpidx + args.argc; memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
ctx->out[ctx->cpidx + ctx->argc] = NULL;
return ctx->cpidx + ctx->argc;
}

int parse_options(int argc, const char **argv, const struct option *options,
const char * const usagestr[], int flags)
{
struct parse_opt_ctx_t ctx;

parse_options_start(&ctx, argc, argv, flags);
switch (parse_options_step(&ctx, options, usagestr)) {
case PARSE_OPT_HELP:
exit(129);
case PARSE_OPT_DONE:
break;
default: /* PARSE_OPT_UNKNOWN */
if (ctx.argv[0][1] == '-') {
error("unknown option `%s'", ctx.argv[0] + 2);
} else {
error("unknown switch `%c'", *ctx.opt);
}
usage_with_options(usagestr, options);
}

return parse_options_end(&ctx);
} }


#define USAGE_OPTS_WIDTH 24 #define USAGE_OPTS_WIDTH 24
#define USAGE_GAP 2 #define USAGE_GAP 2


void usage_with_options_internal(const char * const *usagestr, int usage_with_options_internal(const char * const *usagestr,
const struct option *opts, int full) const struct option *opts, int full)
{ {
fprintf(stderr, "usage: %s\n", *usagestr++); fprintf(stderr, "usage: %s\n", *usagestr++);
while (*usagestr && **usagestr) while (*usagestr && **usagestr)
@ -392,15 +445,23 @@ void usage_with_options_internal(const char * const *usagestr,
} }
fputc('\n', stderr); fputc('\n', stderr);


exit(129); return PARSE_OPT_HELP;
} }


void usage_with_options(const char * const *usagestr, void usage_with_options(const char * const *usagestr,
const struct option *opts) const struct option *opts)
{ {
usage_with_options_internal(usagestr, opts, 0); usage_with_options_internal(usagestr, opts, 0);
exit(129);
}

int parse_options_usage(const char * const *usagestr,
const struct option *opts)
{
return usage_with_options_internal(usagestr, opts, 0);
} }



/*----- some often used options -----*/ /*----- some often used options -----*/
#include "cache.h" #include "cache.h"



35
parse-options.h
Unescape View File

@ -20,6 +20,7 @@ enum parse_opt_type {
enum parse_opt_flags { enum parse_opt_flags {
PARSE_OPT_KEEP_DASHDASH = 1, PARSE_OPT_KEEP_DASHDASH = 1,
PARSE_OPT_STOP_AT_NON_OPTION = 2, PARSE_OPT_STOP_AT_NON_OPTION = 2,
PARSE_OPT_KEEP_ARGV0 = 4,
}; };


enum parse_opt_option_flags { enum parse_opt_option_flags {
@ -111,6 +112,40 @@ extern int parse_options(int argc, const char **argv,
extern NORETURN void usage_with_options(const char * const *usagestr, extern NORETURN void usage_with_options(const char * const *usagestr,
const struct option *options); const struct option *options);


/*----- incremantal advanced APIs -----*/

enum {
PARSE_OPT_HELP = -1,
PARSE_OPT_DONE,
PARSE_OPT_UNKNOWN,
};

/*
* It's okay for the caller to consume argv/argc in the usual way.
* Other fields of that structure are private to parse-options and should not
* be modified in any way.
*/
struct parse_opt_ctx_t {
const char **argv;
const char **out;
int argc, cpidx;
const char *opt;
int flags;
};

extern int parse_options_usage(const char * const *usagestr,
const struct option *opts);

extern void parse_options_start(struct parse_opt_ctx_t *ctx,
int argc, const char **argv, int flags);

extern int parse_options_step(struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[]);

extern int parse_options_end(struct parse_opt_ctx_t *ctx);


/*----- some often used options -----*/ /*----- some often used options -----*/
extern int parse_opt_abbrev_cb(const struct option *, const char *, int); extern int parse_opt_abbrev_cb(const struct option *, const char *, int);
extern int parse_opt_approxidate_cb(const struct option *, const char *, int); extern int parse_opt_approxidate_cb(const struct option *, const char *, int);

591
revision.c
Unescape View File

@ -10,6 +10,7 @@
#include "grep.h" #include "grep.h"
#include "reflog-walk.h" #include "reflog-walk.h"
#include "patch-ids.h" #include "patch-ids.h"
#include "decorate.h"


volatile show_early_output_fn_t show_early_output; volatile show_early_output_fn_t show_early_output;


@ -973,6 +974,226 @@ static void add_ignore_packed(struct rev_info *revs, const char *name)
revs->ignore_packed[num] = NULL; revs->ignore_packed[num] = NULL;
} }


static int handle_revision_opt(struct rev_info *revs, int argc, const char **argv,
int *unkc, const char **unkv)
{
const char *arg = argv[0];

/* pseudo revision arguments */
if (!strcmp(arg, "--all") || !strcmp(arg, "--branches") ||
!strcmp(arg, "--tags") || !strcmp(arg, "--remotes") ||
!strcmp(arg, "--reflog") || !strcmp(arg, "--not") ||
!strcmp(arg, "--no-walk") || !strcmp(arg, "--do-walk"))
{
unkv[(*unkc)++] = arg;
return 0;
}

if (!prefixcmp(arg, "--max-count=")) {
revs->max_count = atoi(arg + 12);
} else if (!prefixcmp(arg, "--skip=")) {
revs->skip_count = atoi(arg + 7);
} else if ((*arg == '-') && isdigit(arg[1])) {
/* accept -<digit>, like traditional "head" */
revs->max_count = atoi(arg + 1);
} else if (!strcmp(arg, "-n")) {
if (argc <= 1)
return error("-n requires an argument");
revs->max_count = atoi(argv[1]);
return 2;
} else if (!prefixcmp(arg, "-n")) {
revs->max_count = atoi(arg + 2);
} else if (!prefixcmp(arg, "--max-age=")) {
revs->max_age = atoi(arg + 10);
} else if (!prefixcmp(arg, "--since=")) {
revs->max_age = approxidate(arg + 8);
} else if (!prefixcmp(arg, "--after=")) {
revs->max_age = approxidate(arg + 8);
} else if (!prefixcmp(arg, "--min-age=")) {
revs->min_age = atoi(arg + 10);
} else if (!prefixcmp(arg, "--before=")) {
revs->min_age = approxidate(arg + 9);
} else if (!prefixcmp(arg, "--until=")) {
revs->min_age = approxidate(arg + 8);
} else if (!strcmp(arg, "--first-parent")) {
revs->first_parent_only = 1;
} else if (!strcmp(arg, "-g") || !strcmp(arg, "--walk-reflogs")) {
init_reflog_walk(&revs->reflog_info);
} else if (!strcmp(arg, "--default")) {
if (argc <= 1)
return error("bad --default argument");
revs->def = argv[1];
return 2;
} else if (!strcmp(arg, "--merge")) {
revs->show_merge = 1;
} else if (!strcmp(arg, "--topo-order")) {
revs->lifo = 1;
revs->topo_order = 1;
} else if (!strcmp(arg, "--date-order")) {
revs->lifo = 0;
revs->topo_order = 1;
} else if (!prefixcmp(arg, "--early-output")) {
int count = 100;
switch (arg[14]) {
case '=':
count = atoi(arg+15);
/* Fallthrough */
case 0:
revs->topo_order = 1;
revs->early_output = count;
}
} else if (!strcmp(arg, "--parents")) {
revs->rewrite_parents = 1;
revs->print_parents = 1;
} else if (!strcmp(arg, "--dense")) {
revs->dense = 1;
} else if (!strcmp(arg, "--sparse")) {
revs->dense = 0;
} else if (!strcmp(arg, "--show-all")) {
revs->show_all = 1;
} else if (!strcmp(arg, "--remove-empty")) {
revs->remove_empty_trees = 1;
} else if (!strcmp(arg, "--no-merges")) {
revs->no_merges = 1;
} else if (!strcmp(arg, "--boundary")) {
revs->boundary = 1;
} else if (!strcmp(arg, "--left-right")) {
revs->left_right = 1;
} else if (!strcmp(arg, "--cherry-pick")) {
revs->cherry_pick = 1;
revs->limited = 1;
} else if (!strcmp(arg, "--objects")) {
revs->tag_objects = 1;
revs->tree_objects = 1;
revs->blob_objects = 1;
} else if (!strcmp(arg, "--objects-edge")) {
revs->tag_objects = 1;
revs->tree_objects = 1;
revs->blob_objects = 1;
revs->edge_hint = 1;
} else if (!strcmp(arg, "--unpacked")) {
revs->unpacked = 1;
free(revs->ignore_packed);
revs->ignore_packed = NULL;
revs->num_ignore_packed = 0;
} else if (!prefixcmp(arg, "--unpacked=")) {
revs->unpacked = 1;
add_ignore_packed(revs, arg+11);
} else if (!strcmp(arg, "-r")) {
revs->diff = 1;
DIFF_OPT_SET(&revs->diffopt, RECURSIVE);
} else if (!strcmp(arg, "-t")) {
revs->diff = 1;
DIFF_OPT_SET(&revs->diffopt, RECURSIVE);
DIFF_OPT_SET(&revs->diffopt, TREE_IN_RECURSIVE);
} else if (!strcmp(arg, "-m")) {
revs->ignore_merges = 0;
} else if (!strcmp(arg, "-c")) {
revs->diff = 1;
revs->dense_combined_merges = 0;
revs->combine_merges = 1;
} else if (!strcmp(arg, "--cc")) {
revs->diff = 1;
revs->dense_combined_merges = 1;
revs->combine_merges = 1;
} else if (!strcmp(arg, "-v")) {
revs->verbose_header = 1;
} else if (!strcmp(arg, "--pretty")) {
revs->verbose_header = 1;
get_commit_format(arg+8, revs);
} else if (!prefixcmp(arg, "--pretty=")) {
revs->verbose_header = 1;
get_commit_format(arg+9, revs);
} else if (!strcmp(arg, "--graph")) {
revs->topo_order = 1;
revs->rewrite_parents = 1;
revs->graph = graph_init(revs);
} else if (!strcmp(arg, "--root")) {
revs->show_root_diff = 1;
} else if (!strcmp(arg, "--no-commit-id")) {
revs->no_commit_id = 1;
} else if (!strcmp(arg, "--always")) {
revs->always_show_header = 1;
} else if (!strcmp(arg, "--no-abbrev")) {
revs->abbrev = 0;
} else if (!strcmp(arg, "--abbrev")) {
revs->abbrev = DEFAULT_ABBREV;
} else if (!prefixcmp(arg, "--abbrev=")) {
revs->abbrev = strtoul(arg + 9, NULL, 10);
if (revs->abbrev < MINIMUM_ABBREV)
revs->abbrev = MINIMUM_ABBREV;
else if (revs->abbrev > 40)
revs->abbrev = 40;
} else if (!strcmp(arg, "--abbrev-commit")) {
revs->abbrev_commit = 1;
} else if (!strcmp(arg, "--full-diff")) {
revs->diff = 1;
revs->full_diff = 1;
} else if (!strcmp(arg, "--full-history")) {
revs->simplify_history = 0;
} else if (!strcmp(arg, "--relative-date")) {
revs->date_mode = DATE_RELATIVE;
} else if (!strncmp(arg, "--date=", 7)) {
revs->date_mode = parse_date_format(arg + 7);
} else if (!strcmp(arg, "--log-size")) {
revs->show_log_size = 1;
}
/*
* Grepping the commit log
*/
else if (!prefixcmp(arg, "--author=")) {
add_header_grep(revs, "author", arg+9);
} else if (!prefixcmp(arg, "--committer=")) {
add_header_grep(revs, "committer", arg+12);
} else if (!prefixcmp(arg, "--grep=")) {
add_message_grep(revs, arg+7);
} else if (!strcmp(arg, "--extended-regexp") || !strcmp(arg, "-E")) {
if (revs->grep_filter)
revs->grep_filter->regflags |= REG_EXTENDED;
} else if (!strcmp(arg, "--regexp-ignore-case") || !strcmp(arg, "-i")) {
if (revs->grep_filter)
revs->grep_filter->regflags |= REG_ICASE;
} else if (!strcmp(arg, "--fixed-strings") || !strcmp(arg, "-F")) {
if (revs->grep_filter)
revs->grep_filter->fixed = 1;
} else if (!strcmp(arg, "--all-match")) {
if (revs->grep_filter)
revs->grep_filter->all_match = 1;
} else if (!prefixcmp(arg, "--encoding=")) {
arg += 11;
if (strcmp(arg, "none"))
git_log_output_encoding = xstrdup(arg);
else
git_log_output_encoding = "";
} else if (!strcmp(arg, "--reverse")) {
revs->reverse ^= 1;
} else if (!strcmp(arg, "--children")) {
revs->children.name = "children";
revs->limited = 1;
} else {
int opts = diff_opt_parse(&revs->diffopt, argv, argc);
if (!opts)
unkv[(*unkc)++] = arg;
return opts;
}

return 1;
}

void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[])
{
int n = handle_revision_opt(revs, ctx->argc, ctx->argv,
&ctx->cpidx, ctx->out);
if (n <= 0) {
error("unknown option `%s'", ctx->argv[0]);
usage_with_options(usagestr, options);
}
ctx->argv += n;
ctx->argc -= n;
}

/* /*
* Parse revision information, filling in the "rev_info" structure, * Parse revision information, filling in the "rev_info" structure,
* and removing the used arguments from the argument list. * and removing the used arguments from the argument list.
@ -982,12 +1203,7 @@ static void add_ignore_packed(struct rev_info *revs, const char *name)
*/ */
int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def) int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def)
{ {
int i, flags, seen_dashdash, show_merge; int i, flags, left, seen_dashdash;
const char **unrecognized = argv + 1;
int left = 1;
int all_match = 0;
int regflags = 0;
int fixed = 0;


/* First, search for "--" */ /* First, search for "--" */
seen_dashdash = 0; seen_dashdash = 0;
@ -1003,58 +1219,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
break; break;
} }


flags = show_merge = 0; /* Second, deal with arguments and options */
for (i = 1; i < argc; i++) { flags = 0;
for (left = i = 1; i < argc; i++) {
const char *arg = argv[i]; const char *arg = argv[i];
if (*arg == '-') { if (*arg == '-') {
int opts; int opts;
if (!prefixcmp(arg, "--max-count=")) {
revs->max_count = atoi(arg + 12);
continue;
}
if (!prefixcmp(arg, "--skip=")) {
revs->skip_count = atoi(arg + 7);
continue;
}
/* accept -<digit>, like traditional "head" */
if ((*arg == '-') && isdigit(arg[1])) {
revs->max_count = atoi(arg + 1);
continue;
}
if (!strcmp(arg, "-n")) {
if (argc <= i + 1)
die("-n requires an argument");
revs->max_count = atoi(argv[++i]);
continue;
}
if (!prefixcmp(arg, "-n")) {
revs->max_count = atoi(arg + 2);
continue;
}
if (!prefixcmp(arg, "--max-age=")) {
revs->max_age = atoi(arg + 10);
continue;
}
if (!prefixcmp(arg, "--since=")) {
revs->max_age = approxidate(arg + 8);
continue;
}
if (!prefixcmp(arg, "--after=")) {
revs->max_age = approxidate(arg + 8);
continue;
}
if (!prefixcmp(arg, "--min-age=")) {
revs->min_age = atoi(arg + 10);
continue;
}
if (!prefixcmp(arg, "--before=")) {
revs->min_age = approxidate(arg + 9);
continue;
}
if (!prefixcmp(arg, "--until=")) {
revs->min_age = approxidate(arg + 8);
continue;
}
if (!strcmp(arg, "--all")) { if (!strcmp(arg, "--all")) {
handle_refs(revs, flags, for_each_ref); handle_refs(revs, flags, for_each_ref);
continue; continue;
@ -1071,265 +1242,14 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
handle_refs(revs, flags, for_each_remote_ref); handle_refs(revs, flags, for_each_remote_ref);
continue; continue;
} }
if (!strcmp(arg, "--first-parent")) {
revs->first_parent_only = 1;
continue;
}
if (!strcmp(arg, "--reflog")) { if (!strcmp(arg, "--reflog")) {
handle_reflog(revs, flags); handle_reflog(revs, flags);
continue; continue;
} }
if (!strcmp(arg, "-g") ||
!strcmp(arg, "--walk-reflogs")) {
init_reflog_walk(&revs->reflog_info);
continue;
}
if (!strcmp(arg, "--not")) { if (!strcmp(arg, "--not")) {
flags ^= UNINTERESTING; flags ^= UNINTERESTING;
continue; continue;
} }
if (!strcmp(arg, "--default")) {
if (++i >= argc)
die("bad --default argument");
def = argv[i];
continue;
}
if (!strcmp(arg, "--merge")) {
show_merge = 1;
continue;
}
if (!strcmp(arg, "--topo-order")) {
revs->lifo = 1;
revs->topo_order = 1;
continue;
}
if (!strcmp(arg, "--date-order")) {
revs->lifo = 0;
revs->topo_order = 1;
continue;
}
if (!prefixcmp(arg, "--early-output")) {
int count = 100;
switch (arg[14]) {
case '=':
count = atoi(arg+15);
/* Fallthrough */
case 0:
revs->topo_order = 1;
revs->early_output = count;
continue;
}
}
if (!strcmp(arg, "--parents")) {
revs->rewrite_parents = 1;
revs->print_parents = 1;
continue;
}
if (!strcmp(arg, "--dense")) {
revs->dense = 1;
continue;
}
if (!strcmp(arg, "--sparse")) {
revs->dense = 0;
continue;
}
if (!strcmp(arg, "--show-all")) {
revs->show_all = 1;
continue;
}
if (!strcmp(arg, "--remove-empty")) {
revs->remove_empty_trees = 1;
continue;
}
if (!strcmp(arg, "--no-merges")) {
revs->no_merges = 1;
continue;
}
if (!strcmp(arg, "--boundary")) {
revs->boundary = 1;
continue;
}
if (!strcmp(arg, "--left-right")) {
revs->left_right = 1;
continue;
}
if (!strcmp(arg, "--cherry-pick")) {
revs->cherry_pick = 1;
revs->limited = 1;
continue;
}
if (!strcmp(arg, "--objects")) {
revs->tag_objects = 1;
revs->tree_objects = 1;
revs->blob_objects = 1;
continue;
}
if (!strcmp(arg, "--objects-edge")) {
revs->tag_objects = 1;
revs->tree_objects = 1;
revs->blob_objects = 1;
revs->edge_hint = 1;
continue;
}
if (!strcmp(arg, "--unpacked")) {
revs->unpacked = 1;
free(revs->ignore_packed);
revs->ignore_packed = NULL;
revs->num_ignore_packed = 0;
continue;
}
if (!prefixcmp(arg, "--unpacked=")) {
revs->unpacked = 1;
add_ignore_packed(revs, arg+11);
continue;
}
if (!strcmp(arg, "-r")) {
revs->diff = 1;
DIFF_OPT_SET(&revs->diffopt, RECURSIVE);
continue;
}
if (!strcmp(arg, "-t")) {
revs->diff = 1;
DIFF_OPT_SET(&revs->diffopt, RECURSIVE);
DIFF_OPT_SET(&revs->diffopt, TREE_IN_RECURSIVE);
continue;
}
if (!strcmp(arg, "-m")) {
revs->ignore_merges = 0;
continue;
}
if (!strcmp(arg, "-c")) {
revs->diff = 1;
revs->dense_combined_merges = 0;
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;
continue;
}
if (!strcmp(arg, "--pretty")) {
revs->verbose_header = 1;
get_commit_format(arg+8, revs);
continue;
}
if (!prefixcmp(arg, "--pretty=")) {
revs->verbose_header = 1;
get_commit_format(arg+9, revs);
continue;
}
if (!strcmp(arg, "--graph")) {
revs->topo_order = 1;
revs->rewrite_parents = 1;
revs->graph = graph_init(revs);
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 (!prefixcmp(arg, "--abbrev=")) {
revs->abbrev = strtoul(arg + 9, NULL, 10);
if (revs->abbrev < MINIMUM_ABBREV)
revs->abbrev = MINIMUM_ABBREV;
else if (revs->abbrev > 40)
revs->abbrev = 40;
continue;
}
if (!strcmp(arg, "--abbrev-commit")) {
revs->abbrev_commit = 1;
continue;
}
if (!strcmp(arg, "--full-diff")) {
revs->diff = 1;
revs->full_diff = 1;
continue;
}
if (!strcmp(arg, "--full-history")) {
revs->simplify_history = 0;
continue;
}
if (!strcmp(arg, "--relative-date")) {
revs->date_mode = DATE_RELATIVE;
continue;
}
if (!strncmp(arg, "--date=", 7)) {
revs->date_mode = parse_date_format(arg + 7);
continue;
}
if (!strcmp(arg, "--log-size")) {
revs->show_log_size = 1;
continue;
}

/*
* Grepping the commit log
*/
if (!prefixcmp(arg, "--author=")) {
add_header_grep(revs, "author", arg+9);
continue;
}
if (!prefixcmp(arg, "--committer=")) {
add_header_grep(revs, "committer", arg+12);
continue;
}
if (!prefixcmp(arg, "--grep=")) {
add_message_grep(revs, arg+7);
continue;
}
if (!strcmp(arg, "--extended-regexp") ||
!strcmp(arg, "-E")) {
regflags |= REG_EXTENDED;
continue;
}
if (!strcmp(arg, "--regexp-ignore-case") ||
!strcmp(arg, "-i")) {
regflags |= REG_ICASE;
continue;
}
if (!strcmp(arg, "--fixed-strings") ||
!strcmp(arg, "-F")) {
fixed = 1;
continue;
}
if (!strcmp(arg, "--all-match")) {
all_match = 1;
continue;
}
if (!prefixcmp(arg, "--encoding=")) {
arg += 11;
if (strcmp(arg, "none"))
git_log_output_encoding = xstrdup(arg);
else
git_log_output_encoding = "";
continue;
}
if (!strcmp(arg, "--reverse")) {
revs->reverse ^= 1;
continue;
}
if (!strcmp(arg, "--no-walk")) { if (!strcmp(arg, "--no-walk")) {
revs->no_walk = 1; revs->no_walk = 1;
continue; continue;
@ -1339,13 +1259,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
continue; continue;
} }


opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i); opts = handle_revision_opt(revs, argc - i, argv + i, &left, argv);
if (opts > 0) { if (opts > 0) {
i += opts - 1; i += opts - 1;
continue; continue;
} }
*unrecognized++ = arg; if (opts < 0)
left++; exit(128);
continue; continue;
} }


@ -1369,21 +1289,18 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
} }
} }


if (revs->grep_filter) { if (revs->def == NULL)
revs->grep_filter->regflags |= regflags; revs->def = def;
revs->grep_filter->fixed = fixed; if (revs->show_merge)
}

if (show_merge)
prepare_show_merge(revs); prepare_show_merge(revs);
if (def && !revs->pending.nr) { if (revs->def && !revs->pending.nr) {
unsigned char sha1[20]; unsigned char sha1[20];
struct object *object; struct object *object;
unsigned mode; unsigned mode;
if (get_sha1_with_mode(def, sha1, &mode)) if (get_sha1_with_mode(revs->def, sha1, &mode))
die("bad default revision '%s'", def); die("bad default revision '%s'", revs->def);
object = get_reference(revs, def, sha1, 0); object = get_reference(revs, revs->def, sha1, 0);
add_pending_object_with_mode(revs, object, def, mode); add_pending_object_with_mode(revs, object, revs->def, mode);
} }


/* Did the user ask for any diff output? Run the diff! */ /* Did the user ask for any diff output? Run the diff! */
@ -1417,12 +1334,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
die("diff_setup_done failed"); die("diff_setup_done failed");


if (revs->grep_filter) { if (revs->grep_filter) {
revs->grep_filter->all_match = all_match;
compile_grep_patterns(revs->grep_filter); compile_grep_patterns(revs->grep_filter);
} }


if (revs->reverse && revs->reflog_info) if (revs->reverse && revs->reflog_info)
die("cannot combine --reverse with --walk-reflogs"); die("cannot combine --reverse with --walk-reflogs");
if (revs->rewrite_parents && revs->children.name)
die("cannot combine --parents and --children");


/* /*
* Limitations on the graph functionality * Limitations on the graph functionality
@ -1436,6 +1354,26 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
return left; return left;
} }


static void add_child(struct rev_info *revs, struct commit *parent, struct commit *child)
{
struct commit_list *l = xcalloc(1, sizeof(*l));

l->item = child;
l->next = add_decoration(&revs->children, &parent->object, l);
}

static void set_children(struct rev_info *revs)
{
struct commit_list *l;
for (l = revs->commits; l; l = l->next) {
struct commit *commit = l->item;
struct commit_list *p;

for (p = commit->parents; p; p = p->next)
add_child(revs, p->item, commit);
}
}

int prepare_revision_walk(struct rev_info *revs) int prepare_revision_walk(struct rev_info *revs)
{ {
int nr = revs->pending.nr; int nr = revs->pending.nr;
@ -1464,6 +1402,8 @@ int prepare_revision_walk(struct rev_info *revs)
return -1; return -1;
if (revs->topo_order) if (revs->topo_order)
sort_in_topological_order(&revs->commits, revs->lifo); sort_in_topological_order(&revs->commits, revs->lifo);
if (revs->children.name)
set_children(revs);
return 0; return 0;
} }


@ -1541,6 +1481,11 @@ static int commit_match(struct commit *commit, struct rev_info *opt)
commit->buffer, strlen(commit->buffer)); commit->buffer, strlen(commit->buffer));
} }


static inline int want_ancestry(struct rev_info *revs)
{
return (revs->rewrite_parents || revs->children.name);
}

enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit) enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit)
{ {
if (commit->object.flags & SHOWN) if (commit->object.flags & SHOWN)
@ -1561,13 +1506,13 @@ enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit)
/* Commit without changes? */ /* Commit without changes? */
if (commit->object.flags & TREESAME) { if (commit->object.flags & TREESAME) {
/* drop merges unless we want parenthood */ /* drop merges unless we want parenthood */
if (!revs->rewrite_parents) if (!want_ancestry(revs))
return commit_ignore; return commit_ignore;
/* non-merge - always ignore it */ /* non-merge - always ignore it */
if (!commit->parents || !commit->parents->next) if (!commit->parents || !commit->parents->next)
return commit_ignore; return commit_ignore;
} }
if (revs->rewrite_parents && rewrite_parents(revs, commit) < 0) if (want_ancestry(revs) && rewrite_parents(revs, commit) < 0)
return commit_error; return commit_error;
} }
return commit_show; return commit_show;

8
revision.h
Unescape View File

@ -1,6 +1,8 @@
#ifndef REVISION_H #ifndef REVISION_H
#define REVISION_H #define REVISION_H


#include "parse-options.h"

#define SEEN (1u<<0) #define SEEN (1u<<0)
#define UNINTERESTING (1u<<1) #define UNINTERESTING (1u<<1)
#define TREESAME (1u<<2) #define TREESAME (1u<<2)
@ -26,6 +28,7 @@ struct rev_info {


/* Basic information */ /* Basic information */
const char *prefix; const char *prefix;
const char *def;
void *prune_data; void *prune_data;
unsigned int early_output; unsigned int early_output;


@ -66,6 +69,7 @@ struct rev_info {


/* Format info */ /* Format info */
unsigned int shown_one:1, unsigned int shown_one:1,
show_merge:1,
abbrev_commit:1, abbrev_commit:1,
use_terminator:1, use_terminator:1,
missing_newline:1; missing_newline:1;
@ -105,6 +109,7 @@ struct rev_info {
struct diff_options pruning; struct diff_options pruning;


struct reflog_walk_info *reflog_info; struct reflog_walk_info *reflog_info;
struct decoration children;
}; };


#define REV_TREE_SAME 0 #define REV_TREE_SAME 0
@ -119,6 +124,9 @@ volatile show_early_output_fn_t show_early_output;


extern void init_revisions(struct rev_info *revs, const char *prefix); extern void init_revisions(struct rev_info *revs, const char *prefix);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def); extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def);
extern void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[]);
extern int handle_revision_arg(const char *arg, struct rev_info *revs,int flags,int cant_be_filename); extern int handle_revision_arg(const char *arg, struct rev_info *revs,int flags,int cant_be_filename);


extern int prepare_revision_walk(struct rev_info *revs); extern int prepare_revision_walk(struct rev_info *revs);

Write Preview
Loading…
Cancel
Save