* Re: [PATCH] Introduce Git.pm (v3)
From: Junio C Hamano @ 2006-06-24 1:04 UTC (permalink / raw)
To: Petr Baudis; +Cc: git
In-Reply-To: <20060623123904.GL21864@pasky.or.cz>
Petr Baudis <pasky@suse.cz> writes:
>> By the way, you also need to adjust the testsuite so that it
>> finds the Perl modules from freshly built tree before
>> installing. I think (but haven't checked yet) the stuff written
>> in Python does that already, so you might want to mimic it.
>
> It should be enough to -I../perl/blib/lib -I../perl/blib/arch/auto/Git.
-- >8 --
[PATCH] Perl interface: make testsuite work again.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
t/test-lib.sh | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/t/test-lib.sh b/t/test-lib.sh
index 05f6e79..fba0c51 100755
--- a/t/test-lib.sh
+++ b/t/test-lib.sh
@@ -206,6 +206,8 @@ PYTHON=`sed -e '1{
PYTHONPATH=$(pwd)/../compat
export PYTHONPATH
}
+PERL5LIB=$(pwd)/../perl/blib/lib:$(pwd)/../perl/blib/arch/auto/Git
+export PERL5LIB
test -d ../templates/blt || {
error "You haven't built things yet, have you?"
}
--
1.4.1.rc1.gf2641
^ permalink raw reply related
* Re: [PATCH] Introduce Git.pm (v3)
From: Junio C Hamano @ 2006-06-24 1:01 UTC (permalink / raw)
To: Petr Baudis; +Cc: git
In-Reply-To: <20060623123904.GL21864@pasky.or.cz>
Petr Baudis <pasky@suse.cz> writes:
>> By the way, you also need to adjust the testsuite so that it
>> finds the Perl modules from freshly built tree before
>> installing. I think (but haven't checked yet) the stuff written
>> in Python does that already, so you might want to mimic it.
>
> It should be enough to -I../perl/blib/lib -I../perl/blib/arch/auto/Git.
-- >8 --
[PATCH] Perl interface: add build-time configuration to allow building with -fPIC
On x86-64 it seems that Git.xs does not link without compiling
the main git objects with -fPIC.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
* Also I moved explanation of MOZILLA_SHA1 closer to other SHA1
choices.
Makefile | 20 +++++++++++++-------
1 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/Makefile b/Makefile
index 7842195..c42521e 100644
--- a/Makefile
+++ b/Makefile
@@ -1,11 +1,6 @@
# The default target of this Makefile is...
all:
-# Define MOZILLA_SHA1 environment variable when running make to make use of
-# a bundled SHA1 routine coming from Mozilla. It is GPL'd and should be fast
-# on non-x86 architectures (e.g. PowerPC), while the OpenSSL version (default
-# choice) has very fast version optimized for i586.
-#
# Define NO_OPENSSL environment variable if you do not have OpenSSL.
# This also implies MOZILLA_SHA1.
#
@@ -37,6 +32,14 @@ #
# Define ARM_SHA1 environment variable when running make to make use of
# a bundled SHA1 routine optimized for ARM.
#
+# Define MOZILLA_SHA1 environment variable when running make to make use of
+# a bundled SHA1 routine coming from Mozilla. It is GPL'd and should be fast
+# on non-x86 architectures (e.g. PowerPC), while the OpenSSL version (default
+# choice) has very fast version optimized for i586.
+#
+# Define USE_PIC if you need the main git objects to be built with -fPIC
+# in order to build and link perl/Git.so. x86-64 seems to need this.
+#
# Define NEEDS_SSL_WITH_CRYPTO if you need -lcrypto with -lssl (Darwin).
#
# Define NEEDS_LIBICONV if linking with libc is not enough (Darwin).
@@ -63,13 +66,13 @@ #
# Define COLLISION_CHECK below if you believe that SHA1's
# 1461501637330902918203684832716283019655932542976 hashes do not give you
# sufficient guarantee that no collisions between objects will ever happen.
-
+#
# Define USE_NSEC below if you want git to care about sub-second file mtimes
# and ctimes. Note that you need recent glibc (at least 2.2.4) for this, and
# it will BREAK YOUR LOCAL DIFFS! show-diff and anything using it will likely
# randomly break unless your underlying filesystem supports those sub-second
# times (my ext3 doesn't).
-
+#
# Define USE_STDEV below if you want git to care about the underlying device
# change being considered an inode change from the update-cache perspective.
@@ -450,6 +453,9 @@ else
endif
endif
endif
+ifdef USE_PIC
+ ALL_CFLAGS += -fPIC
+endif
ifdef NO_ACCURATE_DIFF
ALL_CFLAGS += -DNO_ACCURATE_DIFF
endif
--
1.4.1.rc1.gf2641
^ permalink raw reply related
* Re: [PATCH] Introduce Git.pm (v3)
From: Junio C Hamano @ 2006-06-24 0:39 UTC (permalink / raw)
To: Petr Baudis; +Cc: Eric W. Biederman, git
In-Reply-To: <20060623123904.GL21864@pasky.or.cz>
Petr Baudis <pasky@suse.cz> writes:
> There's a patch to build libgit.so, would you take it as an excuse to
> always compile with -fPIC? ;-)
The only benerit we might gain from libgit.so in the current
shape, aside from making it easier to do .xs, is that multiple
git processes would share it in core, and the disk consumption
by 100+ little git commands are reduced -- which largely has
become non-issue with the recent spurt of making everything
built-ins. But that "aside from" is in itself a big plus, so,
well, I am torn.
^ permalink raw reply
* Re: [PATCH] git-commit: filter out log message lines only when editor was run.
From: Junio C Hamano @ 2006-06-24 0:21 UTC (permalink / raw)
To: Yann Dirson; +Cc: git
In-Reply-To: <20060623220405.1915.28636.stgit@gandelf.nowhere.earth>
Yann Dirson <ydirson@altern.org> writes:
> The current behaviour strips out lines starting with a # even when fed
> through stdin or -m. This is particularly bad when importing history from
> another SCM (tailor 0.9.23 uses git-commit). In the best cases all lines
> are stripped and the commit fails with a confusing "empty log message"
> error, but in many cases the commit is done, with loss of information.
I agree with this in principle but we would need to make sure
that our own scripts do not expect that the message is cleaned
up when feeding a commit log message via stdin, -m or -F, and if
they do fix them before applying this patch.
^ permalink raw reply
* Re: x86 asm SHA1 (draft)
From: Junio C Hamano @ 2006-06-24 0:18 UTC (permalink / raw)
To: git; +Cc: linux
In-Reply-To: <20060623171809.5689.qmail@science.horizon.com>
The series to revamp SHA1 is good but judging the merit of each
is outside my expertise, so I'd appreciate help to evaluate
these changes. For example, I cannot choose between competing
three implementations for ppc without having access to a variety
of ppc machines, and even if I did, ppc is not what I normally
use, so incentive to try picking the best one for everybody is
relatively low on my part.
What we would want are obviously (1) no regression, (2) an easy
way for people who build git for their own machine to decide
which one suits them the best, and (3) an easy way to tell the
build mechanism to use the one that is chosen.
The only external interface for the set of SHA1 implementation
alternatives to the outside world is a well established SHA_CTX
type, and three functions SHA1_Init(), SHA1_Update() and
SHA1_Final(), and the alternative implementations are supposed
to be drop-in replaceable.
So let's do something like this:
- When adding a new SHA1 implementation, we need to come up
with a Makefile symbol (similar to PPC_SHA1, MOZILLA_SHA1 and
friends) and set up the build machinery to use the one that
is chosen;
- We need a test program and a build rule in the Makefile that
links with the chosen SHA1 implementation.
- We need a test script that feeds the above program with known
vectors to validate the SHA1 implementation (make sure the
test covers large input to avoid the recent half-gig-limit
problem), and bench the speed on the platform it was built.
- If we wanted to go fancier, another script that builds all
applicable alternatives on the building platform, run the
bench for all of them and automatically pick the right one
for the platform would be a plus.
We probably would want to collect the benchmark results from
popular platforms, have a summary to help people to choose a
sensible one in the toplevel INSTALL file, and include the raw
numbers in Documentation/technical/sha1-implementations.txt.
Once we go the above path, we may want to include both of the
the two new ppc implementations as separate choices as I
understand their performance depends on which ppc you are
talking about.
Any takers?
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Johannes Schindelin @ 2006-06-24 0:04 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Timo Hirvonen, git
In-Reply-To: <7vodwj8n9s.fsf@assigned-by-dhcp.cox.net>
Hi,
On Fri, 23 Jun 2006, Junio C Hamano wrote:
> I personally feel that the benefit of being able to make sure you
> covered everything outweighs the size of initial diff.
IMHO the difficulty of finding bugs is proportional to the square of the
diff size, while the number of people willing to review it is proportional
to its square root. So, if it is not difficult (which it is not at all in
this case), I politely ask to cut the patch size down.
Ciao,
Dscho
^ permalink raw reply
* Re: [PATCH] git-commit: allow -e option anywhere on command line
From: Junio C Hamano @ 2006-06-23 23:56 UTC (permalink / raw)
To: Jeff King; +Cc: git
In-Reply-To: <20060623134338.GA12630@coredump.intra.peff.net>
Makes sense. Thanks.
^ permalink raw reply
* Re: [PATCH] Customizable error handlers
From: Petr Baudis @ 2006-06-23 23:18 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vsllv8ny8.fsf@assigned-by-dhcp.cox.net>
Dear diary, on Sat, Jun 24, 2006 at 01:14:07AM CEST, I got a letter
where Junio C Hamano <junkio@cox.net> said that...
> Petr Baudis <pasky@suse.cz> writes:
>
> > Dear diary, on Fri, Jun 23, 2006 at 03:32:27PM CEST, I got a letter
> > where Petr Baudis <pasky@suse.cz> said that...
> >> diff --git a/git-compat-util.h b/git-compat-util.h
> >> index 5d543d2..e954002 100644
> >> --- a/git-compat-util.h
> >> +++ b/git-compat-util.h
> >> @@ -36,9 +36,13 @@ #endif
> >> #endif
> >>
> >> /* General helper functions */
> >> -extern void usage(const char *err) NORETURN;
> >> -extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
> >> -extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
> >> +void usage(const char *err) NORETURN;
> >> +void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
> >> +int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
> >
> > Wah, this kind of slipped through. Below is a patch without the
> > externs removed.
>
> Oh, I first thought you did that on purpose as a cleanup. After
> all don't they mean the same thing?
AFAIK they do, but we use extern everywhere and I personally consider
it good style to externize declarations of, well, external functions.
--
Petr "Pasky" Baudis
Stuff: http://pasky.or.cz/
A person is just about as big as the things that make them angry.
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Junio C Hamano @ 2006-06-23 23:28 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: Timo Hirvonen, git
In-Reply-To: <Pine.LNX.4.63.0606240024460.29667@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin <Johannes.Schindelin@gmx.de> writes:
> Hi,
>
> On Sat, 24 Jun 2006, Timo Hirvonen wrote:
>
>> This patch series cleans up diff output format options.
>
> Very good.
>
> Although I understand that to convert all users to the new convention, it
> is sensible to rename the constants, I think it is not good to change
> something as DIFF_FORMAT_RAW to OUTPUT_FMT_RAW in the resulting patch.
I personally feel that the benefit of being able to make sure
you covered everything outweighs the size of initial diff.
Thanks Timo. Will take a look.
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Johannes Schindelin @ 2006-06-23 23:18 UTC (permalink / raw)
To: Timo Hirvonen; +Cc: junkio, git
In-Reply-To: <20060624014420.2c3df276.tihirvon@gmail.com>
Hi,
On Sat, 24 Jun 2006, Timo Hirvonen wrote:
> Johannes Schindelin <Johannes.Schindelin@gmx.de> wrote:
>
> > Although I understand that to convert all users to the new convention, it
> > is sensible to rename the constants, I think it is not good to change
> > something as DIFF_FORMAT_RAW to OUTPUT_FMT_RAW in the resulting patch.
Note that I understand this for the purpose of not forgetting to change
things over to "|=" and "&": the compiler will warn you about that now.
But after it compiles, you can change the names back to reduce patch size
and to avoid confusing of dumb people like me.
> > IMHO it is an unnecessary change, and accounts for a lot of the diffstat.
>
> I did it because you can't have many DIFF_FORMAT_* options at the same
> time but OUTPUT_FMT_* can be combined.
But you just renamed them! The name alone does not say "you cannot combine
them".
-- snip --
@@ -150,15 +162,6 @@ #define COMMON_DIFF_OPTIONS_HELP \
" show all files diff when -S is used and hit is found.\n"
extern int diff_queue_is_empty(void);
-
-#define DIFF_FORMAT_RAW 1
-#define DIFF_FORMAT_PATCH 2
-#define DIFF_FORMAT_NO_OUTPUT 3
-#define DIFF_FORMAT_NAME 4
-#define DIFF_FORMAT_NAME_STATUS 5
-#define DIFF_FORMAT_DIFFSTAT 6
-#define DIFF_FORMAT_CHECKDIFF 7
-
-- snap --
You also sneak in some other things, such as renaming output_format to
output_fmt in struct diff_options, making a function static, and expanding
a "(a ? b : c)", without accounting for it in the commit message.
Ciao,
Dscho
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Linus Torvalds @ 2006-06-23 23:16 UTC (permalink / raw)
To: Timo Hirvonen; +Cc: Junio C Hamano, git
In-Reply-To: <20060624011538.9bb179e7.tihirvon@gmail.com>
On Sat, 24 Jun 2006, Timo Hirvonen wrote:
>
> This patch series cleans up diff output format options.
>
> This makes it possible to use any combination of --raw, -p, --stat and
> --summary options and they work as you would expect.
Looks good to me. I'll be very happy never having to remember the option
(or type) --patch-with-stat ever again. Doing just "-p --stat" is just
_so_ much better.
Linus
^ permalink raw reply
* Re: [PATCH] Customizable error handlers
From: Junio C Hamano @ 2006-06-23 23:14 UTC (permalink / raw)
To: Petr Baudis; +Cc: git
In-Reply-To: <20060623133847.GN21864@pasky.or.cz>
Petr Baudis <pasky@suse.cz> writes:
> Dear diary, on Fri, Jun 23, 2006 at 03:32:27PM CEST, I got a letter
> where Petr Baudis <pasky@suse.cz> said that...
>> diff --git a/git-compat-util.h b/git-compat-util.h
>> index 5d543d2..e954002 100644
>> --- a/git-compat-util.h
>> +++ b/git-compat-util.h
>> @@ -36,9 +36,13 @@ #endif
>> #endif
>>
>> /* General helper functions */
>> -extern void usage(const char *err) NORETURN;
>> -extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
>> -extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
>> +void usage(const char *err) NORETURN;
>> +void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
>> +int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
>
> Wah, this kind of slipped through. Below is a patch without the
> externs removed.
Oh, I first thought you did that on purpose as a cleanup. After
all don't they mean the same thing?
^ permalink raw reply
* Re: [PATCH] git-merge --squash
From: Junio C Hamano @ 2006-06-23 23:11 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: Thomas Glanzmann, git
In-Reply-To: <Pine.LNX.4.63.0606231433370.29667@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin <Johannes.Schindelin@gmx.de> writes:
> Isn't this the same as 'git-cherry-pick -n'? I often do a poor man's StGIT
> by cherry picking my way through a messy branch, often combining patches
> by '-n'.
Operationally, it probably is equivalent to the repeated use of
'cherry-pick -n' for all commits on a topic, but that would risk
you having to resolve conflicts unnecessarily when you are
shooting for as the result is a single commit, because you would
have to do N merges with that workflow. Squashing is about
merging the tip of the topic into mainline, so the conflict
resolution needs to be done only once.
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Timo Hirvonen @ 2006-06-23 22:44 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: junkio, git
In-Reply-To: <Pine.LNX.4.63.0606240024460.29667@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin <Johannes.Schindelin@gmx.de> wrote:
> Hi,
>
> On Sat, 24 Jun 2006, Timo Hirvonen wrote:
>
> > This patch series cleans up diff output format options.
>
> Very good.
>
> Although I understand that to convert all users to the new convention, it
> is sensible to rename the constants, I think it is not good to change
> something as DIFF_FORMAT_RAW to OUTPUT_FMT_RAW in the resulting patch.
>
> IMHO it is an unnecessary change, and accounts for a lot of the diffstat.
I did it because you can't have many DIFF_FORMAT_* options at the same
time but OUTPUT_FMT_* can be combined.
--
http://onion.dynserv.net/~timo/
^ permalink raw reply
* Re: [PATCH 2/5] Rework diff options
From: Timo Hirvonen @ 2006-06-23 22:40 UTC (permalink / raw)
To: Timo Hirvonen; +Cc: junkio, git
In-Reply-To: <20060624005252.c694e421.tihirvon@gmail.com>
Timo Hirvonen <tihirvon@gmail.com> wrote:
> @@ -878,13 +867,13 @@ void diff_tree_combined(const unsigned c
> num_paths++;
> }
> if (num_paths) {
> - if (opt->with_raw) {
> - int saved_format = opt->output_format;
> - opt->output_format = DIFF_FORMAT_RAW;
> + if (opt->output_fmt & OUTPUT_FMT_RAW) {
> + int saved_fmt = opt->output_fmt;
> + opt->output_fmt |= OUTPUT_FMT_RAW;
I have no idea if this is more right than this:
opt->output_fmt = OUTPUT_FMT_RAW;
> @@ -852,8 +852,8 @@ int setup_revisions(int argc, const char
> if (revs->combine_merges) {
> revs->ignore_merges = 0;
> if (revs->dense_combined_merges &&
> - (revs->diffopt.output_format != DIFF_FORMAT_DIFFSTAT))
> - revs->diffopt.output_format = DIFF_FORMAT_PATCH;
> + !(revs->diffopt.output_fmt & OUTPUT_FMT_DIFFSTAT))
> + revs->diffopt.output_fmt |= OUTPUT_FMT_PATCH;
I'm not sure about this. Didn't really understand the code :)
--
http://onion.dynserv.net/~timo/
^ permalink raw reply
* Re: [PATCH 0/5] Rework diff options
From: Johannes Schindelin @ 2006-06-23 22:28 UTC (permalink / raw)
To: Timo Hirvonen; +Cc: Junio C Hamano, git
In-Reply-To: <20060624011538.9bb179e7.tihirvon@gmail.com>
Hi,
On Sat, 24 Jun 2006, Timo Hirvonen wrote:
> This patch series cleans up diff output format options.
Very good.
Although I understand that to convert all users to the new convention, it
is sensible to rename the constants, I think it is not good to change
something as DIFF_FORMAT_RAW to OUTPUT_FMT_RAW in the resulting patch.
IMHO it is an unnecessary change, and accounts for a lot of the diffstat.
Ciao,
Dscho
^ permalink raw reply
* [PATCH 0/5] Rework diff options
From: Timo Hirvonen @ 2006-06-23 22:15 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
This patch series cleans up diff output format options.
This makes it possible to use any combination of --raw, -p, --stat and
--summary options and they work as you would expect.
These patches passed all tests but patch 2/5 is quite intrusive...
b/builtin-diff-files.c | 10 +-
b/builtin-diff-index.c | 4
b/builtin-diff-stages.c | 3
b/builtin-diff-tree.c | 3
b/builtin-diff.c | 74 ++++++-----------
b/builtin-log.c | 12 +-
b/combine-diff.c | 45 +++-------
b/diff.c | 207 +++++++++++++++++++++++-------------------------
b/diff.h | 29 +++---
b/git-merge.sh | 3
b/log-tree.c | 15 ++-
b/revision.c | 5 -
12 files changed, 196 insertions(+), 214 deletions(-)
--
http://onion.dynserv.net/~timo/
^ permalink raw reply
* [PATCH 4/5] Make --raw option available for all diff commands
From: Timo Hirvonen @ 2006-06-23 22:00 UTC (permalink / raw)
To: junkio; +Cc: git
In-Reply-To: <20060624003315.804a1796.tihirvon@gmail.com>
Makes --raw a global diff output format option.
Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
---
builtin-diff.c | 48 ++++++++++++------------------------------------
diff.c | 2 ++
2 files changed, 14 insertions(+), 36 deletions(-)
diff --git a/builtin-diff.c b/builtin-diff.c
index b6f7727..8fd91b8 100644
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -39,8 +39,6 @@ static int builtin_diff_files(struct rev
revs->max_count = 3;
else if (!strcmp(arg, "-q"))
silent = 1;
- else if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -107,14 +105,9 @@ static int builtin_diff_b_f(struct rev_i
/* Blob vs file in the working tree*/
struct stat st;
- while (1 < argc) {
- const char *arg = argv[1];
- if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
- else
- usage(builtin_diff_usage);
- argv++; argc--;
- }
+ if (argc > 1)
+ usage(builtin_diff_usage);
+
if (lstat(path, &st))
die("'%s': %s", path, strerror(errno));
if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
@@ -137,14 +130,9 @@ static int builtin_diff_blobs(struct rev
*/
unsigned mode = canon_mode(S_IFREG | 0644);
- while (1 < argc) {
- const char *arg = argv[1];
- if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
- else
- usage(builtin_diff_usage);
- argv++; argc--;
- }
+ if (argc > 1)
+ usage(builtin_diff_usage);
+
stuff_change(&revs->diffopt,
mode, mode,
blob[1].sha1, blob[0].sha1,
@@ -162,8 +150,6 @@ static int builtin_diff_index(struct rev
const char *arg = argv[1];
if (!strcmp(arg, "--cached"))
cached = 1;
- else if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -185,14 +171,9 @@ static int builtin_diff_tree(struct rev_
{
const unsigned char *(sha1[2]);
int swap = 0;
- while (1 < argc) {
- const char *arg = argv[1];
- if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
- else
- usage(builtin_diff_usage);
- argv++; argc--;
- }
+
+ if (argc > 1)
+ usage(builtin_diff_usage);
/* We saw two trees, ent[0] and ent[1].
* if ent[1] is unintesting, they are swapped
@@ -214,14 +195,9 @@ static int builtin_diff_combined(struct
const unsigned char (*parent)[20];
int i;
- while (1 < argc) {
- const char *arg = argv[1];
- if (!strcmp(arg, "--raw"))
- revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
- else
- usage(builtin_diff_usage);
- argv++; argc--;
- }
+ if (argc > 1)
+ usage(builtin_diff_usage);
+
if (!revs->dense_combined_merges && !revs->combine_merges)
revs->dense_combined_merges = revs->combine_merges = 1;
parent = xmalloc(ents * sizeof(*parent));
diff --git a/diff.c b/diff.c
index 45c93c9..ab8aed7 100644
--- a/diff.c
+++ b/diff.c
@@ -1464,6 +1464,8 @@ int diff_opt_parse(struct diff_options *
options->output_fmt |= OUTPUT_FMT_PATCH;
else if (opt_arg(arg, 'U', "unified", &options->context))
options->output_fmt |= OUTPUT_FMT_PATCH;
+ else if (!strcmp(arg, "--raw"))
+ options->output_fmt |= OUTPUT_FMT_RAW;
else if (!strcmp(arg, "--patch-with-raw")) {
options->output_fmt |= OUTPUT_FMT_PATCH | OUTPUT_FMT_RAW;
}
--
1.4.1.rc1.gf603-dirty
^ permalink raw reply related
* [PATCH 2/5] Rework diff options
From: Timo Hirvonen @ 2006-06-23 21:52 UTC (permalink / raw)
To: junkio; +Cc: git
In-Reply-To: <20060624003315.804a1796.tihirvon@gmail.com>
Make raw, diffstat, summary and patch diff output format options
independent of each other.
name-only, name-status and checkdiff options override other options.
Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
---
builtin-diff-files.c | 6 +-
builtin-diff.c | 22 +++---
builtin-log.c | 8 +-
combine-diff.c | 45 ++++-------
diff.c | 199 +++++++++++++++++++++++++-------------------------
diff.h | 29 ++++---
log-tree.c | 15 +++-
revision.c | 4 +
8 files changed, 160 insertions(+), 168 deletions(-)
diff --git a/builtin-diff-files.c b/builtin-diff-files.c
index 5afc1d7..42ca07d 100644
--- a/builtin-diff-files.c
+++ b/builtin-diff-files.c
@@ -47,9 +47,9 @@ int cmd_diff_files(int argc, const char
/*
* Backward compatibility wart - "diff-files -s" used to
* defeat the common diff option "-s" which asked for
- * DIFF_FORMAT_NO_OUTPUT.
+ * OUTPUT_FMT_NONE
*/
- if (rev.diffopt.output_format == DIFF_FORMAT_NO_OUTPUT)
- rev.diffopt.output_format = DIFF_FORMAT_RAW;
+ if (rev.diffopt.output_fmt & OUTPUT_FMT_NONE)
+ rev.diffopt.output_fmt = OUTPUT_FMT_RAW;
return run_diff_files(&rev, silent);
}
diff --git a/builtin-diff.c b/builtin-diff.c
index 99a2f76..372894a 100644
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -40,7 +40,7 @@ static int builtin_diff_files(struct rev
else if (!strcmp(arg, "-q"))
silent = 1;
else if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -56,15 +56,15 @@ static int builtin_diff_files(struct rev
3 < revs->max_count)
usage(builtin_diff_usage);
if (revs->max_count < 0 &&
- (revs->diffopt.output_format == DIFF_FORMAT_PATCH))
+ (revs->diffopt.output_fmt & OUTPUT_FMT_PATCH))
revs->combine_merges = revs->dense_combined_merges = 1;
/*
* Backward compatibility wart - "diff-files -s" used to
* defeat the common diff option "-s" which asked for
- * DIFF_FORMAT_NO_OUTPUT.
+ * OUTPUT_FMT_NONE
*/
- if (revs->diffopt.output_format == DIFF_FORMAT_NO_OUTPUT)
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ if (revs->diffopt.output_fmt & OUTPUT_FMT_NONE)
+ revs->diffopt.output_fmt = OUTPUT_FMT_RAW;
return run_diff_files(revs, silent);
}
@@ -110,7 +110,7 @@ static int builtin_diff_b_f(struct rev_i
while (1 < argc) {
const char *arg = argv[1];
if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -140,7 +140,7 @@ static int builtin_diff_blobs(struct rev
while (1 < argc) {
const char *arg = argv[1];
if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -163,7 +163,7 @@ static int builtin_diff_index(struct rev
if (!strcmp(arg, "--cached"))
cached = 1;
else if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -188,7 +188,7 @@ static int builtin_diff_tree(struct rev_
while (1 < argc) {
const char *arg = argv[1];
if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -217,7 +217,7 @@ static int builtin_diff_combined(struct
while (1 < argc) {
const char *arg = argv[1];
if (!strcmp(arg, "--raw"))
- revs->diffopt.output_format = DIFF_FORMAT_RAW;
+ revs->diffopt.output_fmt |= OUTPUT_FMT_RAW;
else
usage(builtin_diff_usage);
argv++; argc--;
@@ -276,7 +276,7 @@ int cmd_diff(int argc, const char **argv
git_config(git_diff_config);
init_revisions(&rev);
- rev.diffopt.output_format = DIFF_FORMAT_PATCH;
+ rev.diffopt.output_fmt = OUTPUT_FMT_PATCH;
argc = setup_revisions(argc, argv, &rev, NULL);
/* Do we have --cached and not have a pending object, then
diff --git a/builtin-log.c b/builtin-log.c
index 5a8a50b..e4a6385 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -26,8 +26,8 @@ static int cmd_log_wc(int argc, const ch
if (rev->always_show_header) {
if (rev->diffopt.pickaxe || rev->diffopt.filter) {
rev->always_show_header = 0;
- if (rev->diffopt.output_format == DIFF_FORMAT_RAW)
- rev->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
+ if (rev->diffopt.output_fmt & OUTPUT_FMT_RAW)
+ rev->diffopt.output_fmt |= OUTPUT_FMT_NONE;
}
}
@@ -176,11 +176,9 @@ int cmd_format_patch(int argc, const cha
rev.commit_format = CMIT_FMT_EMAIL;
rev.verbose_header = 1;
rev.diff = 1;
- rev.diffopt.with_raw = 0;
- rev.diffopt.with_stat = 1;
rev.combine_merges = 0;
rev.ignore_merges = 1;
- rev.diffopt.output_format = DIFF_FORMAT_PATCH;
+ rev.diffopt.output_fmt = OUTPUT_FMT_DIFFSTAT | OUTPUT_FMT_PATCH;
git_config(git_format_config);
rev.extra_headers = extra_headers;
diff --git a/combine-diff.c b/combine-diff.c
index 64b20cc..d0d8d01 100644
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -771,7 +771,7 @@ static void show_raw_diff(struct combine
if (rev->loginfo)
show_log(rev, rev->loginfo, "\n");
- if (opt->output_format == DIFF_FORMAT_RAW) {
+ if (opt->output_fmt & OUTPUT_FMT_RAW) {
offset = strlen(COLONS) - num_parent;
if (offset < 0)
offset = 0;
@@ -791,8 +791,7 @@ static void show_raw_diff(struct combine
printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
}
- if (opt->output_format == DIFF_FORMAT_RAW ||
- opt->output_format == DIFF_FORMAT_NAME_STATUS) {
+ if (opt->output_fmt & (OUTPUT_FMT_RAW | OUTPUT_FMT_NAME_STATUS)) {
for (i = 0; i < num_parent; i++)
putchar(p->parent[i].status);
putchar(inter_name_termination);
@@ -818,17 +817,12 @@ void show_combined_diff(struct combine_d
struct diff_options *opt = &rev->diffopt;
if (!p->len)
return;
- switch (opt->output_format) {
- case DIFF_FORMAT_RAW:
- case DIFF_FORMAT_NAME_STATUS:
- case DIFF_FORMAT_NAME:
+ if (opt->output_fmt & (OUTPUT_FMT_RAW |
+ OUTPUT_FMT_NAME |
+ OUTPUT_FMT_NAME_STATUS)) {
show_raw_diff(p, num_parent, rev);
- return;
- case DIFF_FORMAT_PATCH:
+ } else if (opt->output_fmt & OUTPUT_FMT_PATCH) {
show_patch_diff(p, num_parent, dense, rev);
- return;
- default:
- return;
}
}
@@ -842,13 +836,9 @@ void diff_tree_combined(const unsigned c
struct diff_options diffopts;
struct combine_diff_path *p, *paths = NULL;
int i, num_paths;
- int do_diffstat;
- do_diffstat = (opt->output_format == DIFF_FORMAT_DIFFSTAT ||
- opt->with_stat);
diffopts = *opt;
- diffopts.with_raw = 0;
- diffopts.with_stat = 0;
+ diffopts.output_fmt &= ~(OUTPUT_FMT_RAW | OUTPUT_FMT_DIFFSTAT);
diffopts.recursive = 1;
/* find set of paths that everybody touches */
@@ -856,19 +846,18 @@ void diff_tree_combined(const unsigned c
/* show stat against the first parent even
* when doing combined diff.
*/
- if (i == 0 && do_diffstat)
- diffopts.output_format = DIFF_FORMAT_DIFFSTAT;
+ if (i == 0 && opt->output_fmt & OUTPUT_FMT_DIFFSTAT)
+ diffopts.output_fmt |= OUTPUT_FMT_DIFFSTAT;
else
- diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+ diffopts.output_fmt |= OUTPUT_FMT_NONE;
diff_tree_sha1(parent[i], sha1, "", &diffopts);
diffcore_std(&diffopts);
paths = intersect_paths(paths, i, num_parent);
- if (do_diffstat && rev->loginfo)
- show_log(rev, rev->loginfo,
- opt->with_stat ? "---\n" : "\n");
+ if (opt->output_fmt & OUTPUT_FMT_DIFFSTAT && rev->loginfo)
+ show_log(rev, rev->loginfo, "---\n");
diff_flush(&diffopts);
- if (opt->with_stat)
+ if (opt->output_fmt & OUTPUT_FMT_DIFFSTAT)
putchar('\n');
}
@@ -878,13 +867,13 @@ void diff_tree_combined(const unsigned c
num_paths++;
}
if (num_paths) {
- if (opt->with_raw) {
- int saved_format = opt->output_format;
- opt->output_format = DIFF_FORMAT_RAW;
+ if (opt->output_fmt & OUTPUT_FMT_RAW) {
+ int saved_fmt = opt->output_fmt;
+ opt->output_fmt |= OUTPUT_FMT_RAW;
for (p = paths; p; p = p->next) {
show_combined_diff(p, num_parent, dense, rev);
}
- opt->output_format = saved_format;
+ opt->output_fmt = saved_fmt;
putchar(opt->line_termination);
}
for (p = paths; p; p = p->next) {
diff --git a/diff.c b/diff.c
index 1db0285..6eb7db0 100644
--- a/diff.c
+++ b/diff.c
@@ -203,7 +203,7 @@ static void emit_rewrite_diff(const char
static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
{
if (!DIFF_FILE_VALID(one)) {
- mf->ptr = ""; /* does not matter */
+ mf->ptr = (char *)""; /* does not matter */
mf->size = 0;
return 0;
}
@@ -395,7 +395,7 @@ static void show_stats(struct diffstat_t
}
for (i = 0; i < data->nr; i++) {
- char *prefix = "";
+ const char *prefix = "";
char *name = data->files[i]->name;
int added = data->files[i]->added;
int deleted = data->files[i]->deleted;
@@ -917,7 +917,7 @@ int diff_populate_filespec(struct diff_f
err_empty:
err = -1;
empty:
- s->data = "";
+ s->data = (char *)"";
s->size = 0;
return err;
}
@@ -1354,7 +1354,7 @@ static void run_checkdiff(struct diff_fi
void diff_setup(struct diff_options *options)
{
memset(options, 0, sizeof(*options));
- options->output_format = DIFF_FORMAT_RAW;
+ options->output_fmt = OUTPUT_FMT_RAW;
options->line_termination = '\n';
options->break_opt = -1;
options->rename_limit = -1;
@@ -1371,23 +1371,26 @@ int diff_setup_done(struct diff_options
(0 <= options->rename_limit && !options->detect_rename))
return -1;
+ if (options->output_fmt & OUTPUT_FMT_NONE)
+ options->output_fmt = 0;
+
+ if (options->output_fmt & (OUTPUT_FMT_NAME |
+ OUTPUT_FMT_CHECKDIFF |
+ OUTPUT_FMT_NONE))
+ options->output_fmt &= ~(OUTPUT_FMT_RAW |
+ OUTPUT_FMT_DIFFSTAT |
+ OUTPUT_FMT_SUMMARY |
+ OUTPUT_FMT_PATCH);
+
/*
* These cases always need recursive; we do not drop caller-supplied
* recursive bits for other formats here.
*/
- if ((options->output_format == DIFF_FORMAT_PATCH) ||
- (options->output_format == DIFF_FORMAT_DIFFSTAT) ||
- (options->output_format == DIFF_FORMAT_CHECKDIFF))
+ if (options->output_fmt & (OUTPUT_FMT_PATCH |
+ OUTPUT_FMT_DIFFSTAT |
+ OUTPUT_FMT_CHECKDIFF))
options->recursive = 1;
- /*
- * These combinations do not make sense.
- */
- if (options->output_format == DIFF_FORMAT_RAW)
- options->with_raw = 0;
- if (options->output_format == DIFF_FORMAT_DIFFSTAT)
- options->with_stat = 0;
-
if (options->detect_rename && options->rename_limit < 0)
options->rename_limit = diff_rename_limit_default;
if (options->setup & DIFF_SETUP_USE_CACHE) {
@@ -1408,7 +1411,7 @@ int diff_setup_done(struct diff_options
return 0;
}
-int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
+static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
{
char c, *eq;
int len;
@@ -1459,22 +1462,20 @@ int diff_opt_parse(struct diff_options *
{
const char *arg = av[0];
if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
- options->output_format = DIFF_FORMAT_PATCH;
+ options->output_fmt |= OUTPUT_FMT_PATCH;
else if (opt_arg(arg, 'U', "unified", &options->context))
- options->output_format = DIFF_FORMAT_PATCH;
+ options->output_fmt |= OUTPUT_FMT_PATCH;
else if (!strcmp(arg, "--patch-with-raw")) {
- options->output_format = DIFF_FORMAT_PATCH;
- options->with_raw = 1;
+ options->output_fmt |= OUTPUT_FMT_PATCH | OUTPUT_FMT_RAW;
}
else if (!strcmp(arg, "--stat"))
- options->output_format = DIFF_FORMAT_DIFFSTAT;
+ options->output_fmt |= OUTPUT_FMT_DIFFSTAT;
else if (!strcmp(arg, "--check"))
- options->output_format = DIFF_FORMAT_CHECKDIFF;
+ options->output_fmt |= OUTPUT_FMT_CHECKDIFF;
else if (!strcmp(arg, "--summary"))
- options->summary = 1;
+ options->output_fmt |= OUTPUT_FMT_SUMMARY;
else if (!strcmp(arg, "--patch-with-stat")) {
- options->output_format = DIFF_FORMAT_PATCH;
- options->with_stat = 1;
+ options->output_fmt |= OUTPUT_FMT_PATCH | OUTPUT_FMT_DIFFSTAT;
}
else if (!strcmp(arg, "-z"))
options->line_termination = 0;
@@ -1483,19 +1484,20 @@ int diff_opt_parse(struct diff_options *
else if (!strcmp(arg, "--full-index"))
options->full_index = 1;
else if (!strcmp(arg, "--binary")) {
- options->output_format = DIFF_FORMAT_PATCH;
+ options->output_fmt |= OUTPUT_FMT_PATCH;
options->full_index = options->binary = 1;
}
else if (!strcmp(arg, "--name-only"))
- options->output_format = DIFF_FORMAT_NAME;
+ options->output_fmt |= OUTPUT_FMT_NAME;
else if (!strcmp(arg, "--name-status"))
- options->output_format = DIFF_FORMAT_NAME_STATUS;
+ options->output_fmt |= OUTPUT_FMT_NAME_STATUS;
else if (!strcmp(arg, "-R"))
options->reverse_diff = 1;
else if (!strncmp(arg, "-S", 2))
options->pickaxe = arg + 2;
- else if (!strcmp(arg, "-s"))
- options->output_format = DIFF_FORMAT_NO_OUTPUT;
+ else if (!strcmp(arg, "-s")) {
+ options->output_fmt |= OUTPUT_FMT_NONE;
+ }
else if (!strncmp(arg, "-O", 2))
options->orderfile = arg + 2;
else if (!strncmp(arg, "--diff-filter=", 14))
@@ -1669,7 +1671,7 @@ static void diff_flush_raw(struct diff_f
int line_termination,
int inter_name_termination,
struct diff_options *options,
- int output_format)
+ int raw)
{
int two_paths;
char status[10];
@@ -1703,7 +1705,7 @@ static void diff_flush_raw(struct diff_f
two_paths = 0;
break;
}
- if (output_format != DIFF_FORMAT_NAME_STATUS) {
+ if (raw) {
printf(":%06o %06o %s ",
p->one->mode, p->two->mode,
diff_unique_abbrev(p->one->sha1, abbrev));
@@ -1720,16 +1722,12 @@ static void diff_flush_raw(struct diff_f
free((void*)path_two);
}
-static void diff_flush_name(struct diff_filepair *p,
- int inter_name_termination,
- int line_termination)
+static void diff_flush_name(struct diff_filepair *p, int line_termination)
{
char *path = p->two->path;
if (line_termination)
path = quote_one(p->two->path);
- else
- path = p->two->path;
printf("%s%c", path, line_termination);
if (p->two->path != path)
free(path);
@@ -1916,50 +1914,44 @@ static void diff_resolve_rename_copy(voi
diff_debug_queue("resolve-rename-copy done", q);
}
-static void flush_one_pair(struct diff_filepair *p,
- int diff_output_format,
- struct diff_options *options,
- struct diffstat_t *diffstat)
+static int check_pair_status(struct diff_filepair *p)
{
- int inter_name_termination = '\t';
- int line_termination = options->line_termination;
- if (!line_termination)
- inter_name_termination = 0;
-
switch (p->status) {
case DIFF_STATUS_UNKNOWN:
- break;
+ return 0;
case 0:
die("internal error in diff-resolve-rename-copy");
- break;
default:
- switch (diff_output_format) {
- case DIFF_FORMAT_DIFFSTAT:
- diff_flush_stat(p, options, diffstat);
- break;
- case DIFF_FORMAT_CHECKDIFF:
- diff_flush_checkdiff(p, options);
- break;
- case DIFF_FORMAT_PATCH:
- diff_flush_patch(p, options);
- break;
- case DIFF_FORMAT_RAW:
- case DIFF_FORMAT_NAME_STATUS:
- diff_flush_raw(p, line_termination,
- inter_name_termination,
- options, diff_output_format);
- break;
- case DIFF_FORMAT_NAME:
- diff_flush_name(p,
- inter_name_termination,
- line_termination);
- break;
- case DIFF_FORMAT_NO_OUTPUT:
- break;
- }
+ return 1;
}
}
+static void flush_one_pair_raw(struct diff_filepair *p,
+ struct diff_options *options, int raw)
+{
+ int inter_name_termination = '\t';
+ int line_termination = options->line_termination;
+
+ if (!line_termination)
+ inter_name_termination = 0;
+ diff_flush_raw(p, line_termination, inter_name_termination,
+ options, raw);
+}
+
+static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
+{
+ int fmt = opt->output_fmt;
+
+ if (fmt & OUTPUT_FMT_CHECKDIFF)
+ diff_flush_checkdiff(p, opt);
+ else if (fmt & OUTPUT_FMT_RAW)
+ flush_one_pair_raw(p, opt, 1);
+ else if (fmt & OUTPUT_FMT_NAME_STATUS)
+ flush_one_pair_raw(p, opt, 0);
+ else if (fmt & OUTPUT_FMT_NAME)
+ diff_flush_name(p, opt->line_termination);
+}
+
static void show_file_mode_name(const char *newdelete, struct diff_filespec *fs)
{
if (fs->mode)
@@ -2042,55 +2034,60 @@ static void diff_summary(struct diff_fil
void diff_flush(struct diff_options *options)
{
struct diff_queue_struct *q = &diff_queued_diff;
- int i;
- int diff_output_format = options->output_format;
- struct diffstat_t *diffstat = NULL;
+ int i, output_fmt = options->output_fmt;
- if (diff_output_format == DIFF_FORMAT_DIFFSTAT || options->with_stat) {
- diffstat = xcalloc(sizeof (struct diffstat_t), 1);
- diffstat->xm.consume = diffstat_consume;
- }
+ /*
+ * Order: raw, stat, summary, patch
+ * or: name/name-status/checkdiff (other bits clear)
+ */
- if (options->with_raw) {
+ if (output_fmt & (OUTPUT_FMT_RAW |
+ OUTPUT_FMT_NAME |
+ OUTPUT_FMT_NAME_STATUS |
+ OUTPUT_FMT_CHECKDIFF)) {
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- flush_one_pair(p, DIFF_FORMAT_RAW, options, NULL);
+ if (check_pair_status(p))
+ flush_one_pair(p, options);
}
- putchar(options->line_termination);
}
- if (options->with_stat) {
+
+ if (output_fmt & OUTPUT_FMT_DIFFSTAT) {
+ struct diffstat_t *diffstat;
+
+ diffstat = xcalloc(sizeof (struct diffstat_t), 1);
+ diffstat->xm.consume = diffstat_consume;
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- flush_one_pair(p, DIFF_FORMAT_DIFFSTAT, options,
- diffstat);
+ if (check_pair_status(p))
+ diff_flush_stat(p, options, diffstat);
}
show_stats(diffstat);
free(diffstat);
- diffstat = NULL;
- if (options->summary)
- for (i = 0; i < q->nr; i++)
- diff_summary(q->queue[i]);
+ }
+
+ if (output_fmt & OUTPUT_FMT_SUMMARY) {
+ for (i = 0; i < q->nr; i++)
+ diff_summary(q->queue[i]);
+ }
+
+ if (output_fmt & (OUTPUT_FMT_DIFFSTAT | OUTPUT_FMT_SUMMARY)) {
if (options->stat_sep)
fputs(options->stat_sep, stdout);
else
putchar(options->line_termination);
}
- for (i = 0; i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- flush_one_pair(p, diff_output_format, options, diffstat);
- }
- if (diffstat) {
- show_stats(diffstat);
- free(diffstat);
+ if (output_fmt & OUTPUT_FMT_PATCH) {
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if (check_pair_status(p))
+ diff_flush_patch(p, options);
+ }
}
- for (i = 0; i < q->nr; i++) {
- if (diffstat && options->summary)
- diff_summary(q->queue[i]);
+ for (i = 0; i < q->nr; i++)
diff_free_filepair(q->queue[i]);
- }
-
free(q->queue);
q->queue = NULL;
q->nr = q->alloc = 0;
diff --git a/diff.h b/diff.h
index de9de57..a16bc5a 100644
--- a/diff.h
+++ b/diff.h
@@ -20,25 +20,37 @@ typedef void (*add_remove_fn_t)(struct d
const unsigned char *sha1,
const char *base, const char *path);
+#define OUTPUT_FMT_RAW 0x0001
+#define OUTPUT_FMT_DIFFSTAT 0x0002
+#define OUTPUT_FMT_SUMMARY 0x0004
+#define OUTPUT_FMT_PATCH 0x0008
+
+/* These override all above */
+#define OUTPUT_FMT_NAME 0x0010
+#define OUTPUT_FMT_NAME_STATUS 0x0020
+#define OUTPUT_FMT_CHECKDIFF 0x0040
+
+/* Same as output_fmt = 0 but we know that -s flag was given
+ * and we should not give default value to output_fmt.
+ */
+#define OUTPUT_FMT_NONE 0x0080
+
struct diff_options {
const char *filter;
const char *orderfile;
const char *pickaxe;
unsigned recursive:1,
- with_raw:1,
- with_stat:1,
tree_in_recursive:1,
binary:1,
full_index:1,
silent_on_remove:1,
find_copies_harder:1,
- summary:1,
color_diff:1;
int context;
int break_opt;
int detect_rename;
int line_termination;
- int output_format;
+ int output_fmt;
int pickaxe_opts;
int rename_score;
int reverse_diff;
@@ -150,15 +162,6 @@ #define COMMON_DIFF_OPTIONS_HELP \
" show all files diff when -S is used and hit is found.\n"
extern int diff_queue_is_empty(void);
-
-#define DIFF_FORMAT_RAW 1
-#define DIFF_FORMAT_PATCH 2
-#define DIFF_FORMAT_NO_OUTPUT 3
-#define DIFF_FORMAT_NAME 4
-#define DIFF_FORMAT_NAME_STATUS 5
-#define DIFF_FORMAT_DIFFSTAT 6
-#define DIFF_FORMAT_CHECKDIFF 7
-
extern void diff_flush(struct diff_options*);
/* diff-raw status letters */
diff --git a/log-tree.c b/log-tree.c
index ebb49f2..2cdb0ab 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -156,15 +156,20 @@ int log_tree_diff_flush(struct rev_info
diffcore_std(&opt->diffopt);
if (diff_queue_is_empty()) {
- int saved_fmt = opt->diffopt.output_format;
- opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
+ int saved_fmt = opt->diffopt.output_fmt;
+ opt->diffopt.output_fmt = OUTPUT_FMT_NONE;
diff_flush(&opt->diffopt);
- opt->diffopt.output_format = saved_fmt;
+ opt->diffopt.output_fmt = saved_fmt;
return 0;
}
- if (opt->loginfo && !opt->no_commit_id)
- show_log(opt, opt->loginfo, opt->diffopt.with_stat ? "---\n" : "\n");
+ if (opt->loginfo && !opt->no_commit_id) {
+ if (opt->diffopt.output_fmt & OUTPUT_FMT_DIFFSTAT) {
+ show_log(opt, opt->loginfo, "---\n");
+ } else {
+ show_log(opt, opt->loginfo, "\n");
+ }
+ }
diff_flush(&opt->diffopt);
return 1;
}
diff --git a/revision.c b/revision.c
index b963f2a..4ad2272 100644
--- a/revision.c
+++ b/revision.c
@@ -852,8 +852,8 @@ int setup_revisions(int argc, const char
if (revs->combine_merges) {
revs->ignore_merges = 0;
if (revs->dense_combined_merges &&
- (revs->diffopt.output_format != DIFF_FORMAT_DIFFSTAT))
- revs->diffopt.output_format = DIFF_FORMAT_PATCH;
+ !(revs->diffopt.output_fmt & OUTPUT_FMT_DIFFSTAT))
+ revs->diffopt.output_fmt |= OUTPUT_FMT_PATCH;
}
revs->diffopt.abbrev = revs->abbrev;
diff_setup_done(&revs->diffopt);
--
1.4.1.rc1.gf603-dirty
^ permalink raw reply related
* [PATCH 5/5] Add --patch option for diff-*
From: Timo Hirvonen @ 2006-06-23 22:01 UTC (permalink / raw)
To: junkio; +Cc: git
In-Reply-To: <20060624003315.804a1796.tihirvon@gmail.com>
Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
---
diff.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/diff.c b/diff.c
index ab8aed7..596a877 100644
--- a/diff.c
+++ b/diff.c
@@ -1460,7 +1460,7 @@ static int opt_arg(const char *arg, int
int diff_opt_parse(struct diff_options *options, const char **av, int ac)
{
const char *arg = av[0];
- if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
+ if (!strcmp(arg, "-p") || !strcmp(arg, "-u") || !strcmp(arg, "--patch"))
options->output_fmt |= OUTPUT_FMT_PATCH;
else if (opt_arg(arg, 'U', "unified", &options->context))
options->output_fmt |= OUTPUT_FMT_PATCH;
--
1.4.1.rc1.gf603-dirty
^ permalink raw reply related
* [PATCH 3/5] Set default diff output format after parsing command line
From: Timo Hirvonen @ 2006-06-23 21:58 UTC (permalink / raw)
To: junkio; +Cc: git
In-Reply-To: <20060624003315.804a1796.tihirvon@gmail.com>
Move code that sets default output format values after command line
argument parsing. Only set defaults if output_fmt was not touched by
command line options.
This makes "git diff --raw" output only in raw format instead of -p --raw.
Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
---
builtin-diff-files.c | 4 ++++
builtin-diff-index.c | 4 ++++
builtin-diff-stages.c | 3 +++
builtin-diff-tree.c | 3 +++
builtin-diff.c | 4 +++-
builtin-log.c | 4 +++-
diff.c | 1 -
7 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/builtin-diff-files.c b/builtin-diff-files.c
index 42ca07d..4cf2e2f 100644
--- a/builtin-diff-files.c
+++ b/builtin-diff-files.c
@@ -36,6 +36,10 @@ int cmd_diff_files(int argc, const char
usage(diff_files_usage);
argv++; argc--;
}
+
+ if (!rev.diffopt.output_fmt)
+ rev.diffopt.output_fmt = OUTPUT_FMT_RAW;
+
/*
* Make sure there are NO revision (i.e. pending object) parameter,
* rev.max_count is reasonable (0 <= n <= 3),
diff --git a/builtin-diff-index.c b/builtin-diff-index.c
index c42ef9a..8e58308 100644
--- a/builtin-diff-index.c
+++ b/builtin-diff-index.c
@@ -28,6 +28,10 @@ int cmd_diff_index(int argc, const char
else
usage(diff_cache_usage);
}
+
+ if (!rev.diffopt.output_fmt)
+ rev.diffopt.output_fmt = OUTPUT_FMT_RAW;
+
/*
* Make sure there is one revision (i.e. pending object),
* and there is no revision filtering parameters.
diff --git a/builtin-diff-stages.c b/builtin-diff-stages.c
index 7c157ca..c26a589 100644
--- a/builtin-diff-stages.c
+++ b/builtin-diff-stages.c
@@ -85,6 +85,9 @@ int cmd_diff_stages(int ac, const char *
ac--; av++;
}
+ if (!diff_options.output_fmt)
+ diff_options.output_fmt = OUTPUT_FMT_RAW;
+
if (ac < 3 ||
sscanf(av[1], "%d", &stage1) != 1 ||
! (0 <= stage1 && stage1 <= 3) ||
diff --git a/builtin-diff-tree.c b/builtin-diff-tree.c
index 3409a39..29b3fe1 100644
--- a/builtin-diff-tree.c
+++ b/builtin-diff-tree.c
@@ -84,6 +84,9 @@ int cmd_diff_tree(int argc, const char *
usage(diff_tree_usage);
}
+ if (!opt->diffopt.output_fmt)
+ opt->diffopt.output_fmt = OUTPUT_FMT_RAW;
+
/*
* NOTE! We expect "a ^b" to be equal to "a..b", so we
* reverse the order of the objects if the second one
diff --git a/builtin-diff.c b/builtin-diff.c
index 372894a..b6f7727 100644
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -276,9 +276,11 @@ int cmd_diff(int argc, const char **argv
git_config(git_diff_config);
init_revisions(&rev);
- rev.diffopt.output_fmt = OUTPUT_FMT_PATCH;
argc = setup_revisions(argc, argv, &rev, NULL);
+ if (!rev.diffopt.output_fmt)
+ rev.diffopt.output_fmt = OUTPUT_FMT_PATCH;
+
/* Do we have --cached and not have a pending object, then
* default to HEAD by hand. Eek.
*/
diff --git a/builtin-log.c b/builtin-log.c
index e4a6385..e72d7fe 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -178,7 +178,6 @@ int cmd_format_patch(int argc, const cha
rev.diff = 1;
rev.combine_merges = 0;
rev.ignore_merges = 1;
- rev.diffopt.output_fmt = OUTPUT_FMT_DIFFSTAT | OUTPUT_FMT_PATCH;
git_config(git_format_config);
rev.extra_headers = extra_headers;
@@ -247,6 +246,9 @@ int cmd_format_patch(int argc, const cha
if (argc > 1)
die ("unrecognized argument: %s", argv[1]);
+ if (!rev.diffopt.output_fmt)
+ rev.diffopt.output_fmt = OUTPUT_FMT_DIFFSTAT | OUTPUT_FMT_PATCH;
+
if (output_directory) {
if (use_stdout)
die("standard output, or directory, which one?");
diff --git a/diff.c b/diff.c
index 6eb7db0..45c93c9 100644
--- a/diff.c
+++ b/diff.c
@@ -1354,7 +1354,6 @@ static void run_checkdiff(struct diff_fi
void diff_setup(struct diff_options *options)
{
memset(options, 0, sizeof(*options));
- options->output_fmt = OUTPUT_FMT_RAW;
options->line_termination = '\n';
options->break_opt = -1;
options->rename_limit = -1;
--
1.4.1.rc1.gf603-dirty
^ permalink raw reply related
* [PATCH 1/5] git-merge: Don't use -p when outputting summary
From: Timo Hirvonen @ 2006-06-23 21:45 UTC (permalink / raw)
To: junkio; +Cc: git
In-Reply-To: <20060624003315.804a1796.tihirvon@gmail.com>
-p is not needed and we only want diffstat and summary.
Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
---
git-merge.sh | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/git-merge.sh b/git-merge.sh
index af1f25b..da5657e 100755
--- a/git-merge.sh
+++ b/git-merge.sh
@@ -55,7 +55,7 @@ finish () {
case "$no_summary" in
'')
- git-diff-tree -p --stat --summary -M "$head" "$1"
+ git-diff-tree --stat --summary -M "$head" "$1"
;;
esac
}
--
1.4.1.rc1.gf603-dirty
^ permalink raw reply related
* [PATCH] git-commit: filter out log message lines only when editor was run.
From: Yann Dirson @ 2006-06-23 22:04 UTC (permalink / raw)
To: junkio; +Cc: git
The current behaviour strips out lines starting with a # even when fed
through stdin or -m. This is particularly bad when importing history from
another SCM (tailor 0.9.23 uses git-commit). In the best cases all lines
are stripped and the commit fails with a confusing "empty log message"
error, but in many cases the commit is done, with loss of information.
Note that it is quite peculiar to just have "#" handled as a leading
comment char here. One commonly meet CVS: or CG: or STG: as prefixes, and
using GIT: would be more robust as well as consistent with other commit
tools. However, that would break any tool relying on the # (if any).
Signed-off-by: Yann Dirson <ydirson@altern.org>
---
git-commit.sh | 19 ++++++++++++-------
1 files changed, 12 insertions(+), 7 deletions(-)
diff --git a/git-commit.sh b/git-commit.sh
index 6dd04fd..aa3b1ea 100755
--- a/git-commit.sh
+++ b/git-commit.sh
@@ -691,13 +691,18 @@ t)
fi
esac
-sed -e '
- /^diff --git a\/.*/{
- s///
- q
- }
- /^#/d
-' "$GIT_DIR"/COMMIT_EDITMSG |
+if test -z "$no_edit"
+then
+ sed -e '
+ /^diff --git a\/.*/{
+ s///
+ q
+ }
+ /^#/d
+ ' "$GIT_DIR"/COMMIT_EDITMSG
+else
+ cat "$GIT_DIR"/COMMIT_EDITMSG
+fi |
git-stripspace >"$GIT_DIR"/COMMIT_MSG
if cnt=`grep -v -i '^Signed-off-by' "$GIT_DIR"/COMMIT_MSG |
^ permalink raw reply related
* Re: A series file for git?
From: Junio C Hamano @ 2006-06-23 21:52 UTC (permalink / raw)
To: Eric W. Biederman; +Cc: git
In-Reply-To: <m1odwkyuf5.fsf_-_@ebiederm.dsl.xmission.com>
ebiederm@xmission.com (Eric W. Biederman) writes:
> Is there any real difference between using git-format-patch | git-am
> and using git-am to apply patches. I was using git-cherry-pick simply
> because it was easier to sha1 too.
>
> - When you reorder patches minor merge conflicts are common
> so a big pipe won't work very often in practice. So you
> need a way to handle failures in the middle.
True. The big pipe's answer to that question is that git-am
stashes what is fed to it just like when it is applying multiple
patches in .dotest/ and lets you continue from where a breakage
happened. Also the way rebase (without the new --merge flag)
worked was to produce format-patch with full blob SHA1's on the
index lines and run git-am with --3way, so it can fall back on
three-way merge when the patch does not apply. This often
resulted in "git-am --3way" detecting a patch that does not
apply, falling back to do a three way to notice that the patch
has already been applied.
I have to think about the rest of your message on "series" file.
^ permalink raw reply
* Re: Ideas for qgit
From: Pavel Roskin @ 2006-06-23 20:59 UTC (permalink / raw)
To: Marco Costalba; +Cc: git
In-Reply-To: <e5bfff550606231112l6ca67799m7dddfabcee055045@mail.gmail.com>
On Fri, 2006-06-23 at 20:12 +0200, Marco Costalba wrote:
> On 6/23/06, Pavel Roskin <proski@gnu.org> wrote:
> > Hi, Marco!
> >
> > As promised, here's what I would like to see in qgit:
> >
> > 1) Bookmarks or quick tags (qtags). It may be useful to mark some
> > commits to make it easier to navigate qgit. Yet I don't want them to
> > mix with real tags. Perhaps qgit could save them separately, e.g.
> > in .git/refs/qtags to facilitate navigation. qtags should appear
> > separately in the popup menu.
> >
>
> Currently we have two types of tags, signed and simple.
I guess they should be shown a bit differently.
> If it is
> possible I would really like to stay with git tags, because bookmarks
> seems to me like reinventing the (broken) wheel.
OK, I don't insist. Then we need a user-friendlier implementation of
Ctrl-Rightclick in the revision list. I stumbled upon it accidentally,
and it looked like a bug at the first glance, when the file box suddenly
went turquoise and stopped showing modified files. I still couldn't
figure out how to turn it off without going to the Patch tab and setting
diff to parent.
> Git is very good in tagging and untagging and IMHO we should stay with
> them, perhaps in the simple version. I really don't see any advantage
> nor immediate and less in the long term to almost duplicate that
> functionality and loosing proven git native tag handling features.
OK
> > 2) The "Patch" tab should be redesigned so that the diff can be shown
> > against the parent or against head/tag/qtag. Users are not supposed to
> > enter SHA1. If they have to, then it only confirms that qgit needs
> > qtags.
> >
>
> Well, you can write also a ref name in SHA1 field. Try with
> "v2.6.17-rc6" or "v1.4.0".
> Perhaps this should be better documented and the SHA1 name is misleading.
I think it also shows that a wrong widget is used. Probably an editable
listbox with all tag and branch names would be better.
> > 3) It would be nice to have some minimal navigating capabilities on the
> > Patch tab. At least it should be possible to go up and down the
> > revision list and go to any head/tag/qtag/stgit patch. It would
> > eliminate the need to switch to the "Rev list" too often.
> >
>
> This make me think of biting the bullet and append patch information
> _also_ below revision description, yes, a la gitk. I think this is
> really what you feel is missing.
Maybe. "Rev list" and "Patch" represent essentially the same thing
shown differently. They can be replaced with one tab if it offers
enough flexibility to use the screen space differently for different
tasks.
> > 4) Some bisect support would be nice, at least as good as in gitk.
> > Actually, I'm not using bisect too much, but it's probably because I'm
> > not debugging Wine these days. Everything else is intelligible :-)
> >
>
> I don't use bisect and I don't know the gitk implementation.
> I will investigate when I found some time. Not a top priority, at
> least for my kind of workflow ;-)
I agree.
> > 5) Branch view based on reflog. Probably there should be an interface
> > allowing to limit the displayed revisions to one branch. I think qgit
> > should still load all revisions that it loads now, but if users start
> > complaining about performance too much, maybe qgit should have an option
> > to load only the logged branch. The problem is that some parents will
> > be unavailable in the view.
> >
>
> I think I didn't understand this. Isn't there command line arguments
> for narrowing loaded revision set?
As far as I understand, reflog is only used to resolve references
specified as branch@date. It doesn't seem to be well integrated with
the rest of git.
> > 7) qgit command line should be documented. "qgit --help" should display
> > help on stdout.
> >
>
> All the stuff in command line is sent directly to git-rev-parse. I
> think this is good because avoids any overlapping between qgit and git
> options and guarantees future compatibility with _any_ git option.
This also means that features not related to git-rev-parse (including
StGIT and possible reflog support) cannot be controlled from the command
line. It's not critical now, but it may become more important.
--
Regards,
Pavel Roskin
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox