* [PATCH 01/12] parse-options: stop when encounter a non-option
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 02/12] parse-options: add two helper functions Bo Yang
` (10 subsequent siblings)
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Since we need to support the syntax like:
-L n1,m1 path1 -L n2,m2 path2.
So, make the parse-options API not stop with a
non-option, but report the status and go on parsing
the following.
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
parse-options.c | 3 ++-
parse-options.h | 3 ++-
2 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/parse-options.c b/parse-options.c
index 0fa79bc..cbb49d3 100644
--- a/parse-options.c
+++ b/parse-options.c
@@ -374,7 +374,7 @@ int parse_options_step(struct parse_opt_ctx_t *ctx,
if (parse_nodash_opt(ctx, arg, options) == 0)
continue;
if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
- break;
+ return PARSE_OPT_NON_OPTION;
ctx->out[ctx->cpidx++] = ctx->argv[0];
continue;
}
@@ -456,6 +456,7 @@ int parse_options(int argc, const char **argv, const char *prefix,
switch (parse_options_step(&ctx, options, usagestr)) {
case PARSE_OPT_HELP:
exit(129);
+ case PARSE_OPT_NON_OPTION:
case PARSE_OPT_DONE:
break;
default: /* PARSE_OPT_UNKNOWN */
diff --git a/parse-options.h b/parse-options.h
index 7435cdb..407697a 100644
--- a/parse-options.h
+++ b/parse-options.h
@@ -161,7 +161,8 @@ extern NORETURN void usage_msg_opt(const char *msg,
enum {
PARSE_OPT_HELP = -1,
PARSE_OPT_DONE,
- PARSE_OPT_UNKNOWN
+ PARSE_OPT_NON_OPTION,
+ PARSE_OPT_UNKNOWN,
};
/*
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 02/12] parse-options: add two helper functions
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
2010-06-26 13:27 ` [PATCH 01/12] parse-options: stop when encounter a non-option Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-27 18:22 ` Junio C Hamano
2010-06-26 13:27 ` [PATCH 03/12] add the basic data structure for line level history Bo Yang
` (9 subsequent siblings)
11 siblings, 1 reply; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
1. parse_options_current: get the current option/argument the API
now is dealing with;
2. parse_options_next: make the API to deal with the next
option/argument.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
parse-options.c | 21 +++++++++++++++++++++
parse-options.h | 4 ++++
2 files changed, 25 insertions(+), 0 deletions(-)
diff --git a/parse-options.c b/parse-options.c
index cbb49d3..013dbdb 100644
--- a/parse-options.c
+++ b/parse-options.c
@@ -439,6 +439,27 @@ unknown:
return PARSE_OPT_DONE;
}
+const char *parse_options_current(struct parse_opt_ctx_t *ctx)
+{
+ return ctx->argv[0];
+}
+
+int parse_options_next(struct parse_opt_ctx_t *ctx, int retain)
+{
+ if (ctx->argc <= 0)
+ return -1;
+
+ if (retain == 1)
+ {
+ ctx->out[ctx->cpidx++] = ctx->argv[0];
+ }
+
+ ctx->argc--;
+ ctx->argv++;
+
+ return 0;
+}
+
int parse_options_end(struct parse_opt_ctx_t *ctx)
{
memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
diff --git a/parse-options.h b/parse-options.h
index 407697a..4791baa 100644
--- a/parse-options.h
+++ b/parse-options.h
@@ -187,6 +187,10 @@ extern int parse_options_step(struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[]);
+extern const char *parse_options_current(struct parse_opt_ctx_t *ctx);
+
+extern int parse_options_next(struct parse_opt_ctx_t *ctx, int retain);
+
extern int parse_options_end(struct parse_opt_ctx_t *ctx);
extern int parse_options_concat(struct option *dst, size_t, struct option *src);
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 02/12] parse-options: add two helper functions
2010-06-26 13:27 ` [PATCH 02/12] parse-options: add two helper functions Bo Yang
@ 2010-06-27 18:22 ` Junio C Hamano
2010-06-30 14:35 ` Bo Yang
0 siblings, 1 reply; 19+ messages in thread
From: Junio C Hamano @ 2010-06-27 18:22 UTC (permalink / raw)
To: Bo Yang; +Cc: git, Jens.Lehmann, trast, jrnieder
> diff --git a/parse-options.c b/parse-options.c
> index cbb49d3..013dbdb 100644
> --- a/parse-options.c
> +++ b/parse-options.c
> @@ -439,6 +439,27 @@ unknown:
> return PARSE_OPT_DONE;
> }
>
> +const char *parse_options_current(struct parse_opt_ctx_t *ctx)
> +{
> + return ctx->argv[0];
> +}
> +
> +int parse_options_next(struct parse_opt_ctx_t *ctx, int retain)
> +{
> + if (ctx->argc <= 0)
> + return -1;
> +
> + if (retain == 1)
> + {
> + ctx->out[ctx->cpidx++] = ctx->argv[0];
> + }
Style. Either drop the unnecessary curly pair, or open the curly at the
end of the line that has the closing parenthesis of "if" condition.
These two functions makes sense. You could then use parse-options-step to
let the machinery mostly be driven by the usual table lookup, and when
(and only when) the machinery says "I don't know what this is", you can
check "current" to see what it is (e.g. it may be "-L"), handle it
yourself, and if you need to do something different (e.g. eat the <path>
that immedately follows "-L"), you can use "next" to skip it without ever
showing that to the table based parseopt machinery.
I however wonder why you would need two passes if you have these two APIs
into parse-options machinery, though...
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH 02/12] parse-options: add two helper functions
2010-06-27 18:22 ` Junio C Hamano
@ 2010-06-30 14:35 ` Bo Yang
0 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-30 14:35 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, Jens.Lehmann, trast, jrnieder
Hi Junio,
On Mon, Jun 28, 2010 at 2:22 AM, Junio C Hamano <gitster@pobox.com> wrote:
>> diff --git a/parse-options.c b/parse-options.c
>> index cbb49d3..013dbdb 100644
>> --- a/parse-options.c
>> +++ b/parse-options.c
>> @@ -439,6 +439,27 @@ unknown:
>> return PARSE_OPT_DONE;
>> }
>>
>> +const char *parse_options_current(struct parse_opt_ctx_t *ctx)
>> +{
>> + return ctx->argv[0];
>> +}
>> +
>> +int parse_options_next(struct parse_opt_ctx_t *ctx, int retain)
>> +{
>> + if (ctx->argc <= 0)
>> + return -1;
>> +
>> + if (retain == 1)
>> + {
>> + ctx->out[ctx->cpidx++] = ctx->argv[0];
>> + }
>
> Style. Either drop the unnecessary curly pair, or open the curly at the
> end of the line that has the closing parenthesis of "if" condition.
>
> These two functions makes sense. You could then use parse-options-step to
> let the machinery mostly be driven by the usual table lookup, and when
> (and only when) the machinery says "I don't know what this is", you can
> check "current" to see what it is (e.g. it may be "-L"), handle it
> yourself, and if you need to do something different (e.g. eat the <path>
> that immedately follows "-L"), you can use "next" to skip it without ever
> showing that to the table based parseopt machinery.
>
> I however wonder why you would need two passes if you have these two APIs
> into parse-options machinery, though...
>
Hmm, yes, I have rewrite the the parsing code as a one pass one. It is
3 or 4 weeks since this parsing code written, so I can't remember
clearly why it adopt this two pass way. :-)
--
Regards!
Bo
----------------------------
My blog: http://blog.morebits.org
Why Git: http://www.whygitisbetterthanx.com/
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 03/12] add the basic data structure for line level history
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
2010-06-26 13:27 ` [PATCH 01/12] parse-options: stop when encounter a non-option Bo Yang
2010-06-26 13:27 ` [PATCH 02/12] parse-options: add two helper functions Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-27 18:23 ` Junio C Hamano
2010-06-26 13:27 ` [PATCH 04/12] parse the -L options Bo Yang
` (8 subsequent siblings)
11 siblings, 1 reply; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
'struct diff_line_range' is the main data structure to store
the user interesting line range. There is one 'diff_line_range'
for each file, and there are multiple 'struct range' in each
'diff_line_range'. In this way, we support multiple ranges.
Within 'struct range', there are multiple 'struct print_range'
which represent a diff chunk.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
Makefile | 2 +
diffcore.h | 3 +
line.c | 453 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
line.h | 122 ++++++++++++++++
revision.c | 13 ++-
revision.h | 9 +-
6 files changed, 597 insertions(+), 5 deletions(-)
create mode 100644 line.c
create mode 100644 line.h
diff --git a/Makefile b/Makefile
index 1fadd43..0183a21 100644
--- a/Makefile
+++ b/Makefile
@@ -496,6 +496,7 @@ LIB_H += grep.h
LIB_H += hash.h
LIB_H += help.h
LIB_H += levenshtein.h
+LIB_H += line.h
LIB_H += list-objects.h
LIB_H += ll-merge.h
LIB_H += log-tree.h
@@ -582,6 +583,7 @@ LIB_OBJS += help.o
LIB_OBJS += hex.o
LIB_OBJS += ident.o
LIB_OBJS += levenshtein.o
+LIB_OBJS += line.o
LIB_OBJS += list-objects.o
LIB_OBJS += ll-merge.o
LIB_OBJS += lockfile.o
diff --git a/diffcore.h b/diffcore.h
index 491bea0..06a6934 100644
--- a/diffcore.h
+++ b/diffcore.h
@@ -23,6 +23,7 @@
#define MINIMUM_BREAK_SIZE 400 /* do not break a file smaller than this */
struct userdiff_driver;
+struct diff_options;
struct diff_filespec {
unsigned char sha1[20];
@@ -51,6 +52,8 @@ struct diff_filespec {
int is_binary;
};
+#define FILESPEC_VALID(f) (f)->sha1_valid
+
extern struct diff_filespec *alloc_filespec(const char *);
extern void free_filespec(struct diff_filespec *);
extern void fill_filespec(struct diff_filespec *, const unsigned char *,
diff --git a/line.c b/line.c
new file mode 100644
index 0000000..7b7f3f3
--- /dev/null
+++ b/line.c
@@ -0,0 +1,453 @@
+#include "line.h"
+#include "cache.h"
+#include "tag.h"
+#include "blob.h"
+#include "tree.h"
+#include "commit.h"
+#include "diff.h"
+#include "decorate.h"
+#include "revision.h"
+#include "xdiff-interface.h"
+#include "strbuf.h"
+#include "log-tree.h"
+
+static void cleanup(struct diff_line_range *r)
+{
+ while (r) {
+ struct diff_line_range *tmp = r->next;
+ DIFF_LINE_RANGE_CLEAR(r);
+ free(r);
+ r = tmp;
+ }
+}
+
+static struct object *find_commit(struct rev_info *revs)
+{
+ struct object *commit = NULL;
+ const char *name = NULL;
+ int i;
+
+ for (i = 0; i < revs->pending.nr; i++) {
+ struct object *obj = revs->pending.objects[i].item;
+ if (obj->flags & UNINTERESTING)
+ continue;
+ while (obj->type == OBJ_TAG)
+ obj = deref_tag(obj, NULL, 0);
+ if (obj->type != OBJ_COMMIT)
+ die("Non commit %s?", revs->pending.objects[i].name);
+ if (commit)
+ die("More than one commit to dig from: %s and %s?",
+ revs->pending.objects[i].name, name);
+ commit = obj;
+ name = revs->pending.objects[i].name;
+ }
+
+ return commit;
+}
+
+static void fill_blob_sha1(struct commit *commit, struct diff_line_range *r)
+{
+ unsigned mode;
+ unsigned char sha1[20];
+
+ while (r) {
+ if (get_tree_entry(commit->object.sha1, r->spec->path,
+ sha1, &mode))
+ goto error;
+ fill_filespec(r->spec, sha1, mode);
+ r = r->next;
+ }
+
+ return ;
+error:
+ die("There is no path %s in the commit", r->spec->path);
+}
+
+static void make_line_log_file(struct diff_filespec *spec, int *lines, int **line_ends)
+{
+ int num = 0, size = 50, cur = 0;
+ int *ends = NULL;
+ char *data = NULL;
+
+ if (diff_populate_filespec(spec, 0))
+ die("Cannot read blob %s", sha1_to_hex(spec->sha1));
+
+ ends = xmalloc(size * sizeof(int));
+ ends[cur++] = -1;
+ data = spec->data;
+ while (num < spec->size) {
+ if (data[num] == '\n' || num == spec->size - 1) {
+ if (cur >= size) {
+ size = size * 2;
+ ends = xrealloc(ends, size * sizeof(int));
+ }
+ ends[cur++] = num;
+ }
+ num ++;
+ }
+
+ /* shrink the array to fit the elements */
+ ends = xrealloc(ends, cur * sizeof(int));
+ *lines = cur;
+ *line_ends = ends;
+}
+
+static const char *nth_line(struct diff_filespec *spec, int line, int lines, int *line_ends)
+{
+ assert(line < lines);
+ assert(spec && spec->data);
+
+ return (char *)spec->data + line_ends[line] + 1;
+}
+
+/*
+ * copied from blame.c, indeed, we can even to use this to test
+ * whether line log works. :)
+ */
+static const char *parse_loc(const char *spec, struct diff_filespec *file,
+ int lines, int *line_ends,
+ long begin, long *ret)
+{
+ char *term;
+ const char *line;
+ long num;
+ int reg_error;
+ regex_t regexp;
+ regmatch_t match[1];
+
+ /* Allow "-L <something>,+20" to mean starting at <something>
+ * for 20 lines, or "-L <something>,-5" for 5 lines ending at
+ * <something>.
+ */
+ if (1 < begin && (spec[0] == '+' || spec[0] == '-')) {
+ num = strtol(spec + 1, &term, 10);
+ if (term != spec + 1) {
+ if (spec[0] == '-')
+ num = 0 - num;
+ if (0 < num)
+ *ret = begin + num - 2;
+ else if (!num)
+ *ret = begin;
+ else
+ *ret = begin + num;
+ return term;
+ }
+ return spec;
+ }
+ num = strtol(spec, &term, 10);
+ if (term != spec) {
+ *ret = num;
+ return term;
+ }
+ if (spec[0] != '/')
+ return spec;
+
+ /* it could be a regexp of form /.../ */
+ for (term = (char *) spec + 1; *term && *term != '/'; term++) {
+ if (*term == '\\')
+ term++;
+ }
+ if (*term != '/')
+ return spec;
+
+ /* try [spec+1 .. term-1] as regexp */
+ *term = 0;
+ begin--; /* input is in human terms */
+ line = nth_line(file, begin, lines, line_ends);
+
+ if (!(reg_error = regcomp(®exp, spec + 1, REG_NEWLINE)) &&
+ !(reg_error = regexec(®exp, line, 1, match, 0))) {
+ const char *cp = line + match[0].rm_so;
+ const char *nline;
+
+ while (begin++ < lines) {
+ nline = nth_line(file, begin, lines, line_ends);
+ if (line <= cp && cp < nline)
+ break;
+ line = nline;
+ }
+ *ret = begin;
+ regfree(®exp);
+ *term++ = '/';
+ return term;
+ }
+ else {
+ char errbuf[1024];
+ regerror(reg_error, ®exp, errbuf, 1024);
+ die("-L parameter '%s': %s", spec + 1, errbuf);
+ }
+}
+
+static void parse_range(int lines, int *line_ends, struct range *r, struct diff_filespec *spec)
+{
+ const char *term;
+
+ term = parse_loc(r->arg, spec, lines, line_ends, 1, &r->start);
+ if (*term == ',') {
+ term = parse_loc(term + 1, spec, lines, line_ends,
+ r->start + 1, &r->end);
+ if (*term) {
+ die("-L parameter's argument should be <start>,<end>");
+ }
+ }
+
+ if (*term) {
+ die("-L parameter's argument should be <start>,<end>");
+ }
+
+ if (r->start > r->end) {
+ long tmp = r->start;
+ r->start = r->end;
+ r->end = tmp;
+ }
+
+ if (r->start < 1)
+ r->start = 1;
+ if (r->end >= lines)
+ r->end = lines - 1;
+}
+
+static void parse_lines(struct commit *commit, struct diff_line_range *r)
+{
+ int i;
+ struct range *rg = NULL;
+ int lines = 0;
+ int *ends = NULL;
+
+ while (r) {
+ struct diff_filespec *spec = r->spec;
+ int num = r->nr;
+ assert(spec);
+ fill_blob_sha1(commit, r);
+ rg = r->ranges;
+ r->ranges = NULL;
+ r->nr = r->alloc = 0;
+ make_line_log_file(spec, &lines, &ends);
+ for (i = 0; i < num; i++) {
+ parse_range(lines, ends, rg + i, spec);
+ diff_line_range_insert(r, rg[i].arg, rg[i].start, rg[i].end);
+ }
+
+ if (ends != NULL) {
+ free(ends);
+ ends = NULL;
+ }
+
+ r = r->next;
+ /* release the memory of old array */
+ free(rg);
+ }
+}
+
+/*
+ * Insert a new line range into a diff_line_range struct, and keep the
+ * r->ranges sorted by their starting line number.
+ */
+struct range *diff_line_range_insert(struct diff_line_range *r, const char *arg,
+ int start, int end)
+{
+ assert(r != NULL);
+ assert(start <= end);
+
+ int i = 0;
+ struct range *rs = r->ranges;
+ int left_extend = 0, right_extend = 0;
+
+ if (r->nr == 0 || rs[r->nr - 1].end < start - 1) {
+ DIFF_LINE_RANGE_GROW(r);
+ rs = r->ranges;
+ int num = r->nr - 1;
+ rs[num].arg = arg;
+ rs[num].start = start;
+ rs[num].end = end;
+ return rs + num;
+ }
+
+ for (; i < r->nr; i++) {
+ if (rs[i].end < start - 1)
+ continue;
+ if (rs[i].end == start - 1) {
+ rs[i].end = end;
+ right_extend = 1;
+ goto out;
+ }
+
+ assert(rs[i].end > start - 1);
+ if (rs[i].start <= start) {
+ if (rs[i].end < end) {
+ rs[i].end = end;
+ right_extend = 1;
+ }
+ goto out;
+ } else if (rs[i].start <= end + 1) {
+ rs[i].start = start;
+ left_extend = 1;
+ if (rs[i].end < end) {
+ rs[i].end = end;
+ right_extend = 1;
+ }
+ goto out;
+ } else {
+ int num = r->nr - i;
+ DIFF_LINE_RANGE_GROW(r);
+ rs = r->ranges;
+ memmove(rs + i + 1, rs + i, num * sizeof(struct range));
+ rs[i].arg = arg;
+ rs[i].start = start;
+ rs[i].end = end;
+ goto out;
+ }
+ }
+
+out:
+ assert(r->nr != i);
+ if (left_extend) {
+ int j = i;
+ for (; j > -1; j--) {
+ if (rs[j].end >= rs[i].start - 1)
+ if (rs[j].start < rs[i].start)
+ rs[i].start = rs[j].start;
+ }
+ memmove(rs + j + 1, rs + i, (r->nr - i) * sizeof(struct range));
+ r->nr -= i - j - 1;
+ }
+ if (right_extend) {
+ int j = i;
+ for (; j < r->nr; j++) {
+ if (rs[j].start <= rs[i].end + 1)
+ if (rs[j].end > rs[i].end)
+ rs[i].end = rs[j].end;
+ }
+ if (j < r->nr) {
+ memmove(rs + i + 1, rs + j, (r->nr - j) * sizeof(struct range));
+ }
+ r->nr -= j - i - 1;
+ }
+ assert(r->nr);
+
+ return rs + i;
+}
+
+void diff_line_range_clear(struct diff_line_range *r)
+{
+ int i = 0, zero = 0;
+
+ for (; i < r->nr; i++) {
+ struct range *rg = r->ranges + i;
+ RANGE_CLEAR(rg);
+ }
+
+ if (r->prev) {
+ zero = 0;
+ if (r->prev->count == 1) {
+ zero = 1;
+ }
+ free_filespec(r->prev);
+ if (zero)
+ r->prev = NULL;
+ }
+ if (r->spec) {
+ zero = 0;
+ if (r->spec->count == 1) {
+ zero = 1;
+ }
+ free_filespec(r->spec);
+ if (zero)
+ r->spec = NULL;
+ }
+
+ r->status = '\0';
+ r->alloc = r->nr = 0;
+
+ if (r->ranges)
+ free(r->ranges);
+ r->ranges = NULL;
+}
+
+void diff_line_range_append(struct diff_line_range *r, const char *arg)
+{
+ DIFF_LINE_RANGE_GROW(r);
+ r->ranges[r->nr - 1].arg = arg;
+}
+
+struct diff_line_range *diff_line_range_merge(struct diff_line_range *out,
+ struct diff_line_range *other)
+{
+ struct diff_line_range *one = out, *two = other;
+ struct diff_line_range *pone;
+
+ while (one) {
+ struct diff_line_range *prev;
+ two = other;
+ prev = other;
+ while (two) {
+ if (!strcmp(one->spec->path, two->spec->path)) {
+ int i = 0;
+ for (; i < two->nr; i++) {
+ diff_line_range_insert(one, NULL,
+ two->ranges[i].start,
+ two->ranges[i].end);
+ }
+ if (prev == other) {
+ other = other->next;
+ } else {
+ prev->next = two->next;
+ }
+ DIFF_LINE_RANGE_CLEAR(two);
+ free(two);
+ two = NULL;
+
+ break;
+ }
+
+ prev = two;
+ two = two->next;
+ }
+
+ pone = one;
+ one = one->next;
+ }
+ pone->next = other;
+
+ return out;
+}
+
+void add_line_range(struct rev_info *revs, struct commit *commit, struct diff_line_range *r)
+{
+ struct diff_line_range *ret = NULL;
+
+ if (r != NULL) {
+ ret = lookup_decoration(&revs->line_range, &commit->object);
+ if (ret != NULL) {
+ diff_line_range_merge(ret, r);
+ } else {
+ add_decoration(&revs->line_range, &commit->object, r);
+ }
+ commit->object.flags |= RANGE_UPDATE;
+ }
+}
+
+struct diff_line_range *lookup_line_range(struct rev_info *revs, struct commit *commit)
+{
+ struct diff_line_range *ret = NULL;
+
+ ret = lookup_decoration(&revs->line_range, &commit->object);
+ return ret;
+}
+
+void setup_line(struct rev_info *rev, struct diff_line_range *r)
+{
+ struct commit *commit = NULL;
+ struct diff_options *opt = &rev->diffopt;
+
+ commit = (struct commit *)find_commit(rev);
+ parse_lines(commit, r);
+
+ add_line_range(rev, commit, r);
+ /*
+ * Note we support -M/-C to detect file rename
+ */
+ opt->nr_paths = 0;
+ diff_tree_release_paths(opt);
+}
+
diff --git a/line.h b/line.h
new file mode 100644
index 0000000..a2f8545
--- /dev/null
+++ b/line.h
@@ -0,0 +1,122 @@
+#ifndef LINE_H
+#define LINE_H
+
+#include "diffcore.h"
+
+struct rev_info;
+struct commit;
+struct diff_line_range;
+struct diff_options;
+
+struct print_range {
+ int start, end;
+ int pstart, pend;
+ int line_added : 1;
+};
+
+struct print_pair {
+ int alloc, nr;
+ struct print_range *ranges;
+};
+
+#define PRINT_RANGE_INIT(r) \
+ do { \
+ (r)->line_added = 0; \
+ } while(0);
+
+#define PRINT_PAIR_INIT(p) \
+ do { \
+ (p)->alloc = (p)->nr = 0; \
+ (p)->ranges = NULL; \
+ } while(0);
+
+#define PRINT_PAIR_GROW(p) \
+ do { \
+ (p)->nr ++; \
+ ALLOC_GROW((p)->ranges, (p)->nr, (p)->alloc); \
+ } while (0);
+
+#define PRINT_PAIR_CLEAR(p) \
+ do { \
+ (p)->alloc = (p)->nr = 0; \
+ if ((p)->ranges) \
+ free((p)->ranges); \
+ (p)->ranges = NULL; \
+ } while(0);
+
+struct range {
+ const char *arg; //The argument to specify this line range
+ long start, end; //The start line number, inclusive
+ long pstart, pend; //The end line number, inclusive
+ struct print_pair pair;
+ //The changed lines inside this range
+ unsigned int diff:1;
+};
+
+struct diff_line_range {
+ struct diff_filespec *prev;
+ struct diff_filespec *spec;
+ char status;
+ int alloc;
+ int nr;
+ struct range *ranges;
+ unsigned int touch:1,
+ diff:1;
+ struct diff_line_range *next;
+};
+
+#define RANGE_INIT(r) \
+ do { \
+ (r)->arg = NULL; \
+ (r)->start = (r)->end = 0; \
+ (r)->pstart = (r)->pend = 0; \
+ PRINT_PAIR_INIT(&((r)->pair)); \
+ (r)->diff = 0; \
+ } while (0);
+
+#define RANGE_CLEAR(r) \
+ do { \
+ (r)->arg = NULL; \
+ (r)->start = (r)->end = 0; \
+ (r)->pstart = (r)->pend = 0; \
+ PRINT_PAIR_CLEAR(&r->pair); \
+ (r)->diff = 0; \
+ } while(0);
+
+#define DIFF_LINE_RANGE_INIT(r) \
+ do { \
+ (r)->prev = (r)->spec = NULL; \
+ (r)->status = '\0'; \
+ (r)->alloc = (r)->nr = 0; \
+ (r)->ranges = NULL; \
+ (r)->next = NULL; \
+ (r)->touch = 0; \
+ (r)->diff = 0; \
+ } while(0);
+
+#define DIFF_LINE_RANGE_GROW(r) \
+ do { \
+ (r)->nr ++; \
+ ALLOC_GROW((r)->ranges, (r)->nr, (r)->alloc); \
+ RANGE_INIT(((r)->ranges + (r)->nr - 1)); \
+ } while(0);
+
+#define DIFF_LINE_RANGE_CLEAR(r) \
+ diff_line_range_clear((r));
+
+extern struct range *diff_line_range_insert(struct diff_line_range *r, const char *arg,
+ int start, int end);
+extern void diff_line_range_append(struct diff_line_range *r, const char *arg);
+
+extern void diff_line_range_clear(struct diff_line_range *r);
+
+extern struct diff_line_range *diff_line_range_merge(struct diff_line_range *out,
+ struct diff_line_range *other);
+
+extern void setup_line(struct rev_info *rev, struct diff_line_range *r);
+
+extern void add_line_range(struct rev_info *revs, struct commit *commit, struct diff_line_range *r);
+
+extern struct diff_line_range *lookup_line_range(struct rev_info *revs, struct commit *commit);
+
+#endif
diff --git a/revision.c b/revision.c
index 7847921..3186e0e 100644
--- a/revision.c
+++ b/revision.c
@@ -1397,18 +1397,19 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
return 1;
}
-void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
+int parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[])
{
int n = handle_revision_opt(revs, ctx->argc, ctx->argv,
&ctx->cpidx, ctx->out);
if (n <= 0) {
- error("unknown option `%s'", ctx->argv[0]);
- usage_with_options(usagestr, options);
+ return -1;
}
ctx->argv += n;
ctx->argc -= n;
+
+ return 0;
}
static int for_each_bad_bisect_ref(each_ref_fn fn, void *cb_data)
@@ -1631,6 +1632,12 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
if (revs->combine_merges)
revs->ignore_merges = 0;
revs->diffopt.abbrev = revs->abbrev;
+
+ if (revs->line) {
+ revs->limited = 1;
+ revs->topo_order = 1;
+ }
+
if (diff_setup_done(&revs->diffopt) < 0)
die("diff_setup_done failed");
diff --git a/revision.h b/revision.h
index 855464f..26c2ff5 100644
--- a/revision.h
+++ b/revision.h
@@ -14,6 +14,7 @@
#define CHILD_SHOWN (1u<<6)
#define ADDED (1u<<7) /* Parents already parsed and added? */
#define SYMMETRIC_LEFT (1u<<8)
+#define RANGE_UPDATE (1u<<9) /* for line level traverse */
#define ALL_REV_FLAGS ((1u<<9)-1)
#define DECORATE_SHORT_REFS 1
@@ -67,7 +68,8 @@ struct rev_info {
cherry_pick:1,
bisect:1,
ancestry_path:1,
- first_parent_only:1;
+ first_parent_only:1,
+ line:1;
/* Diff flags */
unsigned int diff:1,
@@ -132,6 +134,9 @@ struct rev_info {
/* notes-specific options: which refs to show */
struct display_notes_opt notes_opt;
+
+ /* line-level intersting range */
+ struct decoration line_range;
};
#define REV_TREE_SAME 0
@@ -150,7 +155,7 @@ struct setup_revision_opt {
extern void init_revisions(struct rev_info *revs, const char *prefix);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *);
-extern void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
+extern int parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[]);
extern int handle_revision_arg(const char *arg, struct rev_info *revs,int flags,int cant_be_filename);
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 03/12] add the basic data structure for line level history
2010-06-26 13:27 ` [PATCH 03/12] add the basic data structure for line level history Bo Yang
@ 2010-06-27 18:23 ` Junio C Hamano
2010-06-30 14:42 ` Bo Yang
0 siblings, 1 reply; 19+ messages in thread
From: Junio C Hamano @ 2010-06-27 18:23 UTC (permalink / raw)
To: Bo Yang; +Cc: git, Jens.Lehmann, trast, jrnieder
Bo Yang <struggleyb.nku@gmail.com> writes:
> 'struct diff_line_range' is the main data structure to store
> the user interesting line range. There is one 'diff_line_range'
> for each file, and there are multiple 'struct range' in each
> 'diff_line_range'. In this way, we support multiple ranges.
>
> Within 'struct range', there are multiple 'struct print_range'
> which represent a diff chunk.
>
> Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
> ---
> ...
> diff --git a/diffcore.h b/diffcore.h
> index 491bea0..06a6934 100644
> --- a/diffcore.h
> +++ b/diffcore.h
> @@ -51,6 +52,8 @@ struct diff_filespec {
> int is_binary;
> };
>
> +#define FILESPEC_VALID(f) (f)->sha1_valid
The filespec itself is valid even when it refers to an entity in the
working tree. Drop this, as it is misleading, and you don't seem to use
this anywhere.
> +static void cleanup(struct diff_line_range *r)
> +{
> + while (r) {
> + struct diff_line_range *tmp = r->next;
> + DIFF_LINE_RANGE_CLEAR(r);
> + free(r);
> + r = tmp;
Nit. s/tmp/next/;
> +static struct object *find_commit(struct rev_info *revs)
> +{
> + struct object *commit = NULL;
> + const char *name = NULL;
> + int i;
> +
> + for (i = 0; i < revs->pending.nr; i++) {
> + struct object *obj = revs->pending.objects[i].item;
> + if (obj->flags & UNINTERESTING)
> + continue;
> + while (obj->type == OBJ_TAG)
> + obj = deref_tag(obj, NULL, 0);
> + if (obj->type != OBJ_COMMIT)
> + die("Non commit %s?", revs->pending.objects[i].name);
> + if (commit)
> + die("More than one commit to dig from: %s and %s?",
> + revs->pending.objects[i].name, name);
> + commit = obj;
> + name = revs->pending.objects[i].name;
> + }
> +
> + return commit;
> +}
> +
This function is misnamed, as it does a lot more than "find commit". It
also enforces that you have at most one positive commit-ish on the command
line (or whatever populated revs->pending[] array), while making the
caller responsible for diagnosing (and dying if necessary) if there is no
commit-ish.
The sole caller of this doesn't seem to check if the returned value is
NULL. If you make this die upon "more than one commit", probably you
should also make it die upon "no commit".
> +static void fill_blob_sha1(struct commit *commit, struct diff_line_range *r)
> +{
> + unsigned mode;
> + unsigned char sha1[20];
> +
> + while (r) {
> + if (get_tree_entry(commit->object.sha1, r->spec->path,
> + sha1, &mode))
> + goto error;
> + fill_filespec(r->spec, sha1, mode);
> + r = r->next;
> + }
> +
> + return ;
There is a stray SP before semicolon. Drop it.
> +error:
> + die("There is no path %s in the commit", r->spec->path);
> +}
> +
> +static void make_line_log_file(struct diff_filespec *spec, int *lines, int **line_ends)
> +{
I don't see anything like "log-file" in this function.
When we have the whole contents of a blob in a chunk of memory, we always
use "unsigned long" to keep the offsets into it, I think. The type of
"line-ends" should be "unsigned long **" for consistency. I don't offhand
recall how we count number of lines (i.e. type of "lines"), but I suspect
we count them in long.
> + int num = 0, size = 50, cur = 0;
> + int *ends = NULL;
> + char *data = NULL;
> +
> + if (diff_populate_filespec(spec, 0))
> + die("Cannot read blob %s", sha1_to_hex(spec->sha1));
> +
> + ends = xmalloc(size * sizeof(int));
> + ends[cur++] = -1;
> + data = spec->data;
> + while (num < spec->size) {
> + if (data[num] == '\n' || num == spec->size - 1) {
> + if (cur >= size) {
> + size = size * 2;
> + ends = xrealloc(ends, size * sizeof(int));
> + }
> + ends[cur++] = num;
> + }
ARRAY_GROW()???
> + num ++;
There is a stray SP between the operand and unary operator. Drop it.
> +/*
> + * copied from blame.c, indeed, we can even to use this to test
A bit of refactoring would certainly help, before this series graduates
the WIP/RFC stage.
> +static void parse_lines(struct commit *commit, struct diff_line_range *r)
> +{
> + int i;
> + struct range *rg = NULL;
> + int lines = 0;
> + int *ends = NULL;
> +
> + while (r) {
> + struct diff_filespec *spec = r->spec;
> + int num = r->nr;
> + assert(spec);
> + fill_blob_sha1(commit, r);
> + rg = r->ranges;
> + r->ranges = NULL;
> + r->nr = r->alloc = 0;
> + make_line_log_file(spec, &lines, &ends);
> + for (i = 0; i < num; i++) {
> + parse_range(lines, ends, rg + i, spec);
> + diff_line_range_insert(r, rg[i].arg, rg[i].start, rg[i].end);
> + }
> +
> + if (ends != NULL) {
> + free(ends);
> + ends = NULL;
> + }
Under what condition can "ends" be NULL here? You would have died inside
nth_line() when you called parse_range().
Besides, free(NULL) is perfectly Ok.
> +
> + r = r->next;
> + /* release the memory of old array */
> + free(rg);
If you gave "rg" a more descriptive name, the readers would understand
without this comment.
> +/*
> + * Insert a new line range into a diff_line_range struct, and keep the
> + * r->ranges sorted by their starting line number.
> + */
> +struct range *diff_line_range_insert(struct diff_line_range *r, const char *arg,
> + int start, int end)
> +{
> + assert(r != NULL);
> + assert(start <= end);
> +
> + int i = 0;
> + struct range *rs = r->ranges;
> + int left_extend = 0, right_extend = 0;
We avoid decl-after-statement.
> diff --git a/revision.c b/revision.c
> index 7847921..3186e0e 100644
> --- a/revision.c
> +++ b/revision.c
> @@ -1397,18 +1397,19 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
> return 1;
> }
>
> -void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
> +int parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
> const struct option *options,
> const char * const usagestr[])
> {
> int n = handle_revision_opt(revs, ctx->argc, ctx->argv,
> &ctx->cpidx, ctx->out);
> if (n <= 0) {
> - error("unknown option `%s'", ctx->argv[0]);
> - usage_with_options(usagestr, options);
> + return -1;
> }
> ctx->argv += n;
> ctx->argc -= n;
> +
> + return 0;
> }
The function has existing callers and they expect it to fail with
usage_with_options(), never to return. Doesn't this change break them?
This change is not described nor justified in the commit log message.
> static int for_each_bad_bisect_ref(each_ref_fn fn, void *cb_data)
> @@ -1631,6 +1632,12 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
> if (revs->combine_merges)
> revs->ignore_merges = 0;
> revs->diffopt.abbrev = revs->abbrev;
> +
> + if (revs->line) {
> + revs->limited = 1;
> + revs->topo_order = 1;
> + }
> +
> if (diff_setup_done(&revs->diffopt) < 0)
> die("diff_setup_done failed");
>
> diff --git a/revision.h b/revision.h
> index 855464f..26c2ff5 100644
> --- a/revision.h
> +++ b/revision.h
> @@ -14,6 +14,7 @@
> #define CHILD_SHOWN (1u<<6)
> #define ADDED (1u<<7) /* Parents already parsed and added? */
> #define SYMMETRIC_LEFT (1u<<8)
> +#define RANGE_UPDATE (1u<<9) /* for line level traverse */
> #define ALL_REV_FLAGS ((1u<<9)-1)
It doesn't make sense to add a global flag here and keep ALL_REV_FLAGS the
same value. Have you audited the existing code and made sure that they
either do use 1<<9 for their own or their uses of such a custom flag are
compatible with this?
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH 03/12] add the basic data structure for line level history
2010-06-27 18:23 ` Junio C Hamano
@ 2010-06-30 14:42 ` Bo Yang
0 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-30 14:42 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, Jens.Lehmann, trast, jrnieder
On Mon, Jun 28, 2010 at 2:23 AM, Junio C Hamano <gitster@pobox.com> wrote:
>
>> +/*
>> + * copied from blame.c, indeed, we can even to use this to test
>
> A bit of refactoring would certainly help, before this series graduates
> the WIP/RFC stage.
I have put the 'parse_loc' into the line.c and make blame.c use it.
Please see the commit log. :-)
>> diff --git a/revision.c b/revision.c
>> index 7847921..3186e0e 100644
>> --- a/revision.c
>> +++ b/revision.c
>> @@ -1397,18 +1397,19 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
>> return 1;
>> }
>>
>> -void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
>> +int parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
>> const struct option *options,
>> const char * const usagestr[])
>> {
>> int n = handle_revision_opt(revs, ctx->argc, ctx->argv,
>> &ctx->cpidx, ctx->out);
>> if (n <= 0) {
>> - error("unknown option `%s'", ctx->argv[0]);
>> - usage_with_options(usagestr, options);
>> + return -1;
>> }
>> ctx->argv += n;
>> ctx->argc -= n;
>> +
>> + return 0;
>> }
>
> The function has existing callers and they expect it to fail with
> usage_with_options(), never to return. Doesn't this change break them?
>
> This change is not described nor justified in the commit log message.
Yes, this will affect other callers badly. But, with the new one pass
parsing method, we don't need this change anymore, so please forget
it.
>> static int for_each_bad_bisect_ref(each_ref_fn fn, void *cb_data)
>> @@ -1631,6 +1632,12 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
>> if (revs->combine_merges)
>> revs->ignore_merges = 0;
>> revs->diffopt.abbrev = revs->abbrev;
>> +
>> + if (revs->line) {
>> + revs->limited = 1;
>> + revs->topo_order = 1;
>> + }
>> +
>> if (diff_setup_done(&revs->diffopt) < 0)
>> die("diff_setup_done failed");
>>
>> diff --git a/revision.h b/revision.h
>> index 855464f..26c2ff5 100644
>> --- a/revision.h
>> +++ b/revision.h
>> @@ -14,6 +14,7 @@
>> #define CHILD_SHOWN (1u<<6)
>> #define ADDED (1u<<7) /* Parents already parsed and added? */
>> #define SYMMETRIC_LEFT (1u<<8)
>> +#define RANGE_UPDATE (1u<<9) /* for line level traverse */
>> #define ALL_REV_FLAGS ((1u<<9)-1)
>
> It doesn't make sense to add a global flag here and keep ALL_REV_FLAGS the
> same value. Have you audited the existing code and made sure that they
> either do use 1<<9 for their own or their uses of such a custom flag are
> compatible with this?
>
Hmm, I really mean the ALL_REV_FLAGS would be ((1u<<10)-1). :-)
And all the other comments from you are very helpful and I have
changed the according it. Thanks a lot!
--
Regards!
Bo
----------------------------
My blog: http://blog.morebits.org
Why Git: http://www.whygitisbetterthanx.com/
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 04/12] parse the -L options
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (2 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 03/12] add the basic data structure for line level history Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 05/12] export three functions from diff.c Bo Yang
` (7 subsequent siblings)
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
We adopt a two pass parsing method:
1. Don't provide '-L' option to the parsing API, and invoke
API to parse all the options except the '-L' ones;
2. Parse the remaining options(only -L left) with '-L' provided.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
builtin/log.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 121 insertions(+), 1 deletions(-)
diff --git a/builtin/log.c b/builtin/log.c
index f068583..f204129 100644
--- a/builtin/log.c
+++ b/builtin/log.c
@@ -19,6 +19,7 @@
#include "remote.h"
#include "string-list.h"
#include "parse-options.h"
+#include "line.h"
/* Set a default date-time format for git log ("log.date" config variable) */
static const char *default_date_mode = NULL;
@@ -27,11 +28,24 @@ static int default_show_root = 1;
static int decoration_style;
static const char *fmt_patch_subject_prefix = "PATCH";
static const char *fmt_pretty;
+static const char *dashdash = "--";
-static const char * const builtin_log_usage =
+static char builtin_log_usage[] =
"git log [<options>] [<since>..<until>] [[--] <path>...]\n"
+ "git log [<options>] -L n,m <path>\n"
" or: git show [options] <object>...";
+static const char *log_opt_usage[] = {
+ builtin_log_usage,
+ NULL
+};
+
+struct line_opt_callback_data {
+ struct diff_line_range **range;
+ struct parse_opt_ctx_t *ctx;
+ struct rev_info *rev;
+};
+
static int parse_decoration_style(const char *var, const char *value)
{
switch (git_config_maybe_bool(var, value)) {
@@ -49,12 +63,44 @@ static int parse_decoration_style(const char *var, const char *value)
return -1;
}
+static int log_line_range_callback(const struct option *option, const char *arg, int unset)
+{
+ struct line_opt_callback_data *data = option->value;
+ struct diff_line_range *r = *data->range;
+ struct parse_opt_ctx_t *ctx = data->ctx;
+ if (!arg)
+ return -1;
+
+ if (r->nr == 0 && r->next == NULL) {
+ ctx->out[ctx->cpidx++] = dashdash;
+ }
+
+ diff_line_range_append(r, arg);
+ data->rev->line = 1;
+ return 0;
+}
+
static void cmd_log_init(int argc, const char **argv, const char *prefix,
struct rev_info *rev, struct setup_revision_opt *opt)
{
int i;
int decoration_given = 0;
struct userformat_want w;
+ const char *path = NULL, *pathspec = NULL;
+ static struct diff_line_range *range = NULL;
+ static struct parse_opt_ctx_t ctx;
+ static struct line_opt_callback_data line_cb = {&range, &ctx, NULL};
+ static const struct option options[] = {
+ OPT_CALLBACK('L', NULL, &line_cb, "n,m", "Process only line range n,m, counting from 1", log_line_range_callback),
+ OPT_END()
+ };
+ static const struct option null_options[] = {
+ OPT_END()
+ };
+
+ line_cb.rev = rev;
+ range = xmalloc(sizeof(*range));
+ DIFF_LINE_RANGE_INIT(range);
rev->abbrev = DEFAULT_ABBREV;
rev->commit_format = CMIT_FMT_DEFAULT;
@@ -75,6 +121,75 @@ static void cmd_log_init(int argc, const char **argv, const char *prefix,
*/
if (argc == 2 && !strcmp(argv[1], "-h"))
usage(builtin_log_usage);
+
+ /* first pass to deal with normal log arguments */
+ parse_options_start(&ctx, argc, argv, prefix, PARSE_OPT_KEEP_DASHDASH |
+ PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN);
+ for (;;) {
+ switch (parse_options_step(&ctx, null_options, log_opt_usage)) {
+ case PARSE_OPT_HELP:
+ exit(129);
+ case PARSE_OPT_DONE:
+ goto parse_done1;
+ }
+
+ parse_revision_opt(rev, &ctx, null_options, log_opt_usage);
+ }
+parse_done1:
+ argc = parse_options_end(&ctx);
+
+ /* second pass to deal with -L */
+ parse_options_start(&ctx, argc, argv, prefix, PARSE_OPT_KEEP_DASHDASH |
+ PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_STOP_AT_NON_OPTION);
+ for (;;) {
+ switch (parse_options_step(&ctx, options, log_opt_usage)) {
+ case PARSE_OPT_HELP:
+ exit(129);
+ case PARSE_OPT_DONE:
+ goto parse_done2;
+ case PARSE_OPT_NON_OPTION:
+ path = parse_options_current(&ctx);
+ pathspec = prefix_path(prefix, prefix ? strlen(prefix) : 0, path);
+ range->spec = alloc_filespec(pathspec);
+ free((void *)pathspec);
+ if (range->nr == 0) {
+ if(range->next) {
+ die("Path %s need a -L <range> option\n"
+ "If you want follow the history of the whole file "
+ "whether to using 'git log' without -L or using "
+ "'git log -L 1,$ <path>'", range->spec->path);
+ } else {
+ parse_options_next(&ctx, 1);
+ continue;
+ }
+ }
+ struct diff_line_range *r = xmalloc(sizeof(*r));
+ DIFF_LINE_RANGE_INIT(r);
+ r->next = range;
+ range = r;
+ parse_options_next(&ctx, 1);
+ continue;
+ case PARSE_OPT_UNKNOWN:
+ parse_options_next(&ctx, 1);
+ continue;
+ }
+
+ parse_revision_opt(rev, &ctx, options, log_opt_usage);
+ }
+parse_done2:
+ argc = parse_options_end(&ctx);
+
+ /* die if '-L <range>' with no pathspec follow */
+ if (range->nr > 0 && range->spec == NULL) {
+ die("Each -L should follow a pathspec");
+ }
+ /* clear up the last range */
+ if (range->nr == 0) {
+ struct diff_line_range *r = range->next;
+ DIFF_LINE_RANGE_CLEAR(range);
+ range = r;
+ }
+
argc = setup_revisions(argc, argv, rev, opt);
memset(&w, 0, sizeof(w));
@@ -125,6 +240,11 @@ static void cmd_log_init(int argc, const char **argv, const char *prefix,
rev->show_decorations = 1;
load_ref_decorations(decoration_style);
}
+
+ /* Test whether line level history is asked for */
+ if (range && range->nr > 0) {
+ setup_line(rev, range);
+ }
}
/*
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 05/12] export three functions from diff.c
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (3 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 04/12] parse the -L options Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 06/12] add range clone functions Bo Yang
` (6 subsequent siblings)
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Use fill_metainfo to fill the line level diff meta data,
emit_line to print out a line and quote_two to quote
paths.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
diff.c | 6 +++---
diff.h | 18 ++++++++++++++++++
2 files changed, 21 insertions(+), 3 deletions(-)
diff --git a/diff.c b/diff.c
index c692526..9846fc9 100644
--- a/diff.c
+++ b/diff.c
@@ -148,7 +148,7 @@ int git_diff_basic_config(const char *var, const char *value, void *cb)
return git_color_default_config(var, value, cb);
}
-static char *quote_two(const char *one, const char *two)
+char *quote_two(const char *one, const char *two)
{
int need_one = quote_c_style(one, NULL, NULL, 1);
int need_two = quote_c_style(two, NULL, NULL, 1);
@@ -329,7 +329,7 @@ static void emit_line_0(struct diff_options *o, const char *set, const char *res
fputc('\n', file);
}
-static void emit_line(struct diff_options *o, const char *set, const char *reset,
+void emit_line(struct diff_options *o, const char *set, const char *reset,
const char *line, int len)
{
emit_line_0(o, set, reset, line[0], line+1, len-1);
@@ -2568,7 +2568,7 @@ static int similarity_index(struct diff_filepair *p)
return p->score * 100 / MAX_SCORE;
}
-static void fill_metainfo(struct strbuf *msg,
+void fill_metainfo(struct strbuf *msg,
const char *name,
const char *other,
struct diff_filespec *one,
diff --git a/diff.h b/diff.h
index 48abe7a..5d8449c 100644
--- a/diff.h
+++ b/diff.h
@@ -10,6 +10,8 @@ struct rev_info;
struct diff_options;
struct diff_queue_struct;
struct strbuf;
+struct diff_filespec;
+struct diff_filepair;
typedef void (*change_fn_t)(struct diff_options *options,
unsigned old_mode, unsigned new_mode,
@@ -292,4 +294,20 @@ extern void diff_no_index(struct rev_info *, int, const char **, int, const char
extern int index_differs_from(const char *def, int diff_flags);
+/* some output functions line.c need */
+extern void fill_metainfo(struct strbuf *msg,
+ const char *name,
+ const char *other,
+ struct diff_filespec *one,
+ struct diff_filespec *two,
+ struct diff_options *o,
+ struct diff_filepair *p,
+ int *must_show_header,
+ int use_color);
+
+extern void emit_line(struct diff_options *o, const char *set, const char *reset,
+ const char *line, int len);
+
+extern char *quote_two(const char *one, const char *two);
+
#endif /* DIFF_H */
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 06/12] add range clone functions
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (4 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 05/12] export three functions from diff.c Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-27 19:54 ` Junio C Hamano
2010-06-26 13:27 ` [PATCH 07/12] map/take range to parent Bo Yang
` (5 subsequent siblings)
11 siblings, 1 reply; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Both single range clone and deeply clone are supported.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
line.c | 35 +++++++++++++++++++++++++++++++++++
line.h | 4 ++++
2 files changed, 39 insertions(+), 0 deletions(-)
diff --git a/line.c b/line.c
index 7b7f3f3..f765a03 100644
--- a/line.c
+++ b/line.c
@@ -370,6 +370,41 @@ void diff_line_range_append(struct diff_line_range *r, const char *arg)
r->ranges[r->nr - 1].arg = arg;
}
+struct diff_line_range *diff_line_range_clone(struct diff_line_range *r)
+{
+ struct diff_line_range *ret = xmalloc(sizeof(*ret));
+
+ DIFF_LINE_RANGE_INIT(ret);
+ ret->ranges = xcalloc(sizeof(struct range), r->nr);
+ memcpy(ret->ranges, r->ranges, sizeof(struct range) * r->nr);
+
+ ret->alloc = ret->nr = r->nr;
+
+ ret->spec = r->spec;
+ assert(ret->spec);
+ ret->spec->count++;
+
+ return ret;
+}
+
+struct diff_line_range *diff_line_range_clone_deeply(struct diff_line_range *r)
+{
+ struct diff_line_range *ret = NULL;
+ struct diff_line_range *tmp = NULL, *prev = NULL;
+
+ assert(r);
+ ret = tmp = prev = diff_line_range_clone(r);
+ r = r->next;
+ while (r) {
+ tmp = diff_line_range_clone(r);
+ prev->next = tmp;
+ prev = tmp;
+ r = r->next;
+ }
+
+ return ret;
+}
+
struct diff_line_range *diff_line_range_merge(struct diff_line_range *out,
struct diff_line_range *other)
{
diff --git a/line.h b/line.h
index a2f8545..b6f328c 100644
--- a/line.h
+++ b/line.h
@@ -110,6 +110,10 @@ extern void diff_line_range_append(struct diff_line_range *r, const char *arg);
extern void diff_line_range_clear(struct diff_line_range *r);
+extern struct diff_line_range *diff_line_range_clone(struct diff_line_range *r);
+
+extern struct diff_line_range *diff_line_range_clone_deeply(struct diff_line_range *r);
+
extern struct diff_line_range *diff_line_range_merge(struct diff_line_range *out,
struct diff_line_range *other);
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 06/12] add range clone functions
2010-06-26 13:27 ` [PATCH 06/12] add range clone functions Bo Yang
@ 2010-06-27 19:54 ` Junio C Hamano
0 siblings, 0 replies; 19+ messages in thread
From: Junio C Hamano @ 2010-06-27 19:54 UTC (permalink / raw)
To: Bo Yang; +Cc: git, Jens.Lehmann, trast, jrnieder
Bo Yang <struggleyb.nku@gmail.com> writes:
> Both single range clone and deeply clone are supported.
>
> Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
> ---
> line.c | 35 +++++++++++++++++++++++++++++++++++
> line.h | 4 ++++
> 2 files changed, 39 insertions(+), 0 deletions(-)
>
> diff --git a/line.c b/line.c
> index 7b7f3f3..f765a03 100644
> --- a/line.c
> +++ b/line.c
> @@ -370,6 +370,41 @@ void diff_line_range_append(struct diff_line_range *r, const char *arg)
> r->ranges[r->nr - 1].arg = arg;
> }
>
> +struct diff_line_range *diff_line_range_clone(struct diff_line_range *r)
> +{
> + struct diff_line_range *ret = xmalloc(sizeof(*ret));
> +
> + DIFF_LINE_RANGE_INIT(ret);
> + ret->ranges = xcalloc(sizeof(struct range), r->nr);
Please don't break the calloc(nmemb, size-of-one-member) convention.
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 07/12] map/take range to parent
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (5 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 06/12] add range clone functions Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 08/12] print the line log Bo Yang
` (4 subsequent siblings)
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
The interesting line range will be passed to all of its parents.
For non-merge commit, we just map_range the ranges. Generally, the
algorithm do:
1. Run a diffcore_std to find out the pairs;
2. Run a xdi_diff_hunks on each interesting file pair;
3. The map_range_cb callback will be invoked for each diff hunk,
and in the function map_lines we will calculate the pre-image
range from the post-image range.
For merge commit, another take_range pass will be done except the
above normal map_range work. It is used to subtract each same
part lines of the current range out. After this pass, if there is
any line range left, this means the merge must be a non-trivial
merge. This is how the non-trivial merge detect work.
The algorithm that map lines from post-image to pre-image is in
the function map_lines. Generally, we use simple line number
calculation method to do the map.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
line.c | 452 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
revision.h | 3 +
2 files changed, 455 insertions(+), 0 deletions(-)
diff --git a/line.c b/line.c
index f765a03..322fd8a 100644
--- a/line.c
+++ b/line.c
@@ -486,3 +486,455 @@ void setup_line(struct rev_info *rev, struct diff_line_range *r)
diff_tree_release_paths(opt);
}
+struct take_range_cb_data {
+ struct diff_line_range *interesting;
+ struct diff_line_range *range;
+ long plno, tlno;
+ int diff;
+};
+
+#define SCALE_FACTOR 4
+void map_lines(long p_start, long p_end, long t_start, long t_end,
+ long start, long end, long *o_start, long *o_end)
+{
+ /*
+ * xdiff always assign 'same' with the last line number of two
+ * same ranges. When some lines are added from scratch,
+ * p_start = same + 1;
+ * p_end = same;
+ * so, we can understand the following condition.
+ */
+ if (p_start > p_end) {
+ *o_start = *o_end = 0;
+ return;
+ }
+ /* A deletion */
+ if (t_start > t_end) {
+ *o_start = p_start;
+ *o_end = p_end;
+ return;
+ }
+
+ if (start == t_start && end == t_end) {
+ *o_start = p_start;
+ *o_end = p_end;
+ return;
+ }
+
+ /*
+ * A new strategy for lines mapping:
+ *
+ * When the pre-image is no more than 1/4 of the post-image, it
+ * take no sense to say what the real pre-image is, wan can just
+ * treat all the post-image lines as added from scratch.
+ */
+ if (SCALE_FACTOR * (p_end - p_start + 1) < (t_end - t_start + 1)) {
+ *o_start = *o_end = 0;
+ return;
+ }
+
+ *o_start = p_start + start - t_start;
+ *o_end = p_end - (t_end - end);
+
+ if (*o_start > *o_end) {
+ int temp = *o_start;
+ *o_start = *o_end;
+ *o_end = temp;
+ }
+
+ if (*o_start < p_start)
+ *o_start = p_start;
+ if (*o_end > p_end)
+ *o_end = p_end;
+}
+
+static void map_range(struct take_range_cb_data *data, int same,
+ long p_start, long p_end, long t_start, long t_end)
+{
+ struct range *ranges = data->interesting->ranges;
+ long takens, takene, start, end;
+ int i = 0, out = 0, added = 0;
+ long op_start = p_start, op_end = p_end, ot_start = t_start, ot_end = t_end;
+
+ for (; i < data->interesting->nr; i++) {
+ added = 0;
+ if (t_start > ranges[i].end)
+ continue;
+ if (t_end < ranges[i].start)
+ break;
+
+ if (t_start > ranges[i].start) {
+ start = t_start;
+ takens = p_start;
+ if (t_end >= ranges[i].end) {
+ end = ranges[i].end;
+ takene = p_start + end - t_start;
+ } else {
+ end = t_end;
+ takene = p_end;
+ out = 1;
+ }
+ } else {
+ start = ranges[i].start;
+ takens = p_start + start - t_start;
+ if (t_end >= ranges[i].end) {
+ end = ranges[i].end;
+ takene = p_start + end - t_start;
+ } else {
+ end = t_end;
+ takene = p_end;
+ out = 1;
+ }
+ }
+
+ if (!same) {
+ struct print_pair *pair = &ranges[i].pair;
+ PRINT_PAIR_GROW(pair);
+ struct print_range *rr = pair->ranges + pair->nr - 1;
+ PRINT_RANGE_INIT(rr);
+ rr->start = start;
+ rr->end = end;
+ map_lines(op_start, op_end, ot_start, ot_end, start, end,
+ &takens, &takene);
+ if (takens == 0 && takene == 0) {
+ added = 1;
+ rr->line_added = 1;
+ }
+ rr->pstart = takens;
+ rr->pend = takene;
+ data->diff = 1;
+ data->interesting->diff = 1;
+ ranges[i].diff = 1;
+ }
+ if (added) {
+ /* Code movement/copy detect here */
+ } else {
+ struct range *added_range = diff_line_range_insert(data->range,
+ NULL, takens, takene);
+ assert(added_range);
+ ranges[i].pstart = added_range->start;
+ ranges[i].pend = added_range->end;
+ }
+
+ t_start = end + 1;
+ p_start = takene + 1;
+
+ if (out)
+ break;
+ }
+}
+
+static void take_range(struct take_range_cb_data *data,
+ long p_start, long p_end, long t_start, long t_end)
+{
+ struct range *ranges = data->interesting->ranges;
+ long takens, takene, start, end;
+ int i = 0, out = 0, added = 0;
+
+ for (; i < data->interesting->nr; i++) {
+ added = 0;
+ if (t_start > ranges[i].end)
+ continue;
+ if (t_end < ranges[i].start)
+ break;
+
+ if (t_start > ranges[i].start) {
+ long tmp = ranges[i].end;
+ ranges[i].end = t_start - 1;
+ start = t_start;
+ takens = p_start;
+ if (t_end >= tmp) {
+ end = tmp;
+ takene = p_start + end - t_start;
+ p_start = takene + 1;
+ t_start = end + 1;
+ } else {
+ end = t_end;
+ takene = p_end;
+ diff_line_range_insert(data->interesting, NULL,
+ t_end + 1, tmp);
+ out = 1;
+ }
+ } else {
+ start = ranges[i].start;
+ takens = p_start + start - t_start;
+ if (t_end >= ranges[i].end) {
+ int num = data->interesting->nr - 1;
+ end = ranges[i].end;
+ takene = p_start + end - t_start;
+ t_start = end + 1;
+ p_start = takene + 1;
+ memmove(ranges + i, ranges + i + 1, (num - i) * sizeof(*ranges));
+ data->interesting->nr = num;
+ i--;
+ } else {
+ end = t_end;
+ takene = p_end;
+ ranges[i].start = t_end + 1;
+ out = 1;
+ }
+ }
+
+ diff_line_range_insert(data->range, NULL, takens, takene);
+
+ if (out)
+ break;
+ }
+}
+
+static void take_range_cb(void *data, long same, long p_next, long t_next)
+{
+ struct take_range_cb_data *d = data;
+ long p_start = d->plno + 1, t_start = d->tlno + 1;
+ long p_end = p_start + same - t_start, t_end = same;
+
+ /* If one file is added from scratch, this may confuse take_range */
+ if (t_end >= t_start)
+ take_range(d, p_start, p_end, t_start, t_end);
+ d->plno = p_next;
+ d->tlno = t_next;
+}
+
+static void map_range_cb(void *data, long same, long p_next, long t_next)
+{
+ struct take_range_cb_data *d = data;
+
+ long p_start = d->plno + 1;
+ long t_start = d->tlno + 1;
+ long p_end = same - t_start + p_start;
+ long t_end = same;
+
+ /* Firstly, take the unchanged lines from child */
+ if (t_end >= t_start)
+ map_range(d, 1, p_start, p_end, t_start, t_end);
+
+ /* find out which lines to print */
+ t_start = same + 1;
+ p_start = d->plno + t_start - d->tlno;
+ map_range(d, 0, p_start, p_next, t_start, t_next);
+
+ d->plno = p_next;
+ d->tlno = t_next;
+}
+
+static void assign_range_to_parent(struct rev_info *rev, struct commit *c,
+ struct commit *p, struct diff_line_range *r,
+ struct diff_options *opt, int map)
+{
+ struct diff_line_range *rr = xmalloc(sizeof(*rr));
+ struct diff_line_range *cr = rr, *prev_r = rr;
+ struct tree_desc desc1, desc2;
+ void *tree1 = NULL, *tree2 = NULL;
+ unsigned long size1, size2;
+ struct diff_queue_struct *queue;
+ struct take_range_cb_data cb = {NULL, cr, 0, 0};
+ xpparam_t xpp;
+ xdemitconf_t xecfg;
+ int i, diff = 0;
+ xdiff_emit_hunk_consume_fn fn = map ? map_range_cb : take_range_cb;
+
+ DIFF_LINE_RANGE_INIT(cr);
+ memset(&xpp, 0, sizeof(xpp));
+ memset(&xecfg, 0, sizeof(xecfg));
+ xpp.flags = XDF_NEED_MINIMAL;
+ xecfg.ctxlen = xecfg.interhunkctxlen = 0;
+
+ /*
+ * Compose up two trees, for root commit, we make up a empty tree.
+ */
+ assert(c);
+ tree2 = read_object_with_reference(c->tree->object.sha1, "tree", &size2, NULL);
+ if (tree2 == NULL)
+ die("Unable to read tree (%s)", sha1_to_hex(c->tree->object.sha1));
+ init_tree_desc(&desc2, tree2, size2);
+ if (p) {
+ tree1 = read_object_with_reference(p->tree->object.sha1, "tree", &size1, NULL);
+ if (tree1 == NULL)
+ die("Unable to read tree (%s)", sha1_to_hex(p->tree->object.sha1));
+ init_tree_desc(&desc1, tree1, size1);
+ } else {
+ init_tree_desc(&desc1, "", 0);
+ }
+
+ DIFF_QUEUE_CLEAR(&diff_queued_diff);
+ diff_tree(&desc1, &desc2, "", opt);
+ diffcore_std(opt);
+
+ queue = &diff_queued_diff;
+ for (i = 0; i < queue->nr; i++) {
+ struct diff_filepair *pair = queue->queue[i];
+ struct diff_line_range *rg = r;
+ mmfile_t file_p, file_t;
+ while (rg) {
+ assert(rg->spec->path && pair->two->path);
+ if (!strcmp(rg->spec->path, pair->two->path))
+ break;
+ rg = rg->next;
+ }
+
+ if (rg == NULL)
+ continue;
+ rg->touch = 1;
+ if (rg->nr == 0)
+ continue;
+
+ rg->status = pair->status;
+ assert(FILESPEC_VALID(pair->two));
+ diff_populate_filespec(pair->two, 0);
+ file_t.ptr = pair->two->data;
+ file_t.size = pair->two->size;
+
+ if (rg->prev)
+ free_filespec(rg->prev);
+ rg->prev = pair->one;
+ rg->prev->count++;
+ if (FILESPEC_VALID(pair->one)) {
+ diff_populate_filespec(pair->one, 0);
+ file_p.ptr = pair->one->data;
+ file_p.size = pair->one->size;
+ } else {
+ file_p.ptr = "";
+ file_p.size = 0;
+ }
+
+ if (cr->nr != 0) {
+ struct diff_line_range *tmp = xmalloc(sizeof(*tmp));
+ cr->next = tmp;
+ prev_r = cr;
+ cr = tmp;
+ } else if (cr->spec)
+ DIFF_LINE_RANGE_CLEAR(cr);
+
+ DIFF_LINE_RANGE_INIT(cr);
+ if (FILESPEC_VALID(pair->one)) {
+ cr->spec = pair->one;
+ cr->spec->count++;
+ }
+
+ cb.interesting = rg;
+ cb.range = cr;
+ cb.diff = 0;
+ cb.plno = cb.tlno = 0;
+ xdi_diff_hunks(&file_p, &file_t, fn, &cb, &xpp, &xecfg);
+ if (cb.diff)
+ diff = 1;
+ /*
+ * The remain part is the same part.
+ * Instead of calculating the true line number of the two files,
+ * use the biggest integer.
+ */
+ if (map)
+ map_range(&cb, 1, cb.plno + 1, 0x7FFFFFFF, cb.tlno + 1, 0x7FFFFFFF);
+ else
+ take_range(&cb, cb.plno + 1, 0x7FFFFFFF, cb.tlno + 1, 0x7FFFFFFF);
+ }
+ opt->output_format = DIFF_FORMAT_NO_OUTPUT;
+ diff_flush(opt);
+
+ /* Collect the untouch ranges, this comes from the files not changed
+ * between two commit.
+ */
+ struct diff_line_range *rg = r;
+ while (rg) {
+ /* clear the touch one to make it usable in next round */
+ if (rg->touch) {
+ rg->touch = 0;
+ } else {
+ struct diff_line_range *untouch = diff_line_range_clone(rg);
+ if (prev_r == rr && rr->nr == 0) {
+ rr = prev_r = untouch;
+ } else {
+ prev_r->next = untouch;
+ prev_r = untouch;
+ }
+ }
+ rg = rg->next;
+ }
+
+ if (cr->nr == 0) {
+ DIFF_LINE_RANGE_CLEAR(cr);
+ free(cr);
+ if (prev_r == cr) {
+ rr = NULL;
+ } else {
+ prev_r->next = NULL;
+ }
+ }
+
+ if (rr) {
+ assert(p);
+ add_line_range(rev, p, rr);
+ }
+
+ /* and the ranges of current commit c is updated */
+ c->object.flags &= ~RANGE_UPDATE;
+ if (diff)
+ c->object.flags |= NEED_PRINT;
+
+ if (tree1)
+ free(tree1);
+ if (tree2)
+ free(tree2);
+}
+
+static void diff_update_parent_range(struct rev_info *rev, struct commit *commit)
+{
+ struct diff_line_range *r = lookup_line_range(rev, commit);
+ struct commit_list *parents = commit->parents;
+ struct commit *c = NULL;
+ if (parents) {
+ assert(parents->next == NULL);
+ c = parents->item;
+ }
+
+ assign_range_to_parent(rev, commit, c, r, &rev->diffopt, 1);
+}
+
+static void assign_parents_range(struct rev_info *rev, struct commit *commit)
+{
+ struct commit_list *parents = commit->parents;
+ struct diff_line_range *r = lookup_line_range(rev, commit);
+ struct diff_line_range *copy = NULL, *range = NULL;
+ int nontrivial = 0;
+
+ /*
+ * If we are in linear history, update range and flush the patch if
+ * necessary
+ */
+ if (parents == NULL || parents->next == NULL) {
+ return diff_update_parent_range(rev, commit);
+ }
+
+ /*
+ * Loop on the parents and assign the ranges to different
+ * parents, if there is any range left, this commit must
+ * be an evil merge.
+ */
+ copy = diff_line_range_clone_deeply(r);
+ parents = commit->parents;
+ while (parents) {
+ struct commit *p = parents->item;
+ assign_range_to_parent(rev, commit, p, r, &rev->diffopt, 1);
+ assign_range_to_parent(rev, commit, p, copy, &rev->diffopt, 0);
+ parents = parents->next;
+ }
+
+ /*
+ * yes, this must be an evil merge.
+ */
+ range = copy;
+ while (range) {
+ if (range->nr) {
+ commit->object.flags |= NEED_PRINT | EVIL_MERGE;
+ nontrivial = 1;
+ }
+ range = range->next;
+ }
+
+ if (nontrivial) {
+ add_decoration(&rev->nontrivial_merge, &commit->object, copy);
+ } else {
+ cleanup(copy);
+ }
+}
+
diff --git a/revision.h b/revision.h
index 26c2ff5..2bc3750 100644
--- a/revision.h
+++ b/revision.h
@@ -15,6 +15,8 @@
#define ADDED (1u<<7) /* Parents already parsed and added? */
#define SYMMETRIC_LEFT (1u<<8)
#define RANGE_UPDATE (1u<<9) /* for line level traverse */
+#define NEED_PRINT (1u<<10)
+#define EVIL_MERGE (1u<<11)
#define ALL_REV_FLAGS ((1u<<9)-1)
#define DECORATE_SHORT_REFS 1
@@ -137,6 +139,7 @@ struct rev_info {
/* line-level intersting range */
struct decoration line_range;
+ struct decoration nontrivial_merge;
};
#define REV_TREE_SAME 0
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 08/12] print the line log
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (6 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 07/12] map/take range to parent Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-27 23:49 ` Ramkumar Ramachandra
2010-06-26 13:27 ` [PATCH 09/12] map/print ranges along traversing the history topologically Bo Yang
` (3 subsequent siblings)
11 siblings, 1 reply; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
'struct line_chunk' is used to make sure each file is scaned
only once when output. We 'borrow' two function from diff.c
to get the similar output of normal diff.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
line.c | 245 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 245 insertions(+), 0 deletions(-)
diff --git a/line.c b/line.c
index 322fd8a..29bda11 100644
--- a/line.c
+++ b/line.c
@@ -938,3 +938,248 @@ static void assign_parents_range(struct rev_info *rev, struct commit *commit)
}
}
+struct line_chunk {
+ int lone, ltwo;
+ const char *one, *two;
+ const char *one_end, *two_end;
+ struct diff_line_range *range;
+};
+
+static void flush_lines(struct diff_options *opt, const char **ptr, const char *end,
+ int slno, int elno, int *lno, const char *color, const char heading)
+{
+ const char *p = *ptr;
+ struct strbuf buf = STRBUF_INIT;
+ const char *reset;
+
+ if (strcmp(color, ""))
+ reset = "";
+ else
+ reset = diff_get_color_opt(opt, DIFF_RESET);
+
+ strbuf_addf(&buf, "%s%c", color, heading);
+ while (*ptr < end && *lno < slno) {
+ if (**ptr == '\n') {
+ (*lno)++;
+ if (*lno == slno) {
+ (*ptr)++;
+ break;
+ }
+ }
+ (*ptr)++;
+ }
+ assert(*ptr <= end);
+ p = *ptr;
+
+ /*
+ * todo: when --graph landed on master, this should be changed
+ * a little.
+ */
+ while (*ptr < end && *lno <= elno) {
+ if (**ptr == '\n') {
+ fprintf(opt->file, "%s", buf.buf);
+ if (*ptr - p) {
+ fwrite(p, *ptr - p, 1, opt->file);
+ }
+ fprintf(opt->file, "%s\n", reset);
+ p = *ptr + 1;
+ (*lno)++;
+ }
+ (*ptr)++;
+ }
+ if (*lno <= elno) {
+ fprintf(opt->file, "%s", buf.buf);
+ if (*ptr - p) {
+ fwrite(p, *ptr - p, 1, opt->file);
+ }
+ fprintf(opt->file, "%s\n", reset);
+ }
+ strbuf_release(&buf);
+}
+
+static void diff_flush_range(struct diff_options *opt, struct line_chunk *chunk,
+ struct range *range)
+{
+ struct print_pair *pair = &range->pair;
+ const char *old = diff_get_color_opt(opt, DIFF_FILE_OLD);
+ const char *new = diff_get_color_opt(opt, DIFF_FILE_NEW);
+ int i, cur = range->start;
+
+ for (i = 0; i < pair->nr; i++) {
+ struct print_range *pr = pair->ranges + i;
+ if (cur < pr->start)
+ flush_lines(opt, &chunk->two, chunk->two_end,
+ cur, pr->start - 1, &chunk->ltwo, "", ' ');
+
+ if (!pr->line_added)
+ flush_lines(opt, &chunk->one, chunk->one_end,
+ pr->pstart, pr->pend, &chunk->lone, old, '-');
+ flush_lines(opt, &chunk->two, chunk->two_end,
+ pr->start, pr->end, &chunk->ltwo, new, '+');
+
+ cur = pr->end + 1;
+ }
+
+ if (cur <= range->end) {
+ flush_lines(opt, &chunk->two, chunk->two_end,
+ cur, range->end, &chunk->ltwo, "", ' ');
+ }
+}
+
+static void diff_flush_chunks(struct diff_options *opt, struct line_chunk *chunk)
+{
+ struct diff_line_range *range = chunk->range;
+ const char *set = diff_get_color_opt(opt, DIFF_FRAGINFO);
+ const char *reset = diff_get_color_opt(opt, DIFF_RESET);
+ int i;
+
+ for (i = 0; i < range->nr; i++) {
+ struct range *r = range->ranges + i;
+ long lenp = r->pend - r->pstart + 1, pstart = r->pstart;
+ long len = r->end - r->start + 1;
+ if (pstart == 0)
+ lenp = 0;
+
+ fprintf(opt->file, "%s@@ -%ld,%ld +%ld,%ld @@%s\n",
+ set, pstart, lenp, r->start, len, reset);
+
+ diff_flush_range(opt, chunk, r);
+ }
+}
+
+static void diff_flush_filepair(struct rev_info *rev, struct diff_line_range *range)
+{
+ struct diff_options *opt = &rev->diffopt;
+ struct diff_filespec *one = range->prev, *two = range->spec;
+ struct diff_filepair p = {one, two, range->status, 0};
+ struct strbuf header = STRBUF_INIT, meta = STRBUF_INIT;
+ const char *a_prefix, *b_prefix;
+ const char *name_a, *name_b, *a_one, *b_two;
+ const char *lbl[2];
+ const char *set = diff_get_color_opt(opt, DIFF_METAINFO);
+ const char *reset = diff_get_color_opt(opt, DIFF_RESET);
+ struct line_chunk chunk;
+ int must_show_header;
+
+ /*
+ * the ranges that touch no different file, in this case
+ * the line number will not change, and of course we have
+ * no sensible rang->pair since there is no diff run.
+ */
+ if (one == NULL) {
+ return;
+ }
+
+ if (range->status == DIFF_STATUS_DELETED)
+ die("We are following an nonexistent file, interesting!");
+
+ name_a = one->path;
+ name_b = two->path;
+ fill_metainfo(&meta, name_a, name_b, one, two, opt, &p, &must_show_header,
+ DIFF_OPT_TST(opt, COLOR_DIFF));
+
+ diff_set_mnemonic_prefix(opt, "a/", "b/");
+ if (DIFF_OPT_TST(opt, REVERSE_DIFF)) {
+ a_prefix = opt->b_prefix;
+ b_prefix = opt->a_prefix;
+ } else {
+ a_prefix = opt->a_prefix;
+ b_prefix = opt->b_prefix;
+ }
+
+ name_a = DIFF_FILE_VALID(one) ? name_a : name_b;
+ name_b = DIFF_FILE_VALID(two) ? name_b : name_a;
+
+ a_one = quote_two(a_prefix, name_a + (*name_a == '/'));
+ b_two = quote_two(b_prefix, name_b + (*name_b == '/'));
+ lbl[0] = DIFF_FILE_VALID(one) ? a_one : "/dev/null";
+ lbl[1] = DIFF_FILE_VALID(two) ? b_two : "/dev/null";
+ strbuf_addf(&header, "%sdiff --git %s %s%s\n", set, a_one, b_two, reset);
+ if (lbl[0][0] == '/') {
+ strbuf_addf(&header, "%snew file mode %06o%s\n", set, two->mode, reset);
+ } else if (lbl[1][0] == '/') {
+ strbuf_addf(&header, "%sdeleted file mode %06o%s\n", set, one->mode, reset);
+ } else if (one->mode != two->mode) {
+ strbuf_addf(&header, "%sold mode %06o%s\n", set, one->mode, reset);
+ strbuf_addf(&header, "%snew mode %06o%s\n", set, two->mode, reset);
+ }
+
+ fprintf(opt->file, "%s%s", header.buf, meta.buf);
+ strbuf_release(&meta);
+ strbuf_release(&header);
+ fprintf(opt->file, "%s--- %s%s\n", set, lbl[0], reset);
+ fprintf(opt->file, "%s+++ %s%s\n", set, lbl[1], reset);
+ free((void *)a_one);
+ free((void *)b_two);
+
+ chunk.one = one->data;
+ chunk.one_end = one->data + one->size;
+ chunk.lone = 1;
+ chunk.two = two->data;
+ chunk.two_end = two->data + two->size;
+ chunk.ltwo = 1;
+ chunk.range = range;
+ diff_flush_chunks(&rev->diffopt, &chunk);
+}
+
+#define EVIL_MERGE_STR "nontrivial merge found"
+static void flush_nontrivial_merge(struct rev_info *rev, struct diff_line_range *range)
+{
+ struct diff_options *opt = &rev->diffopt;
+ const char *reset = diff_get_color_opt(opt, DIFF_RESET);
+ const char *frag = diff_get_color_opt(opt, DIFF_FRAGINFO);
+ const char *meta = diff_get_color_opt(opt, DIFF_METAINFO);
+ const char *new = diff_get_color_opt(opt, DIFF_FILE_NEW);
+
+ fprintf(opt->file, "%s%s%s\n", meta, EVIL_MERGE_STR, reset);
+
+ while (range) {
+ if (range->nr) {
+ fprintf(opt->file, "%s%s%s\n\n", meta, range->spec->path, reset);
+ int lno = 1;
+ const char *ptr = range->spec->data;
+ const char *end = range->spec->data + range->spec->size;
+ int i = 0;
+ for (; i < range->nr; i++) {
+ struct range *r = range->ranges + i;
+ fprintf(opt->file, "%s@@ %ld,%ld @@%s\n", frag, r->start,
+ r->end - r->start + 1, reset);
+ flush_lines(opt, &ptr, end, r->start, r->end,
+ &lno, new, ' ');
+ }
+ fprintf(opt->file, "\n");
+ }
+ range = range->next;
+ }
+}
+
+static void line_log_flush(struct rev_info *rev, struct commit *c)
+{
+ struct diff_line_range *range = lookup_line_range(rev, c);
+ struct diff_line_range *nontrivial = lookup_decoration(&rev->nontrivial_merge, &c->object);
+ struct log_info log;
+
+ if (range == NULL)
+ return;
+
+ log.commit = c;
+ log.parent = NULL;
+ rev->loginfo = &log;
+ show_log(rev);
+ rev->loginfo = NULL;
+ /*
+ * Add a new line after each commit message, of course we should
+ * add --graph alignment later when the patches comes to master.
+ */
+ fprintf(rev->diffopt.file, "\n");
+
+ if (c->object.flags & EVIL_MERGE)
+ return flush_nontrivial_merge(rev, nontrivial);
+
+ while (range) {
+ if (range->diff)
+ diff_flush_filepair(rev, range);
+ range = range->next;
+ }
+}
+
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 09/12] map/print ranges along traversing the history topologically
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (7 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 08/12] print the line log Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 10/12] add --always-print option Bo Yang
` (2 subsequent siblings)
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Since ranges may change in different branches, we should
make sure we do not pass range to parent until all the
ranges get 'combined' at the commit which is a split commit.
So, topological traversing is necessary.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
builtin/log.c | 5 ++++-
line.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
line.h | 2 ++
3 files changed, 58 insertions(+), 1 deletions(-)
diff --git a/builtin/log.c b/builtin/log.c
index f204129..87d6b2f 100644
--- a/builtin/log.c
+++ b/builtin/log.c
@@ -632,7 +632,10 @@ int cmd_log(int argc, const char **argv, const char *prefix)
memset(&opt, 0, sizeof(opt));
opt.def = "HEAD";
cmd_log_init(argc, argv, prefix, &rev, &opt);
- return cmd_log_walk(&rev);
+ if (rev.line)
+ return cmd_line_log_walk(&rev);
+ else
+ return cmd_log_walk(&rev);
}
/* format-patch */
diff --git a/line.c b/line.c
index 29bda11..46d0937 100644
--- a/line.c
+++ b/line.c
@@ -1183,3 +1183,55 @@ static void line_log_flush(struct rev_info *rev, struct commit *c)
}
}
+int cmd_line_log_walk(struct rev_info *rev)
+{
+ struct commit *commit;
+ struct commit_list *list = NULL;
+ struct diff_line_range *r = NULL;
+
+ if (prepare_revision_walk(rev))
+ die("revision walk prepare failed");
+
+ list = rev->commits;
+ if (list) {
+ list->item->object.flags |= RANGE_UPDATE;
+ list = list->next;
+ }
+ /* Clear the flags */
+ while (list) {
+ list->item->object.flags &= 0x0;
+ list = list->next;
+ }
+
+ list = rev->commits;
+ while (list) {
+ commit = list->item;
+
+ if (commit->object.flags & RANGE_UPDATE) {
+ assign_parents_range(rev, commit);
+ }
+
+ if (commit->object.flags & NEED_PRINT) {
+ line_log_flush(rev, commit);
+ }
+
+ r = lookup_line_range(rev, commit);
+ if (r) {
+ cleanup(r);
+ r = NULL;
+ add_line_range(rev, commit, r);
+ }
+
+ r = lookup_decoration(&rev->nontrivial_merge, &commit->object);
+ if (r) {
+ cleanup(r);
+ r = NULL;
+ add_decoration(&rev->nontrivial_merge, &commit->object, r);
+ }
+
+ list = list->next;
+ }
+
+ return 0;
+}
+
diff --git a/line.h b/line.h
index b6f328c..203c323 100644
--- a/line.h
+++ b/line.h
@@ -123,4 +123,6 @@ extern void add_line_range(struct rev_info *revs, struct commit *commit, struct
extern struct diff_line_range *lookup_line_range(struct rev_info *revs, struct commit *commit);
+extern int cmd_line_log_walk(struct rev_info *rev);
+
#endif
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 10/12] add --always-print option
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (8 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 09/12] map/print ranges along traversing the history topologically Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 11/12] add two test cases Bo Yang
2010-06-26 13:27 ` [PATCH 12/12] some document update Bo Yang
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Always print the interesting ranges even if the current
commit does not change any line of it.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
builtin/log.c | 3 +++
line.c | 11 +++++++++--
revision.h | 3 ++-
3 files changed, 14 insertions(+), 3 deletions(-)
diff --git a/builtin/log.c b/builtin/log.c
index 87d6b2f..a0918ef 100644
--- a/builtin/log.c
+++ b/builtin/log.c
@@ -85,6 +85,7 @@ static void cmd_log_init(int argc, const char **argv, const char *prefix,
{
int i;
int decoration_given = 0;
+ static int always_print = 0;
struct userformat_want w;
const char *path = NULL, *pathspec = NULL;
static struct diff_line_range *range = NULL;
@@ -92,6 +93,7 @@ static void cmd_log_init(int argc, const char **argv, const char *prefix,
static struct line_opt_callback_data line_cb = {&range, &ctx, NULL};
static const struct option options[] = {
OPT_CALLBACK('L', NULL, &line_cb, "n,m", "Process only line range n,m, counting from 1", log_line_range_callback),
+ OPT_BOOLEAN(0, "always-print", &always_print, "Always print the interesting range even if the current commit does not change any line of it"),
OPT_END()
};
static const struct option null_options[] = {
@@ -244,6 +246,7 @@ parse_done2:
/* Test whether line level history is asked for */
if (range && range->nr > 0) {
setup_line(rev, range);
+ rev->always_print = always_print;
}
}
diff --git a/line.c b/line.c
index 46d0937..655fa71 100644
--- a/line.c
+++ b/line.c
@@ -1067,6 +1067,13 @@ static void diff_flush_filepair(struct rev_info *rev, struct diff_line_range *ra
* no sensible rang->pair since there is no diff run.
*/
if (one == NULL) {
+ if (rev->always_print) {
+ chunk.two = two->data;
+ chunk.two_end = two->data + two->size;
+ chunk.ltwo = 1;
+ chunk.range = range;
+ diff_flush_chunks(&rev->diffopt, &chunk);
+ }
return;
}
@@ -1177,7 +1184,7 @@ static void line_log_flush(struct rev_info *rev, struct commit *c)
return flush_nontrivial_merge(rev, nontrivial);
while (range) {
- if (range->diff)
+ if (range->diff || (range->nr && rev->always_print))
diff_flush_filepair(rev, range);
range = range->next;
}
@@ -1211,7 +1218,7 @@ int cmd_line_log_walk(struct rev_info *rev)
assign_parents_range(rev, commit);
}
- if (commit->object.flags & NEED_PRINT) {
+ if (commit->object.flags & NEED_PRINT || rev->always_print) {
line_log_flush(rev, commit);
}
diff --git a/revision.h b/revision.h
index 2bc3750..02ab14c 100644
--- a/revision.h
+++ b/revision.h
@@ -71,7 +71,8 @@ struct rev_info {
bisect:1,
ancestry_path:1,
first_parent_only:1,
- line:1;
+ line:1,
+ always_print:1;
/* Diff flags */
unsigned int diff:1,
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 11/12] add two test cases
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (9 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 10/12] add --always-print option Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
2010-06-26 13:27 ` [PATCH 12/12] some document update Bo Yang
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
t4301: for simple linear history only
t4302: for history contains merge
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
t/t4301-log-line-single-history.sh | 342 ++++++++++++++++++++++++++++++++++++
t/t4302-log-line-merge-history.sh | 118 +++++++++++++
2 files changed, 460 insertions(+), 0 deletions(-)
create mode 100755 t/t4301-log-line-single-history.sh
create mode 100755 t/t4302-log-line-merge-history.sh
diff --git a/t/t4301-log-line-single-history.sh b/t/t4301-log-line-single-history.sh
new file mode 100755
index 0000000..9981496
--- /dev/null
+++ b/t/t4301-log-line-single-history.sh
@@ -0,0 +1,342 @@
+#!/bin/sh
+#
+# Copyright (c) 2010 Bo Yang
+#
+
+test_description='Test git log -L with single line of history
+
+'
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/diff-lib.sh
+
+echo >path0 'void func(){
+ int a = 0;
+ int b = 1;
+ int c;
+ c = a + b;
+}
+'
+
+echo >path1 'void output(){
+ printf("hello world");
+}
+'
+
+test_expect_success \
+ 'add path0/path1 and commit.' \
+ 'git add path0 path1 &&
+ git commit -m "Base commit"'
+
+echo >path0 'void func(){
+ int a = 10;
+ int b = 11;
+ int c;
+ c = a + b;
+}
+'
+
+echo >path1 'void output(){
+ const char *str = "hello world!";
+ printf("%s", str);
+}
+'
+
+test_expect_success \
+ 'Change the 2,3 lines of path0 and path1.' \
+ 'git add path0 path1 &&
+ git commit -m "Change 2,3 lines of path0 and path1"'
+
+echo >path0 'void func(){
+ int a = 10;
+ int b = 11;
+ int c;
+ c = 10 * (a + b);
+}
+'
+
+test_expect_success \
+ 'Change the 5th line of path0.' \
+ 'git add path0 &&
+ git commit -m "Change the 5th line of path0"'
+
+echo >path0 'void func(){
+ int a = 10;
+ int b = 11;
+ printf("%d", a - b);
+}
+'
+
+test_expect_success \
+ 'Final change of path0.' \
+ 'git add path0 &&
+ git commit -m "Final change of path0"'
+
+test_expect_success \
+ 'Show the line level log of path0' \
+ 'git log --pretty=format:%s%n%b -L /func/,/^}/ path0 > current-path0'
+
+test_expect_success \
+ 'Show the line level log of path1' \
+ 'git log --pretty=format:%s%n%b -L /output/,/^}/ path1 > current-path1'
+
+test_expect_success \
+ 'Show the line level log of two files' \
+ 'git log --pretty=format:%s%n%b -L /func/,/^}/ path0 -L /output/,/^}/ path1 > current-pathall'
+
+test_expect_success \
+ 'Test the line number argument' \
+ 'git log --pretty=format:%s%n%b -L 1,2 path0 > current-linenum'
+
+test_expect_success \
+ 'Test the --always-print option' \
+ 'git log --pretty=format:%s%n%b --always-print -L 1,2 path0 > current-always'
+
+cat >expected-path0 <<\EOF
+Final change of path0
+
+diff --git a/path0 b/path0
+index 44db133..1518c15 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,5 @@
+ void func(){
+ int a = 10;
+ int b = 11;
+- int c;
+- c = 10 * (a + b);
++ printf("%d", a - b);
+ }
+
+Change the 5th line of path0
+
+diff --git a/path0 b/path0
+index 9ef1692..44db133 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,6 @@
+ void func(){
+ int a = 10;
+ int b = 11;
+ int c;
+- c = a + b;
++ c = 10 * (a + b);
+ }
+
+Change 2,3 lines of path0 and path1
+
+diff --git a/path0 b/path0
+index aabffdf..9ef1692 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,6 @@
+ void func(){
+- int a = 0;
+- int b = 1;
++ int a = 10;
++ int b = 11;
+ int c;
+ c = a + b;
+ }
+
+Base commit
+
+diff --git a/path0 b/path0
+new file mode 100644
+index 0000000..aabffdf
+--- /dev/null
++++ b/path0
+@@ -0,0 +1,6 @@
++void func(){
++ int a = 0;
++ int b = 1;
++ int c;
++ c = a + b;
++}
+EOF
+
+cat >expected-path1 <<\EOF
+Change 2,3 lines of path0 and path1
+
+diff --git a/path1 b/path1
+index 997d841..1d711b5 100644
+--- a/path1
++++ b/path1
+@@ -1,3 +1,4 @@
+ void output(){
+- printf("hello world");
++ const char *str = "hello world!";
++ printf("%s", str);
+ }
+
+Base commit
+
+diff --git a/path1 b/path1
+new file mode 100644
+index 0000000..997d841
+--- /dev/null
++++ b/path1
+@@ -0,0 +1,3 @@
++void output(){
++ printf("hello world");
++}
+EOF
+
+cat >expected-pathall <<\EOF
+Final change of path0
+
+diff --git a/path0 b/path0
+index 44db133..1518c15 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,5 @@
+ void func(){
+ int a = 10;
+ int b = 11;
+- int c;
+- c = 10 * (a + b);
++ printf("%d", a - b);
+ }
+
+Change the 5th line of path0
+
+diff --git a/path0 b/path0
+index 9ef1692..44db133 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,6 @@
+ void func(){
+ int a = 10;
+ int b = 11;
+ int c;
+- c = a + b;
++ c = 10 * (a + b);
+ }
+
+Change 2,3 lines of path0 and path1
+
+diff --git a/path0 b/path0
+index aabffdf..9ef1692 100644
+--- a/path0
++++ b/path0
+@@ -1,6 +1,6 @@
+ void func(){
+- int a = 0;
+- int b = 1;
++ int a = 10;
++ int b = 11;
+ int c;
+ c = a + b;
+ }
+diff --git a/path1 b/path1
+index 997d841..1d711b5 100644
+--- a/path1
++++ b/path1
+@@ -1,3 +1,4 @@
+ void output(){
+- printf("hello world");
++ const char *str = "hello world!";
++ printf("%s", str);
+ }
+
+Base commit
+
+diff --git a/path0 b/path0
+new file mode 100644
+index 0000000..aabffdf
+--- /dev/null
++++ b/path0
+@@ -0,0 +1,6 @@
++void func(){
++ int a = 0;
++ int b = 1;
++ int c;
++ c = a + b;
++}
+diff --git a/path1 b/path1
+new file mode 100644
+index 0000000..997d841
+--- /dev/null
++++ b/path1
+@@ -0,0 +1,3 @@
++void output(){
++ printf("hello world");
++}
+EOF
+
+cat >expected-linenum <<\EOF
+Change 2,3 lines of path0 and path1
+
+diff --git a/path0 b/path0
+index aabffdf..9ef1692 100644
+--- a/path0
++++ b/path0
+@@ -1,2 +1,2 @@
+ void func(){
+- int a = 0;
++ int a = 10;
+
+Base commit
+
+diff --git a/path0 b/path0
+new file mode 100644
+index 0000000..aabffdf
+--- /dev/null
++++ b/path0
+@@ -0,0 +1,2 @@
++void func(){
++ int a = 0;
+EOF
+
+cat >expected-always <<\EOF
+Final change of path0
+
+diff --git a/path0 b/path0
+index 44db133..1518c15 100644
+--- a/path0
++++ b/path0
+@@ -1,2 +1,2 @@
+ void func(){
+ int a = 10;
+
+Change the 5th line of path0
+
+diff --git a/path0 b/path0
+index 9ef1692..44db133 100644
+--- a/path0
++++ b/path0
+@@ -1,2 +1,2 @@
+ void func(){
+ int a = 10;
+
+Change 2,3 lines of path0 and path1
+
+diff --git a/path0 b/path0
+index aabffdf..9ef1692 100644
+--- a/path0
++++ b/path0
+@@ -1,2 +1,2 @@
+ void func(){
+- int a = 0;
++ int a = 10;
+
+Base commit
+
+diff --git a/path0 b/path0
+new file mode 100644
+index 0000000..aabffdf
+--- /dev/null
++++ b/path0
+@@ -0,0 +1,2 @@
++void func(){
++ int a = 0;
+EOF
+
+test_expect_success \
+ 'validate the output.' \
+ 'test_cmp current-path0 expected-path0 &&
+ test_cmp current-path1 expected-path1 &&
+ test_cmp current-pathall expected-pathall &&
+ test_cmp current-linenum expected-linenum &&
+ test_cmp current-always expected-always'
+
+test_done
diff --git a/t/t4302-log-line-merge-history.sh b/t/t4302-log-line-merge-history.sh
new file mode 100755
index 0000000..70ad0bf
--- /dev/null
+++ b/t/t4302-log-line-merge-history.sh
@@ -0,0 +1,118 @@
+#!/bin/sh
+#
+# Copyright (c) 2010 Bo Yang
+#
+
+test_description='Test git log -L with merge commit
+
+'
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/diff-lib.sh
+
+echo >path0 'void func(){
+ printf("hello");
+}
+'
+
+test_expect_success \
+ 'Add path0 and commit.' \
+ 'git add path0 &&
+ git commit -m "Base commit"'
+
+echo >path0 'void func(){
+ printf("hello earth");
+}
+'
+
+test_expect_success \
+ 'Change path0 in master.' \
+ 'git add path0 &&
+ git commit -m "Change path0 in master"'
+
+test_expect_success \
+ 'Make a new branch from the base commit' \
+ 'git checkout -b feature master^'
+
+echo >path0 'void func(){
+ print("hello moon");
+}
+'
+
+test_expect_success \
+ 'Change path0 in feature.' \
+ 'git add path0 &&
+ git commit -m "Change path0 in feature"'
+
+test_expect_success \
+ 'Merge the master to feature' \
+ '! git merge master'
+
+echo >path0 'void func(){
+ printf("hello earth and moon");
+}
+'
+
+test_expect_success \
+ 'Resolve the conflict' \
+ 'git add path0 &&
+ git commit -m "Merge two branches"'
+
+test_expect_success \
+ 'Show the line level log of path0' \
+ 'git log --pretty=format:%s%n%b -L /func/,/^}/ path0 > current-path0'
+
+test_expect_success \
+ 'Show the line level log of path0' \
+ 'git log --pretty=format:%s%n%b -L /func/,/^}/ path0 > current'
+
+cat >expected <<\EOF
+Merge two branches
+
+nontrivial merge found
+path0
+
+@@ 2,1 @@
+ printf("hello earth and moon");
+
+
+Change path0 in master
+
+diff --git a/path0 b/path0
+index f628dea..bef7fa3 100644
+--- a/path0
++++ b/path0
+@@ -1,3 +1,3 @@
+ void func(){
+- printf("hello");
++ printf("hello earth");
+ }
+
+Change path0 in feature
+
+diff --git a/path0 b/path0
+index f628dea..a940ef6 100644
+--- a/path0
++++ b/path0
+@@ -1,3 +1,3 @@
+ void func(){
+- printf("hello");
++ print("hello moon");
+ }
+
+Base commit
+
+diff --git a/path0 b/path0
+new file mode 100644
+index 0000000..f628dea
+--- /dev/null
++++ b/path0
+@@ -0,0 +1,3 @@
++void func(){
++ printf("hello");
++}
+EOF
+test_expect_success \
+ 'validate the output.' \
+ 'test_cmp current expected'
+
+test_done
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 12/12] some document update
2010-06-26 13:27 [PATCH 00/12] The first version of line level log browser Bo Yang
` (10 preceding siblings ...)
2010-06-26 13:27 ` [PATCH 11/12] add two test cases Bo Yang
@ 2010-06-26 13:27 ` Bo Yang
11 siblings, 0 replies; 19+ messages in thread
From: Bo Yang @ 2010-06-26 13:27 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, trast, jrnieder
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
---
Documentation/git-log.txt | 30 ++++++++++++++++++++++++++++++
1 files changed, 30 insertions(+), 0 deletions(-)
diff --git a/Documentation/git-log.txt b/Documentation/git-log.txt
index 0e6ff31..14a9703 100644
--- a/Documentation/git-log.txt
+++ b/Documentation/git-log.txt
@@ -9,6 +9,7 @@ git-log - Show commit logs
SYNOPSIS
--------
'git log' [<options>] [<since>..<until>] [[\--] <path>...]
+'git log' [<options>] -L n,m <path>
DESCRIPTION
-----------
@@ -19,6 +20,9 @@ command to control what is shown and how, and options applicable to
the 'git diff-*' commands to control how the changes
each commit introduces are shown.
+With '-L' option, the command will help to trace the history of user specified
+line ranges. It can trace multiple ranges coming from multiple files.
+
OPTIONS
-------
@@ -72,6 +76,32 @@ include::diff-options.txt[]
to be prefixed with "\-- " to separate them from options or
refnames.
+-L <start>,<end>::
+ The line range. <start> and <end> can take one of these forms:
+
+- number
++
+If <start> or <end> is a number, it specifies an
+absolute line number (lines count from 1).
++
+
+- /regex/
++
+This form will use the first line matching the given
+POSIX regex. If <end> is a regex, it will search
+starting at the line given by <start>.
++
+
+- +offset or -offset
++
+This is only valid for <end> and will specify a number
+of lines before or after the line given by <start>.
++
+
+--always-print::
+ Always print the interesting range even if the current commit
+ does not change any line of the range.
+
include::rev-list-options.txt[]
--
1.7.1.577.g36cf0.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread