* 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
* Re: Is anybody actually using git-cherry.sh?
From: Johannes Schindelin @ 2006-06-23 20:43 UTC (permalink / raw)
To: Jeff King; +Cc: git
In-Reply-To: <20060623180658.GA24022@coredump.intra.peff.net>
Hi Peff,
On Fri, 23 Jun 2006, Jeff King wrote:
> It looks like patch-id does a flush whenever a sha1 is found at the
> beginning of a line; diff-tree lines simply have the 'diff-tree ' part
> ignored.
Ah! Everything makes sense now. Thanks!
Ciao,
Dscho
^ permalink raw reply
* Re: Added macro support to qgit
From: Pavel Roskin @ 2006-06-23 20:15 UTC (permalink / raw)
To: Marco Costalba; +Cc: git
In-Reply-To: <e5bfff550606231044j4586ea65v191f86a869237b84@mail.gmail.com>
On Fri, 2006-06-23 at 19:44 +0200, Marco Costalba wrote:
> Or just "commands"? in any case I agree "macro" was not a good choice.
For a menubar entry, something short is preferred, so "Commands" or
"Actions" would be better than "external commands". Emacs calls it
"Tools". But for a menu entry and the dialog title, "external commands"
would be better.
> The bug is qgit lets you write the first foo bar, before you press NEW
> button. It shouldn't. Also some buttons enable/disable policy could be
> good.
Definitely.
> > What happens to the arguments qgit is asking for if a multiline entry is
> > executed? I understand they are prepended to the first line. This is
> > not quite logical. Wouldn't it be better to have a shell like notation
> > for them?
I meant appended, sorry.
> I thought of commands sequence as a quick way to run some simple
> commands as git pull, git push or similar without writing a bash
> script, i.e. no $1 for arguments. If you need something more complex
> the external script is supposed to be the proper way.
I think the checkbox controlling whether to ask for arguments allows
selection between "simple" and "complex" commands.
> Perhaps we could remove the external script single edit line and use
> only the multiline edit to let user insert commands or script.
I agree.
> > I see the macros are saved in the qgit configuration for the
> > user .qt/qgitrc, like this:
> Well, this file is really not meant to be view nor to be modified by
> hand, it is mainly a qgit 'private' thing stuff. Being qgit a GUI tool
> with a (nice ;-) ) settings dialog, configuration file is mainly used
> for persistency, not for browsing/setup.
OK
> I hope to fix the external commands interface bugs this week-end.
I'm looking forward to testing it.
--
Regards,
Pavel Roskin
^ permalink raw reply
* x86 asm SHA1 (draft)
From: linux @ 2006-06-23 17:18 UTC (permalink / raw)
To: git
As long as I was hacking on PowerPC asm, I figured I might as well take
a crack at the openssl dependency, too. This is a draft x86 SHA1 that
is a little over 2x faster than the C version on a Pentium M. I haven't
yet started competing with the OpenSSL code.
This might be useful for the folks who are careful about licensing and
don't like to get mixed up in the OpenSSL/GPL license tangle.
Work in progress, but it functions. Public domain.
--- /dev/null 2006-04-13 05:29:14.000000000 -0400
+++ sha1x86.S 2006-06-23 09:14:21.000000000 -0400
@@ -0,0 +1,233 @@
+ .text
+#define K1 0x5a827999
+#define K2 0x6ed9eba1
+#define K3 0x8f1bbcdc
+#define K4 0xca62c1d6
+
+#define A %edi
+#define B %ebx
+#define C %ecx
+#define D %edx
+#define E %ebp
+
+#define T %eax
+
+#define MIX(base) \
+ movl 60-base(%esp),T; \
+ xorl 52-base(%esp),T; \
+ xorl 28-base(%esp),T; \
+ xorl 8-base(%esp),T; \
+ roll $1,T
+
+/*
+ *In these choice functions, C is the value most recently modified
+ * (It was the B that was rotated in the previous round), so schedule its
+ * use as late as possible.
+ */
+
+/* Choice function: bitwise b ? c : d = ((d ^ c) & b) ^ d */
+#define F1(b,c,d,e) \
+ movl d,T; \
+ xorl c,T; \
+ andl b,T; \
+ roll $30,b; \
+ xorl d,T; \
+ addl T,e
+
+/* Parity function: b ^ c ^ d = (b ^ d) ^ c */
+#define F2(b,c,d,e) \
+ movl b,T; \
+ roll $30,b; \
+ xorl d,T; \
+ xorl c,T; \
+ addl T,e
+
+/* Majority function: (b&c) | (c&d) | (d&b) = (b&d) + ((b^d)&c) */
+#define F3(b,c,d,e) \
+ movl b,T; \
+ andl d,T; \
+ addl T,e; \
+ movl b,T; \
+ roll $30,b; \
+ xorl d,T; \
+ andl c,T; \
+ addl T,e
+
+/*
+ * Register assignments:
+ * %eax - temp
+ * %esi - Pointer to input data
+ * %edi, %ebx, %ecx, %edx, %ebp - A..E
+ */
+
+ /*
+ * The basic round:
+ * e += ROTL(e,5) + F(b,c,d) + W[i] + 0x5a827999
+ */
+
+/* This version fetches (and swaps) data from %esi */
+#define ROUND_LOAD(F,a,b,c,d,e,K) \
+ lodsl; \
+ addl $K,e; \
+ bswap T; \
+ addl T,e; \
+ pushl T; \
+ F(b,c,d,e); \
+ movl a,T; \
+ roll $5,T; \
+ addl T,e
+
+/* The standard round: compute the new W value and push it on the stack */
+#define ROUND_MIX(F,a,b,c,d,e,K) \
+ MIX(0); \
+ addl $K,e; \
+ addl T,e; \
+ pushl T; \
+ F(b,c,d,e); \
+ movl a,T; \
+ roll $5,T; \
+ addl T,e
+
+/* Mix the W[] value, but do NOT push it, as it's never used */
+#define ROUND_LAST(F,a,b,c,d,e,K,base) \
+ MIX(base); \
+ addl $K,e; \
+ addl T,e; \
+ F(b,c,d,e); \
+ movl a,T; \
+ roll $5,T; \
+ addl T,e
+
+/* Args are context (A..E, then a W[] array), then input data */
+.globl shaHashBlock
+ .type shaHashBlock, @function
+shaHashBlock:
+ pushl %ebp
+ pushl %ebx
+ pushl %esi
+ pushl %edi
+/* Args now start at 20(%esp) */
+
+ movl 20(%esp),T
+ movl 24(%esp),%esi
+
+ movl (T),A
+ movl 4(T),B
+ movl 8(T),C
+ movl 12(T),D
+ movl 16(T),E
+
+ ROUND_LOAD(F1, A,B,C,D,E, K1);
+ ROUND_LOAD(F1, E,A,B,C,D, K1);
+ ROUND_LOAD(F1, D,E,A,B,C, K1);
+ ROUND_LOAD(F1, C,D,E,A,B, K1);
+ ROUND_LOAD(F1, B,C,D,E,A, K1);
+
+ ROUND_LOAD(F1, A,B,C,D,E, K1);
+ ROUND_LOAD(F1, E,A,B,C,D, K1);
+ ROUND_LOAD(F1, D,E,A,B,C, K1);
+ ROUND_LOAD(F1, C,D,E,A,B, K1);
+ ROUND_LOAD(F1, B,C,D,E,A, K1);
+
+ ROUND_LOAD(F1, A,B,C,D,E, K1);
+ ROUND_LOAD(F1, E,A,B,C,D, K1);
+ ROUND_LOAD(F1, D,E,A,B,C, K1);
+ ROUND_LOAD(F1, C,D,E,A,B, K1);
+ ROUND_LOAD(F1, B,C,D,E,A, K1);
+
+ ROUND_LOAD(F1, A,B,C,D,E, K1);
+ ROUND_MIX(F1, E,A,B,C,D, K1);
+ ROUND_MIX(F1, D,E,A,B,C, K1);
+ ROUND_MIX(F1, C,D,E,A,B, K1);
+ ROUND_MIX(F1, B,C,D,E,A, K1);
+
+ ROUND_MIX(F2, A,B,C,D,E, K2);
+ ROUND_MIX(F2, E,A,B,C,D, K2);
+ ROUND_MIX(F2, D,E,A,B,C, K2);
+ ROUND_MIX(F2, C,D,E,A,B, K2);
+ ROUND_MIX(F2, B,C,D,E,A, K2);
+
+ ROUND_MIX(F2, A,B,C,D,E, K2);
+ ROUND_MIX(F2, E,A,B,C,D, K2);
+ ROUND_MIX(F2, D,E,A,B,C, K2);
+ ROUND_MIX(F2, C,D,E,A,B, K2);
+ ROUND_MIX(F2, B,C,D,E,A, K2);
+
+ ROUND_MIX(F2, A,B,C,D,E, K2);
+ ROUND_MIX(F2, E,A,B,C,D, K2);
+ ROUND_MIX(F2, D,E,A,B,C, K2);
+ ROUND_MIX(F2, C,D,E,A,B, K2);
+ ROUND_MIX(F2, B,C,D,E,A, K2);
+
+ ROUND_MIX(F2, A,B,C,D,E, K2);
+ ROUND_MIX(F2, E,A,B,C,D, K2);
+ ROUND_MIX(F2, D,E,A,B,C, K2);
+ ROUND_MIX(F2, C,D,E,A,B, K2);
+ ROUND_MIX(F2, B,C,D,E,A, K2);
+
+ ROUND_MIX(F3, A,B,C,D,E, K3);
+ ROUND_MIX(F3, E,A,B,C,D, K3);
+ ROUND_MIX(F3, D,E,A,B,C, K3);
+ ROUND_MIX(F3, C,D,E,A,B, K3);
+ ROUND_MIX(F3, B,C,D,E,A, K3);
+
+ ROUND_MIX(F3, A,B,C,D,E, K3);
+ ROUND_MIX(F3, E,A,B,C,D, K3);
+ ROUND_MIX(F3, D,E,A,B,C, K3);
+ ROUND_MIX(F3, C,D,E,A,B, K3);
+ ROUND_MIX(F3, B,C,D,E,A, K3);
+
+ ROUND_MIX(F3, A,B,C,D,E, K3);
+ ROUND_MIX(F3, E,A,B,C,D, K3);
+ ROUND_MIX(F3, D,E,A,B,C, K3);
+ ROUND_MIX(F3, C,D,E,A,B, K3);
+ ROUND_MIX(F3, B,C,D,E,A, K3);
+
+ ROUND_MIX(F3, A,B,C,D,E, K3);
+ ROUND_MIX(F3, E,A,B,C,D, K3);
+ ROUND_MIX(F3, D,E,A,B,C, K3);
+ ROUND_MIX(F3, C,D,E,A,B, K3);
+ ROUND_MIX(F3, B,C,D,E,A, K3);
+
+ ROUND_MIX(F2, A,B,C,D,E, K4);
+ ROUND_MIX(F2, E,A,B,C,D, K4);
+ ROUND_MIX(F2, D,E,A,B,C, K4);
+ ROUND_MIX(F2, C,D,E,A,B, K4);
+ ROUND_MIX(F2, B,C,D,E,A, K4);
+
+ ROUND_MIX(F2, A,B,C,D,E, K4);
+ ROUND_MIX(F2, E,A,B,C,D, K4);
+ ROUND_MIX(F2, D,E,A,B,C, K4);
+ ROUND_MIX(F2, C,D,E,A,B, K4);
+ ROUND_MIX(F2, B,C,D,E,A, K4);
+
+ ROUND_MIX(F2, A,B,C,D,E, K4);
+ ROUND_MIX(F2, E,A,B,C,D, K4);
+ ROUND_MIX(F2, D,E,A,B,C, K4);
+ ROUND_MIX(F2, C,D,E,A,B, K4);
+ ROUND_MIX(F2, B,C,D,E,A, K4);
+
+ ROUND_MIX(F2, A,B,C,D,E, K4);
+ ROUND_MIX(F2, E,A,B,C,D, K4);
+ ROUND_LAST(F2, D,E,A,B,C, K4, 0);
+ ROUND_LAST(F2, C,D,E,A,B, K4, 4);
+ ROUND_LAST(F2, B,C,D,E,A, K4, 8);
+
+ addl $77*4,%esp
+
+ movl 20(%esp),T
+
+ addl A, (T)
+ addl B, 4(T)
+ addl C, 8(T)
+ addl D,12(T)
+ addl E,16(T)
+
+ popl %edi
+ popl %esi
+ popl %ebx
+ popl %ebp
+
+ ret
+
+ .size shaHashBlock, .-shaHashBlock
--- /dev/null 2006-04-13 05:29:14.000000000 -0400
+++ sha1asm.h 2006-06-23 10:24:35.578683250 -0400
@@ -0,0 +1,12 @@
+#include <stdint.h>
+#include <stddef.h> /* For size_t */
+
+typedef struct sha_ctx {
+ uint32_t hash[5];
+ uint32_t data[16];
+ uint32_t sizeL, sizeH;
+} SHA_CTX;
+
+void SHA1_Init(SHA_CTX *ctx);
+void SHA1_Update(SHA_CTX *ctx, const void *dataIn, size_t len);
+void SHA1_Final(unsigned char hashout[20], SHA_CTX *ctx);
--- /dev/null 2006-04-13 05:29:14.000000000 -0400
+++ sha1asm.c 2006-06-23 10:25:26.798757250 -0400
@@ -0,0 +1,163 @@
+
+#include <string.h> /* For memcpy */
+#include <arpa/inet.h> /* For htonl */
+
+#include "sha1asm.h"
+
+#if ASM
+extern void shaHashBlock(SHA_CTX *ctx, uint32_t const *input);
+#else
+
+/*
+ * This chunk of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is SHA 180-1 Reference Implementation (Compact version)
+ *
+ * The Initial Developer of the Original Code is Paul Kocher of
+ * Cryptography Research. Portions created by Paul Kocher are
+ * Copyright (C) 1995-9 by Cryptography Research, Inc. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Paul Kocher
+ *
+ * Alternatively, this portion of this file may be used under the
+ * terms of the GNU General Public License Version 2 or later (the
+ * "GPL"), in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your
+ * version of this file only under the terms of the GPL and not to
+ * allow others to use your version of this file under the MPL,
+ * indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient
+ * may use your version of this file under either the MPL or the
+ * GPL.
+ */
+
+#define ROTL(X,n) (((X) << (n)) | ((X) >> (32-(n))))
+
+static void
+shaHashBlock(SHA_CTX *ctx, uint32_t const *input)
+{
+ int i;
+ uint32_t A,B,C,D,E,T;
+ uint32_t W[80];
+
+ for (i = 0; i < 16; i++)
+ W[i] = ntohl(input[i]);
+ for (i = 16; i < 80; i++) {
+ T = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
+ W[i] = ROTL(T, 1);
+ }
+
+ A = ctx->hash[0];
+ B = ctx->hash[1];
+ C = ctx->hash[2];
+ D = ctx->hash[3];
+ E = ctx->hash[4];
+
+ for (i = 0; i < 20; i++) {
+ T = ROTL(A,5) + (((C^D)&B)^D) + E + W[i] + 0x5a827999;
+ E = D; D = C; C = ROTL(B, 30); B = A; A = T;
+ }
+ for (i = 20; i < 40; i++) {
+ T = ROTL(A,5) + (B^C^D) + E + W[i] + 0x6ed9eba1;
+ E = D; D = C; C = ROTL(B, 30); B = A; A = T;
+ }
+ for (i = 40; i < 60; i++) {
+ T = ROTL(A,5) + (B&C) + (D&(B^C)) + E + W[i] + 0x8f1bbcdc;
+ E = D; D = C; C = ROTL(B, 30); B = A; A = T;
+ }
+ for (i = 60; i < 80; i++) {
+ T = ROTL(A,5) + (B^C^D) + E + W[i] + 0xca62c1d6;
+ E = D; D = C; C = ROTL(B, 30); B = A; A = T;
+ }
+
+ ctx->hash[0] += A;
+ ctx->hash[1] += B;
+ ctx->hash[2] += C;
+ ctx->hash[3] += D;
+ ctx->hash[4] += E;
+}
+#endif
+
+/*
+ * The following part of the file is NOT subject to the above license, and is
+ * instead placed in the public domain.
+ */
+
+void
+SHA1_Init(SHA_CTX *ctx)
+{
+ /* Initialize H with the magic constants (see FIPS180 for constants)
+ */
+ ctx->hash[0] = 0x67452301;
+ ctx->hash[1] = 0xefcdab89;
+ ctx->hash[2] = 0x98badcfe;
+ ctx->hash[3] = 0x10325476;
+ ctx->hash[4] = 0xc3d2e1f0;
+
+ ctx->sizeH = ctx->sizeL = 0;
+}
+
+void
+SHA1_Update(SHA_CTX *ctx, const void *data, size_t len)
+{
+ unsigned pos = ctx->sizeL % 64;
+
+ ctx->sizeL += len;
+ ctx->sizeH += (ctx->sizeL < (uint32_t)len);
+ ctx->sizeH += len >> 16 >> 16; /* In case size_t is 64 bits */
+
+ /* Leading partial block */
+ if (pos) {
+ unsigned avail = 64 - pos;
+ if (avail > len)
+ goto end;
+ memcpy((char *)ctx->data + pos, data, avail);
+ data = (char const *)data + avail;
+ len -= avail;
+ shaHashBlock(ctx, ctx->data);
+ }
+ /* Full blocks */
+ while (len >= 64) {
+ shaHashBlock(ctx, data);
+ data = (char const *)data + 64;
+ len -= 64;
+ }
+ pos = 0;
+end:
+ /* Buffer trailing partial block */
+ memcpy((char *)ctx->data + pos, data, len);
+}
+
+void
+SHA1_Final(unsigned char hashout[20], SHA_CTX *ctx)
+{
+ static unsigned char const padding[64] = { 0x80, 0 /* more zeros */ };
+ uint32_t sizeL = ctx->sizeL;
+ uint32_t sizeH = ctx->sizeH;
+ int i;
+
+ /* Append final padding, leaving 8 bytes free */
+ SHA1_Update(ctx, padding, 64 - ((sizeL + 8) % 64));
+ ctx->data[14] = htonl(sizeH << 3 | sizeL >> 29);
+ ctx->data[15] = htonl(sizeL << 3);
+
+ shaHashBlock(ctx, ctx->data);
+
+ for (i = 0; i < 5; i++)
+ ((uint32_t *)hashout)[i] = htonl(ctx->hash[i]);
+
+ memset(ctx, 0, sizeof *ctx);
+}
+
^ permalink raw reply
* Re: Tracking CVS
From: Jon Smirl @ 2006-06-23 18:14 UTC (permalink / raw)
To: Petr Baudis; +Cc: git
In-Reply-To: <20060623023131.GK21864@pasky.or.cz>
My cg-sync script looks like this now:
#!/usr/bin/env bash
cg-rm -a
cg-status -wnSs \? | xargs cg-add
But when are no files to add or remove I get this:
[jonsmirl@jonsmirl mozilla]$ cg sync
cg-rm: no files to remove
cg-add: usage: cg-add [-N] [-r] FILE...
This is definitely a useful script for tracking CVS. I'd like to see
it added to cogito once it is fully debugged.
--
Jon Smirl
jonsmirl@gmail.com
^ permalink raw reply
* Re: Ideas for qgit
From: Marco Costalba @ 2006-06-23 18:12 UTC (permalink / raw)
To: Pavel Roskin; +Cc: git
In-Reply-To: <1151035711.25640.6.camel@dv>
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. If it is
possible I would really like to stay with git tags, because bookmarks
seems to me like reinventing the (broken) wheel.
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.
> 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.
> 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.
> 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 ;-)
> 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?
> 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.
Again, being qgit a GUI tool we could avoid some command line only
application's habits. In the latter case there's nothing better to do,
but we can run a nicely formatted handbook in an independent window
just pressing F1 and be sure to never mess with any current and future
possible git option.
Marco
^ permalink raw reply
* Re: Is anybody actually using git-cherry.sh?
From: Jeff King @ 2006-06-23 18:06 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: git
In-Reply-To: <Pine.LNX.4.63.0606231818140.29667@wbgn013.biozentrum.uni-wuerzburg.de>
On Fri, Jun 23, 2006 at 06:22:05PM +0200, Johannes Schindelin wrote:
> from git-cherry.sh:
>
> -- snip --
> for c in $inup
> do
> git-diff-tree -p $c
> done | git-patch-id |
> while read id name
> do
> echo $name >>$patch/$id
> done
> -- snap --
>
> AFAICS this _must_ be broken. git-diff-tree -p <ent> does not emit
> "diff-tree <sha1>", and neither "commit <sha1>" lines. So this code
> would yield just one file, treating all diffs as one huge diff. A
> quick fix would be this change (without the patch I sent out earlier):
Maybe I don't understand what you're saying, but it works fine here
(using latest head of master):
$ for c in origin origin^; do git-diff-tree -p $c; done | git-patch-id
1511e4e276ccc98ecf0ea31dad1bc9010869fdaf f60349aa786d519368938d7b6e5bb2006eccb0cf
86ce7eeedd87a78cd8cac79adb6d4d968ece9e53 50f575fc9836704d45a5f732125b8f58103425a4
It looks like patch-id does a flush whenever a sha1 is found at the
beginning of a line; diff-tree lines simply have the 'diff-tree ' part
ignored.
-Peff
^ permalink raw reply
* Re: Added macro support to qgit
From: Marco Costalba @ 2006-06-23 17:44 UTC (permalink / raw)
To: Pavel Roskin; +Cc: git
In-Reply-To: <1151024452.5205.46.camel@dv>
Hi Pavel,
> If I understand correctly, qgit doesn't do that. It calls external
> commands that are not implemented internally, and it doesn't aggregate
> anything. Then why not call them "external commands"?
>
Or just "commands"? in any case I agree "macro" was not a good choice.
> The interface is quite confusing. I see 5 buttons on top, all of which
> are enabled, plus one button labeled as "...", three checkboxes, one
> single-line entry and one multiline entry. I have no I idea where to
> start. Should I click "new" or white something and then click "new"?
> And where's "Cancel"?.
>
> That's what I have tried:
>
> Enter "foo bar" in the multiline entry.
> Click "New"
> Enter "foobar"
> Click "New"
> Enter "abc"
> Select "foobar"
>
> Now "Run external script" is selected and "foo bar" is gone! I believe
> user input should not be discarded without a warning.
>
The bug is qgit lets you write the first foo bar, before you press NEW
button. It shouldn't. Also some buttons enable/disable policy could be
good.
> I also tried something more meaningful. I create a "pull" macro as an
> external script "stg pull". It didn't work. Am I supposed to supply
> full path? Does it understand arguments? It the script supposed to be
> in a certain format? OK, stg is written in python, but how about
> cg-status, a shell script? It doesn't seen to work either.
>
You are not supposed to supply full path, any executable file should
be OK and yes, you could supply arguments. You don't see nothing
because of a silly bug.
> What happens to the arguments qgit is asking for if a multiline entry is
> executed? I understand they are prepended to the first line. This is
> not quite logical. Wouldn't it be better to have a shell like notation
> for them?
>
I thought of commands sequence as a quick way to run some simple
commands as git pull, git push or similar without writing a bash
script, i.e. no $1 for arguments. If you need something more complex
the external script is supposed to be the proper way.
Perhaps we could remove the external script single edit line and use
only the multiline edit to let user insert commands or script.
> I see the macros are saved in the qgit configuration for the
> user .qt/qgitrc, like this:
>
Well, this file is really not meant to be view nor to be modified by
hand, it is mainly a qgit 'private' thing stuff. Being qgit a GUI tool
with a (nice ;-) ) settings dialog, configuration file is mainly used
for persistency, not for browsing/setup.
I hope to fix the external commands interface bugs this week-end.
Thanks for your reports
Marco
^ permalink raw reply
* Is anybody actually using git-cherry.sh?
From: Johannes Schindelin @ 2006-06-23 16:22 UTC (permalink / raw)
To: git
Hi,
from git-cherry.sh:
-- snip --
for c in $inup
do
git-diff-tree -p $c
done | git-patch-id |
while read id name
do
echo $name >>$patch/$id
done
-- snap --
AFAICS this _must_ be broken. git-diff-tree -p <ent> does not emit
"diff-tree <sha1>", and neither "commit <sha1>" lines. So this code would
yield just one file, treating all diffs as one huge diff. A quick fix
would be this change (without the patch I sent out earlier):
+ echo "diff-tree $c"
git-diff-tree -p $c
Am I wrong?
Ciao,
Dscho
^ 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