Merge branch 'rs/color-grep'

* rs/color-grep:
grep: prefer builtin over external one when coloring results
grep: cast printf %.*s "precision" argument explicitly to int
grep: add support for coloring with external greps
grep: color patterns in output
grep: add pmatch and eflags arguments to match_one_pattern()
grep: remove grep_opt argument from match_expr_eval()
grep: micro-optimize hit collection for AND nodes

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 44916b9e7f51073afdcbbf641702e6dda036aa41..12540b605f4f15e93703bed226ab43c0b8d6716b 100644 (file)
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -553,6 +553,25 @@ color.diff.<slot>::
        whitespace errors). The values of these variables may be specified as
        in color.branch.<slot>.
 
+color.grep::
+       When set to `always`, always highlight matches.  When `false` (or
+       `never`), never.  When set to `true` or `auto`, use color only
+       when the output is written to the terminal.  Defaults to `false`.
+
+color.grep.external::
+       The string value of this variable is passed to an external 'grep'
+       command as a command line option if match highlighting is turned
+       on.  If set to an empty string, no option is passed at all,
+       turning off coloring for external 'grep' calls; this is the default.
+       For GNU grep, set it to `--color=always` to highlight matches even
+       when a pager is used.
+
+color.grep.match::
+       Use customized color for matches.  The value of this variable
+       may be specified as in color.branch.<slot>.  It is passed using
+       the environment variables 'GREP_COLOR' and 'GREP_COLORS' when
+       calling an external 'grep'.
+
 color.interactive::
        When set to `always`, always use colors for interactive prompts
        and displays (such as those used by "git-add --interactive").

diff --git a/Documentation/git-grep.txt b/Documentation/git-grep.txt
index 553da6cbb1777a94cb3d6b48dc77c445e18ca2b0..fccb82deb48ec75d25f948e7caa69a44e09f5832 100644 (file)
--- a/Documentation/git-grep.txt
+++ b/Documentation/git-grep.txt
@@ -17,6 +17,7 @@ SYNOPSIS
           [-l | --files-with-matches] [-L | --files-without-match]
           [-z | --null]
           [-c | --count] [--all-match]
+          [--color | --no-color]
           [-A <post-context>] [-B <pre-context>] [-C <context>]
           [-f <file>] [-e] <pattern>
           [--and|--or|--not|(|)|-e <pattern>...] [<tree>...]
@@ -105,6 +106,13 @@ OPTIONS
        Instead of showing every matched line, show the number of
        lines that match.
 
+--color::
+       Show colored matches.
+
+--no-color::
+       Turn off match highlighting, even when the configuration file
+       gives the default to color output.
+
 -[ABC] <context>::
        Show `context` trailing (`A` -- after), or leading (`B`
        -- before), or both (`C` -- context) lines, and place a

diff --git a/builtin-grep.c b/builtin-grep.c
index 3f12ba382690699d96580c3ddb1a61c79520e694..89489ddcf8edb85160036b0336ab4ce80c3cb6bc 100644 (file)
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -22,6 +22,28 @@
 
 static int builtin_grep;
 
+static int grep_config(const char *var, const char *value, void *cb)
+{
+       struct grep_opt *opt = cb;
+
+       if (!strcmp(var, "grep.color") || !strcmp(var, "color.grep")) {
+               opt->color = git_config_colorbool(var, value, -1);
+               return 0;
+       }
+       if (!strcmp(var, "grep.color.external") ||
+           !strcmp(var, "color.grep.external")) {
+               return git_config_string(&(opt->color_external), var, value);
+       }
+       if (!strcmp(var, "grep.color.match") ||
+           !strcmp(var, "color.grep.match")) {
+               if (!value)
+                       return config_error_nonbool(var);
+               color_parse(value, var, opt->color_match);
+               return 0;
+       }
+       return git_color_default_config(var, value, cb);
+}
+
 /*
  * git grep pathspecs are somewhat different from diff-tree pathspecs;
  * pathname wildcards are allowed.
@@ -269,6 +291,21 @@ static int flush_grep(struct grep_opt *opt,
        return status;
 }
 
+static void grep_add_color(struct strbuf *sb, const char *escape_seq)
+{
+       size_t orig_len = sb->len;
+
+       while (*escape_seq) {
+               if (*escape_seq == 'm')
+                       strbuf_addch(sb, ';');
+               else if (*escape_seq != '\033' && *escape_seq  != '[')
+                       strbuf_addch(sb, *escape_seq);
+               escape_seq++;
+       }
+       if (sb->len > orig_len && sb->buf[sb->len - 1] == ';')
+               strbuf_setlen(sb, sb->len - 1);
+}
+
 static int external_grep(struct grep_opt *opt, const char **paths, int cached)
 {
        int i, nr, argc, hit, len, status;
@@ -339,6 +376,23 @@ static int external_grep(struct grep_opt *opt, const char **paths, int cached)
                push_arg("-e");
                push_arg(p->pattern);
        }
+       if (opt->color) {
+               struct strbuf sb = STRBUF_INIT;
+
+               grep_add_color(&sb, opt->color_match);
+               setenv("GREP_COLOR", sb.buf, 1);
+
+               strbuf_reset(&sb);
+               strbuf_addstr(&sb, "mt=");
+               grep_add_color(&sb, opt->color_match);
+               strbuf_addstr(&sb, ":sl=:cx=:fn=:ln=:bn=:se=");
+               setenv("GREP_COLORS", sb.buf, 1);
+
+               strbuf_release(&sb);
+
+               if (opt->color_external && strlen(opt->color_external) > 0)
+                       push_arg(opt->color_external);
+       }
 
        hit = 0;
        argc = nr;
@@ -536,6 +590,12 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
        opt.pattern_tail = &opt.pattern_list;
        opt.regflags = REG_NEWLINE;
 
+       strcpy(opt.color_match, GIT_COLOR_RED GIT_COLOR_BOLD);
+       opt.color = -1;
+       git_config(grep_config, &opt);
+       if (opt.color == -1)
+               opt.color = git_use_color_default;
+
        /*
         * If there is no -- then the paths must exist in the working
         * tree.  If there is no explicit pattern specified with -e or
@@ -732,6 +792,14 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
                        opt.relative = 0;
                        continue;
                }
+               if (!strcmp("--color", arg)) {
+                       opt.color = 1;
+                       continue;
+               }
+               if (!strcmp("--no-color", arg)) {
+                       opt.color = 0;
+                       continue;
+               }
                if (!strcmp("--", arg)) {
                        /* later processing wants to have this at argv[1] */
                        argv--;
@@ -757,6 +825,8 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
                }
        }
 
+       if (opt.color && !opt.color_external)
+               builtin_grep = 1;
        if (!opt.pattern_list)
                die("no pattern given.");
        if ((opt.regflags != REG_NEWLINE) && opt.fixed)

diff --git a/grep.c b/grep.c
index 062b2b6f28f6332518240d2a474a7739735e1ecf..be99b3416867ff68a1c2c1a3646be35baf61f8b2 100644 (file)
--- a/grep.c
+++ b/grep.c
@@ -39,6 +39,8 @@ static void compile_regexp(struct grep_pat *p, struct grep_opt *opt)
 {
        int err;
 
+       p->word_regexp = opt->word_regexp;
+
        if (opt->fixed || is_fixed(p->pattern))
                p->fixed = 1;
        if (opt->regflags & REG_ICASE)
@@ -251,18 +253,6 @@ static int word_char(char ch)
        return isalnum(ch) || ch == '_';
 }
 
-static void show_line(struct grep_opt *opt, const char *bol, const char *eol,
-                     const char *name, unsigned lno, char sign)
-{
-       if (opt->null_following_name)
-               sign = '\0';
-       if (opt->pathname)
-               printf("%s%c", name, sign);
-       if (opt->linenum)
-               printf("%d%c", lno, sign);
-       printf("%.*s\n", (int)(eol-bol), bol);
-}
-
 static void show_name(struct grep_opt *opt, const char *name)
 {
        printf("%s%c", name, opt->null_following_name ? '\0' : '\n');
@@ -306,11 +296,12 @@ static struct {
        { "committer ", 10 },
 };
 
-static int match_one_pattern(struct grep_opt *opt, struct grep_pat *p, char *bol, char *eol, enum grep_context ctx)
+static int match_one_pattern(struct grep_pat *p, char *bol, char *eol,
+                            enum grep_context ctx,
+                            regmatch_t *pmatch, int eflags)
 {
        int hit = 0;
        int saved_ch = 0;
-       regmatch_t pmatch[10];
 
        if ((p->token != GREP_PATTERN) &&
            ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD)))
@@ -329,16 +320,12 @@ static int match_one_pattern(struct grep_opt *opt, struct grep_pat *p, char *bol
        }
 
  again:
-       if (!p->fixed) {
-               regex_t *exp = &p->regexp;
-               hit = !regexec(exp, bol, ARRAY_SIZE(pmatch),
-                              pmatch, 0);
-       }
-       else {
+       if (p->fixed)
                hit = !fixmatch(p->pattern, bol, pmatch);
-       }
+       else
+               hit = !regexec(&p->regexp, bol, 1, pmatch, eflags);
 
-       if (hit && opt->word_regexp) {
+       if (hit && p->word_regexp) {
                if ((pmatch[0].rm_so < 0) ||
                    (eol - bol) <= pmatch[0].rm_so ||
                    (pmatch[0].rm_eo < 0) ||
@@ -378,39 +365,33 @@ static int match_one_pattern(struct grep_opt *opt, struct grep_pat *p, char *bol
        return hit;
 }
 
-static int match_expr_eval(struct grep_opt *o,
-                          struct grep_expr *x,
-                          char *bol, char *eol,
-                          enum grep_context ctx,
-                          int collect_hits)
+static int match_expr_eval(struct grep_expr *x, char *bol, char *eol,
+                          enum grep_context ctx, int collect_hits)
 {
        int h = 0;
+       regmatch_t match;
 
        switch (x->node) {
        case GREP_NODE_ATOM:
-               h = match_one_pattern(o, x->u.atom, bol, eol, ctx);
+               h = match_one_pattern(x->u.atom, bol, eol, ctx, &match, 0);
                break;
        case GREP_NODE_NOT:
-               h = !match_expr_eval(o, x->u.unary, bol, eol, ctx, 0);
+               h = !match_expr_eval(x->u.unary, bol, eol, ctx, 0);
                break;
        case GREP_NODE_AND:
-               if (!collect_hits)
-                       return (match_expr_eval(o, x->u.binary.left,
-                                               bol, eol, ctx, 0) &&
-                               match_expr_eval(o, x->u.binary.right,
-                                               bol, eol, ctx, 0));
-               h = match_expr_eval(o, x->u.binary.left, bol, eol, ctx, 0);
-               h &= match_expr_eval(o, x->u.binary.right, bol, eol, ctx, 0);
+               if (!match_expr_eval(x->u.binary.left, bol, eol, ctx, 0))
+                       return 0;
+               h = match_expr_eval(x->u.binary.right, bol, eol, ctx, 0);
                break;
        case GREP_NODE_OR:
                if (!collect_hits)
-                       return (match_expr_eval(o, x->u.binary.left,
+                       return (match_expr_eval(x->u.binary.left,
                                                bol, eol, ctx, 0) ||
-                               match_expr_eval(o, x->u.binary.right,
+                               match_expr_eval(x->u.binary.right,
                                                bol, eol, ctx, 0));
-               h = match_expr_eval(o, x->u.binary.left, bol, eol, ctx, 0);
+               h = match_expr_eval(x->u.binary.left, bol, eol, ctx, 0);
                x->u.binary.left->hit |= h;
-               h |= match_expr_eval(o, x->u.binary.right, bol, eol, ctx, 1);
+               h |= match_expr_eval(x->u.binary.right, bol, eol, ctx, 1);
                break;
        default:
                die("Unexpected node type (internal error) %d", x->node);
@@ -424,24 +405,104 @@ static int match_expr(struct grep_opt *opt, char *bol, char *eol,
                      enum grep_context ctx, int collect_hits)
 {
        struct grep_expr *x = opt->pattern_expression;
-       return match_expr_eval(opt, x, bol, eol, ctx, collect_hits);
+       return match_expr_eval(x, bol, eol, ctx, collect_hits);
 }
 
 static int match_line(struct grep_opt *opt, char *bol, char *eol,
                      enum grep_context ctx, int collect_hits)
 {
        struct grep_pat *p;
+       regmatch_t match;
+
        if (opt->extended)
                return match_expr(opt, bol, eol, ctx, collect_hits);
 
        /* we do not call with collect_hits without being extended */
        for (p = opt->pattern_list; p; p = p->next) {
-               if (match_one_pattern(opt, p, bol, eol, ctx))
+               if (match_one_pattern(p, bol, eol, ctx, &match, 0))
                        return 1;
        }
        return 0;
 }
 
+static int match_next_pattern(struct grep_pat *p, char *bol, char *eol,
+                             enum grep_context ctx,
+                             regmatch_t *pmatch, int eflags)
+{
+       regmatch_t match;
+
+       if (!match_one_pattern(p, bol, eol, ctx, &match, eflags))
+               return 0;
+       if (match.rm_so < 0 || match.rm_eo < 0)
+               return 0;
+       if (pmatch->rm_so >= 0 && pmatch->rm_eo >= 0) {
+               if (match.rm_so > pmatch->rm_so)
+                       return 1;
+               if (match.rm_so == pmatch->rm_so && match.rm_eo < pmatch->rm_eo)
+                       return 1;
+       }
+       pmatch->rm_so = match.rm_so;
+       pmatch->rm_eo = match.rm_eo;
+       return 1;
+}
+
+static int next_match(struct grep_opt *opt, char *bol, char *eol,
+                     enum grep_context ctx, regmatch_t *pmatch, int eflags)
+{
+       struct grep_pat *p;
+       int hit = 0;
+
+       pmatch->rm_so = pmatch->rm_eo = -1;
+       if (bol < eol) {
+               for (p = opt->pattern_list; p; p = p->next) {
+                       switch (p->token) {
+                       case GREP_PATTERN: /* atom */
+                       case GREP_PATTERN_HEAD:
+                       case GREP_PATTERN_BODY:
+                               hit |= match_next_pattern(p, bol, eol, ctx,
+                                                         pmatch, eflags);
+                               break;
+                       default:
+                               break;
+                       }
+               }
+       }
+       return hit;
+}
+
+static void show_line(struct grep_opt *opt, char *bol, char *eol,
+                     const char *name, unsigned lno, char sign)
+{
+       int rest = eol - bol;
+
+       if (opt->null_following_name)
+               sign = '\0';
+       if (opt->pathname)
+               printf("%s%c", name, sign);
+       if (opt->linenum)
+               printf("%d%c", lno, sign);
+       if (opt->color) {
+               regmatch_t match;
+               enum grep_context ctx = GREP_CONTEXT_BODY;
+               int ch = *eol;
+               int eflags = 0;
+
+               *eol = '\0';
+               while (next_match(opt, bol, eol, ctx, &match, eflags)) {
+                       printf("%.*s%s%.*s%s",
+                              (int)match.rm_so, bol,
+                              opt->color_match,
+                              (int)(match.rm_eo - match.rm_so), bol + match.rm_so,
+                              GIT_COLOR_RESET);
+                       bol += match.rm_eo;
+                       rest -= match.rm_eo;
+                       eflags = REG_NOTBOL;
+               }
+               *eol = ch;
+       }
+       printf("%.*s\n", rest, bol);
+}
+
 static int grep_buffer_1(struct grep_opt *opt, const char *name,
                         char *buf, unsigned long size, int collect_hits)
 {

diff --git a/grep.h b/grep.h
index 5102ce335d29811dd448e173f2e90e8d03b5f011..a67005de62d1442e7ba6a8dc27320225a0d55819 100644 (file)
--- a/grep.h
+++ b/grep.h
@@ -1,5 +1,6 @@
 #ifndef GREP_H
 #define GREP_H
+#include "color.h"
 
 enum grep_pat_token {
        GREP_PATTERN,
@@ -31,6 +32,7 @@ struct grep_pat {
        enum grep_header_field field;
        regex_t regexp;
        unsigned fixed:1;
+       unsigned word_regexp:1;
 };
 
 enum grep_expr_node {
@@ -76,6 +78,9 @@ struct grep_opt {
        unsigned relative:1;
        unsigned pathname:1;
        unsigned null_following_name:1;
+       int color;
+       char color_match[COLOR_MAXLEN];
+       const char *color_external;
        int regflags;
        unsigned pre_context;
        unsigned post_context;