2006-02-26 00:19:46 +00:00
|
|
|
#ifndef REVISION_H
|
|
|
|
|
#define REVISION_H
|
|
|
|
|
|
2008-07-09 21:38:34 +00:00
|
|
|
#include "parse-options.h"
|
2008-08-25 06:15:05 +00:00
|
|
|
#include "grep.h"
|
2010-03-12 17:04:26 +00:00
|
|
|
#include "notes.h"
|
2008-07-09 21:38:34 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
#define SEEN (1u<<0)
|
|
|
|
|
#define UNINTERESTING (1u<<1)
|
2007-11-13 07:16:08 +00:00
|
|
|
#define TREESAME (1u<<2)
|
2006-02-28 23:07:20 +00:00
|
|
|
#define SHOWN (1u<<3)
|
2006-03-01 08:58:56 +00:00
|
|
|
#define TMP_MARK (1u<<4) /* for isolated cases; clean after use */
|
2006-03-28 07:58:34 +00:00
|
|
|
#define BOUNDARY (1u<<5)
|
2007-03-06 00:10:28 +00:00
|
|
|
#define CHILD_SHOWN (1u<<6)
|
2006-04-17 01:12:49 +00:00
|
|
|
#define ADDED (1u<<7) /* Parents already parsed and added? */
|
2006-10-23 00:32:47 +00:00
|
|
|
#define SYMMETRIC_LEFT (1u<<8)
|
2011-03-07 12:31:40 +00:00
|
|
|
#define PATCHSAME (1u<<9)
|
|
|
|
|
#define ALL_REV_FLAGS ((1u<<10)-1)
|
2006-02-26 00:19:46 +00:00
|
|
|
|
2009-08-15 14:23:12 +00:00
|
|
|
#define DECORATE_SHORT_REFS 1
|
|
|
|
|
#define DECORATE_FULL_REFS 2
|
|
|
|
|
|
2006-03-10 09:21:39 +00:00
|
|
|
struct rev_info;
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
struct log_info;
|
2010-03-12 17:04:26 +00:00
|
|
|
struct string_list;
|
2006-03-10 09:21:39 +00:00
|
|
|
|
2011-08-26 00:35:39 +00:00
|
|
|
struct rev_cmdline_info {
|
|
|
|
|
unsigned int nr;
|
|
|
|
|
unsigned int alloc;
|
|
|
|
|
struct rev_cmdline_entry {
|
|
|
|
|
struct object *item;
|
|
|
|
|
const char *name;
|
|
|
|
|
enum {
|
|
|
|
|
REV_CMD_REF,
|
|
|
|
|
REV_CMD_PARENTS_ONLY,
|
|
|
|
|
REV_CMD_LEFT,
|
|
|
|
|
REV_CMD_RIGHT,
|
|
|
|
|
REV_CMD_REV
|
|
|
|
|
} whence;
|
|
|
|
|
unsigned flags;
|
|
|
|
|
} *rev;
|
|
|
|
|
};
|
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
struct rev_info {
|
|
|
|
|
/* Starting list */
|
|
|
|
|
struct commit_list *commits;
|
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 00:42:35 +00:00
|
|
|
struct object_array pending;
|
2006-02-26 00:19:46 +00:00
|
|
|
|
revision walker: Fix --boundary when limited
This cleans up the boundary processing in the commit walker. It
- rips out the boundary logic from the commit walker. Placing
"negative" commits in the revs->commits list was Ok if all we
cared about "boundary" was the UNINTERESTING limiting case,
but conceptually it was wrong.
- makes get_revision_1() function to walk the commits and return
the results as if there is no funny postprocessing flags such
as --reverse, --skip nor --max-count.
- makes get_revision() function the postprocessing phase:
If reverse is given, wait for get_revision_1() to give
everything that it would normally give, and then reverse it
before consuming.
If skip is given, skip that many before going further.
If max is given, stop when we gave out that many.
Now that we are about to return one positive commit, mark
the parents of that commit to be potential boundaries
before returning, iff we are doing the boundary processing.
Return the commit.
- After get_revision() finishes giving out all the positive
commits, if we are doing the boundary processing, we look at
the parents that we marked as potential boundaries earlier,
see if they are really boundaries, and give them out.
It loses more code than it adds, even when the new gc_boundary()
function, which is purely for early optimization, is counted.
Note that this patch is purely for eyeballing and discussion
only. It breaks git-bundle's verify logic because the logic
does not use BOUNDARY_SHOW flag for its internal computation
anymore. After we correct it not to attempt to affect the
boundary processing by setting the BOUNDARY_SHOW flag, we can
remove BOUNDARY_SHOW from revision.h and use that bit assignment
for the new CHILD_SHOWN flag.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-05 21:10:06 +00:00
|
|
|
/* Parents of shown commits */
|
|
|
|
|
struct object_array boundary_commits;
|
|
|
|
|
|
2011-08-26 00:35:39 +00:00
|
|
|
/* The end-points specified by the end user */
|
|
|
|
|
struct rev_cmdline_info cmdline;
|
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
/* Basic information */
|
|
|
|
|
const char *prefix;
|
2008-07-08 13:19:33 +00:00
|
|
|
const char *def;
|
2010-12-17 12:43:06 +00:00
|
|
|
struct pathspec prune_data;
|
2011-05-19 01:08:09 +00:00
|
|
|
unsigned int early_output:1,
|
|
|
|
|
ignore_missing:1;
|
2007-11-03 18:11:10 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
/* Traversal flags */
|
|
|
|
|
unsigned int dense:1,
|
2007-11-05 21:22:34 +00:00
|
|
|
prune:1,
|
2006-04-15 19:09:56 +00:00
|
|
|
no_walk:1,
|
Add "--show-all" revision walker flag for debugging
It's really not very easy to visualize the commit walker, because - on
purpose - it obvously doesn't show the uninteresting commits!
This adds a "--show-all" flag to the revision walker, which will make
it show uninteresting commits too, and they'll have a '^' in front of
them (it also fixes a logic error for !verbose_header for boundary
commits - we should show the '-' even if left_right isn't shown).
A separate patch to gitk to teach it the new '^' was sent
to paulus. With the change in place, it actually is interesting
even for the cases that git doesn't have any problems with, ie
for the kernel you can do:
gitk -d --show-all v2.6.24..
and you see just how far down it has to parse things to see it all. The
use of "-d" is a good idea, since the date-ordered toposort is much better
at showing why it goes deep down (ie the date of some of those commits
after 2.6.24 is much older, because they were merged from trees that
weren't rebased).
So I think this is a useful feature even for non-debugging - just to
visualize what git does internally more.
When it actually breaks out due to the "everybody_uninteresting()"
case, it adds the uninteresting commits (both the one it's looking at
now, and the list of pending ones) to the list
This way, we really list *all* the commits we've looked at.
Because we now end up listing commits we may not even have been parsed
at all "show_log" and "show_commit" need to protect against commits
that don't have a commit buffer entry.
That second part is debatable just how it should work. Maybe we shouldn't
show such entries at all (with this patch those entries do get shown, they
just don't get any message shown with them). But I think this is a useful
case.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-09 22:02:07 +00:00
|
|
|
show_all:1,
|
2006-02-26 00:19:46 +00:00
|
|
|
remove_empty_trees:1,
|
2006-06-11 17:57:35 +00:00
|
|
|
simplify_history:1,
|
2006-02-26 00:19:46 +00:00
|
|
|
lifo:1,
|
|
|
|
|
topo_order:1,
|
revision traversal: show full history with merge simplification
The --full-history traversal keeps all merges in addition to non-merge
commits that touch paths in the given pathspec. This is useful to view
both sides of a merge in a topology like this:
A---M---o
/ /
---O---B
even when A and B makes identical change to the given paths. The revision
traversal without --full-history aims to come up with the simplest history
to explain the final state of the tree, and one of the side branches can
be pruned away.
The behaviour to keep all merges however is inconvenient if neither A nor
B touches the paths we are interested in. --full-history reduces the
topology to:
---O---M---o
in such a case, without removing M.
This adds a post processing phase on top of --full-history traversal to
remove needless merges from the resulting history.
The idea is to compute, for each commit in the "full history" result set,
the commit that should replace it in the simplified history. The commit
to replace it in the final history is determined as follows:
* In any case, we first figure out the replacement commits of parents of
the commit we are looking at. The commit we are looking at is
rewritten as if the replacement commits of its original parents are its
parents. While doing so, we reduce the redundant parents from the
rewritten parent list by not just removing the identical ones, but also
removing a parent that is an ancestor of another parent.
* After the above parent simplification, if the commit is a root commit,
an UNINTERESTING commit, a merge commit, or modifies the paths we are
interested in, then the replacement commit of the commit is itself. In
other words, such a commit is not dropped from the final result.
The first point above essentially means that the history is rewritten in
the bottom up direction. We can rewrite the parent list of a commit only
after we know how all of its parents are rewritten. This means that the
processing needs to happen on the full history (i.e. after limit_list()).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-31 08:17:41 +00:00
|
|
|
simplify_merges:1,
|
2008-11-03 19:25:46 +00:00
|
|
|
simplify_by_decoration:1,
|
2006-02-26 00:19:46 +00:00
|
|
|
tag_objects:1,
|
|
|
|
|
tree_objects:1,
|
|
|
|
|
blob_objects:1,
|
2011-09-01 22:43:34 +00:00
|
|
|
verify_objects:1,
|
2006-02-27 16:54:36 +00:00
|
|
|
edge_hint:1,
|
|
|
|
|
limited:1,
|
2009-02-28 08:00:21 +00:00
|
|
|
unpacked:1,
|
revision walker: Fix --boundary when limited
This cleans up the boundary processing in the commit walker. It
- rips out the boundary logic from the commit walker. Placing
"negative" commits in the revs->commits list was Ok if all we
cared about "boundary" was the UNINTERESTING limiting case,
but conceptually it was wrong.
- makes get_revision_1() function to walk the commits and return
the results as if there is no funny postprocessing flags such
as --reverse, --skip nor --max-count.
- makes get_revision() function the postprocessing phase:
If reverse is given, wait for get_revision_1() to give
everything that it would normally give, and then reverse it
before consuming.
If skip is given, skip that many before going further.
If max is given, stop when we gave out that many.
Now that we are about to return one positive commit, mark
the parents of that commit to be potential boundaries
before returning, iff we are doing the boundary processing.
Return the commit.
- After get_revision() finishes giving out all the positive
commits, if we are doing the boundary processing, we look at
the parents that we marked as potential boundaries earlier,
see if they are really boundaries, and give them out.
It loses more code than it adds, even when the new gc_boundary()
function, which is purely for early optimization, is counted.
Note that this patch is purely for eyeballing and discussion
only. It breaks git-bundle's verify logic because the logic
does not use BOUNDARY_SHOW flag for its internal computation
anymore. After we correct it not to attempt to affect the
boundary processing by setting the BOUNDARY_SHOW flag, we can
remove BOUNDARY_SHOW from revision.h and use that bit assignment
for the new CHILD_SHOWN flag.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-05 21:10:06 +00:00
|
|
|
boundary:2,
|
2010-06-10 11:47:23 +00:00
|
|
|
count:1,
|
2006-12-16 23:31:25 +00:00
|
|
|
left_right:1,
|
2011-02-21 16:09:11 +00:00
|
|
|
left_only:1,
|
|
|
|
|
right_only:1,
|
2008-05-04 10:36:52 +00:00
|
|
|
rewrite_parents:1,
|
|
|
|
|
print_parents:1,
|
2008-10-27 19:51:59 +00:00
|
|
|
show_source:1,
|
2008-11-03 19:23:57 +00:00
|
|
|
show_decorations:1,
|
2007-03-13 08:57:22 +00:00
|
|
|
reverse:1,
|
2008-08-29 19:18:38 +00:00
|
|
|
reverse_output_stage:1,
|
2007-04-09 10:40:38 +00:00
|
|
|
cherry_pick:1,
|
2011-03-07 12:31:40 +00:00
|
|
|
cherry_mark:1,
|
2009-10-27 18:28:07 +00:00
|
|
|
bisect:1,
|
revision: --ancestry-path
"rev-list A..H" computes the set of commits that are ancestors of H, but
excludes the ones that are ancestors of A. This is useful to see what
happened to the history leading to H since A, in the sense that "what does
H have that did not exist in A" (e.g. when you have a choice to update to
H from A).
x---x---A---B---C <-- topic
/ \
x---x---x---o---o---o---o---M---D---E---F---G <-- dev
/ \
x---o---o---o---o---o---o---o---o---o---o---o---N---H <-- master
The result in the above example would be the commits marked with caps
letters (except for A itself, of course), and the ones marked with 'o'.
When you want to find out what commits in H are contaminated with the bug
introduced by A and need fixing, however, you might want to view only the
subset of "A..B" that are actually descendants of A, i.e. excluding the
ones marked with 'o'. Introduce a new option --ancestry-path to compute
this set with "rev-list --ancestry-path A..B".
Note that in practice, you would build a fix immediately on top of A and
"git branch --contains A" will give the names of branches that you would
need to merge the fix into (i.e. topic, dev and master), so this may not
be worth paying the extra cost of postprocessing.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-20 20:48:39 +00:00
|
|
|
ancestry_path:1,
|
2007-03-13 08:57:22 +00:00
|
|
|
first_parent_only:1;
|
2006-02-26 00:19:46 +00:00
|
|
|
|
Common option parsing for "git log --diff" and friends
This basically does a few things that are sadly somewhat interdependent,
and nontrivial to split out
- get rid of "struct log_tree_opt"
The fields in "log_tree_opt" are moved into "struct rev_info", and all
users of log_tree_opt are changed to use the rev_info struct instead.
- add the parsing for the log_tree_opt arguments to "setup_revision()"
- make setup_revision set a flag (revs->diff) if the diff-related
arguments were used. This allows "git log" to decide whether it wants
to show diffs or not.
- make setup_revision() also initialize the diffopt part of rev_info
(which we had from before, but we just didn't initialize it)
- make setup_revision() do all the "finishing touches" on it all (it will
do the proper flag combination logic, and call "diff_setup_done()")
Now, that was the easy and straightforward part.
The slightly more involved part is that some of the programs that want to
use the new-and-improved rev_info parsing don't actually want _commits_,
they may want tree'ish arguments instead. That meant that I had to change
setup_revision() to parse the arguments not into the "revs->commits" list,
but into the "revs->pending_objects" list.
Then, when we do "prepare_revision_walk()", we walk that list, and create
the sorted commit list from there.
This actually cleaned some stuff up, but it's the less obvious part of the
patch, and re-organized the "revision.c" logic somewhat. It actually paves
the way for splitting argument parsing _entirely_ out of "revision.c",
since now the argument parsing really is totally independent of the commit
walking: that didn't use to be true, since there was lots of overlap with
get_commit_reference() handling etc, now the _only_ overlap is the shared
(and trivial) "add_pending_object()" thing.
However, I didn't do that file split, just because I wanted the diff
itself to be smaller, and show the actual changes more clearly. If this
gets accepted, I'll do further cleanups then - that includes the file
split, but also using the new infrastructure to do a nicer "git diff" etc.
Even in this form, it actually ends up removing more lines than it adds.
It's nice to note how simple and straightforward this makes the built-in
"git log" command, even though it continues to support all the diff flags
too. It doesn't get much simpler that this.
I think this is worth merging soonish, because it does allow for future
cleanup and even more sharing of code. However, it obviously touches
"revision.c", which is subtle. I've tested that it passes all the tests we
have, and it passes my "looks sane" detector, but somebody else should
also give it a good look-over.
[jc: squashed the original and three "oops this too" updates, with
another fix-up.]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-14 23:52:13 +00:00
|
|
|
/* 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 */
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
unsigned int shown_one:1,
|
2008-07-08 13:19:33 +00:00
|
|
|
show_merge:1,
|
2010-01-20 21:59:36 +00:00
|
|
|
show_notes:1,
|
|
|
|
|
show_notes_given:1,
|
|
|
|
|
pretty_given:1,
|
2008-04-08 00:11:34 +00:00
|
|
|
abbrev_commit:1,
|
2011-05-18 17:56:04 +00:00
|
|
|
abbrev_commit_given:1,
|
2008-05-04 10:36:54 +00:00
|
|
|
use_terminator:1,
|
2009-09-24 08:28:15 +00:00
|
|
|
missing_newline:1,
|
2011-05-26 22:28:17 +00:00
|
|
|
date_mode_explicit:1,
|
|
|
|
|
preserve_subject:1;
|
2009-11-03 14:59:18 +00:00
|
|
|
unsigned int disable_stdin:1;
|
2011-10-01 15:56:08 +00:00
|
|
|
unsigned int leak_pending:1;
|
2009-11-03 14:59:18 +00:00
|
|
|
|
2007-04-25 06:36:22 +00:00
|
|
|
enum date_mode date_mode;
|
2006-09-06 09:12:09 +00:00
|
|
|
|
Common option parsing for "git log --diff" and friends
This basically does a few things that are sadly somewhat interdependent,
and nontrivial to split out
- get rid of "struct log_tree_opt"
The fields in "log_tree_opt" are moved into "struct rev_info", and all
users of log_tree_opt are changed to use the rev_info struct instead.
- add the parsing for the log_tree_opt arguments to "setup_revision()"
- make setup_revision set a flag (revs->diff) if the diff-related
arguments were used. This allows "git log" to decide whether it wants
to show diffs or not.
- make setup_revision() also initialize the diffopt part of rev_info
(which we had from before, but we just didn't initialize it)
- make setup_revision() do all the "finishing touches" on it all (it will
do the proper flag combination logic, and call "diff_setup_done()")
Now, that was the easy and straightforward part.
The slightly more involved part is that some of the programs that want to
use the new-and-improved rev_info parsing don't actually want _commits_,
they may want tree'ish arguments instead. That meant that I had to change
setup_revision() to parse the arguments not into the "revs->commits" list,
but into the "revs->pending_objects" list.
Then, when we do "prepare_revision_walk()", we walk that list, and create
the sorted commit list from there.
This actually cleaned some stuff up, but it's the less obvious part of the
patch, and re-organized the "revision.c" logic somewhat. It actually paves
the way for splitting argument parsing _entirely_ out of "revision.c",
since now the argument parsing really is totally independent of the commit
walking: that didn't use to be true, since there was lots of overlap with
get_commit_reference() handling etc, now the _only_ overlap is the shared
(and trivial) "add_pending_object()" thing.
However, I didn't do that file split, just because I wanted the diff
itself to be smaller, and show the actual changes more clearly. If this
gets accepted, I'll do further cleanups then - that includes the file
split, but also using the new infrastructure to do a nicer "git diff" etc.
Even in this form, it actually ends up removing more lines than it adds.
It's nice to note how simple and straightforward this makes the built-in
"git log" command, even though it continues to support all the diff flags
too. It doesn't get much simpler that this.
I think this is worth merging soonish, because it does allow for future
cleanup and even more sharing of code. However, it obviously touches
"revision.c", which is subtle. I've tested that it passes all the tests we
have, and it passes my "looks sane" detector, but somebody else should
also give it a good look-over.
[jc: squashed the original and three "oops this too" updates, with
another fix-up.]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-14 23:52:13 +00:00
|
|
|
unsigned int abbrev;
|
|
|
|
|
enum cmit_fmt commit_format;
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
struct log_info *loginfo;
|
2006-05-05 02:30:52 +00:00
|
|
|
int nr, total;
|
2006-05-20 13:40:29 +00:00
|
|
|
const char *mime_boundary;
|
2009-03-23 02:14:05 +00:00
|
|
|
const char *patch_suffix;
|
|
|
|
|
int numbered_files;
|
2008-02-19 03:56:06 +00:00
|
|
|
char *message_id;
|
2009-02-19 21:26:31 +00:00
|
|
|
struct string_list *ref_message_ids;
|
2006-05-31 22:11:49 +00:00
|
|
|
const char *add_signoff;
|
2006-06-02 13:21:17 +00:00
|
|
|
const char *extra_headers;
|
2006-12-25 19:48:35 +00:00
|
|
|
const char *log_reencode;
|
2007-04-11 23:58:07 +00:00
|
|
|
const char *subject_prefix;
|
2007-03-03 23:12:06 +00:00
|
|
|
int no_inline;
|
2007-07-20 18:15:13 +00:00
|
|
|
int show_log_size;
|
Common option parsing for "git log --diff" and friends
This basically does a few things that are sadly somewhat interdependent,
and nontrivial to split out
- get rid of "struct log_tree_opt"
The fields in "log_tree_opt" are moved into "struct rev_info", and all
users of log_tree_opt are changed to use the rev_info struct instead.
- add the parsing for the log_tree_opt arguments to "setup_revision()"
- make setup_revision set a flag (revs->diff) if the diff-related
arguments were used. This allows "git log" to decide whether it wants
to show diffs or not.
- make setup_revision() also initialize the diffopt part of rev_info
(which we had from before, but we just didn't initialize it)
- make setup_revision() do all the "finishing touches" on it all (it will
do the proper flag combination logic, and call "diff_setup_done()")
Now, that was the easy and straightforward part.
The slightly more involved part is that some of the programs that want to
use the new-and-improved rev_info parsing don't actually want _commits_,
they may want tree'ish arguments instead. That meant that I had to change
setup_revision() to parse the arguments not into the "revs->commits" list,
but into the "revs->pending_objects" list.
Then, when we do "prepare_revision_walk()", we walk that list, and create
the sorted commit list from there.
This actually cleaned some stuff up, but it's the less obvious part of the
patch, and re-organized the "revision.c" logic somewhat. It actually paves
the way for splitting argument parsing _entirely_ out of "revision.c",
since now the argument parsing really is totally independent of the commit
walking: that didn't use to be true, since there was lots of overlap with
get_commit_reference() handling etc, now the _only_ overlap is the shared
(and trivial) "add_pending_object()" thing.
However, I didn't do that file split, just because I wanted the diff
itself to be smaller, and show the actual changes more clearly. If this
gets accepted, I'll do further cleanups then - that includes the file
split, but also using the new infrastructure to do a nicer "git diff" etc.
Even in this form, it actually ends up removing more lines than it adds.
It's nice to note how simple and straightforward this makes the built-in
"git log" command, even though it continues to support all the diff flags
too. It doesn't get much simpler that this.
I think this is worth merging soonish, because it does allow for future
cleanup and even more sharing of code. However, it obviously touches
"revision.c", which is subtle. I've tested that it passes all the tests we
have, and it passes my "looks sane" detector, but somebody else should
also give it a good look-over.
[jc: squashed the original and three "oops this too" updates, with
another fix-up.]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-14 23:52:13 +00:00
|
|
|
|
2006-09-17 22:43:40 +00:00
|
|
|
/* Filter by commit log message */
|
2008-08-25 06:15:05 +00:00
|
|
|
struct grep_opt grep_filter;
|
2006-09-17 22:43:40 +00:00
|
|
|
|
2008-05-04 10:36:54 +00:00
|
|
|
/* Display history graph */
|
|
|
|
|
struct git_graph *graph;
|
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
/* special limits */
|
2006-12-20 02:25:32 +00:00
|
|
|
int skip_count;
|
2006-02-26 00:19:46 +00:00
|
|
|
int max_count;
|
|
|
|
|
unsigned long max_age;
|
|
|
|
|
unsigned long min_age;
|
2011-03-21 10:14:06 +00:00
|
|
|
int min_parents;
|
|
|
|
|
int max_parents;
|
2006-03-10 09:21:39 +00:00
|
|
|
|
Common option parsing for "git log --diff" and friends
This basically does a few things that are sadly somewhat interdependent,
and nontrivial to split out
- get rid of "struct log_tree_opt"
The fields in "log_tree_opt" are moved into "struct rev_info", and all
users of log_tree_opt are changed to use the rev_info struct instead.
- add the parsing for the log_tree_opt arguments to "setup_revision()"
- make setup_revision set a flag (revs->diff) if the diff-related
arguments were used. This allows "git log" to decide whether it wants
to show diffs or not.
- make setup_revision() also initialize the diffopt part of rev_info
(which we had from before, but we just didn't initialize it)
- make setup_revision() do all the "finishing touches" on it all (it will
do the proper flag combination logic, and call "diff_setup_done()")
Now, that was the easy and straightforward part.
The slightly more involved part is that some of the programs that want to
use the new-and-improved rev_info parsing don't actually want _commits_,
they may want tree'ish arguments instead. That meant that I had to change
setup_revision() to parse the arguments not into the "revs->commits" list,
but into the "revs->pending_objects" list.
Then, when we do "prepare_revision_walk()", we walk that list, and create
the sorted commit list from there.
This actually cleaned some stuff up, but it's the less obvious part of the
patch, and re-organized the "revision.c" logic somewhat. It actually paves
the way for splitting argument parsing _entirely_ out of "revision.c",
since now the argument parsing really is totally independent of the commit
walking: that didn't use to be true, since there was lots of overlap with
get_commit_reference() handling etc, now the _only_ overlap is the shared
(and trivial) "add_pending_object()" thing.
However, I didn't do that file split, just because I wanted the diff
itself to be smaller, and show the actual changes more clearly. If this
gets accepted, I'll do further cleanups then - that includes the file
split, but also using the new infrastructure to do a nicer "git diff" etc.
Even in this form, it actually ends up removing more lines than it adds.
It's nice to note how simple and straightforward this makes the built-in
"git log" command, even though it continues to support all the diff flags
too. It doesn't get much simpler that this.
I think this is worth merging soonish, because it does allow for future
cleanup and even more sharing of code. However, it obviously touches
"revision.c", which is subtle. I've tested that it passes all the tests we
have, and it passes my "looks sane" detector, but somebody else should
also give it a good look-over.
[jc: squashed the original and three "oops this too" updates, with
another fix-up.]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-14 23:52:13 +00:00
|
|
|
/* diff info for patches and for paths limiting */
|
2006-04-11 01:14:54 +00:00
|
|
|
struct diff_options diffopt;
|
Common option parsing for "git log --diff" and friends
This basically does a few things that are sadly somewhat interdependent,
and nontrivial to split out
- get rid of "struct log_tree_opt"
The fields in "log_tree_opt" are moved into "struct rev_info", and all
users of log_tree_opt are changed to use the rev_info struct instead.
- add the parsing for the log_tree_opt arguments to "setup_revision()"
- make setup_revision set a flag (revs->diff) if the diff-related
arguments were used. This allows "git log" to decide whether it wants
to show diffs or not.
- make setup_revision() also initialize the diffopt part of rev_info
(which we had from before, but we just didn't initialize it)
- make setup_revision() do all the "finishing touches" on it all (it will
do the proper flag combination logic, and call "diff_setup_done()")
Now, that was the easy and straightforward part.
The slightly more involved part is that some of the programs that want to
use the new-and-improved rev_info parsing don't actually want _commits_,
they may want tree'ish arguments instead. That meant that I had to change
setup_revision() to parse the arguments not into the "revs->commits" list,
but into the "revs->pending_objects" list.
Then, when we do "prepare_revision_walk()", we walk that list, and create
the sorted commit list from there.
This actually cleaned some stuff up, but it's the less obvious part of the
patch, and re-organized the "revision.c" logic somewhat. It actually paves
the way for splitting argument parsing _entirely_ out of "revision.c",
since now the argument parsing really is totally independent of the commit
walking: that didn't use to be true, since there was lots of overlap with
get_commit_reference() handling etc, now the _only_ overlap is the shared
(and trivial) "add_pending_object()" thing.
However, I didn't do that file split, just because I wanted the diff
itself to be smaller, and show the actual changes more clearly. If this
gets accepted, I'll do further cleanups then - that includes the file
split, but also using the new infrastructure to do a nicer "git diff" etc.
Even in this form, it actually ends up removing more lines than it adds.
It's nice to note how simple and straightforward this makes the built-in
"git log" command, even though it continues to support all the diff flags
too. It doesn't get much simpler that this.
I think this is worth merging soonish, because it does allow for future
cleanup and even more sharing of code. However, it obviously touches
"revision.c", which is subtle. I've tested that it passes all the tests we
have, and it passes my "looks sane" detector, but somebody else should
also give it a good look-over.
[jc: squashed the original and three "oops this too" updates, with
another fix-up.]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-14 23:52:13 +00:00
|
|
|
struct diff_options pruning;
|
2006-04-11 01:14:54 +00:00
|
|
|
|
2007-01-11 10:47:48 +00:00
|
|
|
struct reflog_walk_info *reflog_info;
|
2008-04-03 09:12:06 +00:00
|
|
|
struct decoration children;
|
2008-08-14 17:59:44 +00:00
|
|
|
struct decoration merge_simplification;
|
2010-03-12 17:04:26 +00:00
|
|
|
|
|
|
|
|
/* notes-specific options: which refs to show */
|
|
|
|
|
struct display_notes_opt notes_opt;
|
2010-06-10 11:47:23 +00:00
|
|
|
|
|
|
|
|
/* commit counts */
|
|
|
|
|
int count_left;
|
|
|
|
|
int count_right;
|
2011-04-26 08:24:29 +00:00
|
|
|
int count_same;
|
2006-02-26 00:19:46 +00:00
|
|
|
};
|
|
|
|
|
|
2006-03-10 09:21:39 +00:00
|
|
|
#define REV_TREE_SAME 0
|
2009-06-03 01:34:01 +00:00
|
|
|
#define REV_TREE_NEW 1 /* Only new files */
|
|
|
|
|
#define REV_TREE_OLD 2 /* Only files removed */
|
|
|
|
|
#define REV_TREE_DIFFERENT 3 /* Mixed changes */
|
2006-03-10 09:21:39 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
/* revision.c */
|
2007-11-03 18:11:10 +00:00
|
|
|
typedef void (*show_early_output_fn_t)(struct rev_info *, struct commit_list *);
|
2008-08-21 00:34:30 +00:00
|
|
|
extern volatile show_early_output_fn_t show_early_output;
|
2006-03-10 09:21:39 +00:00
|
|
|
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt {
|
|
|
|
|
const char *def;
|
2010-03-09 07:27:25 +00:00
|
|
|
void (*tweak)(struct rev_info *, struct setup_revision_opt *);
|
2010-07-07 13:39:12 +00:00
|
|
|
const char *submodule;
|
2010-03-09 06:58:09 +00:00
|
|
|
};
|
|
|
|
|
|
2006-07-29 04:21:48 +00:00
|
|
|
extern void init_revisions(struct rev_info *revs, const char *prefix);
|
2010-03-09 06:58:09 +00:00
|
|
|
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *);
|
2008-07-09 21:38:34 +00:00
|
|
|
extern void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
|
|
|
|
|
const struct option *options,
|
|
|
|
|
const char * const usagestr[]);
|
2006-09-06 04:28:36 +00:00
|
|
|
extern int handle_revision_arg(const char *arg, struct rev_info *revs,int flags,int cant_be_filename);
|
|
|
|
|
|
2007-05-04 21:54:57 +00:00
|
|
|
extern int prepare_revision_walk(struct rev_info *revs);
|
2006-02-28 19:24:00 +00:00
|
|
|
extern struct commit *get_revision(struct rev_info *revs);
|
2011-03-07 12:31:39 +00:00
|
|
|
extern char *get_revision_mark(const struct rev_info *revs, const struct commit *commit);
|
2011-03-10 14:45:03 +00:00
|
|
|
extern void put_revision_mark(const struct rev_info *revs, const struct commit *commit);
|
2006-02-28 19:24:00 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
extern void mark_parents_uninteresting(struct commit *commit);
|
|
|
|
|
extern void mark_tree_uninteresting(struct tree *tree);
|
|
|
|
|
|
|
|
|
|
struct name_path {
|
|
|
|
|
struct name_path *up;
|
|
|
|
|
int elem_len;
|
|
|
|
|
const char *elem;
|
|
|
|
|
};
|
|
|
|
|
|
show_object(): push path_name() call further down
In particular, pushing the "path_name()" call _into_ the show() function
would seem to allow
- more clarity into who "owns" the name (ie now when we free the name in
the show_object callback, it's because we generated it ourselves by
calling path_name())
- not calling path_name() at all, either because we don't care about the
name in the first place, or because we are actually happy walking the
linked list of "struct name_path *" and the last component.
Now, I didn't do that latter optimization, because it would require some
more coding, but especially looking at "builtin-pack-objects.c", we really
don't even want the whole pathname, we really would be better off with the
list of path components.
Why? We use that name for two things:
- add_preferred_base_object(), which actually _wants_ to traverse the
path, and now does it by looking for '/' characters!
- for 'name_hash()', which only cares about the last 16 characters of a
name, so again, generating the full name seems to be just unnecessary
work.
Anyway, so I didn't look any closer at those things, but it did convince
me that the "show_object()" calling convention was crazy, and we're
actually better off doing _less_ in list-objects.c, and giving people
access to the internal data structures so that they can decide whether
they want to generate a path-name or not.
This patch does that, and then for people who did use the name (even if
they might do something more clever in the future), it just does the
straightforward "name = path_name(path, component); .. free(name);" thing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-04-11 01:15:26 +00:00
|
|
|
char *path_name(const struct name_path *path, const char *name);
|
process_{tree,blob}: show objects without buffering
Here's a less trivial thing, and slightly more dubious one.
I was looking at that "struct object_array objects", and wondering why we
do that. I have honestly totally forgotten. Why not just call the "show()"
function as we encounter the objects? Rather than add the objects to the
object_array, and then at the very end going through the array and doing a
'show' on all, just do things more incrementally.
Now, there are possible downsides to this:
- the "buffer using object_array" _can_ in theory result in at least
better I-cache usage (two tight loops rather than one more spread out
one). I don't think this is a real issue, but in theory..
- this _does_ change the order of the objects printed. Instead of doing a
"process_tree(revs, commit->tree, &objects, NULL, "");" in the loop
over the commits (which puts all the root trees _first_ in the object
list, this patch just adds them to the list of pending objects, and
then we'll traverse them in that order (and thus show each root tree
object together with the objects we discover under it)
I _think_ the new ordering actually makes more sense, but the object
ordering is actually a subtle thing when it comes to packing
efficiency, so any change in order is going to have implications for
packing. Good or bad, I dunno.
- There may be some reason why we did it that odd way with the object
array, that I have simply forgotten.
Anyway, now that we don't buffer up the objects before showing them
that may actually result in lower memory usage during that whole
traverse_commit_list() phase.
This is seriously not very deeply tested. It makes sense to me, it seems
to pass all the tests, it looks ok, but...
Does anybody remember why we did that "object_array" thing? It used to be
an "object_list" a long long time ago, but got changed into the array due
to better memory usage patterns (those linked lists of obejcts are
horrible from a memory allocation standpoint). But I wonder why we didn't
do this back then. Maybe there's a reason for it.
Or maybe there _used_ to be a reason, and no longer is.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-04-11 00:27:58 +00:00
|
|
|
|
2011-08-17 21:30:34 +00:00
|
|
|
extern void show_object_with_name(FILE *, struct object *, const struct name_path *, const char *);
|
|
|
|
|
|
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 00:42:35 +00:00
|
|
|
extern void add_object(struct object *obj,
|
|
|
|
|
struct object_array *p,
|
|
|
|
|
struct name_path *path,
|
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
|
|
extern void add_pending_object(struct rev_info *revs, struct object *obj, const char *name);
|
2011-10-01 15:43:52 +00:00
|
|
|
extern void add_pending_sha1(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags);
|
2006-02-26 00:19:46 +00:00
|
|
|
|
2007-12-11 18:09:04 +00:00
|
|
|
extern void add_head_to_pending(struct rev_info *);
|
|
|
|
|
|
2007-11-04 20:12:05 +00:00
|
|
|
enum commit_action {
|
|
|
|
|
commit_ignore,
|
|
|
|
|
commit_show,
|
|
|
|
|
commit_error
|
|
|
|
|
};
|
|
|
|
|
|
2009-08-19 02:34:33 +00:00
|
|
|
extern enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit);
|
2007-11-04 20:12:05 +00:00
|
|
|
extern enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit);
|
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
#endif
|