From 295ba2fb894be23cd1d1b0b34186e694b8e36076 Mon Sep 17 00:00:00 2001 From: Davide Libenzi Date: Thu, 13 Apr 2006 16:45:13 -0700 Subject: [PATCH 1/8] xdiff: post-process hunks to make them consistent. --- xdiff/xdiffi.c | 114 +++++++++++++++++++++++++++++++++++++++++++++--- xdiff/xmacros.h | 1 + 2 files changed, 110 insertions(+), 5 deletions(-) diff --git a/xdiff/xdiffi.c b/xdiff/xdiffi.c index 641362d056..b95ade2c1b 100644 --- a/xdiff/xdiffi.c +++ b/xdiff/xdiffi.c @@ -45,6 +45,8 @@ static long xdl_split(unsigned long const *ha1, long off1, long lim1, long *kvdf, long *kvdb, int need_min, xdpsplit_t *spl, xdalgoenv_t *xenv); static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2); +static int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo); + @@ -395,6 +397,110 @@ static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, } +static int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo) { + long ix, ixo, ixs, ixref, grpsiz, nrec = xdf->nrec; + char *rchg = xdf->rchg, *rchgo = xdfo->rchg; + xrecord_t **recs = xdf->recs; + + /* + * This is the same of what GNU diff does. Move back and forward + * change groups for a consistent and pretty diff output. This also + * helps in finding joineable change groups and reduce the diff size. + */ + for (ix = ixo = 0;;) { + /* + * Find the first changed line in the to-be-compacted file. + * We need to keep track of both indexes, so if we find a + * changed lines group on the other file, while scanning the + * to-be-compacted file, we need to skip it properly. Note + * that loops that are testing for changed lines on rchg* do + * not need index bounding since the array is prepared with + * a zero at position -1 and N. + */ + for (; ix < nrec && !rchg[ix]; ix++) + while (rchgo[ixo++]); + if (ix == nrec) + break; + + /* + * Record the start of a changed-group in the to-be-compacted file + * and find the end of it, on both to-be-compacted and other file + * indexes (ix and ixo). + */ + ixs = ix; + for (ix++; rchg[ix]; ix++); + for (; rchgo[ixo]; ixo++); + + do { + grpsiz = ix - ixs; + + /* + * If the line before the current change group, is equal to + * the last line of the current change group, shift backward + * the group. + */ + while (ixs > 0 && recs[ixs - 1]->ha == recs[ix - 1]->ha && + XDL_RECMATCH(recs[ixs - 1], recs[ix - 1])) { + rchg[--ixs] = 1; + rchg[--ix] = 0; + + /* + * This change might have joined two change groups, + * so we try to take this scenario in account by moving + * the start index accordingly (and so the other-file + * end-of-group index). + */ + for (; rchg[ixs - 1]; ixs--); + while (rchgo[--ixo]); + } + + /* + * Record the end-of-group position in case we are matched + * with a group of changes in the other file (that is, the + * change record before the enf-of-group index in the other + * file is set). + */ + ixref = rchgo[ixo - 1] ? ix: nrec; + + /* + * If the first line of the current change group, is equal to + * the line next of the current change group, shift forward + * the group. + */ + while (ix < nrec && recs[ixs]->ha == recs[ix]->ha && + XDL_RECMATCH(recs[ixs], recs[ix])) { + rchg[ixs++] = 0; + rchg[ix++] = 1; + + /* + * This change might have joined two change groups, + * so we try to take this scenario in account by moving + * the start index accordingly (and so the other-file + * end-of-group index). Keep tracking the reference + * index in case we are shifting together with a + * corresponding group of changes in the other file. + */ + for (; rchg[ix]; ix++); + while (rchgo[++ixo]) + ixref = ix; + } + } while (grpsiz != ix - ixs); + + /* + * Try to move back the possibly merged group of changes, to match + * the recorded postion in the other file. + */ + while (ixref < ix) { + rchg[--ixs] = 1; + rchg[--ix] = 0; + while (rchgo[--ixo]); + } + } + + return 0; +} + + int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr) { xdchange_t *cscr = NULL, *xch; char *rchg1 = xe->xdf1.rchg, *rchg2 = xe->xdf2.rchg; @@ -440,13 +546,13 @@ int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, return -1; } - - if (xdl_build_script(&xe, &xscr) < 0) { + if (xdl_change_compact(&xe.xdf1, &xe.xdf2) < 0 || + xdl_change_compact(&xe.xdf2, &xe.xdf1) < 0 || + xdl_build_script(&xe, &xscr) < 0) { xdl_free_env(&xe); return -1; } - if (xscr) { if (xdl_emit_diff(&xe, xscr, ecb, xecfg) < 0) { @@ -454,10 +560,8 @@ int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdl_free_env(&xe); return -1; } - xdl_free_script(xscr); } - xdl_free_env(&xe); return 0; diff --git a/xdiff/xmacros.h b/xdiff/xmacros.h index 4c2fde80c1..78f02603b8 100644 --- a/xdiff/xmacros.h +++ b/xdiff/xmacros.h @@ -33,6 +33,7 @@ #define XDL_ISDIGIT(c) ((c) >= '0' && (c) <= '9') #define XDL_HASHLONG(v, b) (((unsigned long)(v) * GR_PRIME) >> ((CHAR_BIT * sizeof(unsigned long)) - (b))) #define XDL_PTRFREE(p) do { if (p) { xdl_free(p); (p) = NULL; } } while (0) +#define XDL_RECMATCH(r1, r2) ((r1)->size == (r2)->size && memcmp((r1)->ptr, (r2)->ptr, (r1)->size) == 0) #define XDL_LE32_PUT(p, v) \ do { \ unsigned char *__p = (unsigned char *) (p); \ From 42b5c78845feb44f1d36eecad4c72336d5c2a9c5 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Fri, 14 Apr 2006 23:21:34 -0700 Subject: [PATCH 2/8] GIT v1.3.0-rc4 I've merged everything I think is ready for 1.3.0, so this is the final round -- hopefully I can release this with minimum last-minute fixup as v1.3.0 early next week. Signed-off-by: Junio C Hamano --- GIT-VERSION-GEN | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/GIT-VERSION-GEN b/GIT-VERSION-GEN index 656f55542c..e88fe5ae7c 100755 --- a/GIT-VERSION-GEN +++ b/GIT-VERSION-GEN @@ -1,7 +1,7 @@ #!/bin/sh GVF=GIT-VERSION-FILE -DEF_VER=v1.3-rc3.GIT +DEF_VER=v1.3-rc4.GIT # First try git-describe, then see if there is a version file # (included in release tarballs), then default From 5069b1cf6177f837830dd3ac402bee4f3d088fa5 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sat, 15 Apr 2006 03:22:00 -0700 Subject: [PATCH 3/8] diff-tree: typefix. Recent diff_tree_setup_paths() update made it take a second argument of type "struct diff_options", but we passed another struct that happenes to have that type at the beginning by mistake. Signed-off-by: Junio C Hamano --- diff-tree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/diff-tree.c b/diff-tree.c index 2b79dd0a68..7015b06c7f 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -120,7 +120,7 @@ int main(int argc, const char **argv) if (opt->diffopt.output_format == DIFF_FORMAT_PATCH) opt->diffopt.recursive = 1; - diff_tree_setup_paths(get_pathspec(prefix, argv), opt); + diff_tree_setup_paths(get_pathspec(prefix, argv), &opt->diffopt); diff_setup_done(&opt->diffopt); switch (nr_sha1) { From 6f4780f9dfd3bc6b23f9ea66b3d49577e0a0c2f9 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sat, 15 Apr 2006 14:02:10 -0700 Subject: [PATCH 4/8] diff --stat: do not do its own three-dashes. I missed that "git-diff-* --stat" spits out three-dash separator on its own without being asked. Remove it. When we output commit log followed by diff, perhaps --patch-with-stat, for downstream consumer, we _would_ want the three-dash between the message and the diff material, but that logic belongs to the caller, not diff generator. Signed-off-by: Junio C Hamano --- diff.c | 2 -- git.c | 4 +++- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/diff.c b/diff.c index f1b672d2dc..cda8d2069e 100644 --- a/diff.c +++ b/diff.c @@ -245,8 +245,6 @@ static void show_stats(struct diffstat_t* data) if (data->nr == 0) return; - printf("---\n"); - for (i = 0; i < data->nr; i++) { struct diffstat_file *file = data->files[i]; diff --git a/git.c b/git.c index 78ed403ed1..61265a8566 100644 --- a/git.c +++ b/git.c @@ -388,8 +388,10 @@ static int cmd_log(int argc, const char **argv, char **envp) pretty_print_commit(commit_format, commit, ~0, buf, LOGSIZE, abbrev); printf("%s\n", buf); - if (do_diff) + if (do_diff) { + printf("---\n"); log_tree_commit(&opt, commit); + } shown = 1; free(commit->buffer); commit->buffer = NULL; From 1cd95087c331e17c44a8b62f0614d55e621dcfd4 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 15 Apr 2006 11:13:49 -0700 Subject: [PATCH 5/8] Support "git cmd --help" syntax The "--help" argument is special, in that it is (along with "--version") in that is taken by the "git" program itself rather than the sub-command, and thus we've had the syntax "git --help cmd". However, as anybody who has ever used CVS or some similar devil-spawn program, it's confusing as h*ll when options before the sub-command act differently from options after the sub-command, so this quick hack just makes it acceptable to do "git cmd --help" instead, and get the exact same result. It may be hacky, but it's simple and does the trick. Of course, this does not help if you use one of the non-builtin commands without using the "git" helper. Ie you won't be getting a man-page just because you do "git-rev-list --help". Don't expect us to be quite _that_ helpful. Signed-off-by: Linus Torvalds Signed-off-by: Junio C Hamano --- git.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/git.c b/git.c index 61265a8566..140ed1873d 100644 --- a/git.c +++ b/git.c @@ -413,6 +413,12 @@ static void handle_internal_command(int argc, const char **argv, char **envp) }; int i; + /* Turn "git cmd --help" into "git help cmd" */ + if (argc > 1 && !strcmp(argv[1], "--help")) { + argv[1] = argv[0]; + argv[0] = cmd = "help"; + } + for (i = 0; i < ARRAY_SIZE(commands); i++) { struct cmd_struct *p = commands+i; if (strcmp(p->cmd, cmd)) From cbdda024049947366804d60bdc5e5fc3ab3ee3a5 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sat, 15 Apr 2006 18:38:32 -0700 Subject: [PATCH 6/8] diff-files --stat: do not dump core with unmerged index. Signed-off-by: Junio C Hamano --- diff.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/diff.c b/diff.c index cda8d2069e..46e8529a64 100644 --- a/diff.c +++ b/diff.c @@ -202,6 +202,8 @@ struct diffstat_t { int alloc; struct diffstat_file { char *name; + unsigned is_unmerged:1; + unsigned is_binary:1; unsigned int added, deleted; } **files; }; @@ -248,6 +250,8 @@ static void show_stats(struct diffstat_t* data) for (i = 0; i < data->nr; i++) { struct diffstat_file *file = data->files[i]; + if (file->is_binary || file->is_unmerged) + continue; if (max_change < file->added + file->deleted) max_change = file->added + file->deleted; len = strlen(file->name); @@ -292,11 +296,15 @@ static void show_stats(struct diffstat_t* data) if (max + len > 70) max = 70 - len; - if (added < 0) { - /* binary file */ + if (data->files[i]->is_binary) { printf(" %s%-*s | Bin\n", prefix, len, name); goto free_diffstat_file; - } else if (added + deleted == 0) { + } + else if (data->files[i]->is_unmerged) { + printf(" %s%-*s | Unmerged\n", prefix, len, name); + goto free_diffstat_file; + } + else if (added + deleted == 0) { total_files--; goto free_diffstat_file; } @@ -424,11 +432,16 @@ static void builtin_diffstat(const char *name_a, const char *name_b, data = diffstat_add(diffstat, name_a ? name_a : name_b); + if (!one || !two) { + data->is_unmerged = 1; + return; + } + if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0) die("unable to read files to diff"); if (mmfile_is_binary(&mf1) || mmfile_is_binary(&mf2)) - data->added = -1; + data->is_binary = 1; else { /* Crazy xdl interfaces.. */ xpparam_t xpp; From 293532739415d287786a312ec10849723383796e Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Sat, 15 Apr 2006 13:41:18 +0200 Subject: [PATCH 7/8] diff-options: add --patch-with-stat With this option, git prepends a diffstat in front of the patch. Since I really, really do not know what a diffstat of a combined diff ("merge diff") should look like, the diffstat is not generated for these. Signed-off-by: Johannes Schindelin Signed-off-by: Junio C Hamano --- Documentation/diff-options.txt | 3 +++ diff.c | 17 ++++++++++++++++- diff.h | 3 +++ 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/Documentation/diff-options.txt b/Documentation/diff-options.txt index 447e522a7b..c183dc9da0 100644 --- a/Documentation/diff-options.txt +++ b/Documentation/diff-options.txt @@ -10,6 +10,9 @@ --stat:: Generate a diffstat instead of a patch. +--patch-with-stat:: + Generate patch and prepend its diffstat. + -z:: \0 line termination on output diff --git a/diff.c b/diff.c index 46e8529a64..b54bbfa627 100644 --- a/diff.c +++ b/diff.c @@ -1060,6 +1060,10 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac) } else if (!strcmp(arg, "--stat")) options->output_format = DIFF_FORMAT_DIFFSTAT; + else if (!strcmp(arg, "--patch-with-stat")) { + options->output_format = DIFF_FORMAT_PATCH; + options->with_stat = 1; + } else if (!strcmp(arg, "-z")) options->line_termination = 0; else if (!strncmp(arg, "-l", 2)) @@ -1529,7 +1533,7 @@ void diff_flush(struct diff_options *options) int diff_output_format = options->output_format; struct diffstat_t *diffstat = NULL; - if (diff_output_format == DIFF_FORMAT_DIFFSTAT) { + if (diff_output_format == DIFF_FORMAT_DIFFSTAT || options->with_stat) { diffstat = xcalloc(sizeof (struct diffstat_t), 1); diffstat->xm.consume = diffstat_consume; } @@ -1541,6 +1545,17 @@ void diff_flush(struct diff_options *options) } putchar(options->line_termination); } + if (options->with_stat) { + for (i = 0; i < q->nr; i++) { + struct diff_filepair *p = q->queue[i]; + flush_one_pair(p, DIFF_FORMAT_DIFFSTAT, options, + diffstat); + } + show_stats(diffstat); + free(diffstat); + diffstat = NULL; + 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); diff --git a/diff.h b/diff.h index 2f8aff2cd4..f783baef14 100644 --- a/diff.h +++ b/diff.h @@ -25,6 +25,7 @@ struct diff_options { const char *pickaxe; unsigned recursive:1, with_raw:1, + with_stat:1, tree_in_recursive:1, full_index:1; int break_opt; @@ -120,6 +121,8 @@ extern void diffcore_std_no_resolve(struct diff_options *); " --patch-with-raw\n" \ " output both a patch and the diff-raw format.\n" \ " --stat show diffstat instead of patch.\n" \ +" --patch-with-stat\n" \ +" output a patch and prepend its diffstat.\n" \ " --name-only show only names of changed files.\n" \ " --name-status show names and status of changed files.\n" \ " --full-index show full object name on index lines.\n" \ From 402461aab17292b78bd36a17bff18e48d544cc9a Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Sun, 16 Apr 2006 04:44:25 +0200 Subject: [PATCH 8/8] pager: do not fork a pager if PAGER is set to empty. This skips an extra pipe, and helps debugging tremendously. [jc: PAGER=cat is a questionable hack and should be done as a separate patch. ] Signed-off-by: Johannes Schindelin Signed-off-by: Junio C Hamano --- pager.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pager.c b/pager.c index 1364e15d23..e5ba2738b6 100644 --- a/pager.c +++ b/pager.c @@ -5,22 +5,24 @@ * something different on Windows, for example. */ -static void run_pager(void) +static void run_pager(const char *pager) { - const char *prog = getenv("PAGER"); - if (!prog) - prog = "less"; - setenv("LESS", "-S", 0); - execlp(prog, prog, NULL); + execlp(pager, pager, NULL); } void setup_pager(void) { pid_t pid; int fd[2]; + const char *pager = getenv("PAGER"); if (!isatty(1)) return; + if (!pager) + pager = "less"; + else if (!*pager) + return; + if (pipe(fd) < 0) return; pid = fork(); @@ -43,6 +45,7 @@ void setup_pager(void) close(fd[0]); close(fd[1]); - run_pager(); + setenv("LESS", "-S", 0); + run_pager(pager); exit(255); }